forge/arma/server/addons/org/functions/fnc_treasuryService.sqf

#include "..\script_component.hpp"

#pragma hemtt ignore_variables ["_self"]
GVAR(OrgTreasuryServiceBase) = compileFinal createHashMapFromArray [
    ["#type", "OrgTreasuryService"],
    ["buildChargeResult", compileFinal {
        params [["_message", "Unable to process organization payment.", [""]]];

        createHashMapFromArray [
            ["success", false],
            ["message", _message],
            ["patch", createHashMap],
            ["memberUids", []]
        ]
    }],
    ["resolveOrgMemberUids", compileFinal {
        params [["_org", createHashMap, [createHashMap]], ["_requesterUid", "", [""]]];

        private _memberUids = keys (_org getOrDefault ["members", createHashMap]);
        if (_requesterUid isNotEqualTo "" && { !(_requesterUid in _memberUids) }) then {
            _memberUids pushBack _requesterUid;
        };

        _memberUids
    }],
    ["canManageTreasury", compileFinal {
        params [["_orgID", "", [""]], ["_org", createHashMap, [createHashMap]], ["_requesterUid", "", [""]], ["_requesterPlayer", objNull, [objNull]]];

        private _ownerUid = _org getOrDefault ["owner", ""];
        private _isDefaultOrg = (_orgID isEqualTo "default") || { toLowerANSI _ownerUid isEqualTo "server" };
        private _isDefaultOrgCeo = _isDefaultOrg
            && { _requesterPlayer isNotEqualTo objNull }
            && { toLowerANSI (vehicleVarName _requesterPlayer) isEqualTo "ceo" };

        (_ownerUid isEqualTo _requesterUid) || _isDefaultOrgCeo
    }],
    ["assignCreditLine", compileFinal {
        params [["_requesterUid", "", [""]], ["_memberUid", "", [""]], ["_memberName", "", [""]], ["_amount", 0, [0]]];

        private _result = createHashMapFromArray [
            ["success", false],
            ["message", ""],
            ["patch", createHashMap],
            ["memberUids", []]
        ];

        if (
            _requesterUid isEqualTo ""
            || { _memberUid isEqualTo "" }
            || { _amount <= 0 }
        ) exitWith {
            _result set ["message", "A valid requester, member, and credit amount are required."];
            _result
        };

        private _requesterActor = EGVAR(actor,Registry) getOrDefault [_requesterUid, createHashMap];
        private _orgID = _requesterActor getOrDefault ["organization", "default"];
        if (_orgID isEqualTo "") then { _orgID = "default"; };

        private _org = GVAR(OrgStore) call ["loadById", [_orgID]];
        if (_org isEqualTo createHashMap) exitWith {
            _result set ["message", "Unable to load organization data for credit line assignment."];
            _result
        };

        private _requesterPlayer = [_requesterUid] call EFUNC(common,getPlayer);
        if !(_self call ["canManageTreasury", [_orgID, _org, _requesterUid, _requesterPlayer]]) exitWith {
            _result set ["message", "Only the organization leader or CEO can manage treasury actions."];
            _result
        };

        private _members = _org getOrDefault ["members", createHashMap];
        private _memberRecord = _members getOrDefault [_memberUid, createHashMap];
        if (_memberRecord isEqualTo createHashMap) exitWith {
            _result set ["message", "Selected member was not found in the organization roster."];
            _result
        };

        private _resolvedMemberName = _memberRecord getOrDefault ["name", _memberName];
        if (_resolvedMemberName isEqualTo "") then { _resolvedMemberName = _memberName; };

        private _creditLines = +(_org getOrDefault ["credit_lines", createHashMap]);
        _creditLines set [_memberUid, createHashMapFromArray [
            ["uid", _memberUid],
            ["name", _resolvedMemberName],
            ["amount", _amount]
        ]];

        private _patch = GVAR(OrgStore) call ["set", [_orgID, "credit_lines", _creditLines, false]];
        private _memberUids = _self call ["resolveOrgMemberUids", [_org, _requesterUid]];

        _result set ["success", true];
        _result set ["message", format ["Credit line of $%1 assigned to %2.", [_amount] call EFUNC(common,formatNumber), _resolvedMemberName]];
        _result set ["patch", _patch];
        _result set ["memberUids", _memberUids];
        _result
    }],
    ["chargeCheckout", compileFinal {
        params [["_requesterUid", "", [""]], ["_requesterPlayer", objNull, [objNull]], ["_source", "org_funds", [""]], ["_amount", 0, [0]], ["_commit", false, [false]]];

        private _result = _self call ["buildChargeResult", []];
        private _requesterActor = EGVAR(actor,Registry) getOrDefault [_requesterUid, createHashMap];
        private _orgID = _requesterActor getOrDefault ["organization", "default"];
        if (_orgID isEqualTo "") then { _orgID = "default"; };

        private _org = GVAR(OrgStore) call ["loadById", [_orgID]];
        if (_org isEqualTo createHashMap) exitWith {
            _result set ["message", "Organization data is unavailable for checkout."];
            _result
        };

        private _memberUids = _self call ["resolveOrgMemberUids", [_org, _requesterUid]];

        switch (toLowerANSI _source) do {
            case "org_funds": {
                if !(_self call ["canManageTreasury", [_orgID, _org, _requesterUid, _requesterPlayer]]) exitWith {
                    _result set ["message", "Only the organization leader or CEO can charge org funds."];
                    _result
                };

                private _funds = _org getOrDefault ["funds", 0];
                if (_funds < _amount) exitWith {
                    _result set ["message", "Organization funds cannot cover this checkout."];
                    _result
                };

                private _patch = createHashMapFromArray [["funds", (_funds - _amount)]];
                if (_commit) then { _patch = GVAR(OrgStore) call ["mset", [_orgID, _patch, false]]; };

                _result set ["success", true];
                _result set ["message", ""];
                _result set ["patch", _patch];
                _result set ["memberUids", _memberUids];
                _result
            };
            case "credit_line": {
                private _creditLines = +(_org getOrDefault ["credit_lines", createHashMap]);
                private _memberCredit = +(_creditLines getOrDefault [_requesterUid, createHashMap]);
                private _creditAmount = _memberCredit getOrDefault ["amount", 0];
                if (_creditAmount < _amount) exitWith {
                    _result set ["message", "Assigned credit line cannot cover this checkout."];
                    _result
                };

                _memberCredit set ["uid", _requesterUid];
                _memberCredit set ["amount", (_creditAmount - _amount)];
                _creditLines set [_requesterUid, _memberCredit];

                private _patch = createHashMapFromArray [["credit_lines", _creditLines]];
                if (_commit) then { _patch = GVAR(OrgStore) call ["mset", [_orgID, _patch, false]]; };

                _result set ["success", true];
                _result set ["message", ""];
                _result set ["patch", _patch];
                _result set ["memberUids", _memberUids];
                _result
            };
            default {
                _result set ["message", "Selected organization payment source is unsupported."];
                _result
            };
        };
    }]
];

GVAR(OrgTreasuryService) = createHashMapObject [GVAR(OrgTreasuryServiceBase)];