App item

While calculating internal signatures of an app, the system considers user signing settings. The data it obtains consists of a set of signatures of two types, for attributes and for files. Each signature includes:

• hash: signature applied to the app’s data.
• body: data that hash is calculated for.
• type: signature type. In the example below, the context includes:
• document1: a Document type app that includes signature settings In the example, the system searches for the signature and uses hash and body to save the obtained signature.

  const app = await Context.data.document1.fetch();
  const dataSigns = await  app.getDataSigns(); 
  const dataSign = res.find( (res: any)  => res.type ===  SignType.File); 
  const newSign: NewSign = { 
    sign: 'aGVsbG8=', 
     codeProvider: 'External', 
    body: btoa(app.data.__file!.id), 
    hash:  dataSign.hash 
  } 
  await app.uploadSign(newSign); 
  

Use this method if you need to add new access permissions to the existing ones.

// Let’s grant the process initiator access to the app  item 
const item = await Context.data.request.fetch(); 
const user = Context. data.__createdBy; 
// We need to retrieve the current access permissions  
const currPermissions = await item.getPermissions(); 
currPermissions.values .push(new PermissionValue(user, [PermissionType.READ])); 
await item. setPermissions(currPermissions); 

// Example of saving signatures to context variables of the  File type 
const app = await Context.data.dokument!.fetch(); 
const  signHistory = await app.getSignHistory(); 
Context.data.sign_attributes =  await signHistory[0].signs[0].createSignFile(); 
const attributes = await  signHistory[0].signs[0].createAttributesFile(); 
if (attributes !==  undefined) { 
 Context.data.attributes = attributes; 
} 

// Let’s write the app item’s subscribers to the context  
const subscribers = await item.getSubscribers(); 
Context.data.subscribers =  subscribers; 

You need to save app items when their data changes.

const  request = await Context.data.service_request.fetch();
request.data.responsible = Context.data.responsible; 
await request.save();  

This method completely replaces the existing permissions with new ones.
There is no point to configure the permission to create an existing app item, so the PermissionValue.Create value is not available.

The status changes immediately after the method is executed. You don’t need to call the ApplicationItem.save method.

The method is used to create a custom signing mechanism for apps. You can use it to apply a signature obtained from an external signature provider to an app. To use this method, you need:

• Byte content of the signature in the Base64 format.
• Signature type.
• Signature provider’s code (a string constant that identifies it).
• Hash of the app data that was signed.
• Data based on which the signature was calculated. In the example:
• document1 is a Document type app in the context.
• The MySignProvider class is an example signature provider. The method returns a flag that indicates the status of the upload. If the flag evaluates to true, the upload of the signature is successful; false means that the upload failed.

  const app = await Context.data.document1. fetch();
  const provider = new MySignProvider(); 
  const innerSigns = await  Conetxt.data.document1.getDataSigns(); 
  const attributesInnerSign =  innerSigns.find(sign => sign.type === SignType.Attributes); 
  const sign =  provider.Sign(attributesInnerSign.body); 
  const newSign: NewSign = { 
     sign: sign, 
    codeProvider: 'MyProvider', 
    body:  attributesInnerSign.body, 
    signType: SignType.Attributes, 
    hash:  attributesInnerSign.hash, 
  }; 
  const isUploaded = await app. uploadSign(newSign);