Page Comparison

customer: ((customer) => Promise<any>)

product: ((product) => Promise<any>)

await add.product({
  sku: 'KS-2003',
  label: 'Test2',
  unitOfMeasure: 1,
  currency: 'CZK',
  formulaName: 'ActionButtons',
  attribute18: 'A'
});

getCurrentUser: (() => Promise<User>)

await app.getCurrentUser()
/*
{
  "version": 2,
  "typedId": 123,
  "loginName": "donatas.ka",
  ...
}
*/

overrideConfig: ((path, value) => Promise<void>)

await configuration.overrideConfig(
  'applicationEnvironment',
  'salesforce'
);

retrieveConfig: ((path, defaultValue?) => Promise<any>)

const visibleDashboards = await configuration.retrieveConfig(
 'customerSpecificFeatureFlag.dashboards.visible.account',
  []
);

callAndReceive: ((message) => Promise<any>)

const message = {
  fields: [
    { id: 'name', value: 'New name' },
    { id: 'description', value: 'New description' }
  ]
};
return crmManager.callAndReceive({ action: 'createNewQuote', data: message })

findAccount: (() => Promise<any>)

findAccounts: ((name) => Promise<{ Id: string; Name: string; }[]>)

findByQuery: ((query) => Promise<any>)

export const crmFindOpportunitiesPre = ({
  result,
  searchText,
  api: { crmManager }
}) => {
  const query = `
    SELECT Id, Name, StageName, RecordType.Name
    FROM Opportunity
    WHERE Name = '%${searchText}%'
    LIMIT 10
  `;
  return crmManager.findByQuery(query).then(list => {
    list.forEach(item => {
      item.Name = `${item.Name} (${item.RecordType.Name})`;
    });
    result.list = list;
    return result;
  });
};

findOpportunitiesByQuery: ((query) => Promise<any>)

getAccountAssociatedValue: (() => Promise<any>)

getAccountAssociationField: (() => Promise<string>)

getCurrentUser: (() => Promise<CrmUser>)

getOpportunityAssociatedValue: (() => Promise<any>)

getOpportunityLineItemURL: ((externalId) => Promise<string>)

getOpportunityURL: ((externalId) => Promise<string>)

getPayload: (() => Promise<any>)

export const quotesDetailNew = async ({
  quoteAPI,
  api: { crmManager }
}) => {
  const payload = await crmManager.getPayload();
  await quoteAPI.setHeaderValue('label', payload.Name);
  await quoteAPI.setHeaderInputValue('Customer', payload.Customer_Number__c);
  await quoteAPI.setHeaderInputValue('ProjectID', payload.Project_Id__c);
  await quoteAPI.setHeaderInputValue('ProjectName', payload.Project__c);
};

getQuoteAccountReferenceField: (() => Promise<string>)

getSObjectURL: (() => Promise<string>)

getSugarCrmEntityById: ((module, id) => Promise<any>)

const parentAccount = await crmManager.getSugarCrmEntityById('Accounts', parentId);

isAccountPage: (() => Promise<boolean>)

isOpportunityPage: (() => Promise<boolean>)

postCall: ((url, method, payload) => Promise<any>)

export const quotesDetailSubmit = async ({
  quoteAPI,
  api: { crmManager, notify }
}) => {
  const externalRef = await quoteAPI.getHeaderValue('externalRef');
  const opportunityUrl = await crmManager.getOpportunityURL(externalRef);
  const totalValue = await quoteAPI.getHeaderOutputResult('TotalAmount');
  const payloadForSF = {
    PriceFx_Quote_No__c: quoteAPI.getHeaderValue('uniqueName'),
    Amount: totalValue
  };
  crmManager.postCall(opportunityUrl, 'PATCH', payloadForSF).then(() => {
    notify.success('Opportunity was updated.');
  });
};

reportOpportunityNumberOfQuotes: (() => Promise<void>)

updateCache: ((path, data) => Promise<void>)

// Data is a parent account for the current account
crmManager.updateCache('sugarCRMData.payload.Account', data)

customer: ((customerId) => Promise<Customer>)

customerByFilter: ((customFilter) => Promise<Customer[]>)

customerByName: ((customerName) => Promise<Customer[]>)

customerExtension: ((tableName, filter) => Promise<CustomerExtension[]>)

productById: ((sku) => Promise<any>)

productByLabel: ((label) => Promise<Product[]>)

navigate: ((targetPage, targetPageState) => Promise<void>)

export const quotesListDataLoad = async ({ api, appPages }) => {
  await api.navigate(appPages.QC_NEW_QUOTE, { id: 'P-123' });
}

await api.notify.error(
  'Error message, with help link',
  {
    urlName: "help",
    url: "<https://help.me>",
    duration: 0
  }
)

translate: ((key, params?) => Promise<string>)

await api.translate(
  'unity_interceptor_already_exists',
  {
    name: 'myInterceptor'
  }
)

getParameters: (() => Promise<string>)