@d19n/youfibre-odin-sdk 1.0.19 → 1.0.21

package/src/api-sdk-v1/InvoiceItemApi.ts

@@ -101,31 +101,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, linkedInvoiceItemId: string) {
-   
-     return await this._deleteLinks(this.moduleName, this.entityName, invoiceItemId, linkedInvoiceItemId);
-   }
-
-      
 }

package/src/api-sdk-v1/LeadApi.ts

@@ -317,32 +317,59 @@
    }
 
       
-    // 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
-      });
-    }
+   const associationDtos = [];
+   for(const param of workOrderIds){
+     associationDtos.push({
+         entity: 'FieldServiceModule:WorkOrder',
+         recordId: param.id,
+         linkType: 'WorkOrder__Lead',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
 
-     return await this._createLinks(this.moduleName, this.entityName, leadId, associationDtos);
+    return await this._createLinks(this.moduleName, this.entityName, leadId, associationDtos);
+  }
+
+  public async unLinkWorkOrderLeads(leadId: string, linkedWorkOrderId: string) {
+  
+    return await this._deleteLinks(this.moduleName, this.entityName, leadId, linkedWorkOrderId);
+  }
+
+      
+   // 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}[]) {
 
-   public async unLinkWorkOrderLeads(leadId: string, linkedLeadId: string) {
-   
-     return await this._deleteLinks(this.moduleName, this.entityName, leadId, linkedLeadId);
+   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, linkedCrmDatasetId: string) {
+  
+    return await this._deleteLinks(this.moduleName, this.entityName, leadId, linkedCrmDatasetId);
+  }
+
       
     // Use this function when you want to return a single record
     public async getOrders(leadId: string) {
@@ -425,4 +452,58 @@
    }
 
       
+   // 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, linkedCallId: string) {
+  
+    return await this._deleteLinks(this.moduleName, this.entityName, leadId, linkedCallId);
+  }
+
+      
+   // 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, linkedFingerprintId: string) {
+  
+    return await this._deleteLinks(this.moduleName, this.entityName, leadId, linkedFingerprintId);
+  }
+
+      
 }

package/src/api-sdk-v1/MilestoneApi.ts

@@ -128,33 +128,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, linkedMilestoneId: string) {
-   
-     return await this._deleteLinks(this.moduleName, this.entityName, milestoneId, linkedMilestoneId);
-   }
-
-      
     // 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/api-sdk-v1/NoteApi.ts

@@ -669,7 +669,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');
    }
         
@@ -1343,19 +1343,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
       });
@@ -1364,9 +1359,9 @@
      return await this._createLinks(this.moduleName, this.entityName, noteId, associationDtos);
    }
 
-   public async unLinkNoteNotes(noteId: string, linkedNoteId: string) {
+   public async unLinkNoteFiles(noteId: string, linkedFileId: string) {
    
-     return await this._deleteLinks(this.moduleName, this.entityName, noteId, linkedNoteId);
+     return await this._deleteLinks(this.moduleName, this.entityName, noteId, linkedFileId);
    }
 
       

package/src/api-sdk-v1/OfferApi.ts

@@ -155,33 +155,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, linkedOfferId: string) {
-   
-     return await this._deleteLinks(this.moduleName, this.entityName, offerId, linkedOfferId);
-   }
-
-      
     // 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/api-sdk-v1/OrderApi.ts

@@ -456,35 +456,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, linkedOrderId: string) {
-   
-     return await this._deleteLinks(this.moduleName, this.entityName, orderId, linkedOrderId);
-   }
-
-      
    // 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');
    }
         
@@ -861,6 +834,28 @@
    }
 
       
+   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, linkedSplitOrderId: string) {
+   
+     return await this._deleteLinks(this.moduleName, this.entityName, orderId, linkedSplitOrderId);
+   }
+
+      
     // 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/api-sdk-v1/OrderItemApi.ts

@@ -398,33 +398,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, linkedOrderItemId: string) {
-   
-     return await this._deleteLinks(this.moduleName, this.entityName, orderItemId, linkedOrderItemId);
-   }
-
-      
     // 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/api-sdk-v1/OrganizationApi.ts

@@ -155,31 +155,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, linkedOrganizationId: string) {
-   
-     return await this._deleteLinks(this.moduleName, this.entityName, organizationId, linkedOrganizationId);
-   }
-
-      
 }

package/src/api-sdk-v1/ProductApi.ts

@@ -317,35 +317,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, linkedProductId: string) {
-   
-     return await this._deleteLinks(this.moduleName, this.entityName, productId, linkedProductId);
-   }
-
-      
-   public async addProductProductLinkProperties(productId: string, dbRecordAssociationId: string, updateDto: OdinLinkedRecordUpdateDto) {
-
-     return await this._updateLinkProperties('ProductModule', 'Product', productId, dbRecordAssociationId, updateDto);
-   }
 }

package/src/api-sdk-v1/ProductComponentApi.ts

@@ -128,31 +128,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, linkedProductComponentId: string) {
-   
-     return await this._deleteLinks(this.moduleName, this.entityName, productComponentId, linkedProductComponentId);
-   }
-
-      
 }

package/src/api-sdk-v1/RestrictionApi.ts

@@ -128,31 +128,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, linkedRestrictionId: string) {
-   
-     return await this._deleteLinks(this.moduleName, this.entityName, restrictionId, linkedRestrictionId);
-   }
-
-      
 }

package/src/api-sdk-v1/ServiceApi.ts

@@ -101,31 +101,4 @@
   }
 
       
-    // Use this function when you want to return a single record
-    public async getServices(serviceId: string) {
-      return await this._getLinks(this.moduleName, this.entityName, serviceId, 'Service');
-    }
-        
-   public async linkServiceServices(serviceId: string, serviceIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
-
-    const associationDtos = [];
-    for(const param of serviceIds){
-      associationDtos.push({
-          entity: 'ServiceModule:Service',
-          recordId: param.id,
-          linkType: 'Service__Service',
-          relationType: param?.relationType,
-          relatedAssociationId: param?.relatedAssociationId
-      });
-    }
-
-     return await this._createLinks(this.moduleName, this.entityName, serviceId, associationDtos);
-   }
-
-   public async unLinkServiceServices(serviceId: string, linkedServiceId: string) {
-   
-     return await this._deleteLinks(this.moduleName, this.entityName, serviceId, linkedServiceId);
-   }
-
-      
 }

package/src/api-sdk-v1/ServiceAppointmentConfigApi.ts

@@ -263,4 +263,48 @@
    }
 
       
+   public async linkManagers(serviceAppointmentConfigId: string, userIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+    const associationDtos = [];
+    for(const param of userIds){
+      associationDtos.push({
+          entity: 'IdentityModule:User',
+          recordId: param.id,
+          linkType: 'Manager',
+          relationType: param?.relationType,
+          relatedAssociationId: param?.relatedAssociationId
+      });
+    }
+
+     return await this._createLinks(this.moduleName, this.entityName, serviceAppointmentConfigId, associationDtos);
+   }
+
+   public async unLinkManagers(serviceAppointmentConfigId: string, linkedUserId: string) {
+   
+     return await this._deleteLinks(this.moduleName, this.entityName, serviceAppointmentConfigId, linkedUserId);
+   }
+
+      
+   public async linkSupervisors(serviceAppointmentConfigId: string, userIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+    const associationDtos = [];
+    for(const param of userIds){
+      associationDtos.push({
+          entity: 'IdentityModule:User',
+          recordId: param.id,
+          linkType: 'Supervisor',
+          relationType: param?.relationType,
+          relatedAssociationId: param?.relatedAssociationId
+      });
+    }
+
+     return await this._createLinks(this.moduleName, this.entityName, serviceAppointmentConfigId, associationDtos);
+   }
+
+   public async unLinkSupervisors(serviceAppointmentConfigId: string, linkedUserId: string) {
+   
+     return await this._deleteLinks(this.moduleName, this.entityName, serviceAppointmentConfigId, linkedUserId);
+   }
+
+      
 }

package/src/api-sdk-v1/SplitOrderApi.ts

@@ -128,31 +128,26 @@
    }
 
       
-    // Use this function when you want to return a single record
-    public async getSplitOrders(splitOrderId: string) {
-      return await this._getLinks(this.moduleName, this.entityName, splitOrderId, 'SplitOrder');
-    }
-        
-   public async linkSplitOrderSplitOrders(splitOrderId: string, splitOrderIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
-
-    const associationDtos = [];
-    for(const param of splitOrderIds){
-      associationDtos.push({
-          entity: 'OrderModule:SplitOrder',
-          recordId: param.id,
-          linkType: 'SplitOrder__SplitOrder',
-          relationType: param?.relationType,
-          relatedAssociationId: param?.relatedAssociationId
-      });
-    }
+   public async linkOrderSplitOrders(splitOrderId: string, orderIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
 
-     return await this._createLinks(this.moduleName, this.entityName, splitOrderId, associationDtos);
+   const associationDtos = [];
+   for(const param of orderIds){
+     associationDtos.push({
+         entity: 'OrderModule:Order',
+         recordId: param.id,
+         linkType: 'Order__SplitOrder',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
    }
 
-   public async unLinkSplitOrderSplitOrders(splitOrderId: string, linkedSplitOrderId: string) {
-   
-     return await this._deleteLinks(this.moduleName, this.entityName, splitOrderId, linkedSplitOrderId);
-   }
+    return await this._createLinks(this.moduleName, this.entityName, splitOrderId, associationDtos);
+  }
+
+  public async unLinkOrderSplitOrders(splitOrderId: string, linkedOrderId: string) {
+  
+    return await this._deleteLinks(this.moduleName, this.entityName, splitOrderId, linkedOrderId);
+  }
 
       
 }