@d19n/youfibre-odin-sdk 1.0.19 → 1.0.21

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

@@ -309,4 +309,64 @@
    }
 
       
+   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, linkedUserIds: string[]) {
+   
+      const associationDtos = [];
+   for(const pk of linkedUserIds){
+     associationDtos.push({
+        primaryKey: serviceAppointmentConfigId,
+        linkedRecordPrimaryKey: pk,
+     });
+   }
+   
+     return await this._deleteLinks(this.moduleName, this.entityName, serviceAppointmentConfigId, associationDtos);
+   }
+
+      
+   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, linkedUserIds: string[]) {
+   
+      const associationDtos = [];
+   for(const pk of linkedUserIds){
+     associationDtos.push({
+        primaryKey: serviceAppointmentConfigId,
+        linkedRecordPrimaryKey: pk,
+     });
+   }
+   
+     return await this._deleteLinks(this.moduleName, this.entityName, serviceAppointmentConfigId, associationDtos);
+   }
+
+      
 }

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

@@ -99,39 +99,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, linkedServiceIds: string[]) {
-   
-      const associationDtos = [];
-   for(const pk of linkedServiceIds){
-     associationDtos.push({
-        primaryKey: serviceId,
-        linkedRecordPrimaryKey: pk,
-     });
-   }
-   
-     return await this._deleteLinks(this.moduleName, this.entityName, serviceId, associationDtos);
-   }
-
-      
 }

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

@@ -134,39 +134,34 @@
    }
 
       
-    // 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, linkedSplitOrderIds: string[]) {
-   
-      const associationDtos = [];
-   for(const pk of linkedSplitOrderIds){
+    return await this._createLinks(this.moduleName, this.entityName, splitOrderId, associationDtos);
+  }
+
+  public async unlinkOrderSplitOrders(splitOrderId: string, linkedOrderIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of linkedOrderIds){
      associationDtos.push({
         primaryKey: splitOrderId,
         linkedRecordPrimaryKey: pk,
      });
    }
-   
-     return await this._deleteLinks(this.moduleName, this.entityName, splitOrderId, associationDtos);
-   }
+
+    return await this._deleteLinks(this.moduleName, this.entityName, splitOrderId, associationDtos);
+  }
 
       
 }

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

@@ -99,41 +99,6 @@
    }
 
       
-    // 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, linkedTransactionIds: string[]) {
-   
-      const associationDtos = [];
-   for(const pk of linkedTransactionIds){
-     associationDtos.push({
-        primaryKey: transactionId,
-        linkedRecordPrimaryKey: pk,
-     });
-   }
-   
-     return await this._deleteLinks(this.moduleName, this.entityName, transactionId, associationDtos);
-   }
-
-      
    // 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/db-sdk-v1/UserDb.ts

@@ -449,4 +449,94 @@
   }
 
       
+   public async linkWorkOrderOwners(userId: string, workOrderIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+   const associationDtos = [];
+   for(const param of workOrderIds){
+     associationDtos.push({
+         entity: 'FieldServiceModule:WorkOrder',
+         recordId: param.id,
+         linkType: 'WorkOrderOwner',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, userId, associationDtos);
+  }
+
+  public async unlinkWorkOrderOwners(userId: string, linkedWorkOrderIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of linkedWorkOrderIds){
+     associationDtos.push({
+        primaryKey: userId,
+        linkedRecordPrimaryKey: pk,
+     });
+   }
+
+    return await this._deleteLinks(this.moduleName, this.entityName, userId, associationDtos);
+  }
+
+      
+   public async linkManagers(userId: string, serviceAppointmentConfigIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+   const associationDtos = [];
+   for(const param of serviceAppointmentConfigIds){
+     associationDtos.push({
+         entity: 'FieldServiceModule:ServiceAppointmentConfig',
+         recordId: param.id,
+         linkType: 'Manager',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, userId, associationDtos);
+  }
+
+  public async unlinkManagers(userId: string, linkedServiceAppointmentConfigIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of linkedServiceAppointmentConfigIds){
+     associationDtos.push({
+        primaryKey: userId,
+        linkedRecordPrimaryKey: pk,
+     });
+   }
+
+    return await this._deleteLinks(this.moduleName, this.entityName, userId, associationDtos);
+  }
+
+      
+   public async linkSupervisors(userId: string, serviceAppointmentConfigIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+   const associationDtos = [];
+   for(const param of serviceAppointmentConfigIds){
+     associationDtos.push({
+         entity: 'FieldServiceModule:ServiceAppointmentConfig',
+         recordId: param.id,
+         linkType: 'Supervisor',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, userId, associationDtos);
+  }
+
+  public async unlinkSupervisors(userId: string, linkedServiceAppointmentConfigIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of linkedServiceAppointmentConfigIds){
+     associationDtos.push({
+        primaryKey: userId,
+        linkedRecordPrimaryKey: pk,
+     });
+   }
+
+    return await this._deleteLinks(this.moduleName, this.entityName, userId, associationDtos);
+  }
+
+      
 }

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

@@ -274,39 +274,39 @@
    }
 
       
-    // 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');
-    }
+   // Use this function when you want to return a single record
+   public async getAccounts(workOrderId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, workOrderId, 'Account');
+   }
         
-   public async linkAccountWorkOrders(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: 'Account__WorkOrder',
-          relationType: param?.relationType,
-          relatedAssociationId: param?.relatedAssociationId
-      });
-    }
+   public async linkAccountWorkOrders(workOrderId: string, accountIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
 
-     return await this._createLinks(this.moduleName, this.entityName, workOrderId, associationDtos);
+   const associationDtos = [];
+   for(const param of accountIds){
+     associationDtos.push({
+         entity: 'CrmModule:Account',
+         recordId: param.id,
+         linkType: 'Account__WorkOrder',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
    }
 
-   public async unlinkAccountWorkOrders(workOrderId: string, linkedWorkOrderIds: string[]) {
-   
-      const associationDtos = [];
-   for(const pk of linkedWorkOrderIds){
+    return await this._createLinks(this.moduleName, this.entityName, workOrderId, associationDtos);
+  }
+
+  public async unlinkAccountWorkOrders(workOrderId: string, linkedAccountIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of linkedAccountIds){
      associationDtos.push({
         primaryKey: workOrderId,
         linkedRecordPrimaryKey: pk,
      });
    }
-   
-     return await this._deleteLinks(this.moduleName, this.entityName, workOrderId, associationDtos);
-   }
+
+    return await this._deleteLinks(this.moduleName, this.entityName, workOrderId, associationDtos);
+  }
 
       
     // Use this function when you want to return a single record
@@ -554,6 +554,41 @@
    }
 
       
+   // Use this function when you want to return a single record
+   public async getPaymentMethodRefunds(workOrderId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, workOrderId, 'PaymentMethodRefund');
+   }
+        
+   public async linkPaymentMethodRefundWorkOrders(workOrderId: string, paymentMethodRefundIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+   const associationDtos = [];
+   for(const param of paymentMethodRefundIds){
+     associationDtos.push({
+         entity: 'BillingModule:PaymentMethodRefund',
+         recordId: param.id,
+         linkType: 'PaymentMethodRefund__WorkOrder',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, workOrderId, associationDtos);
+  }
+
+  public async unlinkPaymentMethodRefundWorkOrders(workOrderId: string, linkedPaymentMethodRefundIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of linkedPaymentMethodRefundIds){
+     associationDtos.push({
+        primaryKey: workOrderId,
+        linkedRecordPrimaryKey: pk,
+     });
+   }
+
+    return await this._deleteLinks(this.moduleName, this.entityName, workOrderId, associationDtos);
+  }
+
+      
     // Use this function when you want to return a single record
     public async getLeads(workOrderId: string) {
       return await this._getLinks(this.moduleName, this.entityName, workOrderId, 'Lead');
@@ -729,6 +764,41 @@
    }
 
       
+   // Use this function when you want to return a single record
+   public async getOrders(workOrderId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, workOrderId, 'Order');
+   }
+        
+   public async linkOrderWorkOrders(workOrderId: 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__WorkOrder',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, workOrderId, associationDtos);
+  }
+
+  public async unlinkOrderWorkOrders(workOrderId: string, linkedOrderIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of linkedOrderIds){
+     associationDtos.push({
+        primaryKey: workOrderId,
+        linkedRecordPrimaryKey: pk,
+     });
+   }
+
+    return await this._deleteLinks(this.moduleName, this.entityName, workOrderId, associationDtos);
+  }
+
+      
     // Use this function when you want to return a single record
     public async getServiceAppointmentConfigs(workOrderId: string) {
       return await this._getLinks(this.moduleName, this.entityName, workOrderId, 'ServiceAppointmentConfig');
@@ -834,6 +904,111 @@
    }
 
       
+   // Use this function when you want to return a single record
+   public async getOrderRemediationTasks(workOrderId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, workOrderId, 'OrderRemediationTask');
+   }
+        
+   public async linkOrderRemediationTaskWorkOrders(workOrderId: 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__WorkOrder',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, workOrderId, associationDtos);
+  }
+
+  public async unlinkOrderRemediationTaskWorkOrders(workOrderId: string, linkedOrderRemediationTaskIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of linkedOrderRemediationTaskIds){
+     associationDtos.push({
+        primaryKey: workOrderId,
+        linkedRecordPrimaryKey: pk,
+     });
+   }
+
+    return await this._deleteLinks(this.moduleName, this.entityName, workOrderId, associationDtos);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getCases(workOrderId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, workOrderId, 'Case');
+   }
+        
+   public async linkCaseWorkOrders(workOrderId: 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__WorkOrder',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, workOrderId, associationDtos);
+  }
+
+  public async unlinkCaseWorkOrders(workOrderId: string, linkedCaseIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of linkedCaseIds){
+     associationDtos.push({
+        primaryKey: workOrderId,
+        linkedRecordPrimaryKey: pk,
+     });
+   }
+
+    return await this._deleteLinks(this.moduleName, this.entityName, workOrderId, associationDtos);
+  }
+
+      
+   // Use this function when you want to return a single record
+   public async getCalls(workOrderId: string) {
+     return await this._getLinks(this.moduleName, this.entityName, workOrderId, 'Call');
+   }
+        
+   public async linkCallWorkOrders(workOrderId: 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__WorkOrder',
+         relationType: param?.relationType,
+         relatedAssociationId: param?.relatedAssociationId
+     });
+   }
+
+    return await this._createLinks(this.moduleName, this.entityName, workOrderId, associationDtos);
+  }
+
+  public async unlinkCallWorkOrders(workOrderId: string, linkedCallIds: string[]) {
+
+   const associationDtos = [];
+   for(const pk of linkedCallIds){
+     associationDtos.push({
+        primaryKey: workOrderId,
+        linkedRecordPrimaryKey: pk,
+     });
+   }
+
+    return await this._deleteLinks(this.moduleName, this.entityName, workOrderId, associationDtos);
+  }
+
+      
     // Use this function when you want to return a single record
     public async getPermissionToFails(workOrderId: string) {
       return await this._getLinks(this.moduleName, this.entityName, workOrderId, 'PermissionToFail');
@@ -1079,6 +1254,36 @@
    }
 
       
+   public async linkWorkOrderOwners(workOrderId: string, userIds: {id: string, relationType?: RelationTypeEnum, relatedAssociationId?: string}[]) {
+
+    const associationDtos = [];
+    for(const param of userIds){
+      associationDtos.push({
+          entity: 'IdentityModule:User',
+          recordId: param.id,
+          linkType: 'WorkOrderOwner',
+          relationType: param?.relationType,
+          relatedAssociationId: param?.relatedAssociationId
+      });
+    }
+
+     return await this._createLinks(this.moduleName, this.entityName, workOrderId, associationDtos);
+   }
+
+   public async unlinkWorkOrderOwners(workOrderId: string, linkedUserIds: string[]) {
+   
+      const associationDtos = [];
+   for(const pk of linkedUserIds){
+     associationDtos.push({
+        primaryKey: workOrderId,
+        linkedRecordPrimaryKey: pk,
+     });
+   }
+   
+     return await this._deleteLinks(this.moduleName, this.entityName, workOrderId, associationDtos);
+   }
+
+      
     // Use this function when you want to return a single record
     public async getNetomniaFtthServiceVisitSheets(workOrderId: string) {
       return await this._getLinks(this.moduleName, this.entityName, workOrderId, 'NetomniaFtthServiceVisitSheet');

package/src/generators/runner.ts

@@ -12,7 +12,6 @@ const entitiesToExclude = [
     'EsTest',
     'KnowledgeArticle',
     'OhRetroAudit',
-    'OrderTest1',
     'OutcomeFormOhRetroAudit',
     'OutcomeFormOverlayA55',
     'OutcomeFormUgRetroAudit',
@@ -26,8 +25,8 @@ const entitiesToExclude = [
 
 (async function exec(){
 
-    generateEntities({ entitiesToExclude });
-    generateTypes({ entitiesToExclude });
+    // generateEntities({ entitiesToExclude });
+    // generateTypes({ entitiesToExclude });
     generateApiSdk({ entitiesToExclude });
     generateDbSdk({ entitiesToExclude });