Erro B2B - NFe 10.0

[Former Member]

Boa tarde pessoal,

Estou implementando o desenvolvimento sugerido pelo Henrique no documento: http://scn.sap.com/docs/DOC-1719

e me deparei com o mesmo erro relatado pelo Rodrigo na thread: http://scn.sap.com/thread/1449476.

Mas, observei que o objeto Interface Mapping do namespace 006, está diferente da versão 005a e também do documento fazendo com que esta implementação não funcione.

No Interface Mapping na versão 005a, tanto  Source quanto Target Message apontando para o objeto procNFe (confere com o documento e com a forma como o UDF foi desenvolvido).

No Interface Mapping na versão 006, Source e Target apontam para o objeto nfeProc.

Não sei se consegui ser clara.

Segue prints dos dois Interface Mappings.

005a

006

Alguém sabe se a implementação este documento deveria funcionar para a versão 10.0 do NFe?

Ou eu estou comendo alguma bola?

Agradeço qualquer ajuda.

Abraços e obrigada,

Luciana R.

[former_member193386 · Accepted solution]

Oi luciana

Tenho um javamapping pronto que usa o email do cliente no xml da NFe para enviala ao XIMail direto para o adaptador vc precisaria de duas coisas, primeiro importa o xsd abaixo no seu externo definitions pois ele que vai ser a saida do seu "NOVO MAPPING" direto para o adaptador:

<?xml version="1.0" encoding="ISO-8859-1"?>
  <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:xi="http://sap.com/xi/XI/Mail/30" targetNamespace="http://sap.com/xi/XI/Mail/30">
          <xs:element name="Mail">
                    <xs:annotation>
                              <xs:documentation>
                              Mail package for XI - Mail Adapter
                              </xs:documentation>
                    </xs:annotation>
                    <xs:complexType>
                              <xs:sequence>
                                        <xs:element name="Subject" type="xs:string" minOccurs="0">
                                                  <xs:annotation>
                                                            <xs:documentation>
                                                            optional subject line
                                                            </xs:documentation>
                                                  </xs:annotation>
                                        </xs:element>
                                        <xs:element name="From" type="xs:string" minOccurs="0">
                                                  <xs:annotation>
                                                            <xs:documentation>
                                                            optional sender email address (required for SMTP)
                                                            </xs:documentation>
                                                  </xs:annotation>
                                        </xs:element>
                                        <xs:element name="To" type="xs:string" minOccurs="0">
                                                  <xs:annotation>
                                                            <xs:documentation>
                                                            optional one or more receiver email addresses (required for SMTP)
                                                            </xs:documentation>
                                                  </xs:annotation>
                                        </xs:element>
                                        <xs:element name="Reply_To" type="xs:string" minOccurs="0">
                                                  <xs:annotation>
                                                            <xs:documentation>
                                                            optional reply-to email addresses
                                                            </xs:documentation>
                                                  </xs:annotation>
                                        </xs:element>
                                        <xs:element name="Content_Type" type="xs:string" minOccurs="0">
                                                  <xs:annotation>
                                                            <xs:documentation>
                                                            optional content type (default is text/plain)
                                                            </xs:documentation>
                                                  </xs:annotation>
                                        </xs:element>
                                        <xs:element name="Content_Description" type="xs:string" minOccurs="0">
                                                  <xs:annotation>
                                                            <xs:documentation>
                                                            optional content description
                                                            </xs:documentation>
                                                  </xs:annotation>
                                        </xs:element>
                                        <xs:element name="Content_Disposition" type="xs:string" minOccurs="0">
                                                  <xs:annotation>
                                                            <xs:documentation>
                                                            optional content disposition
                                                            </xs:documentation>
                                                  </xs:annotation>
                                        </xs:element>
                                        <xs:element name="Date" type="xs:dateTime" minOccurs="0">
                                                  <xs:annotation>
                                                            <xs:documentation>
                                                            optional date
                                                            </xs:documentation>
                                                  </xs:annotation>
                                        </xs:element>
                                        <xs:element name="Message_ID" type="xs:string" minOccurs="0">
                                                  <xs:annotation>
                                                            <xs:documentation>
                                                            optional message id
                                                            </xs:documentation>
                                                  </xs:annotation>
                                        </xs:element>
                                        <xs:element name="X_Mailer" type="xs:string" minOccurs="0">
                                                  <xs:annotation>
                                                            <xs:documentation>
                                                            optional mail program name
                                                            </xs:documentation>
                                                  </xs:annotation>
                                        </xs:element>
                                        <xs:element name="Content" minOccurs="0">
                                                  <xs:annotation>
                                                            <xs:documentation>
                                                            any mixed content type
                                                            </xs:documentation>
                                                  </xs:annotation>
                                        </xs:element>
                              </xs:sequence>
                              <xs:attribute name="encoding" type="xs:string">
                                        <xs:annotation>
                                                  <xs:documentation>
                                                  optional encoding name (base64, quoted-printable)
                                                  </xs:documentation>
                                        </xs:annotation>
                              </xs:attribute>
                    </xs:complexType>
          </xs:element>
          <xs:element name="MailReceipt">
                    <xs:annotation>
                              <xs:documentation>
                              Mail Receipt for XI - Mail Adaper
                              </xs:documentation>
                    </xs:annotation>
                    <xs:complexType>
                              <xs:sequence>
                                        <xs:element name="Server" type="xs:string">
                                                  <xs:annotation>
                                                            <xs:documentation>
                                                            Server URL
                                                            </xs:documentation>
                                                  </xs:annotation>
                                        </xs:element>
                                        <xs:element name="Greeting" type="xs:string">
                                                  <xs:annotation>
                                                            <xs:documentation>
                                                            Server Greeting Message
                                                            </xs:documentation>
                                                  </xs:annotation>
                                        </xs:element>
                                        <xs:element name="Format" type="xs:string">
                                                  <xs:annotation>
                                                            <xs:documentation>
                                                            Message Format XIALL or XIPAYLOAD
                                                            </xs:documentation>
                                                  </xs:annotation>
                                        </xs:element>
                                        <xs:element name="UseMailPackage" type="xs:boolean">
                                                  <xs:annotation>
                                                            <xs:documentation>
                                                            Mail Package Flag
                                                            </xs:documentation>
                                                  </xs:annotation>
                                        </xs:element>
                                        <xs:element name="Encoding" type="xs:string">
                                                  <xs:annotation>
                                                            <xs:documentation>
                                                            Encoding name
                                                            </xs:documentation>
                                                  </xs:annotation>
                                        </xs:element>
                                        <xs:element name="Subject" type="xs:string" minOccurs="0">
                                                  <xs:annotation>
                                                            <xs:documentation>
                                                            Mail Subject
                                                            </xs:documentation>
                                                  </xs:annotation>
                                        </xs:element>
                                        <xs:element name="From" type="xs:dateTime" minOccurs="0">
                                                  <xs:annotation>
                                                            <xs:documentation>
                                                            Mail From
                                                            </xs:documentation>
                                                  </xs:annotation>
                                        </xs:element>
                                        <xs:element name="To" type="xs:string" minOccurs="0">
                                                  <xs:annotation>
                                                            <xs:documentation>
                                                            Mail To
                                                            </xs:documentation>
                                                  </xs:annotation>
                                        </xs:element>
                                        <xs:element name="Date" type="xs:dateTime" minOccurs="0">
                                                  <xs:annotation>
                                                            <xs:documentation>
                                                            Mail date
                                                            </xs:documentation>
                                                  </xs:annotation>
                                        </xs:element>
                                        <xs:element name="MailID" type="xs:string" minOccurs="0">
                                                  <xs:annotation>
                                                            <xs:documentation>
                                                            Mail ID
                                                            </xs:documentation>
                                                  </xs:annotation>
                                        </xs:element>
                              </xs:sequence>
                    </xs:complexType>
          </xs:element>
          <xs:element name="FetchReport">
                    <xs:annotation>
                              <xs:documentation>
                              Fetch Report for XI - Mail Adaper
                              </xs:documentation>
                    </xs:annotation>
                    <xs:complexType>
                              <xs:sequence>
                                        <xs:element name="Server" type="xs:string">
                                                  <xs:annotation>
                                                            <xs:documentation>
                                                            Server URL
                                                            </xs:documentation>
                                                  </xs:annotation>
                                        </xs:element>
                                        <xs:element name="Greeting" type="xs:string">
                                                  <xs:annotation>
                                                            <xs:documentation>
                                                            Server Greeting Message
                                                            </xs:documentation>
                                                  </xs:annotation>
                                        </xs:element>
                                        <xs:element name="User" type="xs:string">
                                                  <xs:annotation>
                                                            <xs:documentation>
                                                            User Name
                                                            </xs:documentation>
                                                  </xs:annotation>
                                        </xs:element>
                                        <xs:element name="Date" type="xs:dateTime" minOccurs="0">
                                                  <xs:annotation>
                                                            <xs:documentation>
                                                            Mail Date
                                                            </xs:documentation>
                                                  </xs:annotation>
                                        </xs:element>
                                        <xs:element name="Messages" type="xi:FetchedMessages">
                                                  <xs:annotation>
                                                            <xs:documentation>
                                                            Mail Messages
                                                            </xs:documentation>
                                                  </xs:annotation>
                                        </xs:element>
                              </xs:sequence>
                    </xs:complexType>
          </xs:element>
          <xs:complexType name="FetchedMessages">
                    <xs:sequence>
                              <xs:element name="item" type="xi:FetchedMessage" minOccurs="0" maxOccurs="unbounded" />
                    </xs:sequence>
                    <xs:attribute name="new" type="xs:int">
                              <xs:annotation>
                                        <xs:documentation>
                                        the number of new messages found
                                        </xs:documentation>
                              </xs:annotation>
                    </xs:attribute>
                    <xs:attribute name="total" type="xs:int">
                              <xs:annotation>
                                        <xs:documentation>
                                        the number of total messages found
                                        </xs:documentation>
                              </xs:annotation>
                    </xs:attribute>
          </xs:complexType>
          <xs:complexType name="FetchedMessage">
                    <xs:sequence>
                              <xs:element name="Subject" type="xs:string">
                                        <xs:annotation>
                                                  <xs:documentation>
                                                  Mail Subject
                                                  </xs:documentation>
                                        </xs:annotation>
                              </xs:element>
                              <xs:element name="From" type="xs:string">
                                        <xs:annotation>
                                                  <xs:documentation>
                                                  Mail From
                                                  </xs:documentation>
                                        </xs:annotation>
                              </xs:element>
                              <xs:element name="To" type="xs:string">
                                        <xs:annotation>
                                                  <xs:documentation>
                                                  Mail To
                                                  </xs:documentation>
                                        </xs:annotation>
                              </xs:element>
                              <xs:element name="Message_ID" type="xs:string">
                                        <xs:annotation>
                                                  <xs:documentation>
                                                  Mail ID
                                                  </xs:documentation>
                                        </xs:annotation>
                              </xs:element>
                    </xs:sequence>
                    <xs:attribute name="status" type="xs:string">
                              <xs:annotation>
                                        <xs:documentation>
                                        the status of XI processing
                                        </xs:documentation>
                              </xs:annotation>
                    </xs:attribute>
                    <xs:attribute name="id" type="xs:string">
                              <xs:annotation>
                                        <xs:documentation>
                                        the XI message ID associated with the mail message
                                        </xs:documentation>
                              </xs:annotation>
                    </xs:attribute>
          </xs:complexType>
</xs:schema>

depois pelo eclipse, gere esse JavaMapping ( exporte para jar ), pesquise no SCN sobre as libs de javammapping que vai precisar importar tbem e como usar o eclipse:

package nfe.custom;
import java.io.BufferedReader;
//import java.io.FileInputStream;
//import java.io.FileOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.util.Map;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Text;
import com.sap.aii.mapping.api.StreamTransformation;
import com.sap.aii.mapping.api.StreamTransformationException;
import com.sap.aii.mapping.lookup.*;
public class B2B_Outbound_Custom implements StreamTransformation  {
          //INI-------------------------------------------------------------
          // Configuracoes quando necessitar usar RFC Lookup
          static String BSystem = "nome do BS do CC RFC";
          static String CChannel = "nome do CC RFC";
          public String getBSystem() {
                    return BSystem;
          }
          public String getCChannel() {
                    return CChannel;
          }
          //END-----------------------------------------------------------
/*          public static void main(String args[]) throws Exception {
                    FileInputStream inFile = new FileInputStream("C:/testes/xmlIn.XML");
                    FileOutputStream outFile = new FileOutputStream("C:/testes/xmlout.XML");
                    B2B_Outbound_Custom xml = new B2B_Outbound_Custom();
                    xml.execute(inFile, outFile);
                    System.out.println("Success");
          }
*/
          public void execute(InputStream in, OutputStream out)
                              throws StreamTransformationException {
                    try{
                              //Transforma mensagem em entrada em string ----INICIO
                              BufferedReader inpxml = new BufferedReader(
                                                  new InputStreamReader(in));
                              StringBuffer buffer = new StringBuffer();
                              String line = "";
                              while ((line = inpxml.readLine()) != null) {
                                        buffer.append(line);
                              }
                              String inptxml = buffer.toString();
                              //Obtendo dados para o envio de e-mail
                              String idNFe = "";
                              String email = "";
                              idNFe = inptxml.substring(inptxml.indexOf("Id=\"NFe")+7,inptxml.indexOf("Id=\"NFe")+52);
                              String temp = inptxml;
                              while( temp.indexOf("<email") > 0){
                                        if ( email.length()>0 ) email += ";";
                                        email = temp.substring(temp.indexOf("<email>")+7,temp.indexOf("</email>"));
                                        temp = temp.substring(temp.indexOf("</email>")+8);
                              }
                              //monta XML de saida XiMail 
                              DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance(); 
                              DocumentBuilder db = dbf.newDocumentBuilder();
                              TransformerFactory tf = TransformerFactory.newInstance();
                              Transformer transform = tf.newTransformer();
                              //Cria escopo do XML
                              Document docout = db.newDocument();
                              Element root = docout.createElement("ns1:Mail");
                              root.setAttribute("xmlns:ns1", "http://sap.com/xi/XI/Mail/30");
                              docout.appendChild(root);
                              //Cria elemento Subject
                              Element subject = docout.createElement("Subject");
                              root.appendChild(subject);
                              Text subjectText = docout.createTextNode("NFe ID - " + idNFe); //Cria valor campo 
                              subject.appendChild(subjectText);
                              //Cria elemento From
                              Element from = docout.createElement("From");
                              root.appendChild(from);
                              Text fromText = docout.createTextNode("nfe@empresa.com.br"); //Cria valor campo 
                              from.appendChild(fromText);
                              //Cria elemento To
                              Element to = docout.createElement("To");
                              root.appendChild(to);
                              Text toText = docout.createTextNode(email); //Cria valor campo 
                              to.appendChild(toText);
                              //Cria elemento Content Type
                              Element contentType = docout.createElement("Content_Type");
                              root.appendChild(contentType);
                              Text contentTypeText = docout.createTextNode("NFe" + idNFe + ".xml"); //Cria valor campo 
                              contentType.appendChild(contentTypeText);
                              //gera content
                              String contentTmp = inptxml.substring(inptxml.indexOf("<NFe>"),inptxml.indexOf("</NFe>") +6);
                              //Cria elemento Content Type
                              Element content = docout.createElement("Content");
                              root.appendChild(content);
                              Text contentText = docout.createTextNode(contentTmp); //Cria valor campo 
                              content.appendChild(contentText);
                              //Fecha o XML
                              DOMSource domS = new DOMSource(docout);
                              transform.transform((domS), new StreamResult(out));
                    } catch (IOException e) {
                              // TODO Auto-generated catch block
                              e.printStackTrace();
                    } catch (ParserConfigurationException e) {
                              // TODO Auto-generated catch block
                              e.printStackTrace();
                    } catch (TransformerConfigurationException e) {
                              // TODO Auto-generated catch block
                              e.printStackTrace();
                    } catch (TransformerException e) {
                              // TODO Auto-generated catch block
                              e.printStackTrace();
                    }
          }
          public void setParameter(Map arg0) {
                    // TODO Auto-generated method stub
          }
}

Com tudo em maos, basta vc modificar o operation Mapping para que fique da maneira esperada na saida nova da mensage e configurar o scenario

[former_member182114 · Accepted solution]

Bom dia Carlos,

No SCN novo você pode anexar arquivos como .TXT o que para textos grandes simplifica a exibição de um código grande assim, além de facilitar a quem interessar usar o código sem ter que "limpar" a numeração de linhas...

Bom, mas isso é apenas para ficar melhor ainda, continue contribuindo.

Atenciosamente, Fernando Da Rós

[former_member193386 · Accepted solution]

claro claro fernando, apenas querendo ajudar o pessoal com as coisas que eu vou descobrindo com a ajuda de vcs

[henrique_pinto · Accepted solution]

Oi Carlos,

na mesma linha do que falamos na outra thread pro Java Mapping, talvez o ideal fosse colocar esse código do XSD num Document e apenas referenciá-lo aqui e nas outras mensagens onde for relevante.

Não precisa colocar o código no corpo da mensagem, pois ficou bem grande.

Show de bola as contribuições.

[Former Member · Accepted solution]

Muito obrigada Rodrigo!!!!!!

Abraços,

Luciana R.

[Former Member]

Olá Carlos,

Estamos implantando a NFE 10.0 e estou com algumas dúvidas no B2B. Vi as suas dicas, de grande valia, mas não consegui chegar num resultado ok.

Eu criei o Java Mapping, está funcionando quando eu testo no Interface Mapping.

Mas quando eu crio a nota o resultado não está ok.

No Canal de Comunicação não estou usando o "Use Mail Package", só que o XML que vai em anexo são os próprios atributos dele, veja abaixo/anexo:

Está faltando fazer alguma configuração/desenvolvimento no canal de comunicação?

Obrigado,

André Vilela.

[former_member193386]

André,

Poderia por favor abrir uma nova thread, dessa maneira fica mais limpo a ajuda o pessoal vai te dar para esse problema

[Former Member]

Carlos,

Pesquisei nos XML´s das minhas notas e não encontrei em nenhuma a TAG mail preenchida.

Nesse caso a solução que você deu não funcionaria. É preciso realizar algum customize no SAP ou GRC para que a tag mail seja preenchida no XML da nota?

[Former Member]

Oi Mariano,

A tag <email> não é enviada automaticamente. É necessário implementar a badi CL_NFE_PRINT/ZCL_NFE_PRINT (método  FILL_HEADER e FILL_ITEM)  para que esta informação chegue no GRC.

Luciana R.

[Former Member]

Bom dia Luciana,

Na versão 10.0 existe um Java Mapping de nome ProxyNamespaceCleaner.java, ele é utilizado para limpar os namespaces gerados pelo ABAP Proxy e transformar no layout correto para envio de e-mail.

Você deve utiliza-lo no seu desenvolvimento conforme a imagem abaixo:

Espero ter ajudado.

Atenciosamente

Marcelo Macedo

[former_member193386]

E ai Marcelo, beleza ? Lembra de mim do projeto da SADIA, entao cara, essse javammaping vc só usa se vc nao usar o XIPAYLOAD, que é mais simples e te da mais opcao.

[Former Member]

Ola Carlos, tudo bem, quanto tempo!!!!

O exemplo que eu fiz para vários clientes além de enviar/montar o corpo do e-mail com o xml renomeado também envio um pdf, fiz um BPM para realizar esta tarefa e por isto ficou um pouco diferente do exemplo do Henrique.

Por isso que eu utilizei este Java Mapping.

Abraços

Marcelo Macedo

[henrique_pinto]

Olá Luciana,

de fato, há um gap entre o guide feito à época para o NFE 1.0 e a necessidade atual do NFE 10.0 (nao depende da versao de layout 005a ou 006, mas sim da versao do produto).

No NFE 10.0, como você notou, a interface ABAP Proxy NTB2B traz o XML aberto e não como string, como no NFE 1.0. Por isso, a estrutura (interface) origem é diferente. Ainda, por isso, não dá pra fazer trivialmente dynamic configuration no mapping usando Message Mapping, senão é possível que o arquivo (e a assinatura digital) seja corrompido. A sugestão seria usar um Java ou ABAP Mapping para copiar o payload da mensagem origem para o destino sem modificá-la e alimentar os message headers de Dynamic Configuration.

Abs,

Henrique.