truflow 0.0.189 → 0.0.191

package/src/ISchedule.ts

@@ -0,0 +1,162 @@
+import mongoose, { Document } from "mongoose";
+
+// Filter condition for matching Allmoxy products/attributes
+export interface IScheduleFilterCondition {
+  field: "product" | "attribute";
+  productId?: number;
+  attributeName?: string;
+  operator: "equals" | "notEquals" | "contains" | "greaterThan" | "lessThan" | "greaterThanOrEqual" | "lessThanOrEqual";
+  value: string;
+}
+
+// Enhanced filter condition for view-level filtering
+export interface IViewFilterCondition {
+  id?: string; // Unique identifier for the filter condition
+  fieldType: "standard" | "customField" | "date" | "attribute"; // Type of field being filtered
+  fieldName: string; // Field name (e.g., "status", "shipDate", custom field name, or attribute name)
+  operator: "equals" | "notEquals" | "contains" | "greaterThan" | "lessThan" | "greaterThanOrEqual" | "lessThanOrEqual" | "in" | "notIn" | "isEmpty" | "isNotEmpty" | "between";
+  value?: any; // Filter value(s) - can be string, number, array for "in"/"notIn", or object with {start, end} for "between"
+  label?: string; // Display label for the field
+}
+
+// Sort configuration for filters
+export interface IFilterSortCondition {
+  fieldType: "standard" | "customField" | "date" | "attribute"; // Type of field being sorted
+  fieldName: string; // Field name to sort by
+  direction: "asc" | "desc"; // Sort direction
+  order: number; // Priority order (lower number = higher priority)
+}
+
+// Saved filter configuration
+export interface ISavedViewFilter {
+  _id?: mongoose.Types.ObjectId;
+  name: string; // Name of the saved filter
+  conditions: IViewFilterCondition[]; // Array of filter conditions
+  conditionOperator: "and" | "or"; // How to combine conditions
+  description?: string; // Optional description
+  sortConditions?: IFilterSortCondition[]; // Sort conditions (applied after filtering)
+}
+
+// A filter group - conditions are combined based on conditionOperator
+export interface IScheduleFilterGroup {
+  conditions: IScheduleFilterCondition[];
+  conditionOperator?: "and" | "or";
+}
+
+// Column/Stage configuration for the schedule
+export interface IScheduleColumn {
+  _id?: mongoose.Types.ObjectId;
+  name: string;
+  machineId: mongoose.Types.ObjectId;
+  offsetDays: number; // Days offset from the base date (ship date or start date)
+  order: number; // Display order of this column
+}
+
+// Display column configuration - controls order and visibility of all columns
+export interface IScheduleDisplayColumn {
+  type: "orderNumber" | "company" | "product" | "quantity" | "shipDate" | "startDate" | "status" | "attribute" | "stage" | "customField";
+  stageColumnId?: mongoose.Types.ObjectId;  // Reference to the stage column if type is "stage"
+  attributeName?: string;  // Reference to the attribute if type is "attribute"
+  customFieldName?: string;  // Reference to the custom field name if type is "customField"
+  order: number;
+  visible: boolean;  // Whether column is visible in the schedule view
+}
+
+// Additional attribute with optional display condition
+export interface IScheduleAdditionalAttribute {
+  attributeName: string;
+  label?: string;  // Optional custom label for display
+  // Optional condition - if specified, attribute only displays when condition is met
+  displayCondition?: {
+    operator: "equals" | "notEquals" | "contains" | "greaterThan" | "lessThan" | "greaterThanOrEqual" | "lessThanOrEqual";
+    value: string;
+  };
+}
+
+// Schedule View - different ways to view the same schedule data
+export interface IScheduleView {
+  _id?: mongoose.Types.ObjectId;
+  name: string;
+  layoutType: "table" | "kanban" | "gantt";
+  // Display column configuration (for table layout)
+  displayColumns?: IScheduleDisplayColumn[];
+  // Sorting configuration
+  sortField?: string;  // Can be "shipDate", "startDate", "status", or a column ID
+  sortDirection?: "asc" | "desc";
+  // Additional attributes to show (beyond filter attributes)
+  additionalAttributes?: (string | IScheduleAdditionalAttribute)[];  // Array of attribute names or attribute configs
+  combineAdditionalAttributes?: boolean;  // Whether to show all additional attributes in one column (like matched attributes)
+  // Product grouping configuration
+  groupByMatchingAttributes?: boolean;  // Whether to group products with matching filter attributes in the same order
+  isDefault?: boolean;  // Whether this is the default view
+  // Saved filters for this view
+  savedFilters?: ISavedViewFilter[];
+  // ID of the default filter to apply
+  defaultFilterId?: mongoose.Types.ObjectId;
+  // Currently active filter (not saved, just for UI state)
+  activeFilterId?: mongoose.Types.ObjectId;
+}
+
+// Custom field definition for schedule entries
+export interface IScheduleCustomField {
+  _id?: mongoose.Types.ObjectId;
+  name: string;                           // Internal field name (e.g., "drill_specs_confirmed")
+  label: string;                          // Display label (e.g., "Drill Specs Confirmed")
+  fieldType: "boolean" | "select" | "text" | "number";  // Type of field
+  options?: string[];                     // Options for select fields (e.g., ["in process", "stuck", "completed"])
+  defaultValue?: string | boolean | number;        // Default value for new entries
+  required?: boolean;                     // Whether field is required
+  order?: number;                         // Display order
+}
+
+// The main Schedule configuration
+export interface ILeanSchedule {
+  _id: mongoose.Types.ObjectId;
+  name: string;
+  description?: string;
+  enabled: boolean;
+  // Filter configuration - groups are ORed together
+  filterGroups: IScheduleFilterGroup[];
+  groupOperator: "and" | "or";
+  // Column/Stage configuration
+  columns: IScheduleColumn[];
+  // Views for this schedule
+  views?: IScheduleView[];
+  // Custom fields for this schedule
+  customFields?: IScheduleCustomField[];
+  // Base date field to calculate offsets from
+  baseDateField: "shipDate" | "startDate";
+  // Legacy fields (kept for backward compatibility, will be migrated to default view)
+  displayColumns?: IScheduleDisplayColumn[];
+  hidePastShipDates?: boolean;
+  hideShippedOrders?: boolean;
+  showShipDate?: boolean;
+  showStartDate?: boolean;
+  defaultSortField?: string;
+  defaultSortDirection?: "asc" | "desc";
+  createdAt?: Date;
+  updatedAt?: Date;
+}
+
+export type ISchedule = ILeanSchedule & Document;
+
+// Schedule Entry - the actual scheduled dates for an order product
+export interface IScheduleEntryDate {
+  columnId: mongoose.Types.ObjectId;
+  date: string; // ISO date string
+}
+
+export interface ILeanScheduleEntry {
+  _id: mongoose.Types.ObjectId;
+  scheduleId: mongoose.Types.ObjectId;
+  orderId: number;
+  orderProductId: string;
+  dates: IScheduleEntryDate[];
+  notes?: string;
+  status?: string;                        // Legacy status field
+  customStatus?: { [key: string]: any }; // Custom status fields (key-value pairs)
+  createdAt?: Date;
+  updatedAt?: Date;
+}
+
+export type IScheduleEntry = ILeanScheduleEntry & Document;

package/src/ISetting.ts

@@ -25,20 +25,63 @@ export interface ILeanHoliday extends ILeanSetting {
   recurs?: string;
 }
 
+export type AttributeFilterOperator = 
+  | "equals" 
+  | "notEquals" 
+  | "contains" 
+  | "notContains" 
+  | "startsWith" 
+  | "endsWith";
+
+export interface IAttributeFilter {
+  attributeName: string;
+  operator?: AttributeFilterOperator;
+  value: any;
+}
+
 export interface ILeanLimit extends ILeanSetting {
   name: string;
   rpd: string;
-  limit: string;
+  capacity: string;
   enabled: boolean;
   products?: [
     {
       name: string;
+      allmoxyProductId?: number;
       sheetGroupingAttribute?: string;
       grainedProduct?: boolean;
       grainedProductAttribute?: string;
+      attributeFilters?: IAttributeFilter[];
+      priority?: number;
     }
   ];
   nestable?: boolean;
+  visibleOnDashboard?: boolean;
+}
+
+export interface IMachinePathStep {
+  machine: mongoose.Types.ObjectId;
+  offsetDays: number;
+  _id?: mongoose.Types.ObjectId;
+}
+
+// Production Line is the new name for Limits, with additional path configuration
+export interface ILeanProductionLine extends ILeanLimit {
+  // Machine path: ordered list of machines with timing offsets
+  machinePath?: IMachinePathStep[];
+}
+
+// Machine or Station in the production facility
+export interface ILeanMachine extends ILeanSetting {
+  name: string;
+  description?: string;
+  type: "machine" | "station";
+  enabled: boolean;
+  // Optional capacity or throughput metrics
+  dailyCapacity?: number;
+  // Optional location or area information
+  location?: string;
+  visibleOnDashboard?: boolean;
 }
 
 export interface ILeanOrderFlag extends ILeanSetting {
@@ -51,7 +94,7 @@ export interface ILeanOrderFlag extends ILeanSetting {
 export interface ILeanSorting extends ILeanSetting {
   headerList?: string[];
   itemList: string[];
-  usage: "totals-groups" | "limits";
+  usage: "totals-groups" | "production-lines" | "machines";
 }
 
 export interface ICalculation {
@@ -68,6 +111,7 @@ export interface ILeanTotalsGroup extends ILeanSetting {
   calculations?: ICalculation[];
   dailyLimit?: number;
   buffer?: number;
+  visibleOnDashboard?: boolean;
 }
 
 export interface ILeanKeyValue extends ILeanSetting {
@@ -92,3 +136,7 @@ export type ISorting = ILeanSorting & Document;
 export type ITotalsGroup = ILeanTotalsGroup & Document;
 
 export type IKeyValue = ILeanKeyValue & Document;
+
+export type IProductionLine = ILeanProductionLine & Document;
+
+export type IMachine = ILeanMachine & Document;

package/src/ISupplier.ts

@@ -1,17 +1,23 @@
 import mongoose, { Document } from "mongoose";
 
+export interface ISupplierContact {
+  _id?: mongoose.Types.ObjectId;
+  name: string;
+  email?: string;
+  phone?: string;
+  role?: string;
+  notifyOnVMIPurchase?: boolean;
+}
+
 export interface ISupplier {
   _id: mongoose.Types.ObjectId;
   name: string;
   code: string;
-  contactInfo: {
-    email?: string;
-    phone?: string;
-    address?: string;
-    contactPerson?: string;
-  };
+  // Contacts array for multiple contacts
+  contacts?: ISupplierContact[];
   notes?: string;
   active: boolean;
+  allowedInventoryTypes?: mongoose.Types.ObjectId[];
   createdAt: Date;
   updatedAt: Date;
 }

package/src/IUser.ts

@@ -1,4 +1,5 @@
 import mongoose, { Document } from "mongoose";
+import { NotificationTag } from "./INotification";
 
 export type IUser = ILeanUser & Document;
 
@@ -11,6 +12,7 @@ export interface ILeanUser {
   permissions: any[];
   groups: any[];
   pushSubscriptions?: PushSubscription[];
+  pushNotificationTags?: NotificationTag[]; // Tags user wants to receive push notifications for
 }
 
 export interface PushSubscription {

package/src/Inventory/IInventoryTransfer.ts

@@ -0,0 +1,108 @@
+import { Document, Types } from "mongoose";
+
+/**
+ * Single item in a bulk transfer
+ */
+export interface ITransferItem {
+  itemId: Types.ObjectId; // Reference to InventoryItem
+  fromLocation: Types.ObjectId;
+  fromLocationPath?: {
+    rackId?: Types.ObjectId;
+    shelfId?: Types.ObjectId;
+    binId?: Types.ObjectId;
+  };
+  toLocation: Types.ObjectId;
+  toLocationPath?: {
+    rackId?: Types.ObjectId;
+    shelfId?: Types.ObjectId;
+    binId?: Types.ObjectId;
+  };
+  quantity?: number;
+}
+
+/**
+ * Inventory transfer - records movement of inventory between locations
+ * Supports both single and bulk transfers
+ */
+export interface IInventoryTransfer {
+  _id: Types.ObjectId;
+  // Single transfer fields (backward compatibility)
+  itemId?: Types.ObjectId; // Reference to InventoryItem
+  fromLocation?: Types.ObjectId; // Reference to Location
+  fromLocationPath?: {
+    rackId?: Types.ObjectId;
+    shelfId?: Types.ObjectId;
+    binId?: Types.ObjectId;
+  };
+  toLocation?: Types.ObjectId; // Reference to Location
+  toLocationPath?: {
+    rackId?: Types.ObjectId;
+    shelfId?: Types.ObjectId;
+    binId?: Types.ObjectId;
+  };
+  quantity?: number; // Optional: if only transferring part of the item
+
+  // Bulk transfer fields
+  items?: ITransferItem[]; // For bulk transfers
+  isBulk?: boolean; // Flag to indicate bulk transfer
+
+  notes?: string;
+  status: "pending" | "completed" | "cancelled";
+  initiatedBy: Types.ObjectId; // Reference to User
+  completedBy?: Types.ObjectId; // Reference to User
+  completedAt?: Date;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+export type IInventoryTransferDocument = IInventoryTransfer & Document;
+
+/**
+ * Count session item - tracks counting of a single inventory item
+ */
+export interface ICountSessionItem {
+  itemId: Types.ObjectId; // Reference to InventoryItem
+  expectedLocation?: Types.ObjectId;
+  expectedLocationPath?: {
+    rackId?: Types.ObjectId;
+    shelfId?: Types.ObjectId;
+    binId?: Types.ObjectId;
+  };
+  actualLocation?: Types.ObjectId;
+  actualLocationPath?: {
+    rackId?: Types.ObjectId;
+    shelfId?: Types.ObjectId;
+    binId?: Types.ObjectId;
+  };
+  expectedQuantity?: number;
+  countedQuantity?: number;
+  status: "pending" | "counted" | "discrepancy" | "resolved";
+  scannedAt?: Date;
+  notes?: string;
+}
+
+/**
+ * Inventory counting session - guides users through rack-by-rack counting
+ */
+export interface IInventoryCountSession {
+  _id: Types.ObjectId;
+  name: string;
+  locationId: Types.ObjectId; // Reference to Location
+  racks: Types.ObjectId[]; // Array of rack IDs to count
+  shelves?: Types.ObjectId[]; // Optional: Array of shelf IDs for granular counting
+  bins?: Types.ObjectId[]; // Optional: Array of bin IDs for most granular counting
+  currentRackIndex: number; // Which rack we're currently counting
+  currentRackId?: Types.ObjectId;
+  items: ICountSessionItem[];
+  totalExpectedItems: number;
+  status: "not_started" | "in_progress" | "completed" | "cancelled";
+  startedBy: Types.ObjectId; // Reference to User
+  startedAt?: Date;
+  completedBy?: Types.ObjectId;
+  completedAt?: Date;
+  notes?: string;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+export type IInventoryCountSessionDocument = IInventoryCountSession & Document;

package/src/Inventory/ILocation.ts

@@ -19,18 +19,28 @@ export interface ILocationComponentBase {
 export interface IBin extends ILocationComponentBase {
   capacity?: number;
   currentStock?: number;
+  // For merged bins: array of bin IDs that are merged into one logical bin
+  mergedWith?: Types.ObjectId[];
+  // If this bin is merged into another, reference the primary bin
+  mergedInto?: Types.ObjectId;
+  // Array of inventory type IDs that can be stored in this bin
+  allowedInventoryTypes?: Types.ObjectId[];
 }
 
 export interface IShelf extends ILocationComponentBase {
   bins: IBin[];
   capacity?: number;
   currentStock?: number;
+  // Array of inventory type IDs that can be stored in this shelf
+  allowedInventoryTypes?: Types.ObjectId[];
 }
 
 export interface IRack extends ILocationComponentBase {
   shelves: IShelf[];
   capacity?: number;
   currentStock?: number;
+  // Array of inventory type IDs that can be stored in this rack
+  allowedInventoryTypes?: Types.ObjectId[];
 }
 
 export interface ILocationMethods {
@@ -48,6 +58,13 @@ export interface ILocation extends Omit<Document, '_id'>, ILocationComponentBase
   capacity?: number;
   currentStock?: number;
   isActive: boolean;
+  // Array of inventory type IDs that can be stored in this location
+  allowedInventoryTypes?: Types.ObjectId[];
+  // VMI (Vendor Managed Inventory) configuration
+  isVMI?: boolean;
+  allowedSuppliers?: Types.ObjectId[]; // Suppliers allowed to manage VMI inventory at this location
+  // Transfer restrictions: controls direction of inventory movement
+  transferRestriction?: "bidirectional" | "inbound_only" | "outbound_only";
 }
 
 export interface ILocationPath {

package/src/Inventory/ISelectFieldDefinition.ts

@@ -0,0 +1,29 @@
+import { Document, Types } from "mongoose";
+
+/**
+ * Select field definition option
+ */
+export interface ISelectOption {
+  key: string; // Unique key for the option (e.g., "4_4_MAPLE")
+  value: string; // Display value (e.g., "4/4 Maple")
+}
+
+/**
+ * Source type for select field data
+ */
+export type SelectFieldSource = "table";
+
+/**
+ * Select field definition - defines a reusable select field with its options
+ */
+export interface ISelectFieldDefinition {
+  _id: Types.ObjectId;
+  name: string; // Display name (e.g., "Material Types", "Finish Options")
+  description?: string;
+  source: SelectFieldSource; // Where the data comes from
+  options: ISelectOption[]; // Options array
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+export type ISelectFieldDefinitionDocument = ISelectFieldDefinition & Document;

package/src/index.ts

@@ -30,5 +30,9 @@ export * from "./Classes/IRoute";
 export * from "./IApplication";
 export * from "./IQualityControl";
 export * from "./Inventory/ILocation";
+export * from "./Inventory/ISelectFieldDefinition";
+export * from "./Inventory/IInventoryTransfer";
 export * from "./IInventory";
 export * from "./ISupplier";
+export * from "./ISchedule";
+export * from "./IAutomation";

package/tsconfig.json

@@ -4,7 +4,10 @@
     "module": "commonjs",
     "declaration": true,
     "outDir": "./dist",
-    "strict": true
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "resolveJsonModule": true
   },
   "include": ["src"],
   "exclude": ["node_modules"]

package/dist/ILocation.d.ts

@@ -1,75 +0,0 @@
-/// <reference types="mongoose/types/aggregate" />
-/// <reference types="mongoose/types/callback" />
-/// <reference types="mongoose/types/collection" />
-/// <reference types="mongoose/types/connection" />
-/// <reference types="mongoose/types/cursor" />
-/// <reference types="mongoose/types/document" />
-/// <reference types="mongoose/types/error" />
-/// <reference types="mongoose/types/expressions" />
-/// <reference types="mongoose/types/helpers" />
-/// <reference types="mongoose/types/middlewares" />
-/// <reference types="mongoose/types/indexes" />
-/// <reference types="mongoose/types/models" />
-/// <reference types="mongoose/types/mongooseoptions" />
-/// <reference types="mongoose/types/pipelinestage" />
-/// <reference types="mongoose/types/populate" />
-/// <reference types="mongoose/types/query" />
-/// <reference types="mongoose/types/schemaoptions" />
-/// <reference types="mongoose/types/schematypes" />
-/// <reference types="mongoose/types/session" />
-/// <reference types="mongoose/types/types" />
-/// <reference types="mongoose/types/utility" />
-/// <reference types="mongoose/types/validation" />
-/// <reference types="mongoose/types/virtuals" />
-/// <reference types="mongoose/types/inferschematype" />
-import { Document, Model, Types } from "mongoose";
-/**
- * Base interface for location components with common fields
- */
-export interface ILocationComponentBase {
-    _id: Types.ObjectId;
-    name: string;
-    code: string;
-    status: number;
-    createdBy: string;
-    createdById: number;
-    createdDate: Date;
-    updatedBy: string;
-    updatedById: number;
-    updatedDate: Date;
-}
-export interface IBin extends ILocationComponentBase {
-    capacity?: number;
-    currentStock?: number;
-}
-export interface IShelf extends ILocationComponentBase {
-    bins: IBin[];
-    capacity?: number;
-    currentStock?: number;
-}
-export interface IRack extends ILocationComponentBase {
-    shelves: IShelf[];
-    capacity?: number;
-    currentStock?: number;
-}
-export interface ILocationMethods {
-    generateUniqueCode(prefix: string): Promise<string>;
-}
-export interface ILocationModel extends Model<ILocation, {}, ILocationMethods> {
-    generateUniqueCode(prefix: string): Promise<string>;
-}
-export interface ILocation extends Omit<Document, '_id'>, ILocationComponentBase {
-    type: "warehouse" | "shed" | "other";
-    description?: string;
-    racks: IRack[];
-    capacity?: number;
-    currentStock?: number;
-    isActive: boolean;
-}
-export interface ILocationPath {
-    locationId: Types.ObjectId;
-    rackId?: Types.ObjectId;
-    shelfId?: Types.ObjectId;
-    binId?: Types.ObjectId;
-    path: string;
-}