Caso de uso do Gerenciador de transações: Geração de documentos com o Documentos do Google

Gere documentos do Gerenciador de transações usando o Documentos do Google e o Script do Google Apps.

Para gerar um documento do Gerenciador de transações, o Documentos do Google combinados com o Script do Google Apps fornece uma solução eficiente e direta. Ao criar APIs personalizadas usando o script de apps, você pode receber facilmente solicitações de GET e POST de um URL direto. Isso elimina a necessidade de middleware, simplificando a integração com serviços como CPQ Ou Gerenciador de transações.

Você pode acionar a geração de documentos por um destes métodos:

• CPQ Webhook: Envia automaticamente solicitações POST para iniciar a criação de documentos.
• Gerenciador de transações: Use isso para gerenciar e automatizar processos.

Configurando um documento do Google para extrair CPQ dados

Para acessar a janela do desenvolvedor, abra o documento do Google onde você deseja integrar o script. Na barra de menus, vá para Extensões > Script de aplicações para abrir o ambiente de desenvolvimento.

Você pode escrever JavaScript personalizado para processar dados e interagir com o Documentos do Google usando o editor de scripts de apps.

Codificação

O script do Google Apps inclui solicitações GET e POST.

• OBTER solicitações ( DoGet ) responda com uma saída de texto simples, útil para verificar se o app web está em execução.
• Solicitações DE PUBLICAÇÃO ( Postar ) Manipule dados de entrada (geralmente JSON), gera o documento com base no modelo e retorna um link para o documento recém-criado.

Isso vídeo explica como DoGet e. Postar Trabalhar em um script do app Documentos do Google.

Ao usar o Gerenciador de transações, você precisa transformar o JSON para enviá-lo para o Documentos do Google. Abaixo está um modelo de exemplo. Se você estiver usando um webhook, consulte Webhooks Para saber como os dados serão enviados para o Documentos do Google.

O bloco de código a seguir mostra um modelo de transformação de exemplo, enviado como POST para a função doPost.

{ 
  "transaction": { 
    "uuid": "{{txn.uuid}}", 
    "term": {{txn.term}}, 
    "stage": "{{txn.stage}}", 
    "status": "{{txn.status}}", 
    "account": "{{txn.account}}", 
    "endDate": "{{txn.endDate}}", 
    "netTotal": {{txn.netTotal}}, 
    "termUnit": "{{txn.termUnit}}", 
    "createdBy": "{{txn.createdBy}}", 
    "quoteName": "{{txn.quoteName}}", 
    "startDate": "{{txn.startDate}}", 
    "accountName": "{{txn.accountName}}", 
    "createdDate": "{{txn.createdDate}}", 
    "opportunity": "{{txn.opportunity}}", 
    "paymentTerm": "{{txn.paymentTerm}}", 
    "quoteNumber": "{{txn.quoteNumber}}", 
    "contractTerm": {{txn.contractTerm}}, 
    "contractType": "{{txn.contractType}}", 
    "currencyCode": "{{txn.currencyCode}}", 
    "estTaxAmount": {{txn.estTaxAmount}}, 
    "modifiedDate": "{{txn.modifiedDate}}", 
    "billToAddress": "{{txn.billToAddress}}", 
    "hardwareTotal": {{txn.hardwareTotal}}, 
    "servicesTotal": {{txn.servicesTotal}}, 
    "shipToAddress": "{{txn.shipToAddress}}", 
    "softwareTotal": {{txn.softwareTotal}}, 
    "discountAmount": {{txn.discountAmount}}, 
    "expirationDate": "{{txn.expirationDate}}", 
    "lastModifiedBy": "{{txn.lastModifiedBy}}", 
    "primaryContact": "{{txn.primaryContact}}", 
    "customerSegment": "{{txn.customerSegment}}", 
    "discountPercent": {{txn.discountPercent}}, 
    "transactionType": "{{txn.transactionType}}", 
    "estTaxPercentage": {{txn.estTaxPercentage}}, 
    "agreementDiscount": {{txn.agreementDiscount}}, 
    "taxEntityLocation": "{{txn.taxEntityLocation}}", 
    "transactionNumber": {{txn.transactionNumber}}, 
    "totalPriceEstimate": {{txn.totalPriceEstimate}}, 
    "overallDealDiscount": {{txn.overallDealDiscount}}, 
    "annualTransactionBands": "{{txn.annualTransactionBands}}", 
    "annualTransactionCount": {{txn.annualTransactionCount}}, 
    "accountSpecificDiscount": {{txn.accountSpecificDiscount}} 
  },   
  "lines": [
  {{#each lines}} 
    { 
      "uuid": "{{txn.line.uuid}}", 
      "productInfo": {
        "productId": "{{txn.line.productId}}",
        "productSku": "{{txn.line.productSku}}",
        "productCode": "{{txn.line.productCode}}",
        "productName": "{{txn.line.productName}}",
        "productType": "{{txn.line.productType}}",
        "productDescription": "{{txn.line.productDescription}}"
      },
      "pricing": {
        "netPrice": {{txn.line.netPrice}},
        "listPrice": {{txn.line.listPrice}},
        "discountAmount": {{txn.line.discountAmount}},
        "discountPercent": {{txn.line.discountPercent}},
        "netTotal": {{txn.line.netTotal}},
        "customerLineDiscount": {{txn.line.customerLineDiscount}},
        "agreementLineDiscount": {{txn.line.agreementLineDiscount}}
      },
      "dates": {
        "startDate": "{{txn.line.startDate}}",
        "endDate": "{{txn.line.endDate}}",
        "createdDate": "{{txn.line.createdDate}}",
        "modifiedDate": "{{txn.line.modifiedDate}}"
      },
      "quantity": {{txn.line.quantity}},
      "currencyCode": "{{txn.line.currencyCode}}",
      "configUUID": "{{txn.line.configUUID}}",
      "orderDetails": {
        "globalOrder": {{txn.line.globalOrder}},
        "orderNumber": {{txn.line.orderNumber}},
        "transactionLineNumber": {{txn.line.transactionLineNumber}}
      },
      "termDetails": {
        "term": {{txn.line.term}},
        "termUnit": "{{txn.line.termUnit}}",
        "termMultiplier": {{txn.line.termMultiplier}}
      },
      "approvals": "{{txn.line.approvals3}}",
      "lastModifiedBy": "{{txn.line.lastModifiedBy}}"
    }
    {{#unless @last}},{{/unless}} 
  {{/each}}
  ]
}

Se você não definir DoGet E tente acessar o URL, você receberá um erro. Se não estiver usando o. DoGet para outros fins, é melhor sempre defini-lo para o seguinte e apenas modificar o texto.

function doGet(e) {
  return ContentService.createTextOutput('Logik Transaction Manager Document Generation Web App is running.');
}

Ao acessar o URL dinâmico, você recebe esta mensagem:

. Postar É importante, porque provavelmente processará as cargas do webhook ou de integração que estão sendo enviadas CPQ Por meio de solicitações POST.

Em seguida, criamos uma função para gerar um documento do Google usando o. Postar função.

No script do Google Apps, o. Postar A função receberá uma solicitação POST contendo dados (no formato JSON) que você deseja preencher em um modelo do Google Doc. A lógica principal para interagir com o Google Doc (ou seja, substituir espaços reservados como (EXEMPLO) com valores reais) serão colocados em uma função separada que é chamada de Postar .

Para configurar o. Postar , defina o. Postar Função para lidar com solicitações POST recebidas e chamar sua função de geração de documentos personalizada. Abaixo está um exemplo de como estruturá-lo.

function doPost(e) {
  // Parse the JSON data from the POST request
  const postData = JSON.parse(e.postData.contents);

  // Call the function to create and populate the Google Doc
  const docLink = createGoogleDocFromTemplate(postData);

  // Return the public link to the generated document in the response
  return ContentService.createTextOutput(docLink);
}

Neste código:

• . PostData O objeto contém os dados analisados enviados na solicitação POST.
• CriateGoogleDocFromTemplate(postData) É a função que você definirá para lidar com a geração do Documentos do Google.
• . DocLink É o link público para o documento do Google gerado, retornado ao chamador.

Em seguida, crie a função de geração de documento. . CriateGoogleDocFromTemplate a função:

1. Faça uma cópia de um modelo do Google Doc.
2. espaços reservados de substituição (por exemplo, (EXEMPLO) ) no documento com os dados correspondentes.
3. retorne um link público para o documento gerado.

O bloco de código a seguir mostra um exemplo CriateGoogleDocFromTemplate função:

function createGoogleDocFromTemplate(data) {
  // Specify the ID of the Google Doc template
  var templateId = 'YOUR_TEMPLATE_DOC_ID_HERE';
  // Make a copy of the template
  var templateDoc = DriveApp.getFileById(templateId).makeCopy();
  var doc = DocumentApp.openById(templateDoc.getId());
  var body = doc.getBody();
  // Replace placeholders with actual data from the POST request
  body.replaceText('{{ACCOUNT_NAME}}', data.transaction.accountName);
  body.replaceText('{{QUOTE_NUMBER}}', data.transaction.quoteNumber);
  body.replaceText('{{USER}}', data.transaction.createdBy);
  // Continue to replace all other placeholders...
  // Save and close the document
  doc.saveAndClose();
  // Make the document public (optional, based on your needs)
  templateDoc.setSharing(DriveApp.Access.ANYONE, DriveApp.Permission.VIEW);
  // Return the public link to the newly created document
  return templateDoc.getUrl();
}

Nesta função:

• A variável templateId armazena o ID do modelo do Google Doc. Você deve substituir "SEU_TEMPLATE_DOC_ID_HERE" Com o ID real do seu modelo.
• MakeCopy() cria uma cópia do modelo.
• ReplaceText(', data.key) Substitui cada espaço reservado no documento por dados reais da solicitação POST DE entrada. Por exemplo, (ACCOUNT_NAME) é substituído por Nome.transaction.accountName .
• O documento é tornado público com SetSharing() , mas você pode ajustar as configurações de compartilhamento conforme necessário.

Registro em Log

O Script do Google Apps oferece registro em log integrado via Logger.log() para depuração, mas um registro em log melhor está disponível no Logs do Google Cloud. Para acessar logs:

Vá para > Exibição > Execuções para verificar as saídas do seu script. Em seguida, conete seu projeto à Google Cloud Platform para exibir os logs.

No Explorador de logs do Google Cloud, aplique o filtro "app_script_function" para exibir logs relacionados ao seu app.

Implantação

• Clique no botão "Implantar" no canto superior direito do editor de scripts de apps.
• Selecione "Implantar como app web".
• Defina a versão do projeto (você pode criar uma nova).
• Defina quem pode acessar o app:
  • Executar como: Isso deve ser definido como Eu, para que o script seja executado com suas permissões.
  • Quem tem acesso: Escolha "Qualquer um" (público).

  

Uma vez implantado, você receberá um URL terminando em /exec para uso em tempo real e. /dev para testes. Este é o URL que os usuários direcionarão para acionar o. DoGet Ou enviar solicitações DE POST para acionar Postar .

Nos exemplos a seguir, as reticências (...) representam o número exclusivo do script da aplicação para seu script.

• Em tempo real: https://script.google.com/macros/s/.../exec
• Desv: https://script.google.com/macros/s/.../dev

Se você quiser testar suas mudanças antes de enviá-las ao vivo, use a URL de desenvolvimento para testar seu script com dados reais.

Cada vez que você reimplantar, será necessário criar uma nova versão do script. Siga estas etapas:

1. No editor de scripts do Google Apps, clique em Implantar no canto superior direito.
2. Selecione Gerencie implantações no menu.
3. Na janela Implantações, clique em Editar na implantação existente ou crie uma nova implantação.
4. Clique em Selecione Versão e clique em Nova versão .

Na janela pop-up, você pode dar um nome ou uma descrição à sua versão. Isso é opcional, mas útil para acompanhar mudanças. Clique em Salvar para criar a nova versão.

Para exibir ou gerenciar suas implantações atuais:

1. No editor de scripts do Google Apps, clique em Implantar .
2. Selecione Gerencie implantações . Aqui, você verá todas as versões ativas do seu script.
3. Você pode editar, excluir ou reimplantar qualquer versão clicando no menu de três pontos ao lado da versão.

• Editar: Atualize uma implantação existente para apontar para uma nova versão.
• Excluir: Remova a implantação totalmente (Observação: O link em tempo real deixará de funcionar se a implantação for excluída).

Se necessário, você pode reverter para uma versão mais antiga do seu app web:

1. Ir para Implantar > Gerenciar implantações.
2. Encontre a versão anterior para a qual você deseja retornar e clique em Editar .
3. Selecione a versão anterior no menu Selecionar versão.
4. Clique em Implantar para ativar a versão anterior.

Isso fornece uma maneira fácil de reverter quaisquer problemas que possam surgir com versões mais recentes.