@d19n/youfibre-odin-sdk 1.0.21 → 1.0.22

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

@@ -128,4 +128,31 @@
   }
 
       
+    // 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,4 +128,31 @@
   }
 
       
+    // 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,4 +101,31 @@
   }
 
       
+    // 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/SplitOrderApi.ts

@@ -128,6 +128,33 @@
    }
 
       
+    // 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
+      });
+    }
+
+     return await this._createLinks(this.moduleName, this.entityName, splitOrderId, associationDtos);
+   }
+
+   public async unLinkSplitOrderSplitOrders(splitOrderId: string, linkedSplitOrderId: string) {
+   
+     return await this._deleteLinks(this.moduleName, this.entityName, splitOrderId, linkedSplitOrderId);
+   }
+
+      
    public async linkOrderSplitOrders(splitOrderId: string, orderIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
 
    const associationDtos = [];

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

@@ -101,6 +101,33 @@
    }
 
       
+    // Use this function when you want to return a single record
+    public async getTransactions(transactionId: string) {
+      return await this._getLinks(this.moduleName, this.entityName, transactionId, 'Transaction');
+    }
+        
+   public async linkTransactionTransactions(transactionId: string, transactionIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+    const associationDtos = [];
+    for(const param of transactionIds){
+      associationDtos.push({
+          entity: 'BillingModule:Transaction',
+          recordId: param.id,
+          linkType: 'Transaction__Transaction',
+          relationType: param?.relationType,
+          relatedAssociationId: param?.relatedAssociationId
+      });
+    }
+
+     return await this._createLinks(this.moduleName, this.entityName, transactionId, associationDtos);
+   }
+
+   public async unLinkTransactionTransactions(transactionId: string, linkedTransactionId: string) {
+   
+     return await this._deleteLinks(this.moduleName, this.entityName, transactionId, linkedTransactionId);
+   }
+
+      
    // Use this function when you want to return a single record
    public async getInvoices(transactionId: string) {
      return await this._getLinks(this.moduleName, this.entityName, transactionId, 'Invoice');

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

@@ -938,6 +938,33 @@
    }
 
       
+    // Use this function when you want to return a single record
+    public async getWorkOrders(workOrderId: string) {
+      return await this._getLinks(this.moduleName, this.entityName, workOrderId, 'WorkOrder');
+    }
+        
+   public async linkWorkOrderWorkOrders(workOrderId: 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__WorkOrder',
+          relationType: param?.relationType,
+          relatedAssociationId: param?.relatedAssociationId
+      });
+    }
+
+     return await this._createLinks(this.moduleName, this.entityName, workOrderId, associationDtos);
+   }
+
+   public async unLinkWorkOrderWorkOrders(workOrderId: string, linkedWorkOrderId: string) {
+   
+     return await this._deleteLinks(this.moduleName, this.entityName, workOrderId, linkedWorkOrderId);
+   }
+
+      
     // Use this function when you want to return a single record
     public async getOhAuditOfInstallations(workOrderId: string) {
       return await this._getLinks(this.moduleName, this.entityName, workOrderId, 'OhAuditOfInstallation');

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

@@ -99,6 +99,41 @@
   }
 
       
+    // Use this function when you want to return a single record
+    public async getBillingRequests(billingRequestId: string) {
+      return await this._getLinks(this.moduleName, this.entityName, billingRequestId, 'BillingRequest');
+    }
+        
+   public async linkBillingRequestBillingRequests(billingRequestId: string, billingRequestIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+    const associationDtos = [];
+    for(const param of billingRequestIds){
+      associationDtos.push({
+          entity: 'BillingModule:BillingRequest',
+          recordId: param.id,
+          linkType: 'BillingRequest__BillingRequest',
+          relationType: param?.relationType,
+          relatedAssociationId: param?.relatedAssociationId
+      });
+    }
+
+     return await this._createLinks(this.moduleName, this.entityName, billingRequestId, associationDtos);
+   }
+
+   public async unlinkBillingRequestBillingRequests(billingRequestId: string, linkedBillingRequestIds: string[]) {
+   
+      const associationDtos = [];
+   for(const pk of linkedBillingRequestIds){
+     associationDtos.push({
+        primaryKey: billingRequestId,
+        linkedRecordPrimaryKey: pk,
+     });
+   }
+   
+     return await this._deleteLinks(this.moduleName, this.entityName, billingRequestId, associationDtos);
+   }
+
+      
     // Use this function when you want to return a single record
     public async getFiles(billingRequestId: string) {
       return await this._getLinks(this.moduleName, this.entityName, billingRequestId, 'File');

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

@@ -64,6 +64,41 @@
    }
 
   
+    // Use this function when you want to return a single record
+    public async getCases(caseId: string) {
+      return await this._getLinks(this.moduleName, this.entityName, caseId, 'Case');
+    }
+        
+   public async linkCaseCases(caseId: 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__Case',
+          relationType: param?.relationType,
+          relatedAssociationId: param?.relatedAssociationId
+      });
+    }
+
+     return await this._createLinks(this.moduleName, this.entityName, caseId, associationDtos);
+   }
+
+   public async unlinkCaseCases(caseId: string, linkedCaseIds: string[]) {
+   
+      const associationDtos = [];
+   for(const pk of linkedCaseIds){
+     associationDtos.push({
+        primaryKey: caseId,
+        linkedRecordPrimaryKey: pk,
+     });
+   }
+   
+     return await this._deleteLinks(this.moduleName, this.entityName, caseId, associationDtos);
+   }
+
+      
     // Use this function when you want to return a single record
     public async getFiles(caseId: string) {
       return await this._getLinks(this.moduleName, this.entityName, caseId, 'File');

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

@@ -99,4 +99,39 @@
   }
 
       
+    // Use this function when you want to return a single record
+    public async getConsumptionRates(consumptionRateId: string) {
+      return await this._getLinks(this.moduleName, this.entityName, consumptionRateId, 'ConsumptionRate');
+    }
+        
+   public async linkConsumptionRateConsumptionRates(consumptionRateId: string, consumptionRateIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+    const associationDtos = [];
+    for(const param of consumptionRateIds){
+      associationDtos.push({
+          entity: 'ProductModule:ConsumptionRate',
+          recordId: param.id,
+          linkType: 'ConsumptionRate__ConsumptionRate',
+          relationType: param?.relationType,
+          relatedAssociationId: param?.relatedAssociationId
+      });
+    }
+
+     return await this._createLinks(this.moduleName, this.entityName, consumptionRateId, associationDtos);
+   }
+
+   public async unlinkConsumptionRateConsumptionRates(consumptionRateId: string, linkedConsumptionRateIds: string[]) {
+   
+      const associationDtos = [];
+   for(const pk of linkedConsumptionRateIds){
+     associationDtos.push({
+        primaryKey: consumptionRateId,
+        linkedRecordPrimaryKey: pk,
+     });
+   }
+   
+     return await this._deleteLinks(this.moduleName, this.entityName, consumptionRateId, associationDtos);
+   }
+
+      
 }

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

@@ -134,4 +134,39 @@
   }
 
       
+    // Use this function when you want to return a single record
+    public async getConsumptionSchedules(consumptionScheduleId: string) {
+      return await this._getLinks(this.moduleName, this.entityName, consumptionScheduleId, 'ConsumptionSchedule');
+    }
+        
+   public async linkConsumptionScheduleConsumptionSchedules(consumptionScheduleId: string, consumptionScheduleIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+    const associationDtos = [];
+    for(const param of consumptionScheduleIds){
+      associationDtos.push({
+          entity: 'ProductModule:ConsumptionSchedule',
+          recordId: param.id,
+          linkType: 'ConsumptionSchedule__ConsumptionSchedule',
+          relationType: param?.relationType,
+          relatedAssociationId: param?.relatedAssociationId
+      });
+    }
+
+     return await this._createLinks(this.moduleName, this.entityName, consumptionScheduleId, associationDtos);
+   }
+
+   public async unlinkConsumptionScheduleConsumptionSchedules(consumptionScheduleId: string, linkedConsumptionScheduleIds: string[]) {
+   
+      const associationDtos = [];
+   for(const pk of linkedConsumptionScheduleIds){
+     associationDtos.push({
+        primaryKey: consumptionScheduleId,
+        linkedRecordPrimaryKey: pk,
+     });
+   }
+   
+     return await this._deleteLinks(this.moduleName, this.entityName, consumptionScheduleId, associationDtos);
+   }
+
+      
 }

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

@@ -519,6 +519,41 @@
   }
 
       
+    // 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');
+    }
+        
+   public async linkContactContacts(contactId: string, contactIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+    const associationDtos = [];
+    for(const param of contactIds){
+      associationDtos.push({
+          entity: 'CrmModule:Contact',
+          recordId: param.id,
+          linkType: 'Contact__Contact',
+          relationType: param?.relationType,
+          relatedAssociationId: param?.relatedAssociationId
+      });
+    }
+
+     return await this._createLinks(this.moduleName, this.entityName, contactId, associationDtos);
+   }
+
+   public async unlinkContactContacts(contactId: string, linkedContactIds: string[]) {
+   
+      const associationDtos = [];
+   for(const pk of linkedContactIds){
+     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');

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

@@ -99,6 +99,41 @@
    }
 
       
+    // 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');

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

@@ -99,4 +99,39 @@
   }
 
       
+    // 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/MilestoneDb.ts

@@ -134,6 +134,41 @@
    }
 
       
+    // 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

@@ -1709,6 +1709,41 @@
   }
 
       
+    // 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}[]) {
+
+    const associationDtos = [];
+    for(const param of noteIds){
+      associationDtos.push({
+          entity: 'SupportModule:Note',
+          recordId: param.id,
+          linkType: 'Note__Note',
+          relationType: param?.relationType,
+          relatedAssociationId: param?.relatedAssociationId
+      });
+    }
+
+     return await this._createLinks(this.moduleName, this.entityName, noteId, associationDtos);
+   }
+
+   public async unlinkNoteNotes(noteId: string, linkedNoteIds: string[]) {
+   
+      const associationDtos = [];
+   for(const pk of linkedNoteIds){
+     associationDtos.push({
+        primaryKey: noteId,
+        linkedRecordPrimaryKey: pk,
+     });
+   }
+   
+     return await this._deleteLinks(this.moduleName, this.entityName, noteId, associationDtos);
+   }
+
+      
    public async linkNoteFiles(noteId: string, fileIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
 
     const associationDtos = [];

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

@@ -169,6 +169,41 @@
   }
 
       
+    // 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,6 +558,41 @@
    }
 
       
+    // 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) {
      return await this._getLinks(this.moduleName, this.entityName, orderId, 'PICRequest');