indas-ui 0.0.1 → 0.1.0

package/dist/lib/api/master/material-group.js

@@ -0,0 +1,96 @@
+'use client';
+// Material Group Master API
+// Handles all material group operations
+import APIClient from '../core/client.js';
+/**
+ * Material Group API class
+ */
+export class MaterialGroupAPI {
+    /**
+     * Get all material groups
+     * Endpoint: GET /api/itemmaster/group
+     */
+    static async getGroups(sessionData) {
+        return APIClient.get('api/itemmaster/group', sessionData);
+    }
+    /**
+     * Get under groups (parent groups) for dropdown
+     * Endpoint: GET /api/itemmaster/under-group
+     */
+    static async getUnderGroups(sessionData) {
+        return APIClient.get('api/itemmaster/under-group', sessionData);
+    }
+    /**
+     * Save a new material group
+     * Endpoint: POST /api/itemmaster/save-group
+     *
+     * Request Body Format:
+     * {
+     *   CostingDataGroupMaster: [{
+     *     ItemSubGroupName: string,
+     *     ItemSubGroupDisplayName: string,
+     *     UnderSubGroupID: number
+     *   }],
+     *   GroupName: string,
+     *   UnderGroupID: number,
+     *   ItemGroupID: number
+     * }
+     *
+     * Response: "Success" or "Exist" (duplicate)
+     */
+    static async saveGroup(groupData, itemGroupID, sessionData) {
+        const requestData = {
+            CostingDataGroupMaster: [groupData],
+            GroupName: groupData.ItemSubGroupName,
+            UnderGroupID: groupData.UnderSubGroupID,
+            ItemGroupID: itemGroupID
+        };
+        return APIClient.post('api/itemmaster/save-group', requestData, sessionData);
+    }
+    /**
+     * Update an existing material group
+     * Endpoint: POST /api/itemmaster/update-group
+     *
+     * Request Body Format:
+     * {
+     *   CostingDataGroupMaster: [{
+     *     ItemSubGroupName: string,
+     *     ItemSubGroupDisplayName: string,
+     *     UnderSubGroupID: number
+     *   }],
+     *   ItemSubGroupUniqueID: string,
+     *   ItemSubGroupLevel: string,
+     *   GroupName: string,
+     *   ItemGroupID: number
+     * }
+     *
+     * Response: "Success" or "Exist" (duplicate)
+     */
+    static async updateGroup(uniqueID, level, groupData, itemGroupID, sessionData) {
+        const requestData = {
+            CostingDataGroupMaster: [groupData],
+            ItemSubGroupUniqueID: uniqueID,
+            ItemSubGroupLevel: level.toString(),
+            GroupName: groupData.ItemSubGroupName,
+            ItemGroupID: itemGroupID
+        };
+        return APIClient.post('api/itemmaster/update-group', requestData, sessionData);
+    }
+    /**
+     * Delete a material group
+     * Endpoint: POST /api/itemmaster/delete-group
+     *
+     * Request Body Format:
+     * {
+     *   ItemSubGroupUniqueID: string
+     * }
+     *
+     * Response: "Success"
+     */
+    static async deleteGroup(uniqueID, sessionData) {
+        const requestData = {
+            ItemSubGroupUniqueID: uniqueID
+        };
+        return APIClient.post('api/itemmaster/delete-group', requestData, sessionData);
+    }
+}

package/dist/lib/api/master/other.d.ts

@@ -0,0 +1,65 @@
+import type { APIResponse } from '../core/types.js';
+/**
+ * Other Settings API class
+ * Manages operations for Other Settings module (Unit, DieMasterImport)
+ */
+export declare class OtherSettingsAPI {
+    /**
+     * Get Unit list
+     * @param sessionData - Session data (REQUIRED)
+     */
+    static getUnitList(sessionData?: any): Promise<APIResponse>;
+    /**
+     * Save Unit
+     * @param unitData - Unit data
+     * @param sessionData - Session data (REQUIRED)
+     */
+    static saveUnit(unitData: {
+        UnitName: string;
+        UnitSymbol: string;
+        Type: string;
+        ConversionValue?: number;
+        DecimalPlace?: number;
+    }, sessionData?: any): Promise<APIResponse>;
+    /**
+     * Update Unit
+     * @param unitData - Unit data with UnitID
+     * @param sessionData - Session data (REQUIRED)
+     */
+    static updateUnit(unitData: {
+        UnitID: number;
+        UnitName: string;
+        UnitSymbol: string;
+        Type: string;
+        ConversionValue?: number;
+        DecimalPlace?: number;
+    }, sessionData?: any): Promise<APIResponse>;
+    /**
+     * Delete Unit
+     * @param unitId - Unit ID
+     * @param sessionData - Session data (REQUIRED)
+     */
+    static deleteUnit(unitId: number, sessionData?: any): Promise<APIResponse>;
+    /**
+     * Import Die Master data from Excel
+     * @param excelData - Array of die master records
+     * @param sessionData - Session data (REQUIRED)
+     */
+    static importDieMaster(excelData: Array<{
+        ProjectNo: string;
+        JobName: string;
+        ProdPlant: string;
+        CustomerName: string;
+        UpsL: number;
+        UpsW: number;
+        NoOfUps: number;
+        Length: number;
+        Width: number;
+        Height: number;
+    }>, sessionData?: any): Promise<APIResponse>;
+    /**
+     * Get Die Master list
+     * @param sessionData - Session data (REQUIRED)
+     */
+    static getDieMasterList(sessionData?: any): Promise<APIResponse>;
+}

package/dist/lib/api/master/other.js

@@ -0,0 +1,56 @@
+'use client';
+// Other Settings API
+// Handles all other settings operations (Unit, DieMasterImport, etc.)
+import APIClient from '../core/client.js';
+/**
+ * Other Settings API class
+ * Manages operations for Other Settings module (Unit, DieMasterImport)
+ */
+export class OtherSettingsAPI {
+    /**
+     * Get Unit list
+     * @param sessionData - Session data (REQUIRED)
+     */
+    static async getUnitList(sessionData) {
+        return APIClient.get('/api/unit/list', sessionData);
+    }
+    /**
+     * Save Unit
+     * @param unitData - Unit data
+     * @param sessionData - Session data (REQUIRED)
+     */
+    static async saveUnit(unitData, sessionData) {
+        return APIClient.post('/api/unit/save', unitData, sessionData);
+    }
+    /**
+     * Update Unit
+     * @param unitData - Unit data with UnitID
+     * @param sessionData - Session data (REQUIRED)
+     */
+    static async updateUnit(unitData, sessionData) {
+        return APIClient.post('/api/unit/update', unitData, sessionData);
+    }
+    /**
+     * Delete Unit
+     * @param unitId - Unit ID
+     * @param sessionData - Session data (REQUIRED)
+     */
+    static async deleteUnit(unitId, sessionData) {
+        return APIClient.post('/api/unit/delete', { UnitID: unitId }, sessionData);
+    }
+    /**
+     * Import Die Master data from Excel
+     * @param excelData - Array of die master records
+     * @param sessionData - Session data (REQUIRED)
+     */
+    static async importDieMaster(excelData, sessionData) {
+        return APIClient.post('/api/diemaster/import', excelData, sessionData);
+    }
+    /**
+     * Get Die Master list
+     * @param sessionData - Session data (REQUIRED)
+     */
+    static async getDieMasterList(sessionData) {
+        return APIClient.get('/api/diemaster/list', sessionData);
+    }
+}

package/dist/lib/api/master/process-types.d.ts

@@ -0,0 +1,178 @@
+/**
+ * Process Detail Master - Main process configuration
+ */
+export interface CostingDataProcessDetailMaster {
+    ProcessID?: number;
+    ToolRequired?: number;
+    ProcessName: string;
+    DisplayProcessName?: string;
+    DepartmentID?: number;
+    TypeofCharges?: string;
+    SizeToBeConsidered?: string;
+    PrePress?: string;
+    StartUnit?: string;
+    EndUnit?: string;
+    UnitConversion?: number;
+    MinimumCharges?: string;
+    SetupCharges?: string;
+    IsDisplay?: boolean;
+    IsEditToBeProduceQty?: boolean;
+    Rate?: string;
+    ProcessProductionType?: string;
+    ProcessPurpose?: string;
+    IsOnlineProcess?: boolean;
+    IsExcludeFromProfit?: boolean | number;
+    IsFabricationWastageCal?: boolean;
+    ProcessModuleType?: string;
+    MinimumQuantityToBeCharged?: number;
+    ProcessFlatWastageValue?: number;
+    ProcessWastagePercentage?: number;
+    ProcessCategory?: string;
+    PerHourCostingParameter?: string;
+    ChargeApplyOnSheets?: string;
+    DryingTime?: number;
+    ProductionTolerancePercentage?: number;
+    ProcessCode?: string;
+    ProcessTypeID?: number;
+    ProcessTypeName?: string;
+    ChargeType?: string;
+    Unit?: string;
+    HSN_SAC_Code?: string;
+    ShortName?: string;
+    Description?: string;
+    IsActive?: boolean;
+    CreatedBy?: number;
+    CreatedDate?: string;
+    ModifiedBy?: number;
+    ModifiedDate?: string;
+}
+/**
+ * Machine Allocation - Links processes to machines
+ */
+export interface CostingDataMachinAllocation {
+    ProcessID?: number;
+    MachineID: number;
+    MachineSpeed?: number;
+    MakeReadyTime?: number;
+    JobChangeOverTime?: number;
+    IsDefaultMachine?: number;
+    MachineName?: string;
+    MachineCode?: string;
+    IsDefault?: boolean;
+    Priority?: number;
+    CreatedBy?: number;
+    CreatedDate?: string;
+}
+/**
+ * Content Allocation - Links processes to content types
+ */
+export interface CostingDataContentAllocation {
+    ContentID: string;
+    ProcessID?: number;
+    ContentName?: string;
+    ContentCode?: string;
+    IsDefault?: boolean;
+    Priority?: number;
+    CreatedBy?: number;
+    CreatedDate?: string;
+}
+/**
+ * Slab Configuration - Defines pricing slabs for processes
+ */
+export interface CostingDataSlab {
+    FromQty: number;
+    ToQty: number;
+    StartUnit?: string;
+    RateFactor?: string;
+    Rate: number;
+    MinimumCharges?: number;
+    IsLocked?: boolean;
+    ProcessID?: number;
+    SlabID?: number;
+    FromValue?: number;
+    ToValue?: number;
+    ChargeValue?: number;
+    ChargeType?: string;
+    Unit?: string;
+    IsActive?: boolean;
+    CreatedBy?: number;
+    CreatedDate?: string;
+    ModifiedBy?: number;
+    ModifiedDate?: string;
+}
+/**
+ * Process Inspection Parameter - Quality control parameters
+ */
+export interface CostingProcessInspectionParameter {
+    DepartmentID: number;
+    SequenceNo: number;
+    ParameterName: string;
+    StandardValue: string;
+    InputFieldType: string;
+    FieldDataType: string;
+    DefaultValue: string;
+}
+/**
+ * Line Clearance Parameter - Production line clearance requirements
+ */
+export interface CostingLineClearanceParameter {
+    DepartmentID: number;
+    SequenceNo: number;
+    ParameterName: string;
+    StandardValue: string;
+    InputFieldType: string;
+    FieldDataType: string;
+    DefaultValue: string;
+}
+/**
+ * Process Tool Group Data - Tool group allocations
+ */
+export interface ProcessToolGroupData {
+    ToolGroupID: number;
+    ProcessID?: number;
+    ToolGroupName?: string;
+    ToolGroupCode?: string;
+    Quantity?: number;
+    IsRequired?: boolean;
+    CreatedBy?: number;
+    CreatedDate?: string;
+}
+/**
+ * Material Allocation - Links processes to material groups
+ */
+export interface CostingDataMaterialAllocation {
+    ItemID: number;
+    ProcessID?: number;
+    MaterialGroupID?: number;
+    MaterialGroupName?: string;
+    MaterialGroupCode?: string;
+    Quantity?: number;
+    Unit?: string;
+    IsRequired?: boolean;
+    CreatedBy?: number;
+    CreatedDate?: string;
+}
+/**
+ * Complete Process Master Save Request Body
+ */
+export interface SaveProcessMasterDataRequest {
+    CostingDataProcessDetailMaster: CostingDataProcessDetailMaster[];
+    CostingDataMachinAllocation: CostingDataMachinAllocation[];
+    CostingDataContentAllocation: CostingDataContentAllocation[];
+    CostingDataSlab: CostingDataSlab[];
+    ProcessName: string;
+    finalStringContent: string;
+    CostingProcessInspectionParameter: CostingProcessInspectionParameter[];
+    CostingLineClearanceParameter: CostingLineClearanceParameter[];
+    ProcessToolGroupData: ProcessToolGroupData[];
+    AllocattedMachineID: string;
+    CostingDataMaterialAllocation: CostingDataMaterialAllocation[];
+}
+/**
+ * Save Process Master Data Response
+ */
+export interface SaveProcessMasterDataResponse {
+    success: boolean;
+    message: string;
+    data?: any;
+}

package/dist/lib/api/master/process-types.js

@@ -0,0 +1,4 @@
+'use client';
+// Process Master Types
+// TypeScript definitions for Process Master data structures
+export {};

package/dist/lib/api/master/process.d.ts

@@ -0,0 +1,94 @@
+import type { APIResponse } from '../core/types.js';
+import type { SaveProcessMasterDataRequest, SaveProcessMasterDataResponse } from './process-types.js';
+/**
+ * Process Master API class
+ */
+export declare class ProcessMasterAPI {
+    /**
+     * Get all processes from the database
+     */
+    static getProcesses(sessionData?: any): Promise<APIResponse>;
+    /**
+     * Create a new process
+     */
+    static createProcess(processData: any, sessionData?: any): Promise<APIResponse>;
+    /**
+     * Update an existing process
+     * Uses POST method with specific request body format
+     * Request body format:
+     * {
+     *   CostingDataProcessDetailMaster: [{ ...processFields }],
+     *   finalStringContent: string,
+     *   AllocattedMachineID: string,
+     *   ProcessID: string
+     * }
+     * Response format: "Success"
+     */
+    static updateProcess(processId: string, processData: {
+        CostingDataProcessDetailMaster: any[];
+        finalStringContent: string;
+        AllocattedMachineID: string;
+        ProcessID: string;
+        PrcoessID: string;
+        [key: string]: any;
+    }, sessionData?: any): Promise<APIResponse<string>>;
+    /**
+     * Delete a process
+     * Uses POST method with ProcessID in URL path
+     * Response format: "Success"
+     */
+    static deleteProcess(processId: number, sessionData?: any): Promise<APIResponse<string>>;
+    /**
+     * Get a single process by ID
+     */
+    static getProcess(processId: string, sessionData?: any): Promise<APIResponse>;
+    /**
+     * Get existing slabs for a specific process
+     */
+    static getProcessSlabs(processId: string, sessionData?: any): Promise<APIResponse>;
+    /**
+     * Get type of charges dropdown options
+     */
+    static getTypeOfCharges(sessionData?: any): Promise<APIResponse>;
+    /**
+     * Get start unit dropdown options
+     */
+    static getStartUnit(sessionData?: any): Promise<APIResponse>;
+    /**
+     * Get machine allocation data for process master
+     */
+    static getMachineAllocation(sessionData?: any): Promise<APIResponse>;
+    /**
+     * Get allocated machines list for a specific process
+     */
+    static getAllocatedMachinesList(processId: number, sessionData?: any, productionUnitId?: number): Promise<APIResponse>;
+    /**
+     * Get allocated tool groups list for a specific process
+     */
+    static getAllocatedToolGroupsList(processId: number, sessionData?: any): Promise<APIResponse>;
+    /**
+     * Get allocated material groups list for a specific process
+     */
+    static getAllocatedMaterialGroupsList(processId: number, sessionData?: any): Promise<APIResponse>;
+    /**
+     * Get tool group list for tool allocation
+     */
+    static getToolGroupList(sessionData?: any): Promise<APIResponse>;
+    /**
+     * Get material group list for material allocation
+     */
+    static getMaterialGroupList(sessionData?: any): Promise<APIResponse>;
+    /**
+     * Get inspection parameters for a specific process
+     */
+    static getInspectionParameters(processId: number, sessionData?: any): Promise<APIResponse>;
+    /**
+     * Get line clearance parameters for a specific process
+     */
+    static getLineClearanceParameters(processId: number, sessionData?: any): Promise<APIResponse>;
+    /**
+     * Save process master data
+     * Saves complete process master configuration including all allocations, slabs, and parameters
+     */
+    static saveProcessMasterData(processData: SaveProcessMasterDataRequest, sessionData?: any): Promise<APIResponse<SaveProcessMasterDataResponse>>;
+}

package/dist/lib/api/master/process.js

@@ -0,0 +1,124 @@
+'use client';
+// Process Master API
+// Handles all process master operations
+import APIClient from '../core/client.js';
+/**
+ * Process Master API class
+ */
+export class ProcessMasterAPI {
+    /**
+     * Get all processes from the database
+     */
+    static async getProcesses(sessionData) {
+        return APIClient.get('api/processmaster/processmaster', sessionData);
+    }
+    /**
+     * Create a new process
+     */
+    static async createProcess(processData, sessionData) {
+        return APIClient.post('api/processmaster/processmaster', processData, sessionData);
+    }
+    /**
+     * Update an existing process
+     * Uses POST method with specific request body format
+     * Request body format:
+     * {
+     *   CostingDataProcessDetailMaster: [{ ...processFields }],
+     *   finalStringContent: string,
+     *   AllocattedMachineID: string,
+     *   ProcessID: string
+     * }
+     * Response format: "Success"
+     */
+    static async updateProcess(processId, processData, sessionData) {
+        return APIClient.post('api/processmaster/updateprocessmasterdata', processData, sessionData);
+    }
+    /**
+     * Delete a process
+     * Uses POST method with ProcessID in URL path
+     * Response format: "Success"
+     */
+    static async deleteProcess(processId, sessionData) {
+        return APIClient.post(`api/processmaster/deleteprocessmasterdata/${processId}`, {}, sessionData);
+    }
+    /**
+     * Get a single process by ID
+     */
+    static async getProcess(processId, sessionData) {
+        return APIClient.get(`api/processmaster/processmaster/${processId}`, sessionData);
+    }
+    /**
+     * Get existing slabs for a specific process
+     */
+    static async getProcessSlabs(processId, sessionData) {
+        return APIClient.get(`api/processmaster/existslab/${processId}`, sessionData);
+    }
+    /**
+     * Get type of charges dropdown options
+     */
+    static async getTypeOfCharges(sessionData) {
+        return APIClient.get('api/processmaster/GetTypeOfCharges', sessionData);
+    }
+    /**
+     * Get start unit dropdown options
+     */
+    static async getStartUnit(sessionData) {
+        return APIClient.get('api/processmaster/StartUnit', sessionData);
+    }
+    /**
+     * Get machine allocation data for process master
+     */
+    static async getMachineAllocation(sessionData) {
+        return APIClient.get('api/processmaster/machigrid', sessionData);
+    }
+    /**
+     * Get allocated machines list for a specific process
+     */
+    static async getAllocatedMachinesList(processId, sessionData, productionUnitId) {
+        const qs = productionUnitId && productionUnitId > 0 ? `?ProductionUnitID=${productionUnitId}` : '';
+        return APIClient.get(`api/processmaster/getallocatedmachineslist/${processId}${qs}`, sessionData);
+    }
+    /**
+     * Get allocated tool groups list for a specific process
+     */
+    static async getAllocatedToolGroupsList(processId, sessionData) {
+        return APIClient.get(`api/processmaster/getprocessallocatedtoolgroups/${processId}`, sessionData);
+    }
+    /**
+     * Get allocated material groups list for a specific process
+     */
+    static async getAllocatedMaterialGroupsList(processId, sessionData) {
+        return APIClient.get(`api/processmaster/getprocessallocatedmaterialgroups/${processId}`, sessionData);
+    }
+    /**
+     * Get tool group list for tool allocation
+     */
+    static async getToolGroupList(sessionData) {
+        return APIClient.get('api/processmaster/gettoolgrouplist', sessionData);
+    }
+    /**
+     * Get material group list for material allocation
+     */
+    static async getMaterialGroupList(sessionData) {
+        return APIClient.get('api/processmaster/getMaterialgrouplist', sessionData);
+    }
+    /**
+     * Get inspection parameters for a specific process
+     */
+    static async getInspectionParameters(processId, sessionData) {
+        return APIClient.get(`api/processmaster/LoadProcessInspectionParameter/${processId}`, sessionData);
+    }
+    /**
+     * Get line clearance parameters for a specific process
+     */
+    static async getLineClearanceParameters(processId, sessionData) {
+        return APIClient.get(`api/processmaster/LoadLineClearanceParameter/${processId}`, sessionData);
+    }
+    /**
+     * Save process master data
+     * Saves complete process master configuration including all allocations, slabs, and parameters
+     */
+    static async saveProcessMasterData(processData, sessionData) {
+        return APIClient.post('api/processmaster/saveprocessmasterdata', processData, sessionData);
+    }
+}

package/dist/lib/api/master/production-units.d.ts

@@ -0,0 +1,10 @@
+import type { APIResponse } from '../core/types.js';
+/**
+ * Production Units API class
+ */
+export declare class ProductionUnitsAPI {
+    /**
+     * Get all production units
+     */
+    static getProductionUnits(sessionData?: any): Promise<APIResponse>;
+}

package/dist/lib/api/master/production-units.js

@@ -0,0 +1,15 @@
+'use client';
+// Production Units API
+// Handles production units operations
+import APIClient from '../core/client.js';
+/**
+ * Production Units API class
+ */
+export class ProductionUnitsAPI {
+    /**
+     * Get all production units
+     */
+    static async getProductionUnits(sessionData) {
+        return APIClient.get('api/othermaster/getproductionunits', sessionData);
+    }
+}