@d19n/youfibre-odin-sdk 1.0.19 → 1.0.21

package/src/db-sdk-v1/ContactDb.ts

@@ -64,40 +64,75 @@
    }
 
   
-    // Use this function when you want to return a single record
-    public async getContacts(contactId: string) {
-      return await this._getLinks(this.moduleName, this.entityName, contactId, 'Contact');
-    }
+   // Use this function when you want to return a single record
+   public async getOrganizations(contactId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, contactId, 'Organization');
+   }
         
-   public async linkOrganizationContacts(contactId: string, contactIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+   public async linkOrganizationContacts(contactId: string, organizationIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
 
-    const associationDtos = [];
-    for(const param of contactIds){
-      associationDtos.push({
-          entity: 'CrmModule:Contact',
-          recordId: param.id,
-          linkType: 'Organization__Contact',
-          relationType: param?.relationType,
-          relatedAssociationId: param?.relatedAssociationId
-      });
-    }
-
-     return await this._createLinks(this.moduleName, this.entityName, contactId, associationDtos);
+   const associationDtos = [];
+   for(const param of organizationIds){
+     associationDtos.push({
+         entity: 'CrmModule:Organization',
+         recordId: param.id,
+         linkType: 'Organization__Contact',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
    }
 
-   public async unlinkOrganizationContacts(contactId: string, linkedContactIds: string[]) {
-   
-      const associationDtos = [];
-   for(const pk of linkedContactIds){
+    return await this._createLinks(this.moduleName, this.entityName, contactId, associationDtos);
+  }
+
+  public async unlinkOrganizationContacts(contactId: string, linkedOrganizationIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of linkedOrganizationIds){
      associationDtos.push({
         primaryKey: contactId,
         linkedRecordPrimaryKey: pk,
      });
    }
-   
-     return await this._deleteLinks(this.moduleName, this.entityName, contactId, associationDtos);
+
+    return await this._deleteLinks(this.moduleName, this.entityName, contactId, associationDtos);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getAccounts(contactId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, contactId, 'Account');
+   }
+        
+   public async linkBillingContacts(contactId: string, accountIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+   const associationDtos = [];
+   for(const param of accountIds){
+     associationDtos.push({
+         entity: 'CrmModule:Account',
+         recordId: param.id,
+         linkType: 'BillingContact',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
    }
 
+    return await this._createLinks(this.moduleName, this.entityName, contactId, associationDtos);
+  }
+
+  public async unlinkBillingContacts(contactId: string, linkedAccountIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of linkedAccountIds){
+     associationDtos.push({
+        primaryKey: contactId,
+        linkedRecordPrimaryKey: pk,
+     });
+   }
+
+    return await this._deleteLinks(this.moduleName, this.entityName, contactId, associationDtos);
+  }
+
       
     // Use this function when you want to return a single record
     public async getActivitys(contactId: string) {
@@ -169,6 +204,111 @@
    }
 
       
+   // Use this function when you want to return a single record
+   public async getWorkOrders(contactId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, contactId, 'WorkOrder');
+   }
+        
+   public async linkWorkOrderContacts(contactId: string, workOrderIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+   const associationDtos = [];
+   for(const param of workOrderIds){
+     associationDtos.push({
+         entity: 'FieldServiceModule:WorkOrder',
+         recordId: param.id,
+         linkType: 'WorkOrder__Contact',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, contactId, associationDtos);
+  }
+
+  public async unlinkWorkOrderContacts(contactId: string, linkedWorkOrderIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of linkedWorkOrderIds){
+     associationDtos.push({
+        primaryKey: contactId,
+        linkedRecordPrimaryKey: pk,
+     });
+   }
+
+    return await this._deleteLinks(this.moduleName, this.entityName, contactId, associationDtos);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getOrders(contactId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, contactId, 'Order');
+   }
+        
+   public async linkOrderContacts(contactId: string, orderIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+   const associationDtos = [];
+   for(const param of orderIds){
+     associationDtos.push({
+         entity: 'OrderModule:Order',
+         recordId: param.id,
+         linkType: 'Order__Contact',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, contactId, associationDtos);
+  }
+
+  public async unlinkOrderContacts(contactId: string, linkedOrderIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of linkedOrderIds){
+     associationDtos.push({
+        primaryKey: contactId,
+        linkedRecordPrimaryKey: pk,
+     });
+   }
+
+    return await this._deleteLinks(this.moduleName, this.entityName, contactId, associationDtos);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getLeads(contactId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, contactId, 'Lead');
+   }
+        
+   public async linkLeadContacts(contactId: string, leadIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+   const associationDtos = [];
+   for(const param of leadIds){
+     associationDtos.push({
+         entity: 'CrmModule:Lead',
+         recordId: param.id,
+         linkType: 'Lead__Contact',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, contactId, associationDtos);
+  }
+
+  public async unlinkLeadContacts(contactId: string, linkedLeadIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of linkedLeadIds){
+     associationDtos.push({
+        primaryKey: contactId,
+        linkedRecordPrimaryKey: pk,
+     });
+   }
+
+    return await this._deleteLinks(this.moduleName, this.entityName, contactId, associationDtos);
+  }
+
+      
     // Use this function when you want to return a single record
     public async getAddresss(contactId: string) {
       return await this._getLinks(this.moduleName, this.entityName, contactId, 'Address');
@@ -239,6 +379,41 @@
    }
 
       
+   // Use this function when you want to return a single record
+   public async getInvoices(contactId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, contactId, 'Invoice');
+   }
+        
+   public async linkInvoiceContacts(contactId: string, invoiceIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+   const associationDtos = [];
+   for(const param of invoiceIds){
+     associationDtos.push({
+         entity: 'BillingModule:Invoice',
+         recordId: param.id,
+         linkType: 'Invoice__Contact',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, contactId, associationDtos);
+  }
+
+  public async unlinkInvoiceContacts(contactId: string, linkedInvoiceIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of linkedInvoiceIds){
+     associationDtos.push({
+        primaryKey: contactId,
+        linkedRecordPrimaryKey: pk,
+     });
+   }
+
+    return await this._deleteLinks(this.moduleName, this.entityName, contactId, associationDtos);
+  }
+
+      
     // Use this function when you want to return a single record
     public async getBillingRequests(contactId: string) {
       return await this._getLinks(this.moduleName, this.entityName, contactId, 'BillingRequest');
@@ -309,6 +484,76 @@
    }
 
       
+   // Use this function when you want to return a single record
+   public async getCommissions(contactId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, contactId, 'Commission');
+   }
+        
+   public async linkCommissionContacts(contactId: string, commissionIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+   const associationDtos = [];
+   for(const param of commissionIds){
+     associationDtos.push({
+         entity: 'BillingModule:Commission',
+         recordId: param.id,
+         linkType: 'Commission__Contact',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, contactId, associationDtos);
+  }
+
+  public async unlinkCommissionContacts(contactId: string, linkedCommissionIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of linkedCommissionIds){
+     associationDtos.push({
+        primaryKey: contactId,
+        linkedRecordPrimaryKey: pk,
+     });
+   }
+
+    return await this._deleteLinks(this.moduleName, this.entityName, contactId, associationDtos);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getOneTouchSwitchs(contactId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, contactId, 'OneTouchSwitch');
+   }
+        
+   public async linkOneTouchSwitchContacts(contactId: string, oneTouchSwitchIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+   const associationDtos = [];
+   for(const param of oneTouchSwitchIds){
+     associationDtos.push({
+         entity: 'OrderModule:OneTouchSwitch',
+         recordId: param.id,
+         linkType: 'OneTouchSwitch__Contact',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, contactId, associationDtos);
+  }
+
+  public async unlinkOneTouchSwitchContacts(contactId: string, linkedOneTouchSwitchIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of linkedOneTouchSwitchIds){
+     associationDtos.push({
+        primaryKey: contactId,
+        linkedRecordPrimaryKey: pk,
+     });
+   }
+
+    return await this._deleteLinks(this.moduleName, this.entityName, contactId, associationDtos);
+  }
+
+      
     // Use this function when you want to return a single record
     public async getContactIdentitys(contactId: string) {
       return await this._getLinks(this.moduleName, this.entityName, contactId, 'ContactIdentity');
@@ -379,6 +624,41 @@
    }
 
       
+   // Use this function when you want to return a single record
+   public async getDeactivationApprovals(contactId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, contactId, 'DeactivationApproval');
+   }
+        
+   public async linkDeactivationApprovalContacts(contactId: string, deactivationApprovalIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+   const associationDtos = [];
+   for(const param of deactivationApprovalIds){
+     associationDtos.push({
+         entity: 'OrderModule:DeactivationApproval',
+         recordId: param.id,
+         linkType: 'DeactivationApproval__Contact',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, contactId, associationDtos);
+  }
+
+  public async unlinkDeactivationApprovalContacts(contactId: string, linkedDeactivationApprovalIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of linkedDeactivationApprovalIds){
+     associationDtos.push({
+        primaryKey: contactId,
+        linkedRecordPrimaryKey: pk,
+     });
+   }
+
+    return await this._deleteLinks(this.moduleName, this.entityName, contactId, associationDtos);
+  }
+
+      
     // Use this function when you want to return a single record
     public async getPhoneNumbers(contactId: string) {
       return await this._getLinks(this.moduleName, this.entityName, contactId, 'PhoneNumber');
@@ -414,6 +694,76 @@
    }
 
       
+   // Use this function when you want to return a single record
+   public async getOrderRemediationTasks(contactId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, contactId, 'OrderRemediationTask');
+   }
+        
+   public async linkOrderRemediationTaskContacts(contactId: string, orderRemediationTaskIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+   const associationDtos = [];
+   for(const param of orderRemediationTaskIds){
+     associationDtos.push({
+         entity: 'OrderModule:OrderRemediationTask',
+         recordId: param.id,
+         linkType: 'OrderRemediationTask__Contact',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, contactId, associationDtos);
+  }
+
+  public async unlinkOrderRemediationTaskContacts(contactId: string, linkedOrderRemediationTaskIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of linkedOrderRemediationTaskIds){
+     associationDtos.push({
+        primaryKey: contactId,
+        linkedRecordPrimaryKey: pk,
+     });
+   }
+
+    return await this._deleteLinks(this.moduleName, this.entityName, contactId, associationDtos);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getCases(contactId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, contactId, 'Case');
+   }
+        
+   public async linkCaseContacts(contactId: string, caseIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+   const associationDtos = [];
+   for(const param of caseIds){
+     associationDtos.push({
+         entity: 'SupportModule:Case',
+         recordId: param.id,
+         linkType: 'Case__Contact',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, contactId, associationDtos);
+  }
+
+  public async unlinkCaseContacts(contactId: string, linkedCaseIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of linkedCaseIds){
+     associationDtos.push({
+        primaryKey: contactId,
+        linkedRecordPrimaryKey: pk,
+     });
+   }
+
+    return await this._deleteLinks(this.moduleName, this.entityName, contactId, associationDtos);
+  }
+
+      
     // Use this function when you want to return a single record
     public async getAppointments(contactId: string) {
       return await this._getLinks(this.moduleName, this.entityName, contactId, 'Appointment');
@@ -449,6 +799,41 @@
    }
 
       
+   // Use this function when you want to return a single record
+   public async getCalls(contactId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, contactId, 'Call');
+   }
+        
+   public async linkCallContacts(contactId: string, callIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+   const associationDtos = [];
+   for(const param of callIds){
+     associationDtos.push({
+         entity: 'NotificationModule:Call',
+         recordId: param.id,
+         linkType: 'Call__Contact',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, contactId, associationDtos);
+  }
+
+  public async unlinkCallContacts(contactId: string, linkedCallIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of linkedCallIds){
+     associationDtos.push({
+        primaryKey: contactId,
+        linkedRecordPrimaryKey: pk,
+     });
+   }
+
+    return await this._deleteLinks(this.moduleName, this.entityName, contactId, associationDtos);
+  }
+
+      
     // Use this function when you want to return a single record
     public async getPaymentMethods(contactId: string) {
       return await this._getLinks(this.moduleName, this.entityName, contactId, 'PaymentMethod');
@@ -484,4 +869,39 @@
    }
 
       
+   // Use this function when you want to return a single record
+   public async getFingerprints(contactId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, contactId, 'Fingerprint');
+   }
+        
+   public async linkFingerprintContacts(contactId: string, fingerprintIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+   const associationDtos = [];
+   for(const param of fingerprintIds){
+     associationDtos.push({
+         entity: 'CrmModule:Fingerprint',
+         recordId: param.id,
+         linkType: 'Fingerprint__Contact',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, contactId, associationDtos);
+  }
+
+  public async unlinkFingerprintContacts(contactId: string, linkedFingerprintIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of linkedFingerprintIds){
+     associationDtos.push({
+        primaryKey: contactId,
+        linkedRecordPrimaryKey: pk,
+     });
+   }
+
+    return await this._deleteLinks(this.moduleName, this.entityName, contactId, associationDtos);
+  }
+
+      
 }

package/src/db-sdk-v1/ContactIdentityDb.ts

@@ -99,41 +99,6 @@
    }
 
       
-    // Use this function when you want to return a single record
-    public async getContactIdentitys(contactIdentityId: string) {
-      return await this._getLinks(this.moduleName, this.entityName, contactIdentityId, 'ContactIdentity');
-    }
-        
-   public async linkContactIdentityContactIdentitys(contactIdentityId: string, contactIdentityIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
-
-    const associationDtos = [];
-    for(const param of contactIdentityIds){
-      associationDtos.push({
-          entity: 'CrmModule:ContactIdentity',
-          recordId: param.id,
-          linkType: 'ContactIdentity__ContactIdentity',
-          relationType: param?.relationType,
-          relatedAssociationId: param?.relatedAssociationId
-      });
-    }
-
-     return await this._createLinks(this.moduleName, this.entityName, contactIdentityId, associationDtos);
-   }
-
-   public async unlinkContactIdentityContactIdentitys(contactIdentityId: string, linkedContactIdentityIds: string[]) {
-   
-      const associationDtos = [];
-   for(const pk of linkedContactIdentityIds){
-     associationDtos.push({
-        primaryKey: contactIdentityId,
-        linkedRecordPrimaryKey: pk,
-     });
-   }
-   
-     return await this._deleteLinks(this.moduleName, this.entityName, contactIdentityId, associationDtos);
-   }
-
-      
    // Use this function when you want to return a single record
    public async getContacts(contactIdentityId: string) {
      return await this._getLinks(this.moduleName, this.entityName, contactIdentityId, 'Contact');