608 lines
27 KiB
Plaintext
608 lines
27 KiB
Plaintext
#include "..\script_component.hpp"
|
|
|
|
/*
|
|
* File: fnc_initAssignmentRepository.sqf
|
|
* Author: IDSolutions
|
|
* Date: 2026-03-30
|
|
* Public: No
|
|
*
|
|
* Description:
|
|
* Initializes the CAD assignment repository for contract assignment
|
|
* state and dispatcher/group-leader task actions.
|
|
*
|
|
* Arguments:
|
|
* None
|
|
*
|
|
* Return Value:
|
|
* CAD assignment repository object [HASHMAP OBJECT]
|
|
*
|
|
* Example:
|
|
* call forge_server_cad_fnc_initAssignmentRepository
|
|
*/
|
|
|
|
#pragma hemtt ignore_variables ["_self"]
|
|
GVAR(AssignmentRepositoryBaseClass) = compileFinal createHashMapFromArray [
|
|
["#type", "CadAssignmentRepositoryBaseClass"],
|
|
["#create", compileFinal {
|
|
_self set ["ownershipHydrated", false];
|
|
}],
|
|
["loadState", compileFinal {
|
|
private _result = createHashMapFromArray [
|
|
["success", false],
|
|
["assignments", createHashMap],
|
|
["dispatchOrders", createHashMap]
|
|
];
|
|
|
|
private _persistenceService = _self getOrDefault ["persistenceService", createHashMap];
|
|
if (_persistenceService isEqualTo createHashMap) exitWith { _result };
|
|
|
|
private _assignmentsResult = _persistenceService call ["loadAssignments", []];
|
|
if !(_assignmentsResult getOrDefault ["success", false]) exitWith { _result };
|
|
|
|
private _ordersResult = _persistenceService call ["loadDispatchOrders", []];
|
|
if !(_ordersResult getOrDefault ["success", false]) exitWith { _result };
|
|
|
|
private _assignmentRegistry = +(_assignmentsResult getOrDefault ["data", createHashMap]);
|
|
private _dispatchOrderRegistry = +(_ordersResult getOrDefault ["data", createHashMap]);
|
|
|
|
if !(_self getOrDefault ["ownershipHydrated", false]) then {
|
|
{
|
|
if ((_y getOrDefault ["state", ""]) isNotEqualTo "acknowledged") then { continue; };
|
|
if ((_y getOrDefault ["acknowledgedByUid", ""]) isEqualTo "") then { continue; };
|
|
if ((_dispatchOrderRegistry getOrDefault [_x, createHashMap]) isNotEqualTo createHashMap) then { continue; };
|
|
if !((EGVAR(task,TaskStore) call ["getTaskStatus", [_x]]) in ["assigned", "active"]) then { continue; };
|
|
|
|
EGVAR(task,TaskStore) call ["acceptTask", [_x, _y getOrDefault ["acknowledgedByUid", ""]]];
|
|
EGVAR(task,TaskStore) call ["setTaskStatus", [_x, "active"]];
|
|
} forEach _assignmentRegistry;
|
|
|
|
_self set ["ownershipHydrated", true];
|
|
};
|
|
|
|
_result set ["success", true];
|
|
_result set ["assignments", _assignmentRegistry];
|
|
_result set ["dispatchOrders", _dispatchOrderRegistry];
|
|
_result
|
|
}],
|
|
["pruneAssignments", compileFinal {
|
|
private _state = _self call ["loadState", []];
|
|
if !(_state getOrDefault ["success", false]) exitWith { 0 };
|
|
|
|
private _assignmentRegistry = _state getOrDefault ["assignments", createHashMap];
|
|
private _dispatchOrderRegistry = _state getOrDefault ["dispatchOrders", createHashMap];
|
|
private _keysToRemove = [];
|
|
|
|
{
|
|
if ((_dispatchOrderRegistry getOrDefault [_x, createHashMap]) isNotEqualTo createHashMap) then {
|
|
continue;
|
|
};
|
|
|
|
private _status = EGVAR(task,TaskStore) call ["getTaskStatus", [_x]];
|
|
if !(_status in ["available", "assigned", "active", ""]) then {
|
|
_keysToRemove pushBack _x;
|
|
};
|
|
} forEach _assignmentRegistry;
|
|
|
|
private _persistenceService = _self getOrDefault ["persistenceService", createHashMap];
|
|
if (_persistenceService isNotEqualTo createHashMap) then {
|
|
{
|
|
_persistenceService call ["deleteAssignment", [_x]];
|
|
} forEach _keysToRemove;
|
|
};
|
|
|
|
count _keysToRemove
|
|
}],
|
|
["getAssignments", compileFinal {
|
|
private _state = _self call ["loadState", []];
|
|
if !(_state getOrDefault ["success", false]) exitWith { [] };
|
|
|
|
values (_state getOrDefault ["assignments", createHashMap])
|
|
}],
|
|
["isDispatchOrder", compileFinal {
|
|
params [["_taskID", "", [""]]];
|
|
|
|
if (_taskID isEqualTo "") exitWith { false };
|
|
|
|
private _state = _self call ["loadState", []];
|
|
if !(_state getOrDefault ["success", false]) exitWith { false };
|
|
|
|
((_state getOrDefault ["dispatchOrders", createHashMap]) getOrDefault [_taskID, createHashMap]) isNotEqualTo createHashMap
|
|
}],
|
|
["getAssignmentByTaskId", compileFinal {
|
|
params [["_taskID", "", [""]]];
|
|
|
|
if (_taskID isEqualTo "") exitWith { createHashMap };
|
|
|
|
private _state = _self call ["loadState", []];
|
|
if !(_state getOrDefault ["success", false]) exitWith { createHashMap };
|
|
|
|
+((_state getOrDefault ["assignments", createHashMap]) getOrDefault [_taskID, createHashMap])
|
|
}],
|
|
["getDispatchOrderByTaskId", compileFinal {
|
|
params [["_taskID", "", [""]]];
|
|
|
|
if (_taskID isEqualTo "") exitWith { createHashMap };
|
|
|
|
private _state = _self call ["loadState", []];
|
|
if !(_state getOrDefault ["success", false]) exitWith { createHashMap };
|
|
|
|
+((_state getOrDefault ["dispatchOrders", createHashMap]) getOrDefault [_taskID, createHashMap])
|
|
}],
|
|
["getCurrentTaskIdForGroup", compileFinal {
|
|
params [["_groupID", "", [""]]];
|
|
|
|
if (_groupID isEqualTo "") exitWith { "" };
|
|
|
|
private _state = _self call ["loadState", []];
|
|
if !(_state getOrDefault ["success", false]) exitWith { "" };
|
|
|
|
private _assignmentRegistry = _state getOrDefault ["assignments", createHashMap];
|
|
private _dispatchOrderRegistry = _state getOrDefault ["dispatchOrders", createHashMap];
|
|
private _taskID = "";
|
|
|
|
{
|
|
if ((_y getOrDefault ["groupId", ""]) isNotEqualTo _groupID) then { continue; };
|
|
if !((_y getOrDefault ["state", ""]) in ["assigned", "acknowledged"]) then { continue; };
|
|
|
|
private _dispatchOrder = +(_dispatchOrderRegistry getOrDefault [_x, createHashMap]);
|
|
if (_dispatchOrder isEqualTo createHashMap) then {
|
|
if !((EGVAR(task,TaskStore) call ["getTaskStatus", [_x]]) in ["assigned", "active"]) then { continue; };
|
|
_taskID = _x;
|
|
} else {
|
|
_taskID = _dispatchOrder getOrDefault ["title", _x];
|
|
};
|
|
} forEach _assignmentRegistry;
|
|
|
|
_taskID
|
|
}],
|
|
["buildDispatchOrderEntry", compileFinal {
|
|
params [
|
|
["_taskID", "", [""]],
|
|
["_order", createHashMap, [createHashMap]],
|
|
["_assignment", createHashMap, [createHashMap]],
|
|
["_groupRepository", createHashMap, [createHashMap]]
|
|
];
|
|
|
|
if (_taskID isEqualTo "" || { _order isEqualTo createHashMap }) exitWith { createHashMap };
|
|
|
|
private _entry = +_order;
|
|
private _targetGroupID = _order getOrDefault ["targetGroupId", ""];
|
|
if (_targetGroupID isNotEqualTo "") then {
|
|
private _targetGroup = _groupRepository call ["getGroupRecord", [_targetGroupID]];
|
|
if (_targetGroup isNotEqualTo createHashMap) then {
|
|
private _targetCallsign = _targetGroup getOrDefault ["callsign", _targetGroupID];
|
|
_entry set ["targetGroupCallsign", _targetCallsign];
|
|
_entry set ["position", +(_targetGroup getOrDefault ["position", _entry getOrDefault ["position", []]])];
|
|
_entry set ["title", format ["Backup %1", _targetCallsign]];
|
|
|
|
if ((_order getOrDefault ["note", ""]) isEqualTo "") then {
|
|
_entry set ["description", format ["Dispatch order to back up %1 at its current position.", _targetCallsign]];
|
|
};
|
|
};
|
|
};
|
|
|
|
_entry set ["taskId", _taskID];
|
|
_entry set ["taskID", _taskID];
|
|
_entry set ["type", _entry getOrDefault ["type", "dispatch_order"]];
|
|
_entry set ["isDispatchOrder", true];
|
|
_entry set ["assignedGroupId", _assignment getOrDefault ["groupId", ""]];
|
|
_entry set ["assignmentState", [_assignment getOrDefault ["state", ""], "unassigned"] select (_assignment isEqualTo createHashMap)];
|
|
_entry
|
|
}],
|
|
["buildDispatchOrderEntryForTask", compileFinal {
|
|
params [
|
|
["_taskID", "", [""]],
|
|
["_groupRepository", createHashMap, [createHashMap]]
|
|
];
|
|
|
|
if (_taskID isEqualTo "") exitWith { createHashMap };
|
|
|
|
private _state = _self call ["loadState", []];
|
|
if !(_state getOrDefault ["success", false]) exitWith { createHashMap };
|
|
|
|
private _order = +((_state getOrDefault ["dispatchOrders", createHashMap]) getOrDefault [_taskID, createHashMap]);
|
|
if (_order isEqualTo createHashMap) exitWith { createHashMap };
|
|
|
|
private _assignment = +((_state getOrDefault ["assignments", createHashMap]) getOrDefault [_taskID, createHashMap]);
|
|
_self call ["buildDispatchOrderEntry", [_taskID, _order, _assignment, _groupRepository]]
|
|
}],
|
|
["assignTaskToGroup", compileFinal {
|
|
params [
|
|
["_requesterUid", "", [""]],
|
|
["_taskID", "", [""]],
|
|
["_groupID", "", [""]],
|
|
["_note", "", [""]]
|
|
];
|
|
|
|
private _result = createHashMapFromArray [
|
|
["success", false],
|
|
["message", "Unable to assign task."],
|
|
["assignment", createHashMap]
|
|
];
|
|
|
|
private _permissionService = _self getOrDefault ["permissionService", createHashMap];
|
|
if !(_permissionService call ["canDispatch", [_requesterUid]]) exitWith {
|
|
_result set ["message", "You are not authorized to assign contracts."];
|
|
_result
|
|
};
|
|
|
|
private _state = _self call ["loadState", []];
|
|
if !(_state getOrDefault ["success", false]) exitWith {
|
|
_result set ["message", "CAD extension state is unavailable."];
|
|
_result
|
|
};
|
|
|
|
private _assignmentRegistry = _state getOrDefault ["assignments", createHashMap];
|
|
private _dispatchOrderRegistry = _state getOrDefault ["dispatchOrders", createHashMap];
|
|
private _isDispatchOrder = (_dispatchOrderRegistry getOrDefault [_taskID, createHashMap]) isNotEqualTo createHashMap;
|
|
|
|
if (!_isDispatchOrder && { (EGVAR(task,TaskStore) call ["getTaskStatus", [_taskID]]) isNotEqualTo "available" }) exitWith {
|
|
_result set ["message", "Task is no longer available."];
|
|
_result
|
|
};
|
|
|
|
private _existingAssignment = +(_assignmentRegistry getOrDefault [_taskID, createHashMap]);
|
|
if (
|
|
_existingAssignment isNotEqualTo createHashMap
|
|
&& { (_existingAssignment getOrDefault ["state", ""]) in ["assigned", "acknowledged"] }
|
|
) exitWith {
|
|
_result set ["message", ["Task is already assigned and must be declined or completed before reassignment.", "Dispatch order is already assigned and must be declined or closed before reassignment."] select _isDispatchOrder];
|
|
_result set ["assignment", _existingAssignment];
|
|
_result
|
|
};
|
|
|
|
private _groupRepository = _self getOrDefault ["groupRepository", createHashMap];
|
|
private _groupRecord = _groupRepository call ["getGroupRecord", [_groupID]];
|
|
if (_groupRecord isEqualTo createHashMap) exitWith {
|
|
_result set ["message", "Selected group is unavailable."];
|
|
_result
|
|
};
|
|
|
|
private _leaderUid = _groupRecord getOrDefault ["leaderUid", ""];
|
|
if (_leaderUid isEqualTo "") exitWith {
|
|
_result set ["message", "Selected group has no online leader."];
|
|
_result
|
|
};
|
|
|
|
private _requesterPlayer = [_requesterUid] call EFUNC(common,getPlayer);
|
|
private _assignment = createHashMapFromArray [
|
|
["taskId", _taskID],
|
|
["groupId", _groupID],
|
|
["groupCallsign", _groupRecord getOrDefault ["callsign", _groupID]],
|
|
["assignedByUid", _requesterUid],
|
|
["assignedByName", ["Dispatcher", name _requesterPlayer] select (_requesterPlayer isNotEqualTo objNull)],
|
|
["assignedAt", serverTime],
|
|
["state", "assigned"],
|
|
["note", _note]
|
|
];
|
|
|
|
private _persistenceService = _self getOrDefault ["persistenceService", createHashMap];
|
|
if (_persistenceService isEqualTo createHashMap) exitWith {
|
|
_result set ["message", "CAD extension state is unavailable."];
|
|
_result
|
|
};
|
|
|
|
private _assignResult = _persistenceService call ["assignAssignment", [_taskID, _assignment]];
|
|
if !(_assignResult getOrDefault ["success", false]) exitWith {
|
|
_result set ["message", "CAD extension rejected the assignment."];
|
|
_result
|
|
};
|
|
|
|
private _assignData = +(_assignResult getOrDefault ["data", createHashMap]);
|
|
_assignment = +(_assignData getOrDefault ["assignment", createHashMap]);
|
|
if (_assignment isEqualTo createHashMap) exitWith {
|
|
_result set ["message", "CAD extension returned an invalid assignment."];
|
|
_result
|
|
};
|
|
|
|
private _activityEntry = +(_assignData getOrDefault ["activity", createHashMap]);
|
|
if (_activityEntry isNotEqualTo createHashMap) then {
|
|
private _activityRepository = _self getOrDefault ["activityRepository", createHashMap];
|
|
_activityRepository call ["appendEntry", [_activityEntry]];
|
|
};
|
|
|
|
if (!_isDispatchOrder) then {
|
|
EGVAR(task,TaskStore) call ["setTaskStatus", [_taskID, "assigned"]];
|
|
};
|
|
|
|
_result set ["success", true];
|
|
_result set ["message", _assignData getOrDefault ["message", ["Task assigned.", "Dispatch order assigned."] select _isDispatchOrder]];
|
|
_result set ["assignment", _assignment];
|
|
_result set ["leaderUid", _leaderUid];
|
|
_result set ["isDispatchOrder", _isDispatchOrder];
|
|
if (_isDispatchOrder) then {
|
|
_result set ["order", +(_dispatchOrderRegistry getOrDefault [_taskID, createHashMap])];
|
|
};
|
|
_result
|
|
}],
|
|
["createDispatchOrder", compileFinal {
|
|
params [
|
|
["_requesterUid", "", [""]],
|
|
["_assigneeGroupID", "", [""]],
|
|
["_targetGroupID", "", [""]],
|
|
["_note", "", [""]],
|
|
["_priority", "priority", [""]],
|
|
["_request", createHashMap, [createHashMap]]
|
|
];
|
|
|
|
private _result = createHashMapFromArray [
|
|
["success", false],
|
|
["message", "Unable to create dispatch order."],
|
|
["assignment", createHashMap],
|
|
["order", createHashMap]
|
|
];
|
|
|
|
private _permissionService = _self getOrDefault ["permissionService", createHashMap];
|
|
if !(_permissionService call ["canDispatch", [_requesterUid]]) exitWith {
|
|
_result set ["message", "You are not authorized to create dispatch orders."];
|
|
_result
|
|
};
|
|
|
|
if (_assigneeGroupID isEqualTo "" || { _targetGroupID isEqualTo "" }) exitWith {
|
|
_result set ["message", "Assignee and target groups are required."];
|
|
_result
|
|
};
|
|
|
|
if (_assigneeGroupID isEqualTo _targetGroupID) exitWith {
|
|
_result set ["message", "Assignee and target groups must be different."];
|
|
_result
|
|
};
|
|
|
|
private _groupRepository = _self getOrDefault ["groupRepository", createHashMap];
|
|
private _assigneeGroup = _groupRepository call ["getGroupRecord", [_assigneeGroupID]];
|
|
if (_assigneeGroup isEqualTo createHashMap) exitWith {
|
|
_result set ["message", "Selected assignee group is unavailable."];
|
|
_result
|
|
};
|
|
|
|
private _assigneeLeaderUid = _assigneeGroup getOrDefault ["leaderUid", ""];
|
|
if (_assigneeLeaderUid isEqualTo "") exitWith {
|
|
_result set ["message", "Selected assignee group has no online leader."];
|
|
_result
|
|
};
|
|
|
|
private _targetGroup = _groupRepository call ["getGroupRecord", [_targetGroupID]];
|
|
if (_targetGroup isEqualTo createHashMap) exitWith {
|
|
_result set ["message", "Selected target group is unavailable."];
|
|
_result
|
|
};
|
|
|
|
private _validPriorities = ["routine", "priority", "emergency"];
|
|
private _finalPriority = toLowerANSI _priority;
|
|
if !(_finalPriority in _validPriorities) then {
|
|
_finalPriority = "priority";
|
|
};
|
|
|
|
private _requesterPlayer = [_requesterUid] call EFUNC(common,getPlayer);
|
|
private _dispatchContext = createHashMapFromArray [
|
|
["assigneeGroupId", _assigneeGroupID],
|
|
["assigneeGroupCallsign", _assigneeGroup getOrDefault ["callsign", _assigneeGroupID]],
|
|
["targetGroupId", _targetGroupID],
|
|
["targetGroupCallsign", _targetGroup getOrDefault ["callsign", _targetGroupID]],
|
|
["targetPosition", +(_targetGroup getOrDefault ["position", []])],
|
|
["createdByUid", _requesterUid],
|
|
["createdByName", ["Dispatcher", name _requesterPlayer] select (_requesterPlayer isNotEqualTo objNull)],
|
|
["requestId", _request getOrDefault ["requestId", ""]],
|
|
["requestType", _request getOrDefault ["type", ""]],
|
|
["requestTitle", _request getOrDefault ["title", ""]],
|
|
["requestSummary", _request getOrDefault ["summary", ""]],
|
|
["requestFields", +(_request getOrDefault ["fields", createHashMap])],
|
|
["note", _note],
|
|
["priority", _finalPriority],
|
|
["createdAt", serverTime]
|
|
];
|
|
|
|
private _persistenceService = _self getOrDefault ["persistenceService", createHashMap];
|
|
if (_persistenceService isEqualTo createHashMap) exitWith {
|
|
_result set ["message", "CAD extension state is unavailable."];
|
|
_result
|
|
};
|
|
|
|
private _createResult = _persistenceService call ["createDispatchOrderFromContext", [_dispatchContext]];
|
|
if !(_createResult getOrDefault ["success", false]) exitWith {
|
|
_result set ["message", "CAD extension rejected the dispatch order."];
|
|
_result
|
|
};
|
|
|
|
private _createData = +(_createResult getOrDefault ["data", createHashMap]);
|
|
private _taskID = _createData getOrDefault ["taskId", ""];
|
|
private _order = +(_createData getOrDefault ["order", createHashMap]);
|
|
private _assignment = +(_createData getOrDefault ["assignment", createHashMap]);
|
|
if (_taskID isEqualTo "" || { _order isEqualTo createHashMap } || { _assignment isEqualTo createHashMap }) exitWith {
|
|
_result set ["message", "CAD extension returned an invalid dispatch order."];
|
|
_result
|
|
};
|
|
|
|
private _activityEntry = +(_createData getOrDefault ["activity", createHashMap]);
|
|
if (_activityEntry isNotEqualTo createHashMap) then {
|
|
private _activityRepository = _self getOrDefault ["activityRepository", createHashMap];
|
|
_activityRepository call ["appendEntry", [_activityEntry]];
|
|
};
|
|
|
|
_result set ["success", true];
|
|
_result set ["message", _createData getOrDefault ["message", "Dispatch order created."]];
|
|
_result set ["assignment", _assignment];
|
|
_result set ["order", _order];
|
|
_result set ["leaderUid", _assigneeLeaderUid];
|
|
_result set ["isDispatchOrder", true];
|
|
_result
|
|
}],
|
|
["closeDispatchOrder", compileFinal {
|
|
params [["_requesterUid", "", [""]], ["_taskID", "", [""]]];
|
|
|
|
private _result = createHashMapFromArray [
|
|
["success", false],
|
|
["message", "Unable to close dispatch order."],
|
|
["assignment", createHashMap]
|
|
];
|
|
|
|
private _permissionService = _self getOrDefault ["permissionService", createHashMap];
|
|
if !(_permissionService call ["canDispatch", [_requesterUid]]) exitWith {
|
|
_result set ["message", "You are not authorized to close dispatch orders."];
|
|
_result
|
|
};
|
|
|
|
private _state = _self call ["loadState", []];
|
|
if !(_state getOrDefault ["success", false]) exitWith {
|
|
_result set ["message", "CAD extension state is unavailable."];
|
|
_result
|
|
};
|
|
|
|
private _order = +((_state getOrDefault ["dispatchOrders", createHashMap]) getOrDefault [_taskID, createHashMap]);
|
|
if (_order isEqualTo createHashMap) exitWith {
|
|
_result set ["message", "Dispatch order could not be resolved."];
|
|
_result
|
|
};
|
|
|
|
private _assignment = +((_state getOrDefault ["assignments", createHashMap]) getOrDefault [_taskID, createHashMap]);
|
|
|
|
private _persistenceService = _self getOrDefault ["persistenceService", createHashMap];
|
|
if (_persistenceService isEqualTo createHashMap) exitWith {
|
|
_result set ["message", "CAD extension state is unavailable."];
|
|
_result
|
|
};
|
|
|
|
private _closeResult = _persistenceService call ["closeDispatchOrder", [_taskID]];
|
|
if !(_closeResult getOrDefault ["success", false]) exitWith {
|
|
_result set ["message", "CAD extension rejected the dispatch order close."];
|
|
_result
|
|
};
|
|
|
|
private _closeData = +(_closeResult getOrDefault ["data", createHashMap]);
|
|
_assignment = +(_closeData getOrDefault ["assignment", _assignment]);
|
|
|
|
private _activityEntry = +(_closeData getOrDefault ["activity", createHashMap]);
|
|
if (_activityEntry isNotEqualTo createHashMap) then {
|
|
_activityEntry set ["actorUid", _requesterUid];
|
|
private _activityRepository = _self getOrDefault ["activityRepository", createHashMap];
|
|
_activityRepository call ["appendEntry", [_activityEntry]];
|
|
};
|
|
|
|
_result set ["success", true];
|
|
_result set ["message", _closeData getOrDefault ["message", "Dispatch order closed."]];
|
|
_result set ["assignment", _assignment];
|
|
_result set ["isDispatchOrder", true];
|
|
_result
|
|
}],
|
|
["applyAssignmentTransition", compileFinal {
|
|
params [["_requesterUid", "", [""]], ["_taskID", "", [""]]];
|
|
|
|
private _result = createHashMapFromArray [
|
|
["success", false],
|
|
["message", "Unable to update task assignment."],
|
|
["assignment", createHashMap]
|
|
];
|
|
|
|
private _transition = _this param [2, "acknowledge", [""]];
|
|
private _state = _self call ["loadState", []];
|
|
if !(_state getOrDefault ["success", false]) exitWith {
|
|
_result set ["message", "CAD extension state is unavailable."];
|
|
_result
|
|
};
|
|
|
|
private _assignment = +((_state getOrDefault ["assignments", createHashMap]) getOrDefault [_taskID, createHashMap]);
|
|
private _isDispatchOrder = ((_state getOrDefault ["dispatchOrders", createHashMap]) getOrDefault [_taskID, createHashMap]) isNotEqualTo createHashMap;
|
|
if (_assignment isEqualTo createHashMap) exitWith {
|
|
_result set ["message", "Task is not assigned."];
|
|
_result
|
|
};
|
|
|
|
private _groupID = _assignment getOrDefault ["groupId", ""];
|
|
private _groupRepository = _self getOrDefault ["groupRepository", createHashMap];
|
|
if !(_groupRepository call ["isGroupLeader", [_requesterUid, _groupID]]) exitWith {
|
|
_result set ["message", format ["Only the assigned group leader can %1 this task.", _transition]];
|
|
_result
|
|
};
|
|
|
|
switch (_transition) do {
|
|
case "acknowledge": {
|
|
if (!_isDispatchOrder) then {
|
|
private _acceptResult = EGVAR(task,TaskStore) call ["acceptTask", [_taskID, _requesterUid]];
|
|
if !(_acceptResult getOrDefault ["success", false]) exitWith {
|
|
_result set ["message", _acceptResult getOrDefault ["message", "Failed to accept task."]];
|
|
_result
|
|
};
|
|
EGVAR(task,TaskStore) call ["setTaskStatus", [_taskID, "active"]];
|
|
};
|
|
};
|
|
case "decline": {
|
|
if (!_isDispatchOrder) then {
|
|
EGVAR(task,TaskStore) call ["releaseTaskOwnership", [_taskID]];
|
|
EGVAR(task,TaskStore) call ["setTaskStatus", [_taskID, "available"]];
|
|
};
|
|
};
|
|
};
|
|
|
|
if (_result getOrDefault ["success", false]) exitWith { _result };
|
|
|
|
private _persistenceService = _self getOrDefault ["persistenceService", createHashMap];
|
|
if (_persistenceService isEqualTo createHashMap) exitWith {
|
|
_result set ["message", "CAD extension state is unavailable."];
|
|
_result
|
|
};
|
|
|
|
private _patch = switch (_transition) do {
|
|
case "decline": {
|
|
createHashMapFromArray [
|
|
["state", "declined"],
|
|
["declinedAt", serverTime],
|
|
["declinedByUid", _requesterUid]
|
|
]
|
|
};
|
|
default {
|
|
createHashMapFromArray [
|
|
["state", "acknowledged"],
|
|
["acknowledgedAt", serverTime],
|
|
["acknowledgedByUid", _requesterUid]
|
|
]
|
|
};
|
|
};
|
|
private _transitionResult = switch (_transition) do {
|
|
case "decline": { _persistenceService call ["declineAssignment", [_taskID, _patch]] };
|
|
default { _persistenceService call ["acknowledgeAssignment", [_taskID, _patch]] };
|
|
};
|
|
if !(_transitionResult getOrDefault ["success", false]) exitWith {
|
|
_result set ["message", switch (_transition) do {
|
|
case "decline": { "CAD extension rejected the decline." };
|
|
default { "CAD extension rejected the acknowledgement." };
|
|
}];
|
|
_result
|
|
};
|
|
|
|
private _transitionData = +(_transitionResult getOrDefault ["data", createHashMap]);
|
|
_assignment = +(_transitionData getOrDefault ["assignment", createHashMap]);
|
|
if (_assignment isEqualTo createHashMap) exitWith {
|
|
_result set ["message", "CAD extension returned an invalid assignment."];
|
|
_result
|
|
};
|
|
|
|
private _activityEntry = +(_transitionData getOrDefault ["activity", createHashMap]);
|
|
if (_activityEntry isNotEqualTo createHashMap) then {
|
|
if (_isDispatchOrder) then {
|
|
_activityEntry set ["type", format ["dispatch_order_%1", _transition]];
|
|
_activityEntry set ["message", format ["%1 %2d %3.", _requesterUid, _transition, _taskID]];
|
|
};
|
|
|
|
private _activityRepository = _self getOrDefault ["activityRepository", createHashMap];
|
|
_activityRepository call ["appendEntry", [_activityEntry]];
|
|
};
|
|
|
|
_result set ["success", true];
|
|
_result set ["message", switch (_transition) do {
|
|
case "decline": { [_transitionData getOrDefault ["message", "Task declined and returned to the contract board."], "Dispatch order declined and returned to the dispatch board."] select _isDispatchOrder };
|
|
default { [_transitionData getOrDefault ["message", "Task acknowledged."], "Dispatch order acknowledged."] select _isDispatchOrder };
|
|
}];
|
|
_result set ["assignment", _assignment];
|
|
_result set ["isDispatchOrder", _isDispatchOrder];
|
|
_result
|
|
}],
|
|
["acknowledgeTask", compileFinal {
|
|
_self call ["applyAssignmentTransition", [_this # 0, _this # 1, "acknowledge"]]
|
|
}],
|
|
["declineTask", compileFinal {
|
|
_self call ["applyAssignmentTransition", [_this # 0, _this # 1, "decline"]]
|
|
}]
|
|
];
|
|
|
|
createHashMapObject [GVAR(AssignmentRepositoryBaseClass)]
|