ESR: Message and Java Mapping’s – in a Single Message Mapping!!

In this blog, I would like to share my recent experience with Graphical mapping in regards to having java mapping in it

For those who don’t know the concept of ‘having a java mapping within graphical mapping‘, please check Sunil Chandra‘s blog: Write Java Mapping directly in ESR!

We can also call graphical mapping using super.transform(TransformationInput in, TransformationOutput out) method from same graphical mapping as per  Daniel Graversen‘s blog: Hacking: To get error from the PI Mapping Mapping realtime.

So now the question is, can we club the above ‘two blog concepts in a single graphical mapping’ ?

(or)

Rather I would say, ‘can we have below operation mapping patterns in a single graphical mapping’ ?

Pattern1:

1) JavaMapping 2) GraphicalMapping

Pattern2:

1) GraphicalMapping 2) JavaMapping

Pattern3:

1) JavaMapping One 2) GraphicalMapping 3) JavaMapping Two

Well, it is not possible directly, and this is where this blog comes into picture

The solution is, we should override standard TransformationInput, TransformationOutput, InputPayload and OutputPayload classes with our own implementation code.

With a little bit experimentation I am able to achieve above patterns in a single graphical mapping. Please note that, the java code should be put under Graphical mapping –> Functions –> ‘Attributes and Methods’ section.

Please use only required pattern and remove/comment the rest of patterns as per your needs

Java Code:-

InputAttachments inputAttachments;
InputHeader inputHeader;
InputParameters inputParameters;
DynamicConfiguration dynamicConfiguration;
OutputAttachments outputAttachments;
OutputHeader outputHeader;
OutputParameters outputParameters;
public void transform(TransformationInput in, TransformationOutput out) throws StreamTransformationException{
  try
  {
  dynamicConfiguration = in.getDynamicConfiguration();
  inputAttachments = in.getInputAttachments();
  inputHeader = in.getInputHeader();
  inputParameters = in.getInputParameters();
  outputAttachments = out.getOutputAttachments();
  outputHeader = out.getOutputHeader();
  outputParameters = out.getOutputParameters();
  InputStream is = (InputStream) in.getInputPayload().getInputStream();
  /*
  * **************************** GuideLines for Java Mapping ********************************************************************
  * You can have java mapping code INLINE if it is few lines. And if it is a big and complex code, then I recommend to isolate
  * java mapping logic and develop it separately as a NORMAL java program. Import it as 'imported archive' and refer it in graphical mapping
  * And then call the externally developed public method here
  * Recommendation for external method signature: public ByteArrayOutputStream YourExtBussLogicMethod(InputStream is, ...)
  * **********************************************************************************************************************************
  */
  /*BEGIN ************************************************* PATTERN 1 (JM - GM) **************************************************/
  //Java Mapping: YourExtBussLogicMethod(is) code is nothing but your java mapping logic. You can also have INLINE code here
  ByteArrayOutputStream baos = YourExtBussLogicMethod(is);
  InputStream newInputStream = new ByteArrayInputStream(baos.toByteArray());
  InputPayloadImpl payloadInObj = new InputPayloadImpl(newInputStream);
  TransformationInputImpl transformInObj = new TransformationInputImpl(payloadInObj);
  //Graphical mapping called here
  super.transform(transformInObj, out);
  /*END ************************************************* PATTERN 1 (JM - GM) **************************************************/
  /*BEGIN ************************************************* PATTERN 2 (GM - JM)  **************************************************/
  InputPayloadImpl payloadInObj = new InputPayloadImpl(is);
  TransformationInputImpl transformInObj = new TransformationInputImpl(payloadInObj);
  OutputStream os = new ByteArrayOutputStream();
  OutPayloadImpl payloadOutObj = new OutPayloadImpl(os);
  TransformationOutputImpl transformOutObj = new TransformationOutputImpl(payloadOutObj);
  // Graphical mapping called here, but the transformed stream is written to intermediate ByteArrayOutputStream 'os'
  super.transform(transformInObj, transformOutObj);
  OutputPayload outPayload = transformOutObj.getOutputPayload();
  ByteArrayOutputStream baos1 = (ByteArrayOutputStream) outPayload.getOutputStream();
  InputStream is1 = new ByteArrayInputStream(baos1.toByteArray());
  //Java Mapping: This funciton code is nothing but your java mapping logic. You can also have INLINE code here
  ByteArrayOutputStream baos2 = YourExtBussLogicMethod(is1);
  // Finally write it to actual mapping runtime outputstream fetched from TransformationOutput
  out.getOutputPayload().getOutputStream().write(baos2.toByteArray())
  /*END ************************************************* PATTERN 2 (GM - JM) **************************************************/
  /*BEGIN ************************************************* PATTERN 3 (JM1 - GM - JM2) **************************************************/
  //Java Mapping1:This funciton code is nothing but your java mapping logic. You can also have INLINE code here
  ByteArrayOutputStream baos = YourExtBussLogicMethod1(is);
  InputStream newInputStream = new ByteArrayInputStream(baos.toByteArray());
  InputPayloadImpl payloadInObj = new InputPayloadImpl(newInputStream);
  TransformationInputImpl transformInObj = new TransformationInputImpl(payloadInObj);
  OutputStream os = new ByteArrayOutputStream();
  OutPayloadImpl payloadOutObj = new OutPayloadImpl(os);
  TransformationOutputImpl transformOutObj = new TransformationOutputImpl(payloadOutObj);
  // Graphical mapping called here, but the transformed stream is written to intermediate ByteArrayOutputStream 'os'
  super.transform(transformInObj, transformOutObj);
  OutputPayload outPayload = transformOutObj.getOutputPayload();
  ByteArrayOutputStream baos1 = (ByteArrayOutputStream) outPayload.getOutputStream();
  InputStream is1 = new ByteArrayInputStream(baos1.toByteArray());
  //Java Mapping2:This funciton code is nothing but your java mapping logic. You can also have INLINE code here
  ByteArrayOutputStream baos2 = YourExtBussLogicMethod2(is1);
  //Finally write it to actual mapping runtime outputstream 'out' fetched from TransformationOutput
  out.getOutputPayload().getOutputStream().write(baos2.toByteArray());
  /*END ************************************************* PATTERN 3 (JM1 - GM - JM2) **************************************************/
  }
  catch (Exception e){
  throw new StreamTransformationException(e.getMessage());
  }
}
class InputPayloadImpl extends InputPayload{
  InputStream in;
    public InputPayloadImpl(InputStream in){
  this.in = in;
  }
  @Override
    public InputStream getInputStream(){
  return in;
  }
}
class TransformationInputImpl extends TransformationInput{
  InputPayload payload;
  public DynamicConfiguration getDynamicConfiguration(){
  return dynamicConfiguration;
  }
  public TransformationInputImpl(InputPayload payload){
  this.payload = payload;
  }
  @Override
  public InputAttachments getInputAttachments(){
  return inputAttachments;
  }
  @Override
  public InputHeader getInputHeader(){
  return inputHeader;
  }
  @Override
  public InputParameters getInputParameters(){
  return inputParameters;
  }
  @Override
  public InputPayload getInputPayload(){
  return payload;
  }
}
class OutPayloadImpl extends OutputPayload {
    OutputStream ou;
    public OutPayloadImpl(OutputStream ou){
  this.ou = ou;}
  @Override
    public OutputStream getOutputStream(){
  return ou;}
}
class TransformationOutputImpl extends TransformationOutput {
    OutputPayload payload;
    public TransformationOutputImpl(OutputPayload payload){
  this.payload = payload;
  }
  @Override
    public void copyInputAttachments(){ }
  @Override
    public OutputAttachments getOutputAttachments(){
  return outputAttachments;
  }
  @Override
    public OutputHeader getOutputHeader(){
  return outputHeader;
  }
  @Override
    public OutputParameters getOutputParameters() {
  return outputParameters;
  }
  @Override
    public OutputPayload getOutputPayload(){
  return payload;
  }
}

The advantage of isolating and developing public ByteArrayOutputStream YourExtBussLogicMethod(InputStream is) java code classes externally is that we don’t have to rely on SAP’s java mapping api to compile the code 🙂

Hope this concept will be helpful. And please share your valuable feedback..