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

#include "..\script_component.hpp"

#pragma hemtt ignore_variables ["_self"]
GVAR(OrgMembershipServiceBase) = compileFinal createHashMapFromArray [
    ["#type", "OrgMembershipService"],
    ["buildMembershipResult", compileFinal {
        params [["_message", "", [""]]];

        createHashMapFromArray [
            ["success", false],
            ["message", _message],
            ["actorPatch", createHashMap]
        ]
    }],
    ["verifyMember", compileFinal {
        params [["_org", createHashMap, [createHashMap]], ["_orgID", "", [""]], ["_uid", "", [""]], ["_player", objNull, [objNull]], ["_actor", createHashMap, [createHashMap]]];

        if (_orgID isEqualTo "" || { _uid isEqualTo "" }) exitWith { _org };

        private _members = _org getOrDefault ["members", createHashMap];
        if ((_members getOrDefault [_uid, objNull]) isNotEqualTo objNull) exitWith { _org };

        ["org:members:add", [_orgID, _uid]] call EFUNC(extension,extCall) params ["_memberResult", "_memberSuccess"];
        if (!_memberSuccess) then {
            ["WARNING", format ["Failed to add %1 to org %2 members: %3", _uid, _orgID, _memberResult]] call EFUNC(common,log);
        };

        private _memberName = _actor getOrDefault ["name", ""];
        if (_memberName isEqualTo "" && { _player isNotEqualTo objNull }) then {
            _memberName = name _player;
        };
        if (_memberName isEqualTo "") then {
            _memberName = "Unknown";
        };

        private _updatedMembers = +_members;
        _updatedMembers set [_uid, createHashMapFromArray [["uid", _uid], ["name", _memberName]]];
        _org set ["members", _updatedMembers];

        _org
    }],
    ["addMember", compileFinal {
        params [["_orgID", "", [""]], ["_uid", "", [""]], ["_player", objNull, [objNull]], ["_actor", createHashMap, [createHashMap]]];

        if (_orgID isEqualTo "" || { _uid isEqualTo "" }) exitWith { createHashMap };

        private _org = GVAR(OrgStore) call ["loadById", [_orgID]];
        if (_org isEqualTo createHashMap) exitWith { _org };

        _org = _self call ["verifyMember", [_org, _orgID, _uid, _player, _actor]];
        GVAR(Registry) set [_orgID, _org, true];

        _org
    }],
    ["removeMember", compileFinal {
        params [["_orgID", "", [""]], ["_uid", "", [""]]];

        if (_orgID isEqualTo "" || { _uid isEqualTo "" }) exitWith { createHashMap };

        private _org = GVAR(OrgStore) call ["loadById", [_orgID]];
        if (_org isEqualTo createHashMap) exitWith { _org };

        ["org:members:remove", [_orgID, _uid]] call EFUNC(extension,extCall) params ["_memberResult", "_memberSuccess"];
        if (!_memberSuccess) exitWith {
            ["WARNING", format ["Failed to remove %1 from org %2 members: %3", _uid, _orgID, _memberResult]] call EFUNC(common,log);
            createHashMap
        };

        private _updatedMembers = +(_org getOrDefault ["members", createHashMap]);
        _updatedMembers deleteAt _uid;
        _org set ["members", _updatedMembers];
        GVAR(Registry) set [_orgID, _org, true];

        _org
    }],
    ["restoreDefaultMembership", compileFinal {
        params [["_uid", "", [""]], ["_player", objNull, [objNull]], ["_actor", createHashMap, [createHashMap]]];

        private _result = _self call ["buildMembershipResult", []];
        if (_uid isEqualTo "") exitWith {
            _result set ["message", "A valid player UID is required."];
            _result
        };

        private _resolvedPlayer = _player;
        if (_resolvedPlayer isEqualTo objNull) then {
            _resolvedPlayer = [_uid] call EFUNC(common,getPlayer);
        };

        private _resolvedActor = EGVAR(actor,Registry) getOrDefault [_uid, _actor];
        private _actorPatch = EGVAR(actor,ActorStore) call ["set", [EGVAR(actor,Registry), "actor:update", _uid, "organization", "default", true]];
        private _defaultActor = EGVAR(actor,Registry) getOrDefault [_uid, _resolvedActor];
        private _defaultOrg = _self call ["addMember", ["default", _uid, _resolvedPlayer, _defaultActor]];
        if (_defaultOrg isEqualTo createHashMap) exitWith {
            _result set ["message", "Failed to restore default organization membership."];
            _result
        };

        GVAR(IndexRegistry) set [_uid, createHashMapFromArray [["orgID", "default"]]];
        _result set ["success", true];
        _result set ["actorPatch", _actorPatch];
        _result
    }],
    ["leave", compileFinal {
        params [["_uid", "", [""]]];

        private _result = createHashMapFromArray [
            ["success", false],
            ["message", ""],
            ["actorPatch", createHashMap],
            ["notification", []]
        ];

        if (_uid isEqualTo "") exitWith {
            _result set ["message", "A valid player UID is required."];
            _result
        };

        private _player = [_uid] call EFUNC(common,getPlayer);
        private _actor = EGVAR(actor,Registry) getOrDefault [_uid, createHashMap];
        private _orgID = _actor getOrDefault ["organization", ""];
        if (_orgID isEqualTo "" || { toLower _orgID isEqualTo "default" }) exitWith {
            _result set ["message", "You are already assigned to the default organization."];
            _result
        };

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

        private _ownerUid = _org getOrDefault ["owner", ""];
        if (_ownerUid isEqualTo _uid) exitWith {
            _result set ["message", "Organization owners must disband the organization instead of leaving it."];
            _result
        };

        private _orgName = _org getOrDefault ["name", "Organization"];
        private _updatedOrg = _self call ["removeMember", [_orgID, _uid]];
        if (_updatedOrg isEqualTo createHashMap) exitWith {
            _result set ["message", "Failed to remove you from the organization roster."];
            _result
        };

        private _defaultResult = _self call ["restoreDefaultMembership", [_uid, _player, _actor]];
        if !(_defaultResult getOrDefault ["success", false]) exitWith {
            _result set ["message", _defaultResult getOrDefault ["message", "Failed to restore default organization membership."]];
            _result
        };

        private _message = format ["You left %1 and returned to the default organization.", _orgName];
        _result set ["success", true];
        _result set ["message", _message];
        _result set ["actorPatch", _defaultResult getOrDefault ["actorPatch", createHashMap]];
        _result set ["notification", ["info", "Organization Left", _message, 6000]];
        _result
    }],
    ["disband", compileFinal {
        params [["_uid", "", [""]]];

        private _result = createHashMapFromArray [
            ["success", false],
            ["message", ""],
            ["members", []]
        ];

        if (_uid isEqualTo "") exitWith {
            _result set ["message", "A valid player UID is required."];
            _result
        };

        private _actor = EGVAR(actor,Registry) getOrDefault [_uid, createHashMap];
        private _orgID = _actor getOrDefault ["organization", ""];
        if (_orgID isEqualTo "" || { toLower _orgID isEqualTo "default" }) exitWith {
            _result set ["message", "Only active player organizations can be disbanded."];
            _result
        };

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

        private _ownerUid = _org getOrDefault ["owner", ""];
        if (_ownerUid isEqualTo "" || { _ownerUid isNotEqualTo _uid }) exitWith {
            _result set ["message", "Only the organization owner can disband this organization."];
            _result
        };

        private _orgName = _org getOrDefault ["name", "Organization"];
        private _memberMap = _org getOrDefault ["members", createHashMap];
        private _memberUids = keys _memberMap;
        if !(_uid in _memberUids) then {
            _memberUids pushBack _uid;
        };

        private _deleteResult = GVAR(OrgStore) call ["delete", [_orgID]];
        if !(_deleteResult getOrDefault ["success", false]) exitWith {
            _result set ["message", _deleteResult getOrDefault ["message", "Failed to disband organization."]];
            _result
        };

        private _memberResults = [];
        {
            private _memberUid = _x;
            if (_memberUid isNotEqualTo "") then {
                private _memberPlayer = [_memberUid] call EFUNC(common,getPlayer);
                private _memberActor = EGVAR(actor,Registry) getOrDefault [_memberUid, createHashMap];
                private _defaultResult = _self call ["restoreDefaultMembership", [_memberUid, _memberPlayer, _memberActor]];
                if !(_defaultResult getOrDefault ["success", false]) then {
                    ["WARNING", format ["Failed to restore default org for %1 after disbanding %2: %3", _memberUid, _orgID, _defaultResult getOrDefault ["message", "Unknown error."]]] call EFUNC(common,log);
                };

                private _responseMessage = [
                    format ["%1 has been disbanded.", _orgName],
                    format ["Your organization, %1, has been disbanded.", _orgName]
                ] select (_memberUid isEqualTo _uid);

                private _notificationParams = [
                    ["warning", "Organization Disbanded", _responseMessage, 6000],
                    ["success", "Organization Disbanded", _responseMessage, 6000]
                ] select (_memberUid isEqualTo _uid);

                _memberResults pushBack (createHashMapFromArray [
                    ["uid", _memberUid],
                    ["requester", _memberUid isEqualTo _uid],
                    ["message", _responseMessage],
                    ["notification", _notificationParams],
                    ["actorPatch", _defaultResult getOrDefault ["actorPatch", createHashMap]]
                ]);
            };
        } forEach _memberUids;

        _result set ["success", true];
        _result set ["message", format ["%1 has been disbanded.", _orgName]];
        _result set ["members", _memberResults];
        _result
    }]
];

GVAR(OrgMembershipService) = createHashMapObject [GVAR(OrgMembershipServiceBase)];