diff --git a/Explicação.md b/Explicação.md
new file mode 100644
index 0000000..44ae7a9
--- /dev/null
+++ b/Explicação.md
@@ -0,0 +1,317 @@
+---
+title: Explicação
+description: 
+published: true
+date: 2026-06-22T19:40:48.978Z
+tags: 
+editor: markdown
+dateCreated: 2026-06-22T19:40:46.381Z
+---
+
+# Explicacao Didatica do Trecho `chartData`
+
+## Trecho analisado
+
+```javascript
+const chartData = this._dashboardDataset
+    .filter(item => item.Type === 'MATERIAL_STATUS')
+    .map((item) => ({
+        ...item,
+        DisplayStatus: ColorMaterialFormatter.colorMaterialSubtitle(item.Key2)
+    }));
+```
+
+## Objetivo geral do codigo
+
+Esse trecho pega uma lista maior de dados chamada `this._dashboardDataset`, seleciona apenas os itens que representam status de material e cria uma nova lista com esses itens, adicionando um campo novo chamado `DisplayStatus`.
+
+Em outras palavras:
+
+1. Filtra somente os itens importantes para esse caso.
+2. Monta um novo array com os mesmos dados do item original.
+3. Acrescenta uma informacao formatada para exibicao.
+
+## Explicacao linha por linha
+
+### 1. Declaracao da constante
+
+```javascript
+const chartData = ...
+```
+
+- `const` cria uma constante.
+- `chartData` sera a variavel que vai guardar o resultado final.
+- Esse resultado sera um novo array.
+
+## 2. Uso de `this._dashboardDataset`
+
+```javascript
+this._dashboardDataset
+```
+
+- `this` normalmente representa o objeto atual, por exemplo um controller ou classe.
+- `_dashboardDataset` parece ser uma propriedade desse objeto.
+- O nome indica que ela armazena os dados usados no dashboard.
+
+Entao o codigo esta comecando a trabalhar sobre esse array principal.
+
+## 3. A funcao `filter`
+
+```javascript
+.filter(item => item.Type === 'MATERIAL_STATUS')
+```
+
+### O que `filter` faz
+
+A funcao `filter()` percorre todos os itens de um array e retorna um novo array contendo apenas os itens que passam em uma condicao.
+
+### Como funciona aqui
+
+Para cada `item` do array:
+
+```javascript
+item.Type === 'MATERIAL_STATUS'
+```
+
+Essa expressao verifica se a propriedade `Type` do item e exatamente igual a `'MATERIAL_STATUS'`.
+
+### Resultado do `filter`
+
+- Se for verdadeiro, o item permanece no array novo.
+- Se for falso, o item e descartado.
+
+### Exemplo
+
+Se o array original for:
+
+```javascript
+[
+  { Type: 'MATERIAL_STATUS', Key2: 'A' },
+  { Type: 'OTHER', Key2: 'B' },
+  { Type: 'MATERIAL_STATUS', Key2: 'C' }
+]
+```
+
+Depois do `filter`, o resultado sera:
+
+```javascript
+[
+  { Type: 'MATERIAL_STATUS', Key2: 'A' },
+  { Type: 'MATERIAL_STATUS', Key2: 'C' }
+]
+```
+
+## 4. A arrow function usada no `filter`
+
+```javascript
+item => item.Type === 'MATERIAL_STATUS'
+```
+
+Essa e uma **arrow function**, que e uma forma curta de escrever funcao em JavaScript.
+
+Ela equivale a algo assim:
+
+```javascript
+function(item) {
+    return item.Type === 'MATERIAL_STATUS';
+}
+```
+
+Ou seja, para cada item, ela retorna `true` ou `false`.
+
+## 5. A funcao `map`
+
+```javascript
+.map((item) => ({
+    ...item,
+    DisplayStatus: ColorMaterialFormatter.colorMaterialSubtitle(item.Key2)
+}));
+```
+
+### O que `map` faz
+
+A funcao `map()` percorre um array e transforma cada item em outro valor.
+
+No final, ela devolve um novo array com a mesma quantidade de itens, mas cada item pode ter sido modificado ou recriado.
+
+### Como funciona aqui
+
+Depois do `filter`, o `map()` pega cada item que sobrou e cria um novo objeto com:
+
+- todos os campos do item original
+- mais um campo novo chamado `DisplayStatus`
+
+## 6. O que significa `...item`
+
+```javascript
+...item
+```
+
+Isso e o **spread operator**.
+
+Nesse contexto, ele copia as propriedades do objeto `item` para dentro do novo objeto.
+
+Exemplo:
+
+Se `item` for:
+
+```javascript
+{
+  Type: 'MATERIAL_STATUS',
+  Key1: 'MAT1',
+  Key2: 'RED'
+}
+```
+
+Entao:
+
+```javascript
+{
+  ...item
+}
+```
+
+vira algo equivalente a:
+
+```javascript
+{
+  Type: 'MATERIAL_STATUS',
+  Key1: 'MAT1',
+  Key2: 'RED'
+}
+```
+
+Isso e muito util para reaproveitar os dados existentes sem precisar escrever propriedade por propriedade.
+
+## 7. Criacao do campo `DisplayStatus`
+
+```javascript
+DisplayStatus: ColorMaterialFormatter.colorMaterialSubtitle(item.Key2)
+```
+
+Aqui o codigo cria uma nova propriedade chamada `DisplayStatus`.
+
+O valor dela vem da chamada:
+
+```javascript
+ColorMaterialFormatter.colorMaterialSubtitle(item.Key2)
+```
+
+### O que isso faz
+
+- `ColorMaterialFormatter` parece ser um objeto utilitario de formatacao.
+- `colorMaterialSubtitle(...)` parece ser uma funcao desse objeto.
+- `item.Key2` e o valor enviado para essa funcao.
+
+Provavelmente essa funcao pega um codigo interno e devolve um texto melhor para exibicao.
+
+### Exemplo possivel
+
+Se:
+
+```javascript
+item.Key2 = 'RED'
+```
+
+e a funcao retornar:
+
+```javascript
+'Vermelho'
+```
+
+o novo objeto passara a ter:
+
+```javascript
+DisplayStatus: 'Vermelho'
+```
+
+## 8. Por que ha parenteses em volta do objeto no `map`
+
+```javascript
+(item) => ({
+    ...item,
+    DisplayStatus: ...
+})
+```
+
+Esses parenteses extras existem porque a arrow function esta retornando um objeto diretamente.
+
+Sem esses parenteses, o JavaScript poderia interpretar as chaves como bloco de codigo, e nao como objeto.
+
+## 9. Resultado final de `chartData`
+
+No final, `chartData` sera um novo array contendo:
+
+- apenas itens com `Type === 'MATERIAL_STATUS'`
+- todos os campos originais desses itens
+- mais o campo `DisplayStatus`
+
+## Exemplo completo
+
+### Array original
+
+```javascript
+this._dashboardDataset = [
+  { Type: 'MATERIAL_STATUS', Key1: 'MAT1', Key2: 'RED' },
+  { Type: 'OTHER', Key1: 'X', Key2: 'Y' },
+  { Type: 'MATERIAL_STATUS', Key1: 'MAT2', Key2: 'GREEN' }
+];
+```
+
+### Supondo que:
+
+```javascript
+ColorMaterialFormatter.colorMaterialSubtitle('RED')   // 'Vermelho'
+ColorMaterialFormatter.colorMaterialSubtitle('GREEN') // 'Verde'
+```
+
+### Resultado em `chartData`
+
+```javascript
+[
+  {
+    Type: 'MATERIAL_STATUS',
+    Key1: 'MAT1',
+    Key2: 'RED',
+    DisplayStatus: 'Vermelho'
+  },
+  {
+    Type: 'MATERIAL_STATUS',
+    Key1: 'MAT2',
+    Key2: 'GREEN',
+    DisplayStatus: 'Verde'
+  }
+]
+```
+
+## Diferenca importante em relacao ao `forEach`
+
+Nesse caso, o codigo usa `map()`, que cria um novo array com novos objetos.
+
+Isso e diferente de um `forEach()` alterando diretamente os objetos originais.
+
+### Vantagem disso
+
+- o codigo fica mais declarativo
+- evita alterar a lista original sem necessidade
+- facilita manutencao e leitura
+
+## Resumo simples
+
+Esse trecho:
+
+1. pega os dados do dashboard
+2. filtra apenas os itens do tipo `MATERIAL_STATUS`
+3. cria uma nova versao de cada item
+4. adiciona o campo `DisplayStatus` com um valor formatado para exibicao
+
+## Conclusao
+
+Para um dev junior, a ideia principal e lembrar:
+
+- `filter()` serve para **selecionar**
+- `map()` serve para **transformar**
+- `...item` serve para **copiar as propriedades do objeto**
+- `ColorMaterialFormatter.colorMaterialSubtitle(item.Key2)` serve para **formatar um valor para exibicao**
+
+Esse e um padrao muito comum em JavaScript moderno quando trabalhamos com listas de dados.
diff --git a/Plano.md b/Plano.md
new file mode 100644
index 0000000..9f88e0f
--- /dev/null
+++ b/Plano.md
@@ -0,0 +1,219 @@
+---
+title: Plano
+description: 
+published: true
+date: 2026-06-22T19:37:58.369Z
+tags: 
+editor: markdown
+dateCreated: 2026-06-22T19:36:05.776Z
+---
+
+# Correção da persistência do campo `WoNotInterface`
+
+## Contexto
+
+Hoje a persistência do campo `Interface para ordens/notas` depende de `getSelectedIndex()` no `Select` `editorOption`.
+
+O problema é que os itens desse `Select` são montados dinamicamente em `fillWorkOrderNotificationInterface()`. Como a lista muda conforme a existência de `WebGuiLink` e `FioriLink`, o índice visual não é confiável para representar o valor técnico salvo em `WoNotInterface`.
+
+Em outras palavras:
+
+- `0` nem sempre deve significar apenas a primeira opção visível
+- `1` nem sempre corresponde a `G`
+- `2` nem sempre corresponde a `F`
+
+O campo precisa persistir o valor técnico real da opção selecionada:
+
+- `''` para padrão SIGGA P&S
+- `G` para SAP WebGUI
+- `F` para SAP Fiori
+
+## Problema atual
+
+Trecho atual:
+
+```js
+oParam.WoNotInterface = this.getWoNotInterfaceFieldMap(this._control.editorOption.getSelectedIndex().toString());
+```
+
+### O que faz
+
+Lê o índice selecionado de `editorOption`, converte para string e envia esse valor para `getWoNotInterfaceFieldMap(...)`.
+
+### Por que existe
+
+A implementação atual tenta mapear posição visual do `Select` para o valor persistido em `WoNotInterface`.
+
+### Qual problema evita
+
+Na prática, não evita o problema principal. Como `editorOption` é montado dinamicamente, `getSelectedIndex()` não representa de forma estável `OrdNotInterface.Default`, `OrdNotInterface.WebGui` ou `OrdNotInterface.Fiori`.
+
+## Objetivo da correção
+
+A correção deve fazer `editorOption` trabalhar com `key` explícita por item, usando os valores técnicos definidos em `OrdNotInterface`.
+
+Isso permite que a persistência use `getSelectedKey()` em vez de `getSelectedIndex()`, removendo a dependência da posição visual.
+
+Valores esperados para `WoNotInterface`:
+
+- `OrdNotInterface.Default` -> `''`
+- `OrdNotInterface.WebGui` -> `'G'`
+- `OrdNotInterface.Fiori` -> `'F'`
+
+## Bloco 1: montagem do `Select`
+
+```js
+fillWorkOrderNotificationInterface() {
+    const aItems = [{
+        key: OrdNotInterface.Default,
+        text: this.getResourceText("WorkOrderNotificationInterfacePSOption")
+    }];
+
+    if (this._control.DataSourceForm.getModel(GENERAL_MODEL).oData.WebGuiLink) {
+        aItems.push({
+            key: OrdNotInterface.WebGui,
+            text: this.getResourceText("WorkOrderNotificationInterfaceWebGuiOption")
+        });
+    }
+
+    if (this._control.DataSourceForm.getModel(GENERAL_MODEL).oData.FioriLink) {
+        aItems.push({
+            key: OrdNotInterface.Fiori,
+            text: this.getResourceText("WorkOrderNotificationInterfaceFioriOption")
+        });
+    }
+
+    this._control.editorOption.destroyItems();
+
+    aItems.forEach((item) => {
+        this._control.editorOption.addItem(new sap.ui.core.Item({
+            key: item.key,
+            text: item.text
+        }));
+    });
+
+    const sInterface = this.getWoNotInterfaceFieldMap(
+        this._control.DataSourceForm.getModel(GENERAL_MODEL).oData.WoNotInterface
+    );
+
+    this._control.editorOption.setSelectedKey(sInterface);
+}
+```
+
+### O que faz
+
+Esse bloco monta o `editorOption` com `key` explícita para cada item e depois seleciona o valor salvo usando `setSelectedKey(...)`.
+
+### Por que existe
+
+Ele garante que cada opção visível no `Select` represente diretamente um valor técnico de `WoNotInterface`, usando `OrdNotInterface` como fonte de verdade.
+
+### Qual problema evita
+
+Evita que `editorOption` dependa da posição do item na lista. Com `getSelectedKey()`, o código deixa de assumir que a segunda opção sempre é `G` ou que a terceira sempre é `F`.
+
+## Bloco 2: normalização do valor
+
+```js
+getWoNotInterfaceFieldMap(value) {
+    if (value === '1') {
+        return OrdNotInterface.WebGui;
+    }
+
+    if (value === '2') {
+        return OrdNotInterface.Fiori;
+    }
+
+    if (value === '0' || value === '' || value == null) {
+        return OrdNotInterface.Default;
+    }
+
+    if (value === OrdNotInterface.WebGui) {
+        return OrdNotInterface.WebGui;
+    }
+
+    if (value === OrdNotInterface.Fiori) {
+        return OrdNotInterface.Fiori;
+    }
+
+    return OrdNotInterface.Default;
+}
+```
+
+### O que faz
+
+Esse bloco normaliza o valor de `WoNotInterface`, aceitando tanto o formato legado por índice (`0`, `1`, `2`) quanto o formato correto por valor técnico (`''`, `G`, `F`).
+
+### Por que existe
+
+Ele preserva compatibilidade durante a transição. Se ainda houver dado legado ou algum fluxo antigo passando índice, o método converte isso para o valor real esperado por `OrdNotInterface`.
+
+### Qual problema evita
+
+Evita inconsistência entre leitura e gravação de `WoNotInterface`. Também impede que `editorOption` quebre ao carregar registros antigos ainda dependentes de `getSelectedIndex()`.
+
+## Bloco 3: persistência
+
+```js
+oParam.WoNotInterface = this.getWoNotInterfaceFieldMap(this._control.editorOption.getSelectedKey());
+```
+
+### O que faz
+
+Esse bloco persiste `WoNotInterface` a partir do `key` selecionado em `editorOption`.
+
+### Por que existe
+
+A persistência precisa usar `getSelectedKey()` porque o valor técnico correto está no `key` do item, não na sua posição visual.
+
+### Qual problema evita
+
+Evita que `WoNotInterface` grave `G` ou `F` incorretamente quando a ordem do `Select` mudar. Também elimina a fragilidade do uso de `getSelectedIndex()`.
+
+## Referências de código
+
+Arquivos relevantes:
+
+- `webapp/controller/Config/auxiliary/ConfigGeneralAuxiliary.js`
+- `webapp/resources/js/constant/OData/OrdNotInterface.js`
+
+Pontos principais em `ConfigGeneralAuxiliary.js`:
+
+- montagem do `editorOption`
+- normalização de `WoNotInterface`
+- persistência de `oParam.WoNotInterface`
+
+Fonte de verdade dos valores técnicos:
+
+- `OrdNotInterface.Default`
+- `OrdNotInterface.WebGui`
+- `OrdNotInterface.Fiori`
+
+## Resultado esperado
+
+Após a correção:
+
+- `WoNotInterface` passa a ser persistido como `''`, `G` ou `F`
+- `editorOption` deixa de depender da posição visual dos itens
+- `getSelectedKey()` substitui `getSelectedIndex()` no fluxo correto
+- a exibição dinâmica das opções não influencia mais o valor salvo
+
+## Cenários de validação
+
+- Somente opção padrão disponível:
+  - `editorOption` exibe apenas SIGGA P&S
+  - `WoNotInterface` salva `''`
+
+- WebGUI disponível:
+  - `editorOption` exibe SIGGA P&S e SAP WebGUI
+  - ao selecionar SAP WebGUI, `WoNotInterface` salva `G`
+
+- Fiori disponível:
+  - `editorOption` exibe SIGGA P&S e SAP Fiori
+  - ao selecionar SAP Fiori, `WoNotInterface` salva `F`
+
+- Combinações diferentes de opções visíveis:
+  - mesmo com ordem visual variável, `WoNotInterface` continua persistindo o valor correto
+
+- Reabertura da tela:
+  - o valor salvo volta corretamente selecionado via `setSelectedKey(...)` no `editorOption`
diff --git a/home.md b/home.md
new file mode 100644
index 0000000..f12e158
--- /dev/null
+++ b/home.md
@@ -0,0 +1,46 @@
+---
+title: Abap Wiki
+description: Wiki para Abaps
+published: true
+date: 2026-07-13T13:29:01.441Z
+tags: 
+editor: markdown
+dateCreated: 2024-11-26T21:44:49.076Z
+---
+
+# Abap Wiki
+Teste de pagina!!
+
+![screenshot_545.png](/screenshot_545.png)
+
+
+```python
+import pyautogui
+import time
+
+# Tempo entre movimentos (em segundos)
+intervalo = 10
+
+# Distância do movimento do mouse
+movimento = 50
+
+print("Programa iniciado. Pressione CTRL + C para parar.")
+
+try:
+    while True:
+        # Pega posição atual do mouse
+        x, y = pyautogui.position()
+
+        # Move o mouse levemente
+        pyautogui.moveTo(x + movimento, y, duration=1.2)
+        pyautogui.moveTo(x, y, duration=1.2)
+
+        print(f"Mouse movido às {time.strftime('%H:%M:%S')}")
+
+        # Aguarda próximo ciclo
+        time.sleep(intervalo)
+
+except KeyboardInterrupt:
+    print("Programa encerrado pelo usuário.")
+
+```
\ No newline at end of file
diff --git a/logo.png b/logo.png
new file mode 100644
index 0000000..c527996
Binary files /dev/null and b/logo.png differ
diff --git a/screenshot_545.png b/screenshot_545.png
new file mode 100644
index 0000000..bf2c635
Binary files /dev/null and b/screenshot_545.png differ