truflow 0.0.188 → 0.0.190

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "truflow",
-  "version": "0.0.188",
+  "version": "0.0.190",
   "main": "./dist/index.js",
   "license": "MIT",
   "scripts": {
     "build": "tsc",
+    "watch": "tsc --watch",
     "prepublish": "tsc"
   },
   "dependencies": {
@@ -12,8 +13,16 @@
     "@types/express": "^4.17.17",
     "@types/luxon": "^3.3.0",
     "mongoose": "^7.3.4",
-    "socket.io": "^4.7.5",
-    "typescript": "^5.1.6"
+    "socket.io": "^4.7.5"
   },
-  "packageManager": "yarn@1.22.22+sha512.a6b2f7906b721bba3d67d4aff083df04dad64c399707841b7acf00f6b133b7ac24255f2652fa22ae3534329dc6180534e98d17432037ff6fd140556e2bb3137e"
+  "packageManager": "yarn@1.22.22+sha512.a6b2f7906b721bba3d67d4aff083df04dad64c399707841b7acf00f6b133b7ac24255f2652fa22ae3534329dc6180534e98d17432037ff6fd140556e2bb3137e",
+  "devDependencies": {
+    "@hokify/agenda": "^6.3.0",
+    "@types/node": "^24.10.1",
+    "express": "^5.2.1",
+    "luxon": "^3.7.2",
+    "mongoose": "^9.0.1",
+    "socket.io": "^4.8.1",
+    "typescript": "5.3.3"
+  }
 }

package/src/Helpers/IOrders/IMoveOrder.ts

@@ -5,7 +5,7 @@ export interface IMoveOrderTotalsData {
   startDate: string;
   updatedStartDate: string;
   entries: {
-    limitsGroup: string;
+    productionLine: string;
     quantity: number;
   }[];
 }

package/src/Helpers/IZapier/index.ts

@@ -1,25 +1,28 @@
 import { DateTime } from "luxon";
-import { ILimit } from "../../ISetting";
+import { IProductionLine } from "../../ISetting";
 import { IZapierOrder } from "../../Routes/IZapierRoutes";
 import { IOrderProduct, IOrder } from "../../IOrder";
 import mongoose from "mongoose";
 
-export type IFetchLimits = (type: string) => Promise<ILimit>;
+export type IFetchProductionLines = (type: string) => Promise<IProductionLine>;
+// Backward compatibility alias
+export type IFetchLimits = IFetchProductionLines;
 
 export type ICalculateInitialStartDate = (
   shipDate: DateTime,
-  limits: ILimit
+  productionLine: IProductionLine
 ) => Promise<{ startDate: DateTime; isHighlighted: boolean }>;
 
 export type ICheckDailyTotals = (
   date: string,
   quantity: number,
-  limitData: ILimit
+  productionLineData: IProductionLine
 ) => Promise<{ result: boolean; exists?: boolean } | boolean>;
 
 export type ICalculateStartDate = (
   startDate: DateTime,
-  isHighlighted: boolean
+  isHighlighted: boolean,
+  productionLineId?: string
 ) => Promise<{ startDate: DateTime; isHighlighted: boolean }>;
 
 export type ICalculateRPD = (
@@ -29,7 +32,7 @@ export type ICalculateRPD = (
 
 export type ICalculateShipDate = (
   startDate: DateTime,
-  limits: ILimit
+  productionLine: IProductionLine
 ) => Promise<DateTime>;
 
 export type ICalculateStartDates = (

package/src/IAutomation.ts

@@ -0,0 +1,264 @@
+import mongoose, { Document } from "mongoose";
+
+// Trigger types that can start an automation
+export type AutomationTriggerType = 
+  | "order.created"           // When a new order is created
+  | "order.updated"           // When an order is updated
+  | "order.status_changed"    // When order status changes
+  | "schedule.entry_added"    // When order matches schedule filters and is added
+  | "schedule.field_changed"  // When a custom schedule field value changes
+  | "measurement.added"       // When a measurement is added to an order product
+  | "measurement.completed";  // When all measurements are completed for an order
+
+// Action types that can be executed
+export type AutomationActionType = 
+  | "webhook"                 // Trigger a webhook (HTTP request)
+  | "email"                   // Send an email
+  | "notification"            // Send in-app notification to user(s)
+  | "sms"                     // Send SMS/text message
+  | "slack"                   // Post to Slack channel
+  | "update_field"            // Update order or schedule entry field
+  | "add_note";               // Add a note to the order
+
+// Condition operators for filtering
+export type AutomationConditionOperator = 
+  | "equals" 
+  | "notEquals" 
+  | "contains" 
+  | "notContains"
+  | "greaterThan" 
+  | "lessThan" 
+  | "greaterThanOrEqual"
+  | "lessThanOrEqual"
+  | "exists"
+  | "notExists"
+  | "in"           // Value is in array
+  | "notIn";       // Value is not in array
+
+// Condition for filtering when automation should run
+export interface IAutomationCondition {
+  field: string;                          // e.g., "status", "allmoxyData.productAttributes.finish_color"
+  operator: AutomationConditionOperator;
+  value?: string | number;                // Value to compare against (not needed for exists/notExists)
+}
+
+// Filter operators with more options
+export type AutomationFilterOperator = AutomationConditionOperator;
+
+// Logic operator for combining multiple filters
+export type AutomationFilterLogic = "AND" | "OR";
+
+// Individual filter definition
+export interface IAutomationFilter {
+  field: string;                          // Field to check (e.g., "order.companyName", "measurement.width")
+  operator: AutomationFilterOperator;
+  value?: any;                            // Value to compare against (can be string, number, array for in/notIn)
+  enabled?: boolean;                      // Allow temporarily disabling individual filters
+}
+
+// Filter group that can be AND/OR combined
+export interface IAutomationFilterGroup {
+  logic: AutomationFilterLogic;           // How to combine filters in this group (AND/OR)
+  filters: IAutomationFilter[];           // Individual filters in the group
+}
+
+// Result of evaluating a single filter
+export interface IAutomationFilterEvaluationResult {
+  filter: IAutomationFilter;
+  matched: boolean;
+  actualValue?: any;                      // The actual value that was checked
+  reason?: string;                        // Human-readable reason for match/no-match
+}
+
+// Result of evaluating all filters
+export interface IAutomationFiltersEvaluationResult {
+  matched: boolean;                       // Overall result: did filters pass?
+  filterResults: IAutomationFilterEvaluationResult[];  // Results for each filter
+  logic: AutomationFilterLogic;           // Logic used to combine filters
+}
+
+// Webhook action configuration
+export interface IAutomationWebhookAction {
+  type: "webhook";
+  url: string;                            // Webhook URL
+  method?: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";  // HTTP method (default: POST)
+  queryParams?: Record<string, string>;   // Optional query parameters
+  headers?: Record<string, string>;       // Optional custom headers
+  body?: Record<string, any>;             // Optional custom body template (not used for GET)
+}
+
+// Email action configuration
+export interface IAutomationEmailAction {
+  type: "email";
+  to: string[];                           // Array of email addresses (can use template variables)
+  subject: string;                        // Email subject (can use template variables)
+  body: string;                           // Email body (can use template variables)
+  cc?: string[];                          // Optional CC addresses
+  bcc?: string[];                         // Optional BCC addresses
+}
+
+// Notification action configuration
+export interface IAutomationNotificationAction {
+  type: "notification";
+  userIds: string[];                      // Array of user IDs to notify (can be empty for dynamic)
+  title: string;                          // Notification title (can use template variables)
+  message: string;                        // Notification message (can use template variables)
+  notificationType: "info" | "success" | "warning" | "error";
+}
+
+// SMS action configuration
+export interface IAutomationSMSAction {
+  type: "sms";
+  phoneNumbers: string[];                 // Array of phone numbers (can use template variables)
+  message: string;                        // SMS message (can use template variables)
+}
+
+// Slack action configuration
+export interface IAutomationSlackAction {
+  type: "slack";
+  channel: string;                        // Slack channel (e.g., "#general" or webhook URL)
+  message: string;                        // Message to post (can use template variables)
+  username?: string;                      // Optional bot username
+  iconEmoji?: string;                     // Optional emoji icon (e.g., ":robot_face:")
+}
+
+// Update field action configuration
+export interface IAutomationUpdateFieldAction {
+  type: "update_field";
+  targetType: "order" | "scheduleEntry";  // What to update
+  fieldName: string;                      // Field to update (e.g., "status", "customStatus.drill_specs_confirmed")
+  value: string;                          // New value (can use template variables)
+}
+
+// Add note action configuration
+export interface IAutomationAddNoteAction {
+  type: "add_note";
+  noteText: string;                       // Note text (can use template variables)
+  mentionUserIds?: string[];              // Optional user IDs to mention
+}
+
+// Union type for all action configurations
+export type IAutomationAction = 
+  | IAutomationWebhookAction 
+  | IAutomationEmailAction 
+  | IAutomationNotificationAction
+  | IAutomationSMSAction
+  | IAutomationSlackAction
+  | IAutomationUpdateFieldAction
+  | IAutomationAddNoteAction;
+
+// Main automation configuration
+export interface ILeanAutomation {
+  _id: mongoose.Types.ObjectId;
+  name: string;                           // Human-readable name for the automation
+  description?: string;                   // Optional description
+  enabled: boolean;                       // Whether the automation is active
+  
+  // Trigger configuration
+  triggerType: AutomationTriggerType;     // What event triggers this automation
+  
+  // Filters - Pre-conditions that must be met before running
+  filters?: IAutomationFilterGroup;       // Filter group with AND/OR logic
+  
+  // Conditions (DEPRECATED - use filters instead, kept for backwards compatibility)
+  conditions?: IAutomationCondition[];    // Optional conditions that must be met
+  
+  // Optional: Link to specific schedule (for schedule-related triggers)
+  scheduleId?: mongoose.Types.ObjectId;
+  
+  // Actions to execute when triggered
+  actions: IAutomationAction[];           // Array of actions to perform
+  
+  // Metadata
+  createdBy?: mongoose.Types.ObjectId;    // User who created this automation
+  lastTriggeredAt?: Date;                 // Last time this automation ran
+  triggerCount?: number;                  // Number of times this automation has been triggered
+  
+  createdAt?: Date;
+  updatedAt?: Date;
+}
+
+export type IAutomation = ILeanAutomation & Document;
+
+// Context data passed to automation for template variable replacement
+export interface IAutomationContext {
+  order?: {
+    id: number;
+    name: string;
+    companyName: string;
+    status: string;
+    shipDate: string;
+    orderProducts?: any[];
+    [key: string]: any;
+  };
+  orderProduct?: {
+    id: string;
+    type: string;
+    quantity: number;
+    allmoxyData?: {
+      productId?: number;
+      productAttributes?: Array<{
+        attributeName: string;
+        value: any;
+      }>;
+    };
+    [key: string]: any;
+  };
+  measurement?: {
+    width: number;
+    height: number;
+    angle: number;
+    outOfSquare: number;
+    comments?: string;
+    [key: string]: any;
+  };
+  schedule?: {
+    id: string;
+    name: string;
+    [key: string]: any;
+  };
+  scheduleEntry?: {
+    id: string;
+    scheduleId: string;
+    orderId: number;
+    orderProductId: string;
+    customStatus?: { [key: string]: any };
+    [key: string]: any;
+  };
+  fieldChange?: {
+    fieldName: string;      // Name of the field that changed
+    oldValue: any;          // Previous value
+    newValue: any;          // New value
+  };
+  triggeredBy?: {
+    userId?: string;
+    userName?: string;
+    source?: string;
+  };
+  [key: string]: any;  // Allow additional context fields
+}
+
+// Execution log for tracking automation runs
+export interface ILeanAutomationLog {
+  _id: mongoose.Types.ObjectId;
+  automationId: mongoose.Types.ObjectId;
+  automationName: string;
+  triggerType: AutomationTriggerType;
+  status: "success" | "error" | "partial" | "skipped";  // partial = some actions failed, skipped = filters didn't match
+  context: IAutomationContext;              // Context data at time of execution
+  
+  // Filter evaluation results
+  filterEvaluation?: IAutomationFiltersEvaluationResult;  // Results of filter evaluation
+  
+  actionsExecuted: {
+    actionType: AutomationActionType;
+    status: "success" | "error";
+    error?: string;
+    details?: any;                          // Action-specific execution details
+  }[];
+  error?: string;
+  executedAt: Date;
+  createdAt?: Date;
+}
+
+export type IAutomationLog = ILeanAutomationLog & Document;

package/src/IDailyTotal.ts

@@ -2,8 +2,15 @@ import { Document } from "mongoose";
 
 export type IDailyTotal = ILeanDailyTotal & Document;
 
+export interface ILockedProductionLine {
+  productionLineId: string;
+  productionLineName: string;
+  reason: string;
+}
+
 export interface ILeanDailyTotal {
   _id: string;
   locked: boolean;
+  lockedProductionLines?: ILockedProductionLine[];
   [key: string]: any;
 }

package/src/IExporter.ts

@@ -17,4 +17,5 @@ export interface ILeanExporter {
   csvGenerator?: IHeader[];
   ignoreEmptyFiles: boolean;
   firstLineHeaders: boolean;
+  enabled: boolean;
 }

package/src/IExpress.ts

@@ -10,5 +10,6 @@ export enum IHTTPMethod {
   GET = "get",
   POST = "post",
   PUT = "put",
+  PATCH = "patch",
   DELETE = "delete",
 }

package/src/IIntegration.ts

@@ -36,3 +36,4 @@ export interface ILeanAllmoxyIntegration extends ILeanIntegration {
 }
 
 export type IAllmoxyIntegration = ILeanAllmoxyIntegration & Document;
+

package/src/IInventory.ts

@@ -8,6 +8,7 @@ export interface IField {
   type: "number" | "text" | "select" | "calculation" | "tag"; // Field type
   required?: boolean; // Whether this field is required
   options?: string[]; // For select fields, the available options
+  selectFieldDefinitionId?: mongoose.Types.ObjectId; // Reference to SelectFieldDefinition for select fields
   default?: any; // Default value
   unit?: string; // Unit of measurement if applicable
   validation?: {
@@ -36,11 +37,34 @@ export interface IInventoryType {
   name: string; // e.g., "Lumber", "Steel", "Hardware"
   description?: string;
   fields: IField[]; // Custom fields for this type
+  uniqueIdentifierField?: string; // Field key used as the unique identifier
   defaultLocation?: mongoose.Types.ObjectId;
   tagGenerationEnabled?: boolean;
   enableSupplierField?: boolean; // Whether to show supplier selection
+  supplierRequired?: boolean; // Whether supplier is required when enabled
   enableLocationField?: boolean; // Whether to show location selection
+  locationRequired?: boolean; // Whether location is required when enabled
+  locationPrecision?: "rack" | "shelf" | "bin"; // Maximum level of location detail allowed
+  requiredLocationLevel?: "rack" | "shelf" | "bin"; // Minimum level of location detail required
   groupingAttributes?: string[]; // Field keys that can be used for grouping
+  quantityField?: string; // The field key that represents item quantity
+  // Inventory min/max settings
+  minQuantity?: number; // Minimum quantity before reorder alert
+  maxQuantity?: number; // Maximum quantity to maintain
+  minMaxRequired?: boolean; // Whether min/max is required for items of this type
+  // Lift tag configuration
+  liftTagConfig?: {
+    enabled: boolean;
+    size?: string; // Label size text (e.g., "2x4")
+    fieldsToInclude: string[]; // Field keys to include on the tag
+    includeBarcode?: boolean;
+    showFieldLabels?: boolean;
+    identifierFontSize?: number;
+    includeCreatedDate?: boolean;
+    widthInches?: number;
+    heightInches?: number;
+    textAlignment?: "left" | "right";
+  };
 }
 
 export interface IHistoryEntry {
@@ -55,9 +79,18 @@ export interface IInventoryItem {
   _id: string;
   type: string | IInventoryType;
   location?: string | ILocation;
+  locationPath?: {
+    rackId?: mongoose.Types.ObjectId;
+    shelfId?: mongoose.Types.ObjectId;
+    binId?: mongoose.Types.ObjectId;
+  };
   fields: Map<string, any>;
-  tags: string[];
+  tag: string;
   history: IHistoryEntry[];
+  // Min/max quantities for this specific item
+  minQuantity?: number; // Minimum quantity before reorder alert
+  maxQuantity?: number; // Maximum quantity to maintain
+  currentQuantity?: number; // Current quantity (derived from quantity field if set)
   createdAt: Date;
   updatedAt: Date;
 }
@@ -97,10 +130,15 @@ export interface IInventoryItemResponse {
     name: string;
     [key: string]: any;
   }; // Populated location reference
+  locationPath?: {
+    rackId?: mongoose.Types.ObjectId;
+    shelfId?: mongoose.Types.ObjectId;
+    binId?: mongoose.Types.ObjectId;
+  };
   fields: {
     [key: string]: any;
   }; // Converted from Map to plain object
-  tags: string[];
+  tag: string;
   history: {
     date: Date;
     action: string;

package/src/IMailCache.ts

@@ -9,11 +9,25 @@ export interface ILeanMailCache {
   state: string;
   logs: string[];
   exporterID: string;
+  pdfAttachments?: IPDFAttachment[];
 }
 
 export interface IAttachment {
   fileName: string;
   content: string;
+  contentType?: string;
+}
+
+export interface IPDFAttachment {
+  _id?: mongoose.Types.ObjectId;
+  fileName: string;
+  fileSize: number;
+  contentType: string;
+  uploadedAt: Date;
+  uploadedBy?: string;
+  storagePath?: string;
+  gridFSId?: mongoose.Types.ObjectId;
+  orderNumber?: number;
 }
 
 export type IMailCache = ILeanMailCache & Document;

package/src/IOrder.ts

@@ -48,7 +48,7 @@ export interface IOrderProduct {
   _id: string;
   quantity: number;
   type: string;
-  limitsGroup: string;
+  productionLine: string;
   startDate: string;
   hasStarted: boolean;
   highlight: boolean;

package/src/ISchedule.ts

@@ -0,0 +1,125 @@
+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;
+}
+
+// A filter group - conditions are ANDed together
+export interface IScheduleFilterGroup {
+  conditions: IScheduleFilterCondition[];
+}
+
+// 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
+}
+
+// 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[];
+  // 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;
+  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;