Jacob Schmidt
ff7ff0c4e5
## Summary This finishes the org credit line workflow so it behaves like reserved treasury-backed credit instead of a simple member allowance. ## What changed - reserve org funds immediately when a credit line is assigned - track credit lines with: - approved amount - available amount - outstanding principal - interest rate - amount due - consume reserved credit during store checkout without charging org funds a second time - add credit line repayment through the bank app - sync richer credit line state into org and bank payloads/UI - keep legacy `amount` compatibility mapped to available credit for older consumers ## User-facing behavior - assigning a credit line now reduces available org funds immediately - spending on `credit_line` reduces available credit and creates debt with interest - the bank app now shows outstanding credit debt and allows repayment from personal bank funds - the org treasury view now shows reserved credit and outstanding due totals ## Validation - `cargo fmt` - `npm run build:webui` - `cargo test -p forge-services --quiet` - `cargo test -p forge-server --quiet` ## Follow-up checks - validate in-game that assigning a credit line reduces org funds immediately - validate store checkout with `credit_line` updates available credit and debt correctly - validate bank repayment decreases player bank balance, increases org funds, and reduces amount due Co-authored-by: Jacob Schmidt <innovativestudios@outlook.com> Reviewed-on: #2
564 lines
22 KiB
Plaintext
564 lines
22 KiB
Plaintext
#include "..\script_component.hpp"
|
|
|
|
/*
|
|
* Author: IDSolutions
|
|
* Initializes the task store for task entity tracking, participant
|
|
* contribution tracking, and task outcome application.
|
|
*
|
|
* Arguments:
|
|
* None
|
|
*
|
|
* Return Value:
|
|
* Task store object [HASHMAP OBJECT]
|
|
*
|
|
* Example:
|
|
* call forge_server_task_fnc_initTaskStore
|
|
*
|
|
* Public: No
|
|
*/
|
|
|
|
#pragma hemtt ignore_variables ["_self"]
|
|
GVAR(TaskStore) = createHashMapObject [[
|
|
["#type", "TaskStore"],
|
|
["#create", compileFinal {
|
|
_self set ["participantRegistry", createHashMap];
|
|
_self set ["taskEntityRegistries", createHashMapFromArray [
|
|
["cargo", createHashMap],
|
|
["hostages", createHashMap],
|
|
["hvts", createHashMap],
|
|
["ieds", createHashMap],
|
|
["entities", createHashMap],
|
|
["shooters", createHashMap],
|
|
["targets", createHashMap]
|
|
]];
|
|
|
|
["task:reset", []] call EFUNC(extension,extCall) params ["_result", "_isSuccess"];
|
|
if (
|
|
!_isSuccess
|
|
|| { !(_result isEqualType "") }
|
|
|| { (_result find "Error:") == 0 }
|
|
) then {
|
|
["WARNING", "Failed to reset task backend state during task store initialization."] call EFUNC(common,log);
|
|
};
|
|
}],
|
|
["callTaskStateEnvelope", compileFinal {
|
|
params [["_function", "", [""]], ["_arguments", [], [[]]]];
|
|
|
|
private _envelope = createHashMapFromArray [
|
|
["success", false],
|
|
["error", ""]
|
|
];
|
|
|
|
if (_function isEqualTo "") exitWith { _envelope };
|
|
|
|
[_function, _arguments] call EFUNC(extension,extCall) params ["_result", "_isSuccess"];
|
|
if !_isSuccess exitWith {
|
|
_envelope set ["error", format ["Task backend call '%1' failed.", _function]];
|
|
_envelope
|
|
};
|
|
if !(_result isEqualType "") exitWith {
|
|
_envelope set ["error", format ["Task backend call '%1' returned an invalid response.", _function]];
|
|
_envelope
|
|
};
|
|
if ((_result find "Error:") == 0) exitWith {
|
|
["ERROR", format ["Task extension call '%1' failed: %2", _function, _result]] call EFUNC(common,log);
|
|
_envelope set ["error", _result select [7]];
|
|
_envelope
|
|
};
|
|
|
|
_envelope set ["success", true];
|
|
if (_result isNotEqualTo "") then {
|
|
_envelope set ["data", fromJSON _result];
|
|
};
|
|
|
|
_envelope
|
|
}],
|
|
["callTaskState", compileFinal {
|
|
params [["_function", "", [""]], ["_arguments", [], [[]]], ["_fallback", nil]];
|
|
|
|
private _envelope = _self call ["callTaskStateEnvelope", [_function, _arguments]];
|
|
if !(_envelope getOrDefault ["success", false]) exitWith { _fallback };
|
|
|
|
_envelope getOrDefault ["data", _fallback]
|
|
}],
|
|
["bindTaskOwnership", compileFinal {
|
|
params [["_taskID", "", [""]], ["_requesterUid", "", [""]]];
|
|
|
|
private _result = createHashMapFromArray [
|
|
["success", false],
|
|
["requesterUid", _requesterUid],
|
|
["orgID", "default"],
|
|
["message", ""]
|
|
];
|
|
|
|
if (_taskID isEqualTo "") exitWith {
|
|
_result set ["message", "Missing task ID."];
|
|
_result
|
|
};
|
|
|
|
private _orgID = "default";
|
|
|
|
if (_requesterUid isNotEqualTo "") then {
|
|
private _actor = EGVAR(actor,Registry) getOrDefault [_requesterUid, createHashMap];
|
|
if (_actor isEqualTo createHashMap) then {
|
|
_actor = EGVAR(actor,ActorStore) call ["init", [_requesterUid]];
|
|
};
|
|
|
|
if (_actor isEqualTo createHashMap) exitWith {
|
|
_result set ["message", format ["Failed to load actor for %1.", _requesterUid]];
|
|
_result
|
|
};
|
|
|
|
_orgID = _actor getOrDefault ["organization", ""];
|
|
if (_orgID isEqualTo "") then { _orgID = "default"; };
|
|
};
|
|
|
|
private _context = createHashMapFromArray [
|
|
["requesterUid", _requesterUid],
|
|
["orgId", _orgID]
|
|
];
|
|
private _envelope = _self call [
|
|
"callTaskStateEnvelope",
|
|
[
|
|
"task:ownership:bind",
|
|
[_taskID, toJSON _context]
|
|
]
|
|
];
|
|
if !(_envelope getOrDefault ["success", false]) exitWith {
|
|
_result set ["message", _envelope getOrDefault ["error", "Failed to bind task ownership."]];
|
|
_result
|
|
};
|
|
|
|
private _bindResult = _envelope getOrDefault ["data", createHashMap];
|
|
_result set ["success", true];
|
|
_result set ["message", _bindResult getOrDefault [
|
|
"message",
|
|
["No requester UID provided. Bound task to default organization.", "Task ownership updated."] select (_requesterUid isNotEqualTo "")
|
|
]];
|
|
_result set ["orgID", _bindResult getOrDefault ["orgId", _orgID]];
|
|
_result
|
|
}],
|
|
["releaseTaskOwnership", compileFinal {
|
|
params [["_taskID", "", [""]]];
|
|
|
|
if (_taskID isEqualTo "") exitWith { false };
|
|
|
|
private _envelope = _self call ["callTaskStateEnvelope", ["task:ownership:release", [_taskID]]];
|
|
_envelope getOrDefault ["success", false]
|
|
}],
|
|
["registerTaskCatalogEntry", compileFinal {
|
|
params [["_taskID", "", [""]], ["_entry", createHashMap, [createHashMap]]];
|
|
|
|
if (_taskID isEqualTo "" || { _entry isEqualTo createHashMap }) exitWith { false };
|
|
|
|
private _envelope = _self call [
|
|
"callTaskStateEnvelope",
|
|
[
|
|
"task:catalog:upsert",
|
|
[_taskID, toJSON _entry]
|
|
]
|
|
];
|
|
_envelope getOrDefault ["success", false]
|
|
}],
|
|
["getActiveTaskCatalog", compileFinal {
|
|
private _entries = _self call ["callTaskState", ["task:catalog:active", [], []]];
|
|
if !(_entries isEqualType []) exitWith { [] };
|
|
|
|
_entries
|
|
}],
|
|
["acceptTask", compileFinal {
|
|
params [["_taskID", "", [""]], ["_requesterUid", "", [""]]];
|
|
|
|
private _result = createHashMapFromArray [
|
|
["success", false],
|
|
["message", "Unable to accept task."],
|
|
["entry", createHashMap]
|
|
];
|
|
|
|
if (_taskID isEqualTo "" || { _requesterUid isEqualTo "" }) exitWith {
|
|
_result set ["message", "Missing task ID or requester UID."];
|
|
_result
|
|
};
|
|
|
|
private _actor = EGVAR(actor,Registry) getOrDefault [_requesterUid, createHashMap];
|
|
if (_actor isEqualTo createHashMap) then {
|
|
_actor = EGVAR(actor,ActorStore) call ["init", [_requesterUid]];
|
|
};
|
|
if (_actor isEqualTo createHashMap) exitWith {
|
|
_result set ["message", format ["Failed to load actor for %1.", _requesterUid]];
|
|
_result
|
|
};
|
|
|
|
private _orgID = _actor getOrDefault ["organization", ""];
|
|
if (_orgID isEqualTo "") then { _orgID = "default"; };
|
|
|
|
private _context = createHashMapFromArray [
|
|
["requesterUid", _requesterUid],
|
|
["orgId", _orgID]
|
|
];
|
|
private _envelope = _self call [
|
|
"callTaskStateEnvelope",
|
|
[
|
|
"task:ownership:accept",
|
|
[_taskID, toJSON _context]
|
|
]
|
|
];
|
|
if !(_envelope getOrDefault ["success", false]) exitWith {
|
|
_result set ["message", _envelope getOrDefault ["error", "Unable to accept task."]];
|
|
_result
|
|
};
|
|
|
|
private _acceptResult = _envelope getOrDefault ["data", createHashMap];
|
|
private _entry = _acceptResult getOrDefault ["entry", createHashMap];
|
|
if !(_entry isEqualType createHashMap) then {
|
|
_entry = createHashMap;
|
|
};
|
|
|
|
_result set ["success", true];
|
|
_result set ["message", _acceptResult getOrDefault ["message", "Task accepted."]];
|
|
_result set ["entry", _entry];
|
|
_result
|
|
}],
|
|
["setTaskStatus", compileFinal {
|
|
params [["_taskID", "", [""]], ["_status", "", [""]]];
|
|
|
|
if (_taskID isEqualTo "" || { _status isEqualTo "" }) exitWith { false };
|
|
|
|
[(_self call ["callTaskState", ["task:status:set", [_taskID, _status], false]])] params [["_statusResult", false, [false]]];
|
|
|
|
_statusResult
|
|
}],
|
|
["getTaskStatus", compileFinal {
|
|
params [["_taskID", "", [""]]];
|
|
|
|
if (_taskID isEqualTo "") exitWith { "" };
|
|
|
|
private _status = _self call ["callTaskState", ["task:status:get", [_taskID], ""]];
|
|
if !(_status isEqualType "") exitWith { "" };
|
|
|
|
_status
|
|
}],
|
|
["clearTaskStatus", compileFinal {
|
|
params [["_taskID", "", [""]]];
|
|
|
|
if (_taskID isEqualTo "") exitWith { false };
|
|
|
|
[(_self call ["callTaskState", ["task:status:clear", [_taskID], false]])] params [["_statusResult", false, [false]]];
|
|
|
|
_statusResult
|
|
}],
|
|
["registerTaskEntity", compileFinal {
|
|
params [["_registryKey", "", [""]], ["_taskID", "", [""]], ["_entity", objNull, [objNull]]];
|
|
|
|
if (_registryKey isEqualTo "" || { _taskID isEqualTo "" } || { isNull _entity }) exitWith { false };
|
|
|
|
private _taskEntityRegistries = _self getOrDefault ["taskEntityRegistries", createHashMap];
|
|
private _registry = +(_taskEntityRegistries getOrDefault [_registryKey, createHashMap]);
|
|
private _entities = +(_registry getOrDefault [_taskID, []]);
|
|
_entities pushBackUnique _entity;
|
|
_registry set [_taskID, _entities];
|
|
_taskEntityRegistries set [_registryKey, _registry];
|
|
_self set ["taskEntityRegistries", _taskEntityRegistries];
|
|
|
|
true
|
|
}],
|
|
["getTaskEntities", compileFinal {
|
|
params [["_registryKey", "", [""]], ["_taskID", "", [""]]];
|
|
|
|
if (_registryKey isEqualTo "" || { _taskID isEqualTo "" }) exitWith { [] };
|
|
|
|
private _taskEntityRegistries = _self getOrDefault ["taskEntityRegistries", createHashMap];
|
|
private _registry = _taskEntityRegistries getOrDefault [_registryKey, createHashMap];
|
|
|
|
+(_registry getOrDefault [_taskID, []])
|
|
}],
|
|
["clearTaskEntities", compileFinal {
|
|
params [["_taskID", "", [""]]];
|
|
|
|
if (_taskID isEqualTo "") exitWith { false };
|
|
|
|
private _taskEntityRegistries = _self getOrDefault ["taskEntityRegistries", createHashMap];
|
|
|
|
{
|
|
private _registry = +_y;
|
|
_registry deleteAt _taskID;
|
|
_taskEntityRegistries set [_x, _registry];
|
|
} forEach _taskEntityRegistries;
|
|
|
|
_self set ["taskEntityRegistries", _taskEntityRegistries];
|
|
true
|
|
}],
|
|
["trackParticipants", compileFinal {
|
|
params [["_taskID", "", [""]], ["_entities", [], [[]]], ["_marker", "", [""]], ["_radius", 300, [0]]];
|
|
|
|
if (_taskID isEqualTo "") exitWith { createHashMap };
|
|
|
|
private _participantRegistry = _self getOrDefault ["participantRegistry", createHashMap];
|
|
private _participantSnapshots = +(_participantRegistry getOrDefault [_taskID, createHashMap]);
|
|
private _activePlayers = allPlayers select {
|
|
alive _x
|
|
&& { side group _x isEqualTo west }
|
|
};
|
|
|
|
if (_marker isNotEqualTo "" && { markerShape _marker in ["RECTANGLE", "ELLIPSE"] }) then {
|
|
{
|
|
private _uid = getPlayerUID _x;
|
|
if (_uid isNotEqualTo "" && { _x inArea _marker }) then {
|
|
if !(_uid in _participantSnapshots) then {
|
|
_participantSnapshots set [_uid, createHashMapFromArray [
|
|
["startRating", rating _x]
|
|
]];
|
|
};
|
|
};
|
|
} forEach _activePlayers;
|
|
};
|
|
|
|
if (_radius > 0 && { _entities isNotEqualTo [] }) then {
|
|
{
|
|
private _entity = _x;
|
|
if (isNull _entity) then { continue; };
|
|
|
|
{
|
|
private _uid = getPlayerUID _x;
|
|
if (_uid isNotEqualTo "" && { (_x distance2D _entity) <= _radius }) then {
|
|
if !(_uid in _participantSnapshots) then {
|
|
_participantSnapshots set [_uid, createHashMapFromArray [
|
|
["startRating", rating _x]
|
|
]];
|
|
};
|
|
};
|
|
} forEach _activePlayers;
|
|
} forEach _entities;
|
|
};
|
|
|
|
_participantRegistry set [_taskID, _participantSnapshots];
|
|
_self set ["participantRegistry", _participantRegistry];
|
|
|
|
_participantSnapshots
|
|
}],
|
|
["resolveRewardContext", compileFinal {
|
|
params [["_taskID", "", [""]]];
|
|
|
|
private _result = createHashMapFromArray [
|
|
["requesterUid", ""],
|
|
["orgID", ""],
|
|
["memberUids", []]
|
|
];
|
|
|
|
if (_taskID isEqualTo "") exitWith { _result };
|
|
|
|
private _rewardState = _self call ["callTaskState", ["task:ownership:reward_context", [_taskID], createHashMap]];
|
|
if (_rewardState isEqualTo createHashMap) exitWith { _result };
|
|
|
|
private _requesterUid = _rewardState getOrDefault ["requesterUid", ""];
|
|
private _resolvedOrgID = _rewardState getOrDefault ["orgId", ""];
|
|
if (_resolvedOrgID isEqualTo "") exitWith { _result };
|
|
|
|
private _org = EGVAR(org,OrgStore) call ["loadById", [_resolvedOrgID]];
|
|
private _memberUids = [];
|
|
if (_org isNotEqualTo createHashMap) then {
|
|
private _members = _org getOrDefault ["members", createHashMap];
|
|
if (_members isEqualType createHashMap) then {
|
|
_memberUids = keys _members;
|
|
};
|
|
if (_requesterUid isNotEqualTo "" && { !(_requesterUid in _memberUids) }) then {
|
|
_memberUids pushBack _requesterUid;
|
|
};
|
|
};
|
|
|
|
_result set ["requesterUid", _requesterUid];
|
|
_result set ["orgID", _resolvedOrgID];
|
|
_result set ["memberUids", _memberUids];
|
|
_result
|
|
}],
|
|
["incrementDefuseCount", compileFinal {
|
|
params [["_taskID", "", [""]]];
|
|
|
|
if (_taskID isEqualTo "") exitWith { 0 };
|
|
|
|
private _nextCount = _self call ["callTaskState", ["task:defuse:increment", [_taskID], 0]];
|
|
if !(_nextCount isEqualType 0) exitWith { 0 };
|
|
|
|
_nextCount
|
|
}],
|
|
["getDefuseCount", compileFinal {
|
|
params [["_taskID", "", [""]]];
|
|
|
|
if (_taskID isEqualTo "") exitWith { 0 };
|
|
|
|
private _defuseCount = _self call ["callTaskState", ["task:defuse:get", [_taskID], 0]];
|
|
if !(_defuseCount isEqualType 0) exitWith { 0 };
|
|
|
|
_defuseCount
|
|
}],
|
|
["notifyParticipants", compileFinal {
|
|
params [
|
|
["_taskID", "", [""]],
|
|
["_type", "info", [""]],
|
|
["_title", "Tasks", [""]],
|
|
["_message", "", [""]]
|
|
];
|
|
|
|
if (_taskID isEqualTo "" || { _message isEqualTo "" }) exitWith { false };
|
|
|
|
private _participantRegistry = _self getOrDefault ["participantRegistry", createHashMap];
|
|
private _participantSnapshots = +(_participantRegistry getOrDefault [_taskID, createHashMap]);
|
|
if (_participantSnapshots isEqualTo createHashMap) exitWith { false };
|
|
|
|
{
|
|
private _player = [_x] call EFUNC(common,getPlayer);
|
|
if (isNull _player) then { continue; };
|
|
[CRPC(notifications,recieveNotification), [_type, _title, _message], _player] call CFUNC(targetEvent);
|
|
} forEach (keys _participantSnapshots);
|
|
|
|
true
|
|
}],
|
|
["clearTask", compileFinal {
|
|
params [["_taskID", "", [""]]];
|
|
|
|
if (_taskID isEqualTo "") exitWith { false };
|
|
|
|
private _participantRegistry = _self getOrDefault ["participantRegistry", createHashMap];
|
|
_participantRegistry deleteAt _taskID;
|
|
_self set ["participantRegistry", _participantRegistry];
|
|
_self call ["callTaskState", ["task:clear", [_taskID], false]];
|
|
_self call ["clearTaskEntities", [_taskID]];
|
|
true
|
|
}],
|
|
["applyRatingOutcome", compileFinal {
|
|
params [["_taskID", "", [""]], ["_delta", 0, [0]]];
|
|
|
|
private _result = createHashMapFromArray [
|
|
["participantUids", []],
|
|
["orgIds", []],
|
|
["contributions", createHashMap]
|
|
];
|
|
|
|
if (_taskID isEqualTo "" || { _delta isEqualTo 0 }) exitWith { _result };
|
|
|
|
private _participantRegistry = _self getOrDefault ["participantRegistry", createHashMap];
|
|
private _participantSnapshots = +(_participantRegistry getOrDefault [_taskID, createHashMap]);
|
|
if (_participantSnapshots isEqualTo createHashMap) exitWith { _result };
|
|
|
|
private _rewardContext = _self call ["resolveRewardContext", [_taskID]];
|
|
private _participantUids = keys _participantSnapshots;
|
|
if (_participantUids isEqualTo [] && { _delta > 0 }) then {
|
|
private _requesterUid = _rewardContext getOrDefault ["requesterUid", ""];
|
|
if (_requesterUid isNotEqualTo "") then {
|
|
private _requesterPlayer = [_requesterUid] call EFUNC(common,getPlayer);
|
|
if (!isNull _requesterPlayer) then {
|
|
_participantUids pushBack _requesterUid;
|
|
_participantSnapshots set [_requesterUid, createHashMapFromArray [
|
|
["startRating", rating _requesterPlayer]
|
|
]];
|
|
_participantRegistry set [_taskID, _participantSnapshots];
|
|
_self set ["participantRegistry", _participantRegistry];
|
|
["WARNING", format ["Task %1 had no tracked participants at payout time; falling back to requester %2 for personal earnings.", _taskID, _requesterUid]] call EFUNC(common,log);
|
|
};
|
|
};
|
|
};
|
|
if (_participantUids isEqualTo []) exitWith { _result };
|
|
|
|
private _orgIds = [];
|
|
private _contributions = createHashMap;
|
|
private _totalContribution = 0;
|
|
|
|
if (_delta > 0) then {
|
|
{
|
|
private _uid = _x;
|
|
private _player = [_uid] call EFUNC(common,getPlayer);
|
|
if (isNull _player) then { continue; };
|
|
|
|
_contributions set [_uid, 1];
|
|
_totalContribution = _totalContribution + 1;
|
|
} forEach _participantUids;
|
|
};
|
|
|
|
if (_totalContribution <= 0) exitWith {
|
|
_self call ["clearTask", [_taskID]];
|
|
_result
|
|
};
|
|
|
|
{
|
|
private _uid = _x;
|
|
private _actor = EGVAR(actor,Registry) getOrDefault [_uid, createHashMap];
|
|
if (_actor isEqualTo createHashMap) then {
|
|
_actor = EGVAR(actor,ActorStore) call ["init", [_uid]];
|
|
};
|
|
|
|
private _orgID = _actor getOrDefault ["organization", ""];
|
|
if (_orgID isNotEqualTo "") then {
|
|
_orgIds pushBackUnique _orgID;
|
|
};
|
|
|
|
if (_delta > 0) then {
|
|
private _contribution = _contributions getOrDefault [_uid, 0];
|
|
if (_contribution <= 0) then { continue; };
|
|
|
|
private _account = EGVAR(bank,BankStore) call ["get", [_uid, ""]];
|
|
if (_account isEqualTo createHashMap) then {
|
|
_account = EGVAR(bank,BankStore) call ["init", [_uid]];
|
|
};
|
|
|
|
if (_account isNotEqualTo createHashMap) then {
|
|
private _earnings = _account getOrDefault ["earnings", 0];
|
|
private _earningsDelta = round ((_delta * _contribution) / _totalContribution);
|
|
if (_earningsDelta <= 0) then { continue; };
|
|
|
|
private _patch = EGVAR(bank,BankStore) call [
|
|
"mset",
|
|
[
|
|
_uid,
|
|
createHashMapFromArray [["earnings", (_earnings + _earningsDelta)]],
|
|
false
|
|
]
|
|
];
|
|
if !(_patch isEqualType createHashMap) then { continue; };
|
|
if (_patch isEqualTo createHashMap) then { continue; };
|
|
|
|
EGVAR(bank,BankMessenger) call ["sendAccountSync", [_uid, _patch]];
|
|
};
|
|
};
|
|
} forEach _participantUids;
|
|
|
|
private _ownerOrgID = _rewardContext getOrDefault ["orgID", ""];
|
|
if (_ownerOrgID isNotEqualTo "") then {
|
|
private _org = EGVAR(org,OrgStore) call ["loadById", [_ownerOrgID]];
|
|
|
|
if (_org isNotEqualTo createHashMap) then {
|
|
private _reputation = _org getOrDefault ["reputation", 0];
|
|
private _nextReputation = round (_reputation + _delta);
|
|
_org set ["reputation", _nextReputation];
|
|
private _updatedOrg = EGVAR(org,OrgStore) call [
|
|
"callHotOrg",
|
|
[
|
|
"org:hot:override",
|
|
[_ownerOrgID, toJSON _org]
|
|
]
|
|
];
|
|
|
|
if (_updatedOrg isNotEqualTo createHashMap) then {
|
|
private _patch = createHashMapFromArray [["reputation", _nextReputation]];
|
|
private _memberUids = _rewardContext getOrDefault ["memberUids", []];
|
|
{
|
|
private _player = [_x] call EFUNC(common,getPlayer);
|
|
if (isNull _player) then { continue; };
|
|
[CRPC(org,responseSyncOrg), [_patch], _player] call CFUNC(targetEvent);
|
|
} forEach _memberUids;
|
|
|
|
_orgIds = [_ownerOrgID];
|
|
} else {
|
|
["ERROR", format ["Failed to update organization %1 reputation for task %2.", _ownerOrgID, _taskID]] call EFUNC(common,log);
|
|
};
|
|
};
|
|
};
|
|
|
|
_result set ["participantUids", _participantUids];
|
|
_result set ["orgIds", _orgIds];
|
|
_result set ["contributions", _contributions];
|
|
_result
|
|
}]
|
|
]];
|
|
|
|
GVAR(TaskStore)
|