@agroyaar/sdk 2.4.5 → 3.0.0-0

package/dist/index.cjs

@@ -90,117 +90,9 @@ var createClient = (config, middlewares = []) => {
   return client;
 };
 
-// src/services/dashboard/mechanization/mechanization.service.ts
+// src/services/dashboard/sensors/sensors.service.ts
 var import_ts_belt2 = require("@mobily/ts-belt");
 
-// src/services/dashboard/mechanization/mechanization.mapper.ts
-var mappers = {
-  getMechanizationVariety: (response) => ({
-    id: response.id,
-    name: response.name,
-    iconURL: response.iconURL,
-    kind: response.kind,
-    seasonProcessIds: response.seasonProcessIds,
-    machineUsageIds: response.machineUsageIds,
-    seasonsProcess: response.seasonsProcess
-  }),
-  getMechanizationVarietyList: (response) => response.map(mappers.getMechanizationVariety),
-  getSpeedChangesChart: (response) => ({
-    speed: response.speed,
-    date: response.date
-  }),
-  getSpeedChangesChartPointsList: (response) => response.map(mappers.getSpeedChangesChart),
-  getMechanization: (res) => ({
-    id: res.id,
-    commonName: res.commonName,
-    model: res.model,
-    avatarURL: res.avatarURL,
-    manufactureYear: res.manufactureYear,
-    code: res.code,
-    kind: res.kind,
-    kindName: res.kindName,
-    deviceCode: res.deviceCode,
-    variety: mappers.getMechanizationVariety(res.variety)
-  }),
-  getMechanizations: (response) => response.map(mappers.getMechanization),
-  getSeasonsProcess: (response) => ({
-    id: response.id,
-    label: response.label,
-    mechanizationVarietyIds: response.mechanizationVarietyIds,
-    name: response.name
-  }),
-  getSeasonsProcessList: (response) => response.map(mappers.getSeasonsProcess),
-  getMotorizedMechanizationSensors: (response) => ({
-    id: response.id,
-    speed: response.speed,
-    heading: response.heading,
-    latitude: response.latitude,
-    longitude: response.longitude,
-    fuelLevel: response.fuelLevel,
-    engineRpm: response.engineRpm,
-    deviceCode: response.deviceCode,
-    stateEngine: response.stateEngine,
-    engineOilPressure: response.engineOilPressure,
-    engineWaterTemperature: response.engineWaterTemperature,
-    batteryChargePercentage: response.batteryChargePercentage,
-    mechanizationId: response.mechanizationId
-  }),
-  SubmitTrackingDeviceData: (response) => ({
-    deviceCode: response.deviceCode
-  }),
-  UpdateTrackingDeviceData: (response) => ({
-    deviceCode: response.deviceCode
-  }),
-  DeleteTrackingDeviceData: (response) => ({
-    deviceCode: response.deviceCode
-  }),
-  getQuestion: (dto) => ({
-    id: dto.id,
-    name: dto.key,
-    label: dto.title,
-    placeholder: dto.placeholder,
-    isRequired: dto.required,
-    type: dto.kindName,
-    options: dto.options?.map((item) => ({
-      label: item.label,
-      value: item.id
-    })) ?? []
-  }),
-  getQuestions: (dto) => dto.map(mappers.getQuestion),
-  getMechanizationMovementChange: ({
-    date,
-    heading,
-    latitude,
-    longitude
-  }) => ({
-    longitude,
-    latitude,
-    date,
-    heading
-  }),
-  getMechanizationMovementChanges: (response) => response.map(mappers.getMechanizationMovementChange),
-  verifyPhoneNumber: (dto) => ({
-    phoneNumber: dto.phoneNumber,
-    verificationToken: dto.verificationToken
-  }),
-  getMechanizationTemperatureChange: ({
-    engineWaterTemperature,
-    date
-  }) => ({
-    engineWaterTemperature,
-    date
-  }),
-  getMechanizationTemperatureChanges: (response) => response.map(mappers.getMechanizationTemperatureChange),
-  getMechanizationFuelConsumptionChange: ({
-    fuelConsumption,
-    date
-  }) => ({
-    fuelConsumption,
-    date
-  }),
-  getMechanizationFuelConsumptionChanges: (response) => response.map(mappers.getMechanizationFuelConsumptionChange)
-};
-
 // src/utils/wrapError.ts
 var import_ts_belt = require("@mobily/ts-belt");
 var wrapError = (error) => {
@@ -208,321 +100,464 @@ var wrapError = (error) => {
   return import_ts_belt.R.Error(err);
 };
 
-// src/services/dashboard/mechanization/mechanization.service.ts
-var createMechanizationServices = (client) => ({
-  getMechanizationVarieties: async ({
-    kindName
+// src/services/dashboard/sensors/sensors.mapper.ts
+var sensorsMapper = {
+  getMechanizationSensors: (dto) => ({
+    id: dto.id,
+    speed: dto.speed,
+    heading: dto.heading,
+    latitude: dto.latitude,
+    longitude: dto.longitude,
+    fuelLevel: dto.fuelLevel,
+    engineRpm: dto.engineRpm,
+    deviceCode: dto.deviceCode,
+    stateEngine: dto.stateEngine,
+    engineOilPressure: dto.engineOilPressure,
+    engineWaterTemperature: dto.engineWaterTemperature,
+    batteryChargePercentage: dto.batteryChargePercentage,
+    mechanizationId: dto.mechanizationId
+  }),
+  getMechanizationTemperatureChange: (dto) => ({
+    date: dto.date,
+    engineWaterTemperature: dto.engineWaterTemperature
+  }),
+  getMechanizationTemperatureChanges: (dto) => dto.map(sensorsMapper.getMechanizationTemperatureChange),
+  getMechanizationFuelConsumptionChange: (dto) => ({
+    date: dto.date,
+    fuelConsumption: dto.fuelConsumption
+  }),
+  getMechanizationFuelConsumptionChanges: (dto) => dto.map(sensorsMapper.getMechanizationFuelConsumptionChange)
+};
+
+// src/services/dashboard/sensors/sensors.service.ts
+var createSensorsServices = (client) => ({
+  getMechanizationSensors: async ({
+    pathParams
   }) => {
     try {
-      const { data } = await client.get(
-        `/statics/mechanizations-varieties?kindName=${kindName}`
+      const response = await client.typed(
+        "get",
+        "/farmers/{farmerId}/mechanizations/{mechanizationId}/sensors",
+        {
+          pathParams
+        }
       );
+      const motorizedMechanizationSensors = response.result.data.motorizedMechanizationSensors;
       return import_ts_belt2.R.Ok(
-        mappers.getMechanizationVarietyList(
-          data.result.data.mechanizationVarieties
-        )
+        sensorsMapper.getMechanizationSensors(motorizedMechanizationSensors)
       );
     } catch (error) {
       return wrapError(error);
     }
   },
-  getSpeedChangesChartData: async ({
-    farmerId,
-    mechanizationId
+  getMechanizationTemperatureChanges: async ({
+    params,
+    pathParams
   }) => {
     try {
-      const result = await client.typed(
+      const response = await client.typed(
         "get",
-        "/farmers/{farmerId}/mechanizations/{mechanizationId}/sensors/speed-changes",
+        "/farmers/{farmerId}/mechanizations/{mechanizationId}/sensors/temperature-changes",
         {
-          pathParams: { farmerId, mechanizationId }
+          params,
+          pathParams
         }
       );
+      const temperatureChanges = response.result.data.temperatureChanges;
       return import_ts_belt2.R.Ok(
-        mappers.getSpeedChangesChartPointsList(result.result.data.speedChanges)
+        sensorsMapper.getMechanizationTemperatureChanges(temperatureChanges)
       );
     } catch (error) {
       return wrapError(error);
     }
   },
-  getMechanization: async ({
-    farmerId,
-    mechanizationId
+  getMechanizationFuelConsumptionChanges: async ({
+    params,
+    pathParams
   }) => {
     try {
       const response = await client.typed(
         "get",
-        "/farmers/{farmerId}/mechanizations/{mechanizationId}",
+        "/farmers/{farmerId}/mechanizations/{mechanizationId}/sensors/fuel-consumption-changes",
         {
-          pathParams: {
-            farmerId,
-            mechanizationId
-          }
+          params,
+          pathParams
         }
       );
-      const mechanization = response.result.data.mechanization;
-      return import_ts_belt2.R.Ok(mappers.getMechanization(mechanization));
+      const fuelConsumptionChanges = response.result.data.fuelConsumptionChanges;
+      return import_ts_belt2.R.Ok(
+        sensorsMapper.getMechanizationFuelConsumptionChanges(
+          fuelConsumptionChanges
+        )
+      );
     } catch (error) {
       return wrapError(error);
     }
-  },
-  getMechanizations: async ({
-    farmerId,
-    kindName
-  }) => {
+  }
+});
+
+// src/services/dashboard/seasons-process/seasonsProcess.service.ts
+var import_ts_belt3 = require("@mobily/ts-belt");
+
+// src/services/dashboard/seasons-process/seasonsProcess.mapper.ts
+var seasonsProcessMapper = {
+  getOne: (dto) => ({
+    id: dto.id,
+    label: dto.label,
+    name: dto.name
+  }),
+  getAll: (dto) => dto.map(seasonsProcessMapper.getOne)
+};
+
+// src/services/dashboard/seasons-process/seasonsProcess.service.ts
+var createSeasonsProcess = (client) => ({
+  getSeasonsProcess: async () => {
     try {
       const response = await client.typed(
         "get",
-        "/farmers/{farmerId}/mechanizations",
-        {
-          params: {
-            kindName
-          },
-          pathParams: {
-            farmerId
-          }
-        }
+        "/statics/mechanizations-seasons-process-kinds"
+      );
+      return import_ts_belt3.R.Ok(
+        seasonsProcessMapper.getAll(
+          response.result.data.mechanizationSeasonProcessKinds
+        )
       );
-      const mechanizations = response.result.data.mechanizations;
-      return import_ts_belt2.R.Ok(mappers.getMechanizations(mechanizations));
     } catch (error) {
       return wrapError(error);
     }
-  },
-  getMotorizedMechanizationSensors: async ({
-    farmerId,
-    mechanizationId
+  }
+});
+
+// src/services/dashboard/mechanization-variety/variety.mapper.ts
+var varietiesMapper = {
+  getOne: (dto) => ({
+    id: dto.id,
+    name: dto.name,
+    iconURL: dto.iconURL,
+    kind: dto.kind,
+    seasonProcessIds: dto.seasonProcessIds,
+    machineUsageIds: dto.machineUsageIds,
+    seasonsProcess: dto.seasonsProcess
+  }),
+  getAll: (dto) => dto.map(varietiesMapper.getOne)
+};
+
+// src/services/dashboard/mechanization-variety/variety.service.ts
+var import_ts_belt4 = require("@mobily/ts-belt");
+var createVarietiesService = (client) => ({
+  getAllMechanizationVarieties: async ({
+    params
   }) => {
     try {
-      const response = await client.typed(
+      const { result } = await client.typed(
         "get",
-        "/farmers/{farmerId}/mechanizations/{mechanizationId}/sensors",
+        "/statics/mechanizations-varieties",
+        { params }
+      );
+      const mechanizationVarieties = result.data.mechanizationVarieties;
+      return import_ts_belt4.R.Ok(varietiesMapper.getAll(mechanizationVarieties));
+    } catch (error) {
+      return wrapError(error);
+    }
+  }
+});
+
+// src/services/dashboard/mechanization-question/getQuestion.service.ts
+var import_ts_belt5 = require("@mobily/ts-belt");
+
+// src/services/dashboard/mechanization-question/question.mapper.ts
+var mechanizationQuestionMappers = {
+  getOne: (dto) => ({
+    id: dto.id,
+    name: dto.key,
+    label: dto.title,
+    placeholder: dto.placeholder,
+    isRequired: dto.required,
+    type: dto.kindName,
+    options: dto.options?.map((item) => ({
+      label: item.label,
+      value: item.id
+    })) ?? []
+  }),
+  getAll: (dto) => dto.map(mechanizationQuestionMappers.getOne)
+};
+
+// src/services/dashboard/mechanization-question/getQuestion.service.ts
+var createQuestionServices = (client) => ({
+  getAllMechanizationQuestions: async ({
+    params
+  }) => {
+    try {
+      const data = await client.typed(
+        "get",
+        "/statics/mechanizations-questions",
         {
-          pathParams: {
-            farmerId,
-            mechanizationId
-          }
+          params: { mechanizationVarietyId: params.mechanizationVarietyId }
         }
       );
-      const motorizedMechanizationSensors = response.result.data.motorizedMechanizationSensors;
-      return import_ts_belt2.R.Ok(
-        mappers.getMotorizedMechanizationSensors(motorizedMechanizationSensors)
-      );
+      const questions = data?.result.data.mechanizationsQuestions;
+      return import_ts_belt5.R.Ok(mechanizationQuestionMappers.getAll(questions));
     } catch (error) {
       return wrapError(error);
     }
-  },
-  SubmitTrackingDeviceCode: async ({
-    farmerId,
-    mechanizationId,
-    deviceCode
+  }
+});
+
+// src/services/dashboard/device-code/device.service.ts
+var import_ts_belt6 = require("@mobily/ts-belt");
+
+// src/services/dashboard/device-code/deviceCode.mapper.ts
+var deviceCodeMapper = {
+  create: (dto) => ({
+    deviceCode: dto.deviceCode
+  }),
+  update: (dto) => ({
+    deviceCode: dto.deviceCode
+  }),
+  delete: (dto) => ({
+    deviceCode: dto.deviceCode
+  })
+};
+
+// src/services/dashboard/device-code/device.service.ts
+var createDeviceCodeServices = (client) => ({
+  create: async ({
+    body,
+    pathParams
   }) => {
     try {
       const result = await client.typed(
         "put",
         "/farmers/{farmerId}/mechanizations/{mechanizationId}/submit-device-code",
         {
-          body: { deviceCode },
-          pathParams: {
-            farmerId,
-            mechanizationId
-          }
+          body,
+          pathParams
         }
       );
-      return import_ts_belt2.R.Ok(
-        mappers.SubmitTrackingDeviceData(result.result.data.mechanization)
-      );
+      return import_ts_belt6.R.Ok(deviceCodeMapper.create(result.result.data.mechanization));
     } catch (error) {
       return wrapError(error);
     }
   },
-  getSeasonsProcess: async () => {
+  update: async ({
+    body,
+    pathParams
+  }) => {
     try {
-      const { data } = await client.get(
-        "/statics/mechanizations-seasons-process-kinds"
-      );
-      return import_ts_belt2.R.Ok(
-        mappers.getSeasonsProcessList(
-          data.result.data.mechanizationSeasonProcessKinds
-        )
+      const result = await client.typed(
+        "put",
+        "/farmers/{farmerId}/mechanizations/{mechanizationId}/update-device-code",
+        {
+          body,
+          pathParams
+        }
       );
+      return import_ts_belt6.R.Ok(deviceCodeMapper.update(result.result.data.mechanization));
     } catch (error) {
       return wrapError(error);
     }
   },
-  UpdateTrackingDeviceCode: async ({
-    farmerId,
-    mechanizationId,
-    deviceCode,
-    verificationToken
+  deleteTrackingDeviceCode: async ({
+    body,
+    pathParams
   }) => {
     try {
       const result = await client.typed(
-        "put",
-        "/farmers/{farmerId}/mechanizations/{mechanizationId}/update-device-code",
+        "delete",
+        "/farmers/{farmerId}/mechanizations/{mechanizationId}/delete-device-code",
         {
-          body: {
-            deviceCode,
-            verificationToken
-          },
-          pathParams: {
-            farmerId,
-            mechanizationId
-          }
+          body,
+          pathParams
         }
       );
-      return import_ts_belt2.R.Ok(
-        mappers.UpdateTrackingDeviceData(result.result.data.mechanization)
-      );
+      return import_ts_belt6.R.Ok(deviceCodeMapper.delete(result.result.data.mechanization));
     } catch (error) {
       return wrapError(error);
     }
-  },
-  getMechanizationQuestionList: async ({
-    varietyId
+  }
+});
+
+// src/services/dashboard/charts/charts.service.ts
+var import_ts_belt7 = require("@mobily/ts-belt");
+
+// src/services/dashboard/charts/chart.mapper.ts
+var chartMapper = {
+  getSpeedChange: (dto) => ({
+    speed: dto.speed,
+    date: dto.date
+  }),
+  getSpeedChangesList: (dto) => dto.map(chartMapper.getSpeedChange),
+  getMovementChange: ({
+    date,
+    heading,
+    latitude,
+    longitude
+  }) => ({
+    longitude,
+    latitude,
+    date,
+    heading
+  }),
+  getMovementChangeList: (dto) => ({
+    movementChanges: dto.movementChanges.map(chartMapper.getMovementChange),
+    meta: dto.meta
+  })
+};
+
+// src/services/dashboard/charts/charts.service.ts
+var createChartServices = (client) => ({
+  getSpeedChangesChartData: async ({
+    params,
+    pathParams
   }) => {
     try {
-      const data = await client.typed(
+      const { result } = await client.typed(
         "get",
-        "/statics/mechanizations-questions",
+        "/farmers/{farmerId}/mechanizations/{mechanizationId}/sensors/speed-changes",
         {
-          params: {
-            mechanizationVarietyId: varietyId
-          }
+          pathParams,
+          params
         }
       );
-      const questions = data?.result?.data.mechanizationsQuestions;
-      return import_ts_belt2.R.Ok(mappers.getQuestions(questions));
+      return import_ts_belt7.R.Ok(chartMapper.getSpeedChangesList(result.data.speedChanges));
     } catch (error) {
       return wrapError(error);
     }
   },
   getMechanizationMovementChanges: async ({
-    farmerId,
-    mechanizationId,
-    fromDate,
-    toDate
+    params,
+    pathParams
   }) => {
     try {
       const response = await client.typed(
         "get",
         "/farmers/{farmerId}/mechanizations/{mechanizationId}/sensors/movement-changes",
         {
-          params: {
-            fromDate,
-            toDate
-          },
-          pathParams: {
-            farmerId,
-            mechanizationId
-          }
+          params,
+          pathParams
         }
       );
-      const movementChanges = response.result.data.movementChanges;
-      return import_ts_belt2.R.Ok(mappers.getMechanizationMovementChanges(movementChanges));
+      const data = response.result.data;
+      return import_ts_belt7.R.Ok(chartMapper.getMovementChangeList(data));
     } catch (error) {
       return wrapError(error);
     }
-  },
-  DeleteTrackingDeviceCode: async ({
-    farmerId,
-    mechanizationId,
-    verificationToken
+  }
+});
+
+// src/services/dashboard/auth/auth.service.ts
+var import_ts_belt8 = require("@mobily/ts-belt");
+
+// src/services/dashboard/auth/auth.mapper.ts
+var authMapper = {
+  verifyPhoneNumber: (dto) => ({
+    phoneNumber: dto.phoneNumber,
+    verificationToken: dto.verificationToken
+  })
+};
+
+// src/services/dashboard/auth/auth.service.ts
+var createAuthService = (client) => ({
+  verifyPhoneNumber: async ({
+    body
   }) => {
     try {
-      const result = await client.typed(
-        "delete",
-        "/farmers/{farmerId}/mechanizations/{mechanizationId}/delete-device-code",
+      const result = await client.typed("post", "/auth/verify-phone-number", {
+        body
+      });
+      return import_ts_belt8.R.Ok(
+        authMapper.verifyPhoneNumber(result.result.data.verifyPhoneNumber)
+      );
+    } catch (error) {
+      return wrapError(error);
+    }
+  }
+});
+
+// src/services/dashboard/mechanization/mechanization.service.ts
+var import_ts_belt9 = require("@mobily/ts-belt");
+
+// src/services/dashboard/mechanization/mechanization.mapper.ts
+var mechanizationMapper = {
+  getOne: (dto) => ({
+    id: dto.id,
+    commonName: dto.commonName,
+    model: dto.model,
+    avatarURL: dto.avatarURL,
+    manufactureYear: dto.manufactureYear,
+    code: dto.code,
+    kind: dto.kind,
+    kindName: dto.kindName,
+    deviceCode: dto.deviceCode,
+    variety: varietiesMapper.getOne(dto.variety)
+  }),
+  getAll: (dto) => dto.map(mechanizationMapper.getOne),
+  create: (_res) => ({})
+};
+
+// src/services/dashboard/mechanization/mechanization.service.ts
+var createMechanizationServices = (client) => ({
+  getOne: async ({
+    pathParams
+  }) => {
+    try {
+      const response = await client.typed(
+        "get",
+        "/farmers/{farmerId}/mechanizations/{mechanizationId}",
         {
-          body: {
-            verificationToken
-          },
-          pathParams: {
-            farmerId,
-            mechanizationId
-          }
+          pathParams
         }
       );
-      return import_ts_belt2.R.Ok(
-        mappers.DeleteTrackingDeviceData(result.result.data.mechanization)
-      );
+      const mechanization = response.result.data.mechanization;
+      return import_ts_belt9.R.Ok(mechanizationMapper.getOne(mechanization));
     } catch (error) {
       return wrapError(error);
     }
   },
-  // verifyPhoneNumber: async ({
-  //   phoneNumber,
-  //   otpCode,
-  // }: VerifyPhoneNumberVariables) => {
-  //   try {
-  //     const result = await client.typed(
-  //       "post",
-  //       "/farmers/{farmerId}/cropping-patterns",
-  //       {
-  //         body: {
-  //           otpCode,
-  //           phoneNumber,
-  //         },
-  //       }
-  //     );
-  //     return R.Ok(mappers.verifyPhoneNumber(result));
-  //   } catch (error) {
-  //     return wrapError(error);
-  //   }
-  // },
-  getMechanizationTemperatureChanges: async ({
-    farmerId,
-    mechanizationId,
-    fromDate,
-    toDate
+  getAllMechanizations: async ({
+    pathParams: { farmerId },
+    path: { kindName }
   }) => {
     try {
       const response = await client.typed(
         "get",
-        "/farmers/{farmerId}/mechanizations/{mechanizationId}/sensors/temperature-changes",
+        "/farmers/{farmerId}/mechanizations",
         {
           params: {
-            fromDate,
-            toDate
+            kindName
           },
           pathParams: {
-            farmerId,
-            mechanizationId
+            farmerId
           }
         }
       );
-      const temperatureChanges = response.result.data.temperatureChanges;
-      return import_ts_belt2.R.Ok(
-        mappers.getMechanizationTemperatureChanges(temperatureChanges)
-      );
+      const mechanizations = response.result.data.mechanizations;
+      return import_ts_belt9.R.Ok(mechanizationMapper.getAll(mechanizations));
     } catch (error) {
       return wrapError(error);
     }
   },
-  getMechanizationFuelConsumptionChanges: async ({
-    farmerId,
-    mechanizationId,
-    fromDate,
-    toDate
+  CreateMechanization: async ({
+    body,
+    pathParams
   }) => {
     try {
       const response = await client.typed(
-        "get",
-        "/farmers/{farmerId}/mechanizations/{mechanizationId}/sensors/fuel-consumption-changes",
+        "post",
+        "/farmers/{farmerId}/mechanizations",
         {
-          params: {
-            fromDate,
-            toDate
-          },
           pathParams: {
-            farmerId,
-            mechanizationId
+            farmerId: pathParams.farmerId
+          },
+          body: {
+            avatarURL: body.avatarURL,
+            information: body.information,
+            varietyId: body.varietyId
           }
         }
       );
-      const fuelConsumptionChanges = response.result.data.fuelConsumptionChanges;
-      return import_ts_belt2.R.Ok(
-        mappers.getMechanizationFuelConsumptionChanges(fuelConsumptionChanges)
+      return import_ts_belt9.R.Ok(
+        mechanizationMapper.create(response.result.data.mechanization)
       );
     } catch (error) {
       return wrapError(error);
@@ -535,7 +570,14 @@ var createSDK = (config, middlewares = []) => {
   const client = createClient(config, middlewares);
   return {
     dashboardServices: {
-      mechanization: createMechanizationServices(client)
+      mechanization: createMechanizationServices(client),
+      auth: createAuthService(client),
+      charts: createChartServices(client),
+      deviceCode: createDeviceCodeServices(client),
+      mechanizationQuestion: createQuestionServices(client),
+      seasonsProcess: createSeasonsProcess(client),
+      sensors: createSensorsServices(client),
+      varieties: createVarietiesService(client)
     }
   };
 };