@d19n/youfibre-odin-sdk 1.0.19 → 1.0.21

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

@@ -99,39 +99,4 @@
   }
 
       
-    // Use this function when you want to return a single record
-    public async getInvoiceItems(invoiceItemId: string) {
-      return await this._getLinks(this.moduleName, this.entityName, invoiceItemId, 'InvoiceItem');
-    }
-        
-   public async linkInvoiceItemInvoiceItems(invoiceItemId: string, invoiceItemIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
-
-    const associationDtos = [];
-    for(const param of invoiceItemIds){
-      associationDtos.push({
-          entity: 'BillingModule:InvoiceItem',
-          recordId: param.id,
-          linkType: 'InvoiceItem__InvoiceItem',
-          relationType: param?.relationType,
-          relatedAssociationId: param?.relatedAssociationId
-      });
-    }
-
-     return await this._createLinks(this.moduleName, this.entityName, invoiceItemId, associationDtos);
-   }
-
-   public async unlinkInvoiceItemInvoiceItems(invoiceItemId: string, linkedInvoiceItemIds: string[]) {
-   
-      const associationDtos = [];
-   for(const pk of linkedInvoiceItemIds){
-     associationDtos.push({
-        primaryKey: invoiceItemId,
-        linkedRecordPrimaryKey: pk,
-     });
-   }
-   
-     return await this._deleteLinks(this.moduleName, this.entityName, invoiceItemId, associationDtos);
-   }
-
-      
 }

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

@@ -379,40 +379,75 @@
    }
 
       
-    // Use this function when you want to return a single record
-    public async getLeads(leadId: string) {
-      return await this._getLinks(this.moduleName, this.entityName, leadId, 'Lead');
-    }
+   // Use this function when you want to return a single record
+   public async getWorkOrders(leadId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, leadId, 'WorkOrder');
+   }
         
-   public async linkWorkOrderLeads(leadId: string, leadIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+   public async linkWorkOrderLeads(leadId: string, workOrderIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
 
-    const associationDtos = [];
-    for(const param of leadIds){
-      associationDtos.push({
-          entity: 'CrmModule:Lead',
-          recordId: param.id,
-          linkType: 'WorkOrder__Lead',
-          relationType: param?.relationType,
-          relatedAssociationId: param?.relatedAssociationId
-      });
-    }
-
-     return await this._createLinks(this.moduleName, this.entityName, leadId, associationDtos);
+   const associationDtos = [];
+   for(const param of workOrderIds){
+     associationDtos.push({
+         entity: 'FieldServiceModule:WorkOrder',
+         recordId: param.id,
+         linkType: 'WorkOrder__Lead',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
    }
 
-   public async unlinkWorkOrderLeads(leadId: string, linkedLeadIds: string[]) {
-   
-      const associationDtos = [];
-   for(const pk of linkedLeadIds){
+    return await this._createLinks(this.moduleName, this.entityName, leadId, associationDtos);
+  }
+
+  public async unlinkWorkOrderLeads(leadId: string, linkedWorkOrderIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of linkedWorkOrderIds){
      associationDtos.push({
         primaryKey: leadId,
         linkedRecordPrimaryKey: pk,
      });
    }
-   
-     return await this._deleteLinks(this.moduleName, this.entityName, leadId, associationDtos);
+
+    return await this._deleteLinks(this.moduleName, this.entityName, leadId, associationDtos);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getCrmDatasets(leadId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, leadId, 'CrmDataset');
+   }
+        
+   public async linkCrmDatasetLeads(leadId: string, crmDatasetIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+   const associationDtos = [];
+   for(const param of crmDatasetIds){
+     associationDtos.push({
+         entity: 'CrmModule:CrmDataset',
+         recordId: param.id,
+         linkType: 'CrmDataset__Lead',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, leadId, associationDtos);
+  }
+
+  public async unlinkCrmDatasetLeads(leadId: string, linkedCrmDatasetIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of linkedCrmDatasetIds){
+     associationDtos.push({
+        primaryKey: leadId,
+        linkedRecordPrimaryKey: pk,
+     });
    }
 
+    return await this._deleteLinks(this.moduleName, this.entityName, leadId, associationDtos);
+  }
+
       
     // Use this function when you want to return a single record
     public async getOrders(leadId: string) {
@@ -519,4 +554,74 @@
    }
 
       
+   // Use this function when you want to return a single record
+   public async getCalls(leadId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, leadId, 'Call');
+   }
+        
+   public async linkCallLeads(leadId: 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__Lead',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, leadId, associationDtos);
+  }
+
+  public async unlinkCallLeads(leadId: string, linkedCallIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of linkedCallIds){
+     associationDtos.push({
+        primaryKey: leadId,
+        linkedRecordPrimaryKey: pk,
+     });
+   }
+
+    return await this._deleteLinks(this.moduleName, this.entityName, leadId, associationDtos);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getFingerprints(leadId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, leadId, 'Fingerprint');
+   }
+        
+   public async linkFingerprintLeads(leadId: 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__Lead',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, leadId, associationDtos);
+  }
+
+  public async unlinkFingerprintLeads(leadId: string, linkedFingerprintIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of linkedFingerprintIds){
+     associationDtos.push({
+        primaryKey: leadId,
+        linkedRecordPrimaryKey: pk,
+     });
+   }
+
+    return await this._deleteLinks(this.moduleName, this.entityName, leadId, associationDtos);
+  }
+
+      
 }

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

@@ -134,41 +134,6 @@
    }
 
       
-    // Use this function when you want to return a single record
-    public async getMilestones(milestoneId: string) {
-      return await this._getLinks(this.moduleName, this.entityName, milestoneId, 'Milestone');
-    }
-        
-   public async linkMilestoneMilestones(milestoneId: string, milestoneIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
-
-    const associationDtos = [];
-    for(const param of milestoneIds){
-      associationDtos.push({
-          entity: 'ProjectModule:Milestone',
-          recordId: param.id,
-          linkType: 'Milestone__Milestone',
-          relationType: param?.relationType,
-          relatedAssociationId: param?.relatedAssociationId
-      });
-    }
-
-     return await this._createLinks(this.moduleName, this.entityName, milestoneId, associationDtos);
-   }
-
-   public async unlinkMilestoneMilestones(milestoneId: string, linkedMilestoneIds: string[]) {
-   
-      const associationDtos = [];
-   for(const pk of linkedMilestoneIds){
-     associationDtos.push({
-        primaryKey: milestoneId,
-        linkedRecordPrimaryKey: pk,
-     });
-   }
-   
-     return await this._deleteLinks(this.moduleName, this.entityName, milestoneId, associationDtos);
-   }
-
-      
     // Use this function when you want to return a single record
     public async getNotes(milestoneId: string) {
       return await this._getLinks(this.moduleName, this.entityName, milestoneId, 'Note');

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

@@ -835,7 +835,7 @@
 
       
    // Use this function when you want to return a single record
-   public async getPICRequests(noteId: string) {
+   public async getPicRequests(noteId: string) {
      return await this._getLinks(this.moduleName, this.entityName, noteId, 'PICRequest');
    }
         
@@ -1709,19 +1709,14 @@
   }
 
       
-    // Use this function when you want to return a single record
-    public async getNotes(noteId: string) {
-      return await this._getLinks(this.moduleName, this.entityName, noteId, 'Note');
-    }
-        
-   public async linkNoteNotes(noteId: string, noteIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+   public async linkNoteFiles(noteId: string, fileIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
 
     const associationDtos = [];
-    for(const param of noteIds){
+    for(const param of fileIds){
       associationDtos.push({
-          entity: 'SupportModule:Note',
+          entity: 'SchemaModule:File',
           recordId: param.id,
-          linkType: 'Note__Note',
+          linkType: 'Note__File',
           relationType: param?.relationType,
           relatedAssociationId: param?.relatedAssociationId
       });
@@ -1730,10 +1725,10 @@
      return await this._createLinks(this.moduleName, this.entityName, noteId, associationDtos);
    }
 
-   public async unlinkNoteNotes(noteId: string, linkedNoteIds: string[]) {
+   public async unlinkNoteFiles(noteId: string, linkedFileIds: string[]) {
    
       const associationDtos = [];
-   for(const pk of linkedNoteIds){
+   for(const pk of linkedFileIds){
      associationDtos.push({
         primaryKey: noteId,
         linkedRecordPrimaryKey: pk,

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

@@ -169,41 +169,6 @@
   }
 
       
-    // Use this function when you want to return a single record
-    public async getOffers(offerId: string) {
-      return await this._getLinks(this.moduleName, this.entityName, offerId, 'Offer');
-    }
-        
-   public async linkOfferOffers(offerId: string, offerIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
-
-    const associationDtos = [];
-    for(const param of offerIds){
-      associationDtos.push({
-          entity: 'ProductModule:Offer',
-          recordId: param.id,
-          linkType: 'Offer__Offer',
-          relationType: param?.relationType,
-          relatedAssociationId: param?.relatedAssociationId
-      });
-    }
-
-     return await this._createLinks(this.moduleName, this.entityName, offerId, associationDtos);
-   }
-
-   public async unlinkOfferOffers(offerId: string, linkedOfferIds: string[]) {
-   
-      const associationDtos = [];
-   for(const pk of linkedOfferIds){
-     associationDtos.push({
-        primaryKey: offerId,
-        linkedRecordPrimaryKey: pk,
-     });
-   }
-   
-     return await this._deleteLinks(this.moduleName, this.entityName, offerId, associationDtos);
-   }
-
-      
     // Use this function when you want to return a single record
     public async getDiscounts(offerId: string) {
       return await this._getLinks(this.moduleName, this.entityName, offerId, 'Discount');

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

@@ -558,43 +558,8 @@
    }
 
       
-    // Use this function when you want to return a single record
-    public async getOrders(orderId: string) {
-      return await this._getLinks(this.moduleName, this.entityName, orderId, 'Order');
-    }
-        
-   public async linkOrderOrders(orderId: 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__Order',
-          relationType: param?.relationType,
-          relatedAssociationId: param?.relatedAssociationId
-      });
-    }
-
-     return await this._createLinks(this.moduleName, this.entityName, orderId, associationDtos);
-   }
-
-   public async unlinkOrderOrders(orderId: string, linkedOrderIds: string[]) {
-   
-      const associationDtos = [];
-   for(const pk of linkedOrderIds){
-     associationDtos.push({
-        primaryKey: orderId,
-        linkedRecordPrimaryKey: pk,
-     });
-   }
-   
-     return await this._deleteLinks(this.moduleName, this.entityName, orderId, associationDtos);
-   }
-
-      
    // Use this function when you want to return a single record
-   public async getPICRequests(orderId: string) {
+   public async getPicRequests(orderId: string) {
      return await this._getLinks(this.moduleName, this.entityName, orderId, 'PICRequest');
    }
         
@@ -1083,6 +1048,36 @@
    }
 
       
+   public async linkOrderSplitOrders(orderId: string, splitOrderIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+    const associationDtos = [];
+    for(const param of splitOrderIds){
+      associationDtos.push({
+          entity: 'OrderModule:SplitOrder',
+          recordId: param.id,
+          linkType: 'Order__SplitOrder',
+          relationType: param?.relationType,
+          relatedAssociationId: param?.relatedAssociationId
+      });
+    }
+
+     return await this._createLinks(this.moduleName, this.entityName, orderId, associationDtos);
+   }
+
+   public async unlinkOrderSplitOrders(orderId: string, linkedSplitOrderIds: string[]) {
+   
+      const associationDtos = [];
+   for(const pk of linkedSplitOrderIds){
+     associationDtos.push({
+        primaryKey: orderId,
+        linkedRecordPrimaryKey: pk,
+     });
+   }
+   
+     return await this._deleteLinks(this.moduleName, this.entityName, orderId, associationDtos);
+   }
+
+      
     // Use this function when you want to return a single record
     public async getPhoneNumbers(orderId: string) {
       return await this._getLinks(this.moduleName, this.entityName, orderId, 'PhoneNumber');

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

@@ -484,41 +484,6 @@
    }
 
       
-    // Use this function when you want to return a single record
-    public async getOrderItems(orderItemId: string) {
-      return await this._getLinks(this.moduleName, this.entityName, orderItemId, 'OrderItem');
-    }
-        
-   public async linkOrderItemOrderItems(orderItemId: string, orderItemIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
-
-    const associationDtos = [];
-    for(const param of orderItemIds){
-      associationDtos.push({
-          entity: 'OrderModule:OrderItem',
-          recordId: param.id,
-          linkType: 'OrderItem__OrderItem',
-          relationType: param?.relationType,
-          relatedAssociationId: param?.relatedAssociationId
-      });
-    }
-
-     return await this._createLinks(this.moduleName, this.entityName, orderItemId, associationDtos);
-   }
-
-   public async unlinkOrderItemOrderItems(orderItemId: string, linkedOrderItemIds: string[]) {
-   
-      const associationDtos = [];
-   for(const pk of linkedOrderItemIds){
-     associationDtos.push({
-        primaryKey: orderItemId,
-        linkedRecordPrimaryKey: pk,
-     });
-   }
-   
-     return await this._deleteLinks(this.moduleName, this.entityName, orderItemId, associationDtos);
-   }
-
-      
     // Use this function when you want to return a single record
     public async getVoiceConfigurations(orderItemId: string) {
       return await this._getLinks(this.moduleName, this.entityName, orderItemId, 'VoiceConfiguration');

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

@@ -169,39 +169,4 @@
   }
 
       
-    // Use this function when you want to return a single record
-    public async getOrganizations(organizationId: string) {
-      return await this._getLinks(this.moduleName, this.entityName, organizationId, 'Organization');
-    }
-        
-   public async linkOrganizationOrganizations(organizationId: string, organizationIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
-
-    const associationDtos = [];
-    for(const param of organizationIds){
-      associationDtos.push({
-          entity: 'CrmModule:Organization',
-          recordId: param.id,
-          linkType: 'Organization__Organization',
-          relationType: param?.relationType,
-          relatedAssociationId: param?.relatedAssociationId
-      });
-    }
-
-     return await this._createLinks(this.moduleName, this.entityName, organizationId, associationDtos);
-   }
-
-   public async unlinkOrganizationOrganizations(organizationId: string, linkedOrganizationIds: string[]) {
-   
-      const associationDtos = [];
-   for(const pk of linkedOrganizationIds){
-     associationDtos.push({
-        primaryKey: organizationId,
-        linkedRecordPrimaryKey: pk,
-     });
-   }
-   
-     return await this._deleteLinks(this.moduleName, this.entityName, organizationId, associationDtos);
-   }
-
-      
 }

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

@@ -134,39 +134,4 @@
   }
 
       
-    // Use this function when you want to return a single record
-    public async getProductComponents(productComponentId: string) {
-      return await this._getLinks(this.moduleName, this.entityName, productComponentId, 'ProductComponent');
-    }
-        
-   public async linkProductComponentProductComponents(productComponentId: string, productComponentIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
-
-    const associationDtos = [];
-    for(const param of productComponentIds){
-      associationDtos.push({
-          entity: 'ProductModule:ProductComponent',
-          recordId: param.id,
-          linkType: 'ProductComponent__ProductComponent',
-          relationType: param?.relationType,
-          relatedAssociationId: param?.relatedAssociationId
-      });
-    }
-
-     return await this._createLinks(this.moduleName, this.entityName, productComponentId, associationDtos);
-   }
-
-   public async unlinkProductComponentProductComponents(productComponentId: string, linkedProductComponentIds: string[]) {
-   
-      const associationDtos = [];
-   for(const pk of linkedProductComponentIds){
-     associationDtos.push({
-        primaryKey: productComponentId,
-        linkedRecordPrimaryKey: pk,
-     });
-   }
-   
-     return await this._deleteLinks(this.moduleName, this.entityName, productComponentId, associationDtos);
-   }
-
-      
 }

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

@@ -379,43 +379,4 @@
   }
 
       
-    // Use this function when you want to return a single record
-    public async getProducts(productId: string) {
-      return await this._getLinks(this.moduleName, this.entityName, productId, 'Product');
-    }
-        
-   public async linkProductProducts(productId: string, productIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
-
-    const associationDtos = [];
-    for(const param of productIds){
-      associationDtos.push({
-          entity: 'ProductModule:Product',
-          recordId: param.id,
-          linkType: 'Product__Product',
-          relationType: param?.relationType,
-          relatedAssociationId: param?.relatedAssociationId
-      });
-    }
-
-     return await this._createLinks(this.moduleName, this.entityName, productId, associationDtos);
-   }
-
-   public async unlinkProductProducts(productId: string, linkedProductIds: string[]) {
-   
-      const associationDtos = [];
-   for(const pk of linkedProductIds){
-     associationDtos.push({
-        primaryKey: productId,
-        linkedRecordPrimaryKey: pk,
-     });
-   }
-   
-     return await this._deleteLinks(this.moduleName, this.entityName, productId, associationDtos);
-   }
-
-      
-   public async updateProductProductLinkProperties(productId: string, dbRecordAssociationId: string, updateDto: OdinLinkedRecordUpdateDto) {
-
-     return await this._updateLinkProperties('ProductModule', 'Product', productId, dbRecordAssociationId, updateDto);
-   }
 }

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

@@ -134,39 +134,4 @@
   }
 
       
-    // Use this function when you want to return a single record
-    public async getRestrictions(restrictionId: string) {
-      return await this._getLinks(this.moduleName, this.entityName, restrictionId, 'Restriction');
-    }
-        
-   public async linkRestrictionRestrictions(restrictionId: string, restrictionIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
-
-    const associationDtos = [];
-    for(const param of restrictionIds){
-      associationDtos.push({
-          entity: 'ProductModule:Restriction',
-          recordId: param.id,
-          linkType: 'Restriction__Restriction',
-          relationType: param?.relationType,
-          relatedAssociationId: param?.relatedAssociationId
-      });
-    }
-
-     return await this._createLinks(this.moduleName, this.entityName, restrictionId, associationDtos);
-   }
-
-   public async unlinkRestrictionRestrictions(restrictionId: string, linkedRestrictionIds: string[]) {
-   
-      const associationDtos = [];
-   for(const pk of linkedRestrictionIds){
-     associationDtos.push({
-        primaryKey: restrictionId,
-        linkedRecordPrimaryKey: pk,
-     });
-   }
-   
-     return await this._deleteLinks(this.moduleName, this.entityName, restrictionId, associationDtos);
-   }
-
-      
 }