Histórico da Página

...

Verifique se a entidade sobre a qual a API atuará possui uma transação já definida no repositório de mensagens padronizadas TOTVS. No TFS, acesse a Project Collection TOTVSMSGXML (http://tfs2015.totvs.com.br:8080/tfs/TOTVSMSGXML).
1. Consulte o repositório de mensagens padronizadas em formato JSON. Primeiramente, a pasta STABLE/messages-json/jsonschema, depois a pasta DEV/messages-json/jsonschema.
2. Se não encontrar uma transação, verifique consulte o repositório de mensagens em formato XML, verificando as pastas STABLE/messages-xml/xmlschema e DEV/messages-xml/xmlschema.
3. Selecione, sempre que possível, a maior versão da transação.
Existindo apenas no repositório XML uma transação compatível apenas no repositório XML, deve-se criar o documento OpenAPI (antigo Swagger) equivalente ao documento XSD.
1. O documento OpenAPI deve ser armazenado no TFS, na pasta DEV/messages-json/jsonschema.
2. O modelo de dados pode ser segmentado em blocos menores, desde que obedeçam a estrutura hierárquica e tenham apenas os atributos previstos no documento XSD. Caso a hierarquia seja alterada ou seja retirado ou adicionado campos no modelo, isso implica em uma nova versão da transação. Exemplos de segmentação serão mostrados adiante neste documento.
Havendo necessidade de se criar uma nova versão da transação, esta pode ser criada apenas no repositório JSON, desde que se siga as orientações previstas na documentação de elaboração de mensagem padronizada SOAP/XML, realizando os devidos ajustes para o formato JSON.
1. Lembrando que as versões devem começar de 2.000 pois, por convenção, foi a partir dela desta que se iniciou o uso de InternalId.
Modelar o documento OpenAPI seguindo as orientações para elaboração de mensagem padronizada REST/JSON.
1. A versão da transação fará parte do endpoint da API. Assim, será possível indicar aos clientes das APIs qual o modelo de dados em uso.
  Modelo: http://<servidor>:<porta>/api/<produto>/<modulo>/<versao_transacao>/<nome_transacao>.
  Exemplo: http://api.totvs.com.br:8080/api/datasul/financeiro/v2.004/accountantAccounts.
2. Conforme visto acima, o nome da transação deve ser no plural, para manter consistência com o guia de implementação de APIs.
Submeter o documento OpenAPI ao comitê de integrações para análise e aprovação.
1. Enviar e-mail para [email protected] contendo as seguintes informações:
  1. Nome e versão da transação.
  2. Caminho, no TFS, do documento que modela a transação, seja ele em formato XSD ou OpenAPI.
  3. Data prevista para a reunião de homologação, que deve ser marcada com, no mínimo, 1 semana de antecedência, para que o comitê tenha tempo para avaliar a mensagem proposta.
2. Assim que a prática de modelar mensagens em formato JSON estiver consolidada, pode-se adotar, futuramente, a homologação apenas por e-mail, como acontece atualmente com mensagens em formato XML.
Após aprovação da mensagem pelo comitê, o responsável pela modelagem deve mover o documento, no TFS, para a pasta STABLE/messages-json/jsonschema.

Segmentação do modelo de dados

Considerando Partindo de um modelo XML como base, veremos a seguir um exemplo de uma possível implementação de API usando segmentação do modelo de dados.

...

Entretanto, utilizar o modelo desta forma tem vários problemas como, por exemplo, para fazer a na modificação do contrato, onde teríamos que enviar também as páginas (Sheet) do contrato e os itens das páginas.

Por isso, a segmentação do modelo de dados é permitida, desde que mantenha a estrutura e atributos do modelo XML original.

Nosso modelo OpenAPI poderia ser quebrado segmentado em 3 submodelos:

ContractModel, correspondente ao cabeçalho do contrato.
SheetModel, correspondente às folhas do contrato.
ItemModel, correspondente aos itens vinculados às folhas do contrato.

Convertendo isso para o modelo OpenAPI, teríamos o seguinte:, lembrando que elementos como as tags de documentação foram omitidos por questões didáticas.

Bloco de código

language	js
title	Contract 2.000 - OpenAPI - segmentado
collapse	true

{
  "openapi": "3.0.0",
  "info": {
    "description": "Contrato",
    "version": "2.000",
    "title": "Contract",
    "contact": {
      "name": "T-Talk"
    }
  },
  "paths": {
    "/Contract": {
      "get": {
        "operationId": "contractgetall",
        "description": "Obtem os contratos",
        "responses": {
          "200": {
            "description": "Resposta OK",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ContractModel"
                }
              }
            }
          }
        }
      }
    }
  },
  "servers": [{
      "url": "http://api.totvs.com.br/"
    }
  ],
  "components": {
    "schemas": {
      "ContractModel": {
        "type": "object",
        "properties": {
          "CompanyId": {
            "type": "string"
          },
          "BranchId": {
            "type": "string"
          },
          "CompanyInternalId": {
            "type": "string"
          },
          "InternalId": {
            "type": "string"
          },
          "ContractNumber": {
            "type": "string"
          },
          "ContractReview": {
            "type": "string"
          },
          "ProjectInternalId": {
            "type": "string"
          },
          "BeginDate": {
            "type": "string",
            "format": "date-time"
          },
          "FinalDate": {
            "type": "string",
            "format": "date-time"
          },
          "CustomerCode": {
            "type": "string"
          },
          "CustomerInternalId": {
            "type": "string"
          },
          "ContractTotalValue": {
            "type": "number",
            "format": "float"
          },
          "ContractTypeCode": {
            "type": "string"
          },
          "ContractTypeInternalId": {
            "type": "string"
          },
          "ListOfSheet": {
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/SheetModel"
            }
          }
        },
        "description": "Contrato"
      },
      "SheetModel": {
        "type": "object",
        "properties": {
          "SheetNumber": {
            "type": "string"
          },
          "SheetTypePoperty": {
            "type": "string"
          },
          "UnitPrice": {
            "type": "number",
            "format": "float"
          },
          "SheetTotalValue": {
            "type": "number",
            "format": "float"
          },
          "ListOfItem": {
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/ItemModel"
            }
          }
        }
      },
      "ItemModel": {
        "type": "object",
        "properties": {
          "ItemCode": {
            "type": "string"
          },
          "ItemInternalId": {
            "type": "string"
          },
          "AccountantAcountCode": {
            "type": "string"
          },
          "AccountantAcountInternalId": {
            "type": "string"
          },
          "CostCenterCode": {
            "type": "string"
          },
          "CostCenterInternalId": {
            "type": "string"
          },
          "AccountingItemCode": {
            "type": "string"
          },
          "AccountingItemInternalId": {
            "type": "string"
          },
          "ClassValueCode": {
            "type": "string"
          },
          "ClassValueInternalId": {
            "type": "string"
          },
          "ItemQuantity": {
            "type": "number",
            "format": "float"
          },
          "ItemUnitPrice": {
            "type": "number",
            "format": "float"
          },
          "ItemTotalValue": {
            "type": "number",
            "format": "float"
          },
          "PercentageOfDiscount": {
            "type": "number",
            "format": "float"
          }
        }
      }
    }
  }
}

Consequentemente, esta segmentação será refletida nos endpoints das APIs. Tomando por base a divisão realizada, teríamos o seguinte template:

/v2.000/Contracts/{ContractNumber}/Sheets/{SheetNumber}/Items/{ItemCode}

Neste template, temos as seguintes considerações:

No nível de Contracts utilizamos o submodelo ContractModel. Nos atributos ListOfSheet e ListOfItem, utilizamos os submodelos SheetModel e ItemModel quando os mesmos forem expandidos.
No nível de Sheets, utilizamos apenas o submodelo SheetModel. O modelo ItemModel será utilizado quando o atributo ListOfItem for expandido.
No nível de Items, utilizamos apenas o submodelo ItemModel.

Nos exemplos a seguir veremos a utilização dos endpoints e seus respectivos modelos:

POST /v2.000/Contracts - para inclusão de contratos de forma completa.
GET /v2.000/Contracts - para recuperar a lista de contratos. Nesta chamada podemos retornar apenas os cabeçalhos. As folhas do contrato (Sheets) seriam um item a expandir, assim como os itens (Items).
GET /v2.000/Contracts/100?expand=ListOfSheet - para recuperar um contrato específico, expandindo o atributo ListOfSheet.
POST /v2.000/Contracts/100/Sheets - para incluir uma folha num contrato existente.
DELETE /v2.000/Contracts/100/Sheets/2/Items/1 - para eliminar o item 1 da folha 2 do contrato 100.

Atalhos

Páginas filhas

Versões comparadas

Versão antiga 2

Nova versão 3

Chave

Segmentação do modelo de dados

Artigos relacionados