Item of the "Project Plan Element" app

The method receives the internal signature of the app’s data.

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); 
  

The method retrieves access permissions set for the app item.

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); 

The method gets the history of an app item’s signatures.

// 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; 
} 

List of users subscribed to the app item’s activity stream.

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

The method checks permissions of a user, group, org chart item, or role.

Delete duplicate data in arrays.

The method deletes duplicates in fields that store arrays of links to system objects (users, files, app items, or documents). For example, you can call this method after bulk editing data within an object.

const  app1 = await Context.data.app1.fetch();
const app2 = await Context.data.app2 .fetch(); 
app1.data.executors.push(app2.data.executors); 
app1.normalize();  
// Now we need to go over the elements in the new array 
app1.data.executors .forEach( ... ); 

The method saves an app item.

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();  

The method sets new access permissions for an app item.

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 method changes the status of an app item.

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

The method allows you to subscribe a user to updates in the activity stream of an app item.

The method allows you to unsubscribe a user from updates in the activity stream of an app item.

The method uploads a digital signature.

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);