Developer
860 lines
24 KiB
ObjectPascal
860 lines
24 KiB
ObjectPascal
unit uBusinessServices;
|
|
|
|
interface
|
|
|
|
uses
|
|
SysUtils, Classes, System.JSON, System.Threading, System.Generics.Collections,
|
|
uExceptionHandler, uLogManager, uConfigManager, uKsoap, uSafeLog, uCommonUtils;
|
|
|
|
type
|
|
TAuthResult = record
|
|
Success: Boolean;
|
|
UserID: string;
|
|
UserName: string;
|
|
Token: string;
|
|
ErrorMessage: string;
|
|
procedure Clear;
|
|
class function CreateSuccess(const AUserID, AUserName, AToken: string): TAuthResult; static;
|
|
class function CreateFailure(const AErrorMessage: string): TAuthResult; static;
|
|
end;
|
|
|
|
TWorkOrderInfo = record
|
|
OrderID: string;
|
|
OrderNumber: string;
|
|
MaterialID: string;
|
|
MaterialName: string;
|
|
Quantity: Double;
|
|
Status: string;
|
|
CreateTime: TDateTime;
|
|
procedure Clear;
|
|
end;
|
|
|
|
TWorkOrderEntry = record
|
|
EntryID: string;
|
|
OrderID: string;
|
|
ProcessID: string;
|
|
ProcessName: string;
|
|
Quantity: Double;
|
|
Status: string;
|
|
procedure Clear;
|
|
end;
|
|
|
|
TDeviceStatus = record
|
|
DeviceID: string;
|
|
DeviceName: string;
|
|
IPAddress: string;
|
|
Port: Integer;
|
|
Status: string; // 'Online', 'Offline', 'Error'
|
|
LastHeartbeat: TDateTime;
|
|
procedure Clear;
|
|
end;
|
|
|
|
TAuthService = class
|
|
private
|
|
FBaseURL: string;
|
|
FTimeout: Integer;
|
|
public
|
|
function Login(const UserID, Password: string): TAuthResult;
|
|
function Logout(const Token: string): Boolean;
|
|
function RefreshToken(const Token: string): string;
|
|
function ValidateToken(const Token: string): Boolean;
|
|
constructor Create();
|
|
end;
|
|
|
|
TWorkOrderService = class
|
|
private
|
|
FBaseURL: string;
|
|
FToken: string;
|
|
public
|
|
function GetWorkOrderList(const Status: string = ''): TArray<TWorkOrderInfo>;
|
|
function GetWorkOrderDetail(const OrderID: string): TWorkOrderInfo;
|
|
function GetWorkOrderEntries(const OrderID: string): TArray<TWorkOrderEntry>;
|
|
function CreateWorkOrder(const OrderInfo: TWorkOrderInfo): string;
|
|
function UpdateWorkOrderStatus(const OrderID, Status: string): Boolean;
|
|
function ReportProduction(const OrderID, ProcessID, Quantity: string): Boolean;
|
|
constructor Create(const AToken: string);
|
|
end;
|
|
|
|
TDeviceService = class
|
|
private
|
|
FDevices: TDictionary<string, TDeviceStatus>;
|
|
public
|
|
function GetDeviceStatus(const DeviceID: string): TDeviceStatus;
|
|
function GetAllDevices(): TArray<TDeviceStatus>;
|
|
function ConnectDevice(const DeviceID: string): Boolean;
|
|
function DisconnectDevice(const DeviceID: string): Boolean;
|
|
function SendCommand(const DeviceID, Command: string): string;
|
|
function GetDeviceInfo(const DeviceID: string): TJSONObject;
|
|
constructor Create();
|
|
destructor Destroy; override;
|
|
end;
|
|
|
|
TSyncService = class
|
|
private
|
|
FBaseURL: string;
|
|
FToken: string;
|
|
FIsSyncing: Boolean;
|
|
public
|
|
function SyncData(const Data: TJSONObject): Boolean;
|
|
function SyncBatchData(const DataArray: TJSONArray): Boolean;
|
|
function GetSyncStatus(): TJSONObject;
|
|
function RetryFailedSyncs(): Integer;
|
|
procedure StartAutoSync(IntervalMS: Integer);
|
|
procedure StopAutoSync();
|
|
constructor Create(const AToken: string);
|
|
end;
|
|
|
|
TBusinessServiceFactory = class
|
|
public
|
|
class function GetAuthService(): TAuthService;
|
|
class function GetWorkOrderService(const Token: string): TWorkOrderService;
|
|
class function GetDeviceService(): TDeviceService;
|
|
class function GetSyncService(const Token: string): TSyncService;
|
|
class function GetDeviceConfigService(): TDeviceConfigService;
|
|
class function GetProductionReportingService(const Token: string): TProductionReportingService;
|
|
class function GetDataAccessService(): TDataAccessService;
|
|
end;
|
|
|
|
TDeviceConfigService = class
|
|
private
|
|
FDeviceID: string;
|
|
FFactoryCode: string;
|
|
FPC: string;
|
|
FLine: string;
|
|
FLineNum: string;
|
|
FKB: string;
|
|
FUser: string;
|
|
FPassword: string;
|
|
public
|
|
function LoadDeviceConfig(): Boolean;
|
|
function SaveDeviceConfig(): Boolean;
|
|
function GetServerURL(): string;
|
|
function GetFactoryCode(): string;
|
|
function GetProductionLine(): string;
|
|
function GetOperatorStation(): string;
|
|
function ValidateConfig(): TValidationResult;
|
|
property DeviceID: string read FDeviceID write FDeviceID;
|
|
property FactoryCode: string read FFactoryCode write FFactoryCode;
|
|
property PC: string read FPC write FPC;
|
|
property Line: string read FLine write FLine;
|
|
property LineNum: string read FLineNum write FLineNum;
|
|
property KB: string read FKB write FKB;
|
|
property User: string read FUser write FUser;
|
|
property Password: string read FPassword write FPassword;
|
|
constructor Create();
|
|
end;
|
|
|
|
TProductionReportingService = class
|
|
private
|
|
FToken: string;
|
|
public
|
|
function ReportProduction(const OrderID, ProcessID, Quantity, LotNo: string): Boolean;
|
|
function ReportDefective(const OrderID, ProcessID, DefectType, Quantity: string): Boolean;
|
|
function QueryProductionStatus(const OrderID: string): TJSONObject;
|
|
function ValidateUser(const UserID: string): Boolean;
|
|
function GetWorkOrderInfo(const LotNo: string): TJSONObject;
|
|
function GetProcessList(const LotNo: string): TJSONArray;
|
|
function ValidateGoodsNo(const ItemCode, ProcessCode, WorkOrderNumber: string): Boolean;
|
|
function SubmitProductionData(const UserID, LotNo, ProcessID, GoodsNo: string): Boolean;
|
|
constructor Create(const AToken: string);
|
|
end;
|
|
|
|
TDataAccessService = class
|
|
public
|
|
function ReadConfigValue(const ASection, AKey: string; const ADefault: string = ''): string;
|
|
procedure WriteConfigValue(const ASection, AKey, AValue: string);
|
|
function ReadDeviceInfo(const AKey: string): string;
|
|
function ReadProductionParams(const AKey: string): string;
|
|
function ReadAlarmConfig(const AKey: string): string;
|
|
constructor Create();
|
|
end;
|
|
|
|
implementation
|
|
|
|
{ TAuthResult }
|
|
|
|
procedure TAuthResult.Clear;
|
|
begin
|
|
Success := False;
|
|
UserID := '';
|
|
UserName := '';
|
|
Token := '';
|
|
ErrorMessage := '';
|
|
end;
|
|
|
|
class function TAuthResult.CreateSuccess(const AUserID, AUserName, AToken: string): TAuthResult;
|
|
begin
|
|
Result.Clear;
|
|
Result.Success := True;
|
|
Result.UserID := AUserID;
|
|
Result.UserName := AUserName;
|
|
Result.Token := AToken;
|
|
end;
|
|
|
|
class function TAuthResult.CreateFailure(const AErrorMessage: string): TAuthResult;
|
|
begin
|
|
Result.Clear;
|
|
Result.Success := False;
|
|
Result.ErrorMessage := AErrorMessage;
|
|
end;
|
|
|
|
{ TWorkOrderInfo }
|
|
|
|
procedure TWorkOrderInfo.Clear;
|
|
begin
|
|
OrderID := '';
|
|
OrderNumber := '';
|
|
MaterialID := '';
|
|
MaterialName := '';
|
|
Quantity := 0;
|
|
Status := '';
|
|
CreateTime := 0;
|
|
end;
|
|
|
|
{ TWorkOrderEntry }
|
|
|
|
procedure TWorkOrderEntry.Clear;
|
|
begin
|
|
EntryID := '';
|
|
OrderID := '';
|
|
ProcessID := '';
|
|
ProcessName := '';
|
|
Quantity := 0;
|
|
Status := '';
|
|
end;
|
|
|
|
{ TDeviceStatus }
|
|
|
|
procedure TDeviceStatus.Clear;
|
|
begin
|
|
DeviceID := '';
|
|
DeviceName := '';
|
|
IPAddress := '';
|
|
Port := 0;
|
|
Status := '';
|
|
LastHeartbeat := 0;
|
|
end;
|
|
|
|
{ TAuthService }
|
|
|
|
constructor TAuthService.Create;
|
|
begin
|
|
FBaseURL := Config.GetServerURL;
|
|
FTimeout := Config.GetTimeout;
|
|
end;
|
|
|
|
function TAuthService.Login(const UserID, Password: string): TAuthResult;
|
|
var
|
|
PerfLogger: TPerformanceLogger;
|
|
begin
|
|
PerfLogger := TPerformanceLogger.Create('AuthService.Login', UserID);
|
|
try
|
|
LogManager.InfoCategory(lcSecurity, 'Login attempt for user: %s', [UserID]);
|
|
|
|
try
|
|
// 调用KSoap或REST API进行登录
|
|
Result := TAuthResult.CreateSuccess(UserID, 'Test User', 'test-token-123');
|
|
LogManager.InfoCategory(lcSecurity, 'Login successful for user: %s', [UserID]);
|
|
except
|
|
on E: Exception do
|
|
begin
|
|
LogManager.ErrorCategory(lcSecurity, 'Login failed: %s', [E.Message]);
|
|
Result := TAuthResult.CreateFailure(E.Message);
|
|
end;
|
|
end;
|
|
finally
|
|
PerfLogger.Free;
|
|
end;
|
|
end;
|
|
|
|
function TAuthService.Logout(const Token: string): Boolean;
|
|
begin
|
|
LogManager.InfoCategory(lcSecurity, 'Logout with token: %s', [Token]);
|
|
Result := True;
|
|
end;
|
|
|
|
function TAuthService.RefreshToken(const Token: string): string;
|
|
begin
|
|
LogManager.InfoCategory(lcSecurity, 'Refresh token: %s', [Token]);
|
|
Result := 'refreshed-token-' + IntToStr(Random(1000));
|
|
end;
|
|
|
|
function TAuthService.ValidateToken(const Token: string): Boolean;
|
|
begin
|
|
LogManager.DebugCategory(lcSecurity, 'Validate token: %s', [Token]);
|
|
Result := True;
|
|
end;
|
|
|
|
{ TWorkOrderService }
|
|
|
|
constructor TWorkOrderService.Create(const AToken: string);
|
|
begin
|
|
FBaseURL := Config.GetServerURL;
|
|
FToken := AToken;
|
|
end;
|
|
|
|
function TWorkOrderService.GetWorkOrderList(const Status: string = ''): TArray<TWorkOrderInfo>;
|
|
var
|
|
Info: TWorkOrderInfo;
|
|
PerfLogger: TPerformanceLogger;
|
|
begin
|
|
PerfLogger := TPerformanceLogger.Create('WorkOrderService.GetWorkOrderList', Status);
|
|
try
|
|
LogManager.InfoCategory(lcBusiness, 'Get work order list, status: %s', [Status]);
|
|
|
|
// 模拟数据
|
|
SetLength(Result, 2);
|
|
|
|
Info.Clear;
|
|
Info.OrderID := '1';
|
|
Info.OrderNumber := 'WO-2026-001';
|
|
Info.MaterialID := 'MAT-001';
|
|
Info.MaterialName := '测试物料';
|
|
Info.Quantity := 1000;
|
|
Info.Status := 'A';
|
|
Info.CreateTime := Now;
|
|
Result[0] := Info;
|
|
|
|
Info.Clear;
|
|
Info.OrderID := '2';
|
|
Info.OrderNumber := 'WO-2026-002';
|
|
Info.MaterialID := 'MAT-002';
|
|
Info.MaterialName := '测试物料2';
|
|
Info.Quantity := 500;
|
|
Info.Status := 'B';
|
|
Info.CreateTime := Now - 1;
|
|
Result[1] := Info;
|
|
finally
|
|
PerfLogger.Free;
|
|
end;
|
|
end;
|
|
|
|
function TWorkOrderService.GetWorkOrderDetail(const OrderID: string): TWorkOrderInfo;
|
|
var
|
|
PerfLogger: TPerformanceLogger;
|
|
begin
|
|
PerfLogger := TPerformanceLogger.Create('WorkOrderService.GetWorkOrderDetail', OrderID);
|
|
try
|
|
LogManager.InfoCategory(lcBusiness, 'Get work order detail: %s', [OrderID]);
|
|
Result.Clear;
|
|
Result.OrderID := OrderID;
|
|
Result.OrderNumber := 'WO-2026-001';
|
|
Result.MaterialID := 'MAT-001';
|
|
Result.MaterialName := '测试物料';
|
|
Result.Quantity := 1000;
|
|
Result.Status := 'A';
|
|
Result.CreateTime := Now;
|
|
finally
|
|
PerfLogger.Free;
|
|
end;
|
|
end;
|
|
|
|
function TWorkOrderService.GetWorkOrderEntries(const OrderID: string): TArray<TWorkOrderEntry>;
|
|
var
|
|
Entry: TWorkOrderEntry;
|
|
begin
|
|
LogManager.InfoCategory(lcBusiness, 'Get work order entries: %s', [OrderID]);
|
|
|
|
SetLength(Result, 2);
|
|
Entry.Clear;
|
|
Entry.EntryID := '1';
|
|
Entry.OrderID := OrderID;
|
|
Entry.ProcessID := '101';
|
|
Entry.ProcessName := '装配';
|
|
Entry.Quantity := 500;
|
|
Entry.Status := 'A';
|
|
Result[0] := Entry;
|
|
|
|
Entry.Clear;
|
|
Entry.EntryID := '2';
|
|
Entry.OrderID := OrderID;
|
|
Entry.ProcessID := '102';
|
|
Entry.ProcessName := '测试';
|
|
Entry.Quantity := 300;
|
|
Entry.Status := 'B';
|
|
Result[1] := Entry;
|
|
end;
|
|
|
|
function TWorkOrderService.CreateWorkOrder(const OrderInfo: TWorkOrderInfo): string;
|
|
begin
|
|
LogManager.InfoCategory(lcBusiness, 'Create work order: %s', [OrderInfo.OrderNumber]);
|
|
Result := 'NEW-ORDER-' + IntToStr(Random(10000));
|
|
end;
|
|
|
|
function TWorkOrderService.UpdateWorkOrderStatus(const OrderID, Status: string): Boolean;
|
|
begin
|
|
LogManager.InfoCategory(lcBusiness, 'Update work order status: %s -> %s', [OrderID, Status]);
|
|
Result := True;
|
|
end;
|
|
|
|
function TWorkOrderService.ReportProduction(const OrderID, ProcessID, Quantity: string): Boolean;
|
|
begin
|
|
LogManager.InfoCategory(lcBusiness, 'Report production: Order=%s, Process=%s, Qty=%s', [OrderID, ProcessID, Quantity]);
|
|
Result := True;
|
|
end;
|
|
|
|
{ TDeviceService }
|
|
|
|
constructor TDeviceService.Create;
|
|
begin
|
|
FDevices := TDictionary<string, TDeviceStatus>.Create;
|
|
|
|
// 初始化设备 - 从配置管理器读取
|
|
var Status: TDeviceStatus;
|
|
Status.Clear;
|
|
Status.DeviceID := 'PLC-001';
|
|
Status.DeviceName := '主PLC';
|
|
Status.IPAddress := Config.GetPLCHost;
|
|
Status.Port := Config.GetPLCPort;
|
|
Status.Status := 'Online';
|
|
Status.LastHeartbeat := Now;
|
|
FDevices.Add(Status.DeviceID, Status);
|
|
|
|
Status.Clear;
|
|
Status.DeviceID := 'PLC-002';
|
|
Status.DeviceName := '辅助PLC';
|
|
Status.IPAddress := Config.GetPLCHost; // 可以设置为另一个PLC地址
|
|
Status.Port := Config.GetPLCPort;
|
|
Status.Status := 'Online';
|
|
Status.LastHeartbeat := Now;
|
|
FDevices.Add(Status.DeviceID, Status);
|
|
end;
|
|
|
|
destructor TDeviceService.Destroy;
|
|
begin
|
|
FDevices.Free;
|
|
inherited;
|
|
end;
|
|
|
|
function TDeviceService.GetDeviceStatus(const DeviceID: string): TDeviceStatus;
|
|
var
|
|
Status: TDeviceStatus;
|
|
begin
|
|
LogManager.InfoCategory(lcDevice, 'Get device status: %s', [DeviceID]);
|
|
if FDevices.TryGetValue(DeviceID, Status) then
|
|
Result := Status
|
|
else
|
|
begin
|
|
Result.Clear;
|
|
Result.DeviceID := DeviceID;
|
|
Result.Status := 'Offline';
|
|
end;
|
|
end;
|
|
|
|
function TDeviceService.GetAllDevices(): TArray<TDeviceStatus>;
|
|
var
|
|
Status: TDeviceStatus;
|
|
Count, I: Integer;
|
|
begin
|
|
LogManager.InfoCategory(lcDevice, 'Get all devices');
|
|
Count := FDevices.Count;
|
|
SetLength(Result, Count);
|
|
I := 0;
|
|
for Status in FDevices.Values do
|
|
begin
|
|
Result[I] := Status;
|
|
Inc(I);
|
|
end;
|
|
end;
|
|
|
|
function TDeviceService.ConnectDevice(const DeviceID: string): Boolean;
|
|
begin
|
|
LogManager.InfoCategory(lcDevice, 'Connect device: %s', [DeviceID]);
|
|
Result := True;
|
|
if FDevices.ContainsKey(DeviceID) then
|
|
begin
|
|
var Status := FDevices[DeviceID];
|
|
Status.Status := 'Online';
|
|
Status.LastHeartbeat := Now;
|
|
FDevices.AddOrSetValue(DeviceID, Status);
|
|
end;
|
|
end;
|
|
|
|
function TDeviceService.DisconnectDevice(const DeviceID: string): Boolean;
|
|
begin
|
|
LogManager.InfoCategory(lcDevice, 'Disconnect device: %s', [DeviceID]);
|
|
Result := True;
|
|
if FDevices.ContainsKey(DeviceID) then
|
|
begin
|
|
var Status := FDevices[DeviceID];
|
|
Status.Status := 'Offline';
|
|
FDevices.AddOrSetValue(DeviceID, Status);
|
|
end;
|
|
end;
|
|
|
|
function TDeviceService.SendCommand(const DeviceID, Command: string): string;
|
|
begin
|
|
LogManager.InfoCategory(lcDevice, 'Send command to device %s: %s', [DeviceID, Command]);
|
|
Result := 'OK: Command executed';
|
|
end;
|
|
|
|
function TDeviceService.GetDeviceInfo(const DeviceID: string): TJSONObject;
|
|
begin
|
|
LogManager.InfoCategory(lcDevice, 'Get device info: %s', [DeviceID]);
|
|
Result := TJSONObject.Create;
|
|
Result.AddPair('deviceId', DeviceID);
|
|
Result.AddPair('deviceName', 'Test Device');
|
|
Result.AddPair('status', 'Online');
|
|
end;
|
|
|
|
{ TSyncService }
|
|
|
|
constructor TSyncService.Create(const AToken: string);
|
|
begin
|
|
FBaseURL := Config.GetServerURL;
|
|
FToken := AToken;
|
|
FIsSyncing := False;
|
|
end;
|
|
|
|
function TSyncService.SyncData(const Data: TJSONObject): Boolean;
|
|
var
|
|
PerfLogger: TPerformanceLogger;
|
|
begin
|
|
PerfLogger := TPerformanceLogger.Create('SyncService.SyncData');
|
|
try
|
|
LogManager.InfoCategory(lcNetwork, 'Sync data');
|
|
Result := True;
|
|
finally
|
|
PerfLogger.Free;
|
|
end;
|
|
end;
|
|
|
|
function TSyncService.SyncBatchData(const DataArray: TJSONArray): Boolean;
|
|
var
|
|
PerfLogger: TPerformanceLogger;
|
|
begin
|
|
PerfLogger := TPerformanceLogger.Create('SyncService.SyncBatchData', Format('count=%d', [DataArray.Count]));
|
|
try
|
|
LogManager.InfoCategory(lcNetwork, 'Sync batch data, count: %d', [DataArray.Count]);
|
|
Result := True;
|
|
finally
|
|
PerfLogger.Free;
|
|
end;
|
|
end;
|
|
|
|
function TSyncService.GetSyncStatus(): TJSONObject;
|
|
begin
|
|
LogManager.InfoCategory(lcNetwork, 'Get sync status');
|
|
Result := TJSONObject.Create;
|
|
Result.AddPair('lastSync', FormatDateTime('yyyy-mm-dd hh:nn:ss', Now));
|
|
Result.AddPair('success', TJSONBool.Create(True));
|
|
Result.AddPair('pendingCount', TJSONNumber.Create(0));
|
|
end;
|
|
|
|
function TSyncService.RetryFailedSyncs(): Integer;
|
|
var
|
|
PerfLogger: TPerformanceLogger;
|
|
begin
|
|
PerfLogger := TPerformanceLogger.Create('SyncService.RetryFailedSyncs');
|
|
try
|
|
LogManager.InfoCategory(lcNetwork, 'Retry failed syncs');
|
|
Result := 0;
|
|
finally
|
|
PerfLogger.Free;
|
|
end;
|
|
end;
|
|
|
|
procedure TSyncService.StartAutoSync(IntervalMS: Integer);
|
|
begin
|
|
LogManager.InfoCategory(lcNetwork, 'Start auto sync, interval: %d ms', [IntervalMS]);
|
|
FIsSyncing := True;
|
|
end;
|
|
|
|
procedure TSyncService.StopAutoSync;
|
|
begin
|
|
LogManager.InfoCategory(lcNetwork, 'Stop auto sync');
|
|
FIsSyncing := False;
|
|
end;
|
|
|
|
{ TBusinessServiceFactory }
|
|
|
|
class function TBusinessServiceFactory.GetAuthService(): TAuthService;
|
|
begin
|
|
Result := TAuthService.Create;
|
|
end;
|
|
|
|
class function TBusinessServiceFactory.GetWorkOrderService(const Token: string): TWorkOrderService;
|
|
begin
|
|
Result := TWorkOrderService.Create(Token);
|
|
end;
|
|
|
|
class function TBusinessServiceFactory.GetDeviceService(): TDeviceService;
|
|
begin
|
|
Result := TDeviceService.Create;
|
|
end;
|
|
|
|
class function TBusinessServiceFactory.GetSyncService(const Token: string): TSyncService;
|
|
begin
|
|
Result := TSyncService.Create(Token);
|
|
end;
|
|
|
|
class function TBusinessServiceFactory.GetDeviceConfigService(): TDeviceConfigService;
|
|
begin
|
|
Result := TDeviceConfigService.Create;
|
|
end;
|
|
|
|
class function TBusinessServiceFactory.GetProductionReportingService(const Token: string): TProductionReportingService;
|
|
begin
|
|
Result := TProductionReportingService.Create(Token);
|
|
end;
|
|
|
|
class function TBusinessServiceFactory.GetDataAccessService(): TDataAccessService;
|
|
begin
|
|
Result := TDataAccessService.Create;
|
|
end;
|
|
|
|
{ TDeviceConfigService }
|
|
|
|
constructor TDeviceConfigService.Create;
|
|
begin
|
|
inherited;
|
|
FDeviceID := '';
|
|
FFactoryCode := '';
|
|
FPC := '';
|
|
FLine := '';
|
|
FLineNum := '';
|
|
FKB := '';
|
|
FUser := '';
|
|
FPassword := '';
|
|
end;
|
|
|
|
function TDeviceConfigService.LoadDeviceConfig(): Boolean;
|
|
var
|
|
PerfLogger: TPerformanceLogger;
|
|
begin
|
|
PerfLogger := TPerformanceLogger.Create('DeviceConfigService.LoadDeviceConfig');
|
|
try
|
|
LogManager.InfoCategory(lcBusiness, 'Loading device config');
|
|
Result := True;
|
|
// 从配置管理器加载设备配置
|
|
FDeviceID := Config.GetServerURL;
|
|
FFactoryCode := '';
|
|
FLine := '';
|
|
FLineNum := '';
|
|
FKB := '';
|
|
finally
|
|
PerfLogger.Free;
|
|
end;
|
|
end;
|
|
|
|
function TDeviceConfigService.SaveDeviceConfig(): Boolean;
|
|
var
|
|
PerfLogger: TPerformanceLogger;
|
|
begin
|
|
PerfLogger := TPerformanceLogger.Create('DeviceConfigService.SaveDeviceConfig');
|
|
try
|
|
LogManager.InfoCategory(lcBusiness, 'Saving device config');
|
|
Result := True;
|
|
finally
|
|
PerfLogger.Free;
|
|
end;
|
|
end;
|
|
|
|
function TDeviceConfigService.GetServerURL(): string;
|
|
begin
|
|
Result := Config.GetServerURL;
|
|
end;
|
|
|
|
function TDeviceConfigService.GetFactoryCode(): string;
|
|
begin
|
|
Result := FFactoryCode;
|
|
end;
|
|
|
|
function TDeviceConfigService.GetProductionLine(): string;
|
|
begin
|
|
Result := FLine;
|
|
end;
|
|
|
|
function TDeviceConfigService.GetOperatorStation(): string;
|
|
begin
|
|
Result := FKB;
|
|
end;
|
|
|
|
function TDeviceConfigService.ValidateConfig(): TValidationResult;
|
|
begin
|
|
if FFactoryCode = '' then
|
|
Exit(TValidationResult.Failure('FactoryCode', 'Factory code cannot be empty'));
|
|
if FLine = '' then
|
|
Exit(TValidationResult.Failure('Line', 'Production line cannot be empty'));
|
|
if FUser = '' then
|
|
Exit(TValidationResult.Failure('User', 'User cannot be empty'));
|
|
Result := TValidationResult.Success;
|
|
end;
|
|
|
|
{ TProductionReportingService }
|
|
|
|
constructor TProductionReportingService.Create(const AToken: string);
|
|
begin
|
|
inherited Create;
|
|
FToken := AToken;
|
|
end;
|
|
|
|
function TProductionReportingService.ReportProduction(const OrderID, ProcessID, Quantity, LotNo: string): Boolean;
|
|
var
|
|
PerfLogger: TPerformanceLogger;
|
|
begin
|
|
PerfLogger := TPerformanceLogger.Create('ProductionReportingService.ReportProduction',
|
|
Format('Order=%s, Process=%s, Qty=%s', [OrderID, ProcessID, Quantity]));
|
|
try
|
|
LogManager.InfoCategory(lcBusiness, 'Report production: Order=%s, Process=%s, Qty=%s, Lot=%s',
|
|
[OrderID, ProcessID, Quantity, LotNo]);
|
|
Result := True;
|
|
finally
|
|
PerfLogger.Free;
|
|
end;
|
|
end;
|
|
|
|
function TProductionReportingService.ReportDefective(const OrderID, ProcessID, DefectType, Quantity: string): Boolean;
|
|
var
|
|
PerfLogger: TPerformanceLogger;
|
|
begin
|
|
PerfLogger := TPerformanceLogger.Create('ProductionReportingService.ReportDefective',
|
|
Format('Order=%s, Defect=%s, Qty=%s', [OrderID, DefectType, Quantity]));
|
|
try
|
|
LogManager.InfoCategory(lcBusiness, 'Report defective: Order=%s, Process=%s, Type=%s, Qty=%s',
|
|
[OrderID, ProcessID, DefectType, Quantity]);
|
|
Result := True;
|
|
finally
|
|
PerfLogger.Free;
|
|
end;
|
|
end;
|
|
|
|
function TProductionReportingService.QueryProductionStatus(const OrderID: string): TJSONObject;
|
|
var
|
|
PerfLogger: TPerformanceLogger;
|
|
begin
|
|
PerfLogger := TPerformanceLogger.Create('ProductionReportingService.QueryProductionStatus', OrderID);
|
|
try
|
|
LogManager.InfoCategory(lcBusiness, 'Query production status: Order=%s', [OrderID]);
|
|
Result := TJSONObject.Create;
|
|
Result.AddPair('orderId', OrderID);
|
|
Result.AddPair('status', 'InProgress');
|
|
Result.AddPair('quantity', TJSONNumber.Create(500));
|
|
finally
|
|
PerfLogger.Free;
|
|
end;
|
|
end;
|
|
|
|
function TProductionReportingService.ValidateUser(const UserID: string): Boolean;
|
|
var
|
|
PerfLogger: TPerformanceLogger;
|
|
begin
|
|
PerfLogger := TPerformanceLogger.Create('ProductionReportingService.ValidateUser', UserID);
|
|
try
|
|
LogManager.InfoCategory(lcBusiness, 'Validate user: %s', [UserID]);
|
|
// 调用KJSon.REST_pro_List验证用户
|
|
Result := True; // 模拟实现，实际需要调用真实的验证逻辑
|
|
finally
|
|
PerfLogger.Free;
|
|
end;
|
|
end;
|
|
|
|
function TProductionReportingService.GetWorkOrderInfo(const LotNo: string): TJSONObject;
|
|
var
|
|
PerfLogger: TPerformanceLogger;
|
|
begin
|
|
PerfLogger := TPerformanceLogger.Create('ProductionReportingService.GetWorkOrderInfo', LotNo);
|
|
try
|
|
LogManager.InfoCategory(lcBusiness, 'Get work order info: %s', [LotNo]);
|
|
Result := TJSONObject.Create;
|
|
Result.AddPair('lotNo', LotNo);
|
|
Result.AddPair('orderId', 'ORDER-' + LotNo);
|
|
Result.AddPair('status', 'Active');
|
|
finally
|
|
PerfLogger.Free;
|
|
end;
|
|
end;
|
|
|
|
function TProductionReportingService.GetProcessList(const LotNo: string): TJSONArray;
|
|
var
|
|
PerfLogger: TPerformanceLogger;
|
|
Process: TJSONObject;
|
|
begin
|
|
PerfLogger := TPerformanceLogger.Create('ProductionReportingService.GetProcessList', LotNo);
|
|
try
|
|
LogManager.InfoCategory(lcBusiness, 'Get process list for lot: %s', [LotNo]);
|
|
Result := TJSONArray.Create;
|
|
|
|
// 模拟工序数据
|
|
Process := TJSONObject.Create;
|
|
Process.AddPair('id', '1');
|
|
Process.AddPair('number', 'P001');
|
|
Process.AddPair('processName', '装配');
|
|
Process.AddPair('attention', 'bx');
|
|
Result.AddElement(Process);
|
|
|
|
Process := TJSONObject.Create;
|
|
Process.AddPair('id', '2');
|
|
Process.AddPair('number', 'P002');
|
|
Process.AddPair('processName', '测试');
|
|
Process.AddPair('attention', 'bd');
|
|
Result.AddElement(Process);
|
|
finally
|
|
PerfLogger.Free;
|
|
end;
|
|
end;
|
|
|
|
function TProductionReportingService.ValidateGoodsNo(const ItemCode, ProcessCode, WorkOrderNumber: string): Boolean;
|
|
var
|
|
PerfLogger: TPerformanceLogger;
|
|
begin
|
|
PerfLogger := TPerformanceLogger.Create('ProductionReportingService.ValidateGoodsNo', ItemCode);
|
|
try
|
|
LogManager.InfoCategory(lcBusiness, 'Validate goods no: Item=%s, Process=%s, WO=%s', [ItemCode, ProcessCode, WorkOrderNumber]);
|
|
// 调用KJSon.REST_pro_List验证二维码
|
|
Result := True; // 模拟实现，实际需要调用真实的验证逻辑
|
|
finally
|
|
PerfLogger.Free;
|
|
end;
|
|
end;
|
|
|
|
function TProductionReportingService.SubmitProductionData(const UserID, LotNo, ProcessID, GoodsNo: string): Boolean;
|
|
var
|
|
PerfLogger: TPerformanceLogger;
|
|
begin
|
|
PerfLogger := TPerformanceLogger.Create('ProductionReportingService.SubmitProductionData', Format('User=%s, Lot=%s', [UserID, LotNo]));
|
|
try
|
|
LogManager.InfoCategory(lcBusiness, 'Submit production data: User=%s, Lot=%s, Process=%s, Goods=%s', [UserID, LotNo, ProcessID, GoodsNo]);
|
|
// 提交生产数据到服务器
|
|
Result := True; // 模拟实现，实际需要调用真实的提交逻辑
|
|
finally
|
|
PerfLogger.Free;
|
|
end;
|
|
end;
|
|
|
|
{ TDataAccessService }
|
|
|
|
constructor TDataAccessService.Create;
|
|
begin
|
|
inherited;
|
|
end;
|
|
|
|
function TDataAccessService.ReadConfigValue(const ASection, AKey: string; const ADefault: string = ''): string;
|
|
begin
|
|
LogManager.DebugCategory(lcDatabase, 'Read config: Section=%s, Key=%s', [ASection, AKey]);
|
|
Result := Config.ConfigMgr.GetString(ASection, AKey, ADefault);
|
|
end;
|
|
|
|
procedure TDataAccessService.WriteConfigValue(const ASection, AKey, AValue: string);
|
|
begin
|
|
LogManager.DebugCategory(lcDatabase, 'Write config: Section=%s, Key=%s, Value=%s', [ASection, AKey, AValue]);
|
|
Config.ConfigMgr.SetString(ASection, AKey, AValue);
|
|
end;
|
|
|
|
function TDataAccessService.ReadDeviceInfo(const AKey: string): string;
|
|
begin
|
|
Result := ReadConfigValue('设备信息', AKey, '');
|
|
end;
|
|
|
|
function TDataAccessService.ReadProductionParams(const AKey: string): string;
|
|
begin
|
|
Result := ReadConfigValue('主要参数', AKey, '');
|
|
end;
|
|
|
|
function TDataAccessService.ReadAlarmConfig(const AKey: string): string;
|
|
begin
|
|
Result := ReadConfigValue('报警灯', AKey, '');
|
|
end;
|
|
|
|
end.
|