organization.php

<?php
/*
 * Copyright (C) 2015 Maarch
 *
 * This file is part of bundle organization.
 *
 * Bundle organization is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Bundle organization is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with bundle organization.  If not, see <http://www.gnu.org/licenses/>.
 */
namespace bundle\organization\Controller;

use core\Exception;

/**
 * Control of the organization
 *
 * @package Organization
 * @author  Prosper De Laure <prosper.delaure@maarch.org>
 */
class organization
{
    protected $sdoFactory;
    protected $csv;
    protected $accountController;
    protected $hasSecurityLevel;

    /**
     * Constructor
     * @param \dependency\sdo\Factory $sdoFactory The dependency sdo factory service
     * @param \dependency\csv\Csv     $csv        The dependency csv
     *
     * @return void
     */
    public function __construct(\dependency\sdo\Factory $sdoFactory, \dependency\csv\Csv $csv = null)
    {
        $this->sdoFactory = $sdoFactory;
        $this->csv = $csv;
        $this->accountController = \laabs::newController('auth/userAccount');
        $this->hasSecurityLevel = isset(\laabs::configuration('auth')['useSecurityLevel']) ? (bool) \laabs::configuration('auth')['useSecurityLevel'] : false;
    }

    /**
     * Index of organizations
     *
     * @param integer $limit Maximal number of results to dispay
     * @param string  $query The query of the index
     *
     * @return organization/organization[] An array of organization
     */
    public function index($limit = null, $query = null)
    {
        return $this->sdoFactory->index("organization/organization", array("orgId", "displayName", "isOrgUnit", "registrationNumber", "parentOrgId", "ownerOrgId"), $query, null, null, $limit);
    }

    /**
     * List of organizations
     *
     * @param bool $ownerOrg
     * @param bool $orgUnit
     * @param string $term The term to search in database
     *
     * @return organization/organization[] An array of organization whith service
     */
    public function todisplay($ownerOrg, $orgUnit, $term)
    {
        $authController = \laabs::newController("auth/userAccount");
        $user = $authController->get(\laabs::getToken('AUTH')->accountId);

        $currentOrg = \laabs::getToken("ORGANIZATION");
        $orgList = [];

        if (!$currentOrg || (!empty($currentOrg->orgRoleCodes) && in_array('owner', $currentOrg->orgRoleCodes))) {
            $orgUnitList = $this->getOwnerOriginatorsOrgs(null, $term);
        } else {
            $orgUnitList = $this->getOwnerOriginatorsOrgs($currentOrg, $term);
        }

        foreach ($orgUnitList as $org) {
            $organization = \laabs::newInstance('organization/organization');
            $organization->displayName = $org->displayName;
            $organization->orgId = $org->orgId;
            $organization->parentOrgId = $org->parentOrgId;

            if ($ownerOrg) {
                $orgList[] = $organization;
            }

            if ($orgUnit) {
                foreach ($org->originators as $orgUnit) {
                    if ($org->orgId == $orgUnit->ownerOrgId) {
                        $orgUnit->ownerOrgName = $org->displayName;
                        $orgList[] = $orgUnit;
                    }
                }
            }
        }

        if (isset($orgList)) {
            foreach ($orgList as $org) {
                foreach ($orgList as $orgParent) {
                    if (isset($org->parentOrgId)) {
                        if ($org->parentOrgId == $orgParent->orgId) {
                            $org->parentOrgName = $orgParent->displayName;
                        }
                    }
                }
            }
        }
        return $orgList;
    }

    public function search($term = null, $enabled = "all")
    {
        $user = $this->accountController->get(\laabs::getToken('AUTH')->accountId);

        $currentOrg = \laabs::getToken("ORGANIZATION");
        $owner = true;

        if (isset($currentOrg)) {
            if (!$currentOrg->orgRoleCodes) {
                $owner = false;
            } elseif (is_array($currentOrg->orgRoleCodes) && !in_array('owner', $currentOrg->orgRoleCodes)) {
                $owner = false;
            }
        }

        $queryParts = array();
        $queryParams = array();

        $securityLevel = null;
        if ($this->hasSecurityLevel) {
            $securityLevel = $user->getSecurityLevel();
        }
        if ($securityLevel == $user::SECLEVEL_GENADMIN) {
            $queryParams['isOrgUnit'] = 'false';
            $queryParts['isOrgUnit'] = "isOrgUnit=:isOrgUnit";
        }

        if ($term) {
            $queryParts['term'] = "(registrationNumber ='*".$term."*'
            OR orgName = '*".$term."*'
            OR displayName = '*".$term."*'
            OR parentOrgId = '*".$term."*')";
        }

        if ($enabled !== 'all') {
            $queryParams['enabled'] = $enabled;
            $queryParts['enabled'] = "enabled=:enabled";
        }

        $queryString = "";
        if (count($queryParts)) {
            $queryString = implode(' AND ', $queryParts);
        }

        $length = \laabs::configuration('presentation.maarchRM')['maxResults'];
        $organizationList = $this->sdoFactory->find("organization/organization", $queryString, $queryParams, null, 0, $length);
        $organizationList = \laabs::castMessageCollection($organizationList, "organization/organizationList");

        if ($term || $enabled !== 'all') {
            $organizations = [];
            foreach ($organizationList as $organization) {
                $parentOrgId = (string)$organization->parentOrgId;

                if ($user->ownerOrgId && $organization->ownerOrgId != $user->ownerOrgId) {
                    if (empty($parentOrgId) && $organization->orgId != $user->ownerOrgId) {
                        continue;
                    }
                }

                if ($parentOrgId) {
                    $organization->parentOrgName = $this->sdoFactory->index(
                        'organization/organization',
                        ['displayName'],
                        "orgId='". $parentOrgId . "'"
                    )[$parentOrgId];
                }
                $organizations[] = $organization;
            }

            return $organizations;
        }

        $tree = array();
        $organizationByParent = array();
        foreach ($organizationList as $organization) {
            $parentOrgId = (string)$organization->parentOrgId;

            if ($user->ownerOrgId && $organization->ownerOrgId != $user->ownerOrgId) {
                if (empty($parentOrgId) && $organization->orgId != $user->ownerOrgId) {
                    continue;
                }
            }

            if (empty($parentOrgId) && $owner) {
                $tree[] = $organization;
                continue;
            } elseif (!$owner && (
                (string)$organization->orgId == (string)$currentOrg->ownerOrgId)
                || (string)$organization->orgId == (string) $user->ownerOrgId) {
                $tree[] = $organization;
                continue;
            }

            if (!isset($organizationByParent[$parentOrgId])) {
                $organizationByParent[$parentOrgId] = array();
            }

            $organization->parentOrgName = $this->sdoFactory->index(
                'organization/organization',
                ['displayName'],
                "orgId='". $parentOrgId . "'"
            )[$parentOrgId];
            $organizationByParent[$parentOrgId][] = $organization;
        }

        return $this->buildTree($tree, $organizationByParent);
    }

    /**
     * Get organizations tree
     *
     * @return organization/organizationTree[] The tree of organization
     */
    public function getTree()
    {
        $tree = array();

        $authController = \laabs::newController("auth/userAccount");
        $user = $authController->get(\laabs::getToken('AUTH')->accountId);

        $currentOrg = \laabs::getToken("ORGANIZATION");
        $owner = true;

        if (isset($currentOrg)) {
            if (!$currentOrg->orgRoleCodes) {
                $owner = false;
            } elseif (is_array($currentOrg->orgRoleCodes) && !in_array('owner', $currentOrg->orgRoleCodes)) {
                $owner = false;
            }
        }

        $securityLevel = null;
        if ($this->hasSecurityLevel) {
            $securityLevel = $user->getSecurityLevel();
        }

        if ($securityLevel == $user::SECLEVEL_GENADMIN) {
            $organizationList = $this->sdoFactory->find(
                "organization/organization",
                'isOrgUnit = false',
                [],
                'orgName'
            );
        } else {
            $organizationList = $this->sdoFactory->find(
                "organization/organization",
                null,
                [],
                'orgName'
            );
        }
        $organizationList = \laabs::castMessageCollection($organizationList, "organization/organizationTree");

        // sort organization by parentOrgId
        $organizationByParent = array();
        foreach ($organizationList as $organization) {
            $parentOrgId = (string)$organization->parentOrgId;

            if (empty($parentOrgId) && $owner) {
                $tree[] = $organization;
                continue;
            } elseif (!$owner && (
                    (string)$organization->orgId == (string)$currentOrg->ownerOrgId)
                || (string)$organization->orgId == (string) $user->ownerOrgId) {
                $tree[] = $organization;
                continue;
            }

            if ($user->ownerOrgId && $organization->ownerOrgId != $user->ownerOrgId) {
                if (empty($parentOrgId) && $organization->orgId != $user->ownerOrgId) {
                    continue;
                }
            }

            if (!isset($organizationByParent[$parentOrgId])) {
                $organizationByParent[$parentOrgId] = array();
            }
            $organizationByParent[$parentOrgId][] = $organization;
        }

        return $this->buildTree($tree, $organizationByParent);
    }

    /**
     * Set positions for the organization tree
     * @param object $roots            The organization tree roots
     * @param array  $organizationList The list of organization sorted by parent organization
     *
     * @return object[]
     */
    protected function buildTree($roots, $organizationList)
    {
        foreach ($roots as $organization) {
            $orgId = (string)$organization->orgId;

            if (isset($organizationList[$orgId])) {
                $organization->organization = $this->buildTree($organizationList[$orgId], $organizationList);
            }
        }

        return $roots;
    }

    /**
     * Create an organization
     * @param organization/organization $organization The organization object to create
     *
     * @return string the new organization's Id
     */
    public function create($organization)
    {
        $user = $this->accountController->get(\laabs::getToken('AUTH')->accountId);

        if ($organization->isOrgUnit) {
            $this->accountController->isAuthorized(['func_admin', 'user']);

            $securityLevel = null;
            if ($this->hasSecurityLevel) {
                $securityLevel = $user->getSecurityLevel();
            }

            if ($securityLevel == $user::SECLEVEL_FUNCADMIN) {
                $userOrgIds = [$user->ownerOrgId];
                foreach($this->readDescendantOrg($user->ownerOrgId) as $org){
                    $userOrgIds[] = (string) $org->orgId;
                }
                if (!in_array($organization->ownerOrgId, $userOrgIds)){
                    throw new \core\Exception\ForbiddenException("You are not allowed to do this action");
                }
            }

        } else {
            $this->accountController->isAuthorized('gen_admin');
        }


        if (!$organization->parentOrgId && !in_array($user->accountName, \laabs::configuration("auth")["adminUsers"])) {
            if (\laabs::getToken("ORGANIZATION")) {
                if (!in_array('owner', \laabs::getToken("ORGANIZATION")->orgRoleCodes)) {
                    throw new \core\Exception\ForbiddenException("You're not allowed to create an organization");
                }
            } else {
                throw new \core\Exception\ForbiddenException("You're not allowed to create an organization");
            }
        } else {
            if ($organization->parentOrgId) {
                try {
                    $this->read($organization->parentOrgId);
                } catch (\Exception $e) {
                    throw new \core\Exception\NotFoundException("Organization identified by " . $organization->parentOrgId . " was not find");
                }
            }
        }

        try {
            if (empty($organization->displayName)) {
                $organization->displayName = $organization->orgName;
            }

            $organization->orgId = \laabs::newId();
            $this->sdoFactory->create($organization, 'organization/organization');
        } catch (\Exception $e) {
            throw new \core\Exception\ConflictException("Key already exists");
        }

        return $organization->orgId;
    }

    /**
     * Read an organization by his orgId
     * @param string $orgId The Identifier of the organization to read
     *
     * @return organization/organization the organization
     */
    public function read($orgId)
    {
        $organization = $this->sdoFactory->read("organization/organization", $orgId);
        $organization->users = $this->readUserPositions($orgId);
        $organization->services = $this->readServicePositions($orgId);
        $organization->contacts = $this->getContacts($orgId);
        $organization->archivalProfileAccess = $this->sdoFactory->find('organization/archivalProfileAccess', "orgId='$orgId'");

        return \laabs::castMessage($organization, "organization/organization");
    }

    /**
     * Get an organization by his regitration number
     * @param string $registrationNumber The registration number of the organization
     *
     * @return organization/organization the organization
     */
    public function getOrgByRegNumber($registrationNumber)
    {
        $organization = $this->sdoFactory->read("organization/organization", array('registrationNumber' => $registrationNumber));

        return \laabs::castMessage($organization, "organization/organization");
    }

    /**
     * Get organizations by their role
     * @param string $role The role of the organizations
     *
     * @return organization/organization[] the organizations
     */
    public function getOrgsByRole($role)
    {
        $organizations = $this->sdoFactory->find("organization/organization", "orgRoleCodes = '*$role*'");

        return \laabs::castMessageCollection($organizations, "organization/organization");
    }

    /**
     * List organizations
     * @param string $role The role of organizations
     *
     * @return organization/organization[] The organizations list
     */
    public function orgList($role = null)
    {
        $queryString = "";

        if ($role) {
            $queryString .= "orgRoleCodes = '*$role*'";
        }

        return $this->sdoFactory->index("organization/organization", array("displayName", "registrationNumber"), $queryString, null, array('registrationNumber'));
    }

    /**
     * List organizations
     * @param string $role The role of organizations
     *
     * @return organization/organization[] The organizations list
     */
    public function orgUnitList($role = null)
    {
        $queryString = "";

        if ($role) {
            $queryString .= "orgRoleCodes = '*$role*'";
        }

        $queryString .= "isOrgUnit = 'true'";

        return $this->sdoFactory->index("organization/organization", array("displayName", "registrationNumber"), $queryString, null, array('registrationNumber'));
    }

    /**
     * Get organization's user positions
     * @param string $orgId The organization's identifier
     *
     * @return organization/userPositionTree[] The list of user position
     */
    public function readUserPositions($orgId)
    {
        $users = $this->sdoFactory->find("organization/userPosition", "orgId = '$orgId'");
        $users = \laabs::castMessageCollection($users, 'organization/userPositionTree');

        $userAccountController = \laabs::newController('auth/userAccount');

        foreach ($users as $user) {
            $user->displayName = $userAccountController->edit((string)$user->userAccountId)->displayName;
        }

        return $users;
    }

    /**
     * Get user positions
     * @param string $accountId The user identifier
     *
     * @return organization/userPositionTree[] The list of user position
     */
    public function readUserOrgs($accountId)
    {
        $users = $this->sdoFactory->find("organization/userPosition", "userAccountId = '$accountId'");
        $users = \laabs::castMessageCollection($users, 'organization/userPositionTree');
        $organizations = $this->sdoFactory->find("organization/organization");

        foreach ($users as $user) {
            $user->displayName = $this->sdoFactory->read("organization/organization", $user->orgId)->displayName;

            foreach ($organizations as $org) {
                if ($user->orgId == $org->orgId) {
                    foreach ($organizations as $orgName) {
                        if ($org->ownerOrgId == $orgName->orgId) {
                            $user->ownerOrgName = $orgName->displayName;
                            $user->ownerOrgId = $orgName->orgId;
                        }
                    }
                }
            }
        }

        return $users;
    }

    /**
     * Get organization's service positions
     * @param string $orgId The organization's identifier
     *
     * @return organization/servicePosition[] The list of service position
     */
    public function readServicePositions($orgId)
    {
        $services = $this->sdoFactory->find("organization/servicePosition", "orgId = '$orgId'");
        $services = \laabs::castMessageCollection($services, 'organization/servicePositionTree');

        $userAccountController = \laabs::newController('auth/userAccount');

        foreach ($services as $service) {
            $service->displayName = $userAccountController->edit((string)$service->serviceAccountId)->displayName;
        }

        return $services;
    }

    /**
     * Get organization's contacts
     * @param string $orgId The organization's identifier
     *
     * @return organization/orgContact[] The list of service position
     */
    public function readContact($orgId)
    {
        return $this->sdoFactory->find("organization/orgContact", "orgId = '$orgId'");
    }

    /**
     * Update an organization
     * @param string                    $orgId        The organization identifier
     * @param organization/organization $organization The organization object to update
     *
     * @return boolean The result of the operation
     */
    public function update($orgId, $organization)
    {
        if ($organization->isOrgUnit) {
            $this->accountController->isAuthorized(['func_admin', 'user']);
        } else {
            $this->accountController->isAuthorized('gen_admin');
        }

        $organization->orgId = $orgId;

        if ($organization->beginDate > $organization->endDate) {
            throw new \core\Exception("The end date is lower than the begin date.");
        }


        if (isset($organization->orgRoleCodes) && $organization->orgRoleCodes->contains("owner")) {
            if ($this->sdoFactory->count("organization/organization", "registrationNumber!='$organization->registrationNumber' AND orgRoleCodes='*owner*'")) {
                throw new \core\Exception("An owner is already defined.");
            }
        }

        try {
            if ($this->isUsed($organization->registrationNumber)) {
                $originalOrganization = $this->read($orgId);
                $organization->registrationNumber = $originalOrganization->registrationNumber;
            }

            if (empty($organization->displayName)) {
                $organization->displayName = $organization->orgName;
            }
            $res = $this->sdoFactory->update($organization, 'organization/organization');
        } catch (\Exception $e) {
            throw new \core\Exception("Key already exists");
        }

        return $res;
    }

    /**
     * Sets the status of an org unit
     *
     * @param string $orgId  The org identifier
     * @param bool   $status The new status (enabled = true of false)
     *
     * @return bool The result of the change
     */
    public function changeStatus($orgId, $status)
    {
        $this->accountController->isAuthorized(['func_admin']);

        $organization = $this->sdoFactory->read('organization/organization', $orgId);

        $accountToken = \laabs::getToken('AUTH');
        $account = $this->sdoFactory->read("auth/account", $accountToken->accountId);

        $securityLevel = null;
        if ($this->hasSecurityLevel) {
            $securityLevel = $account->getSecurityLevel();
        }

        if ($securityLevel == $account::SECLEVEL_FUNCADMIN) {
            $userOrgIds = [$account->ownerOrgId];
            foreach($this->readDescendantOrg($account->ownerOrgId) as $org){
                $userOrgIds[] = (string) $org->orgId;
            }
            if (!in_array($organization->ownerOrgId, $userOrgIds)){
                throw new \core\Exception\ForbiddenException("You are not allowed to do this action");
            }
        }

        if (!$organization->isOrgUnit) {
            throw new \core\Exception\ForbiddenException("An organization can't be disabled.");
        }

        if ($status == "true") {
            $organization->enabled = 1;
        } else {
            $organization->enabled = 0;
        }

        return $this->sdoFactory->update($organization);
    }

    /**
     * Move an organization to a new ownerOrg
     * @param string $orgId          The organization identifier
     * @param string $newParentOrgId The new parent organization identifier
     * @param string $newOwnerOrgId  The new owner organization identifier
     *
     * @return boolean The result of the operation
     */
    public function move($orgId, $newParentOrgId = null, $newOwnerOrgId = null)
    {
        if ($newParentOrgId == "") {
            $newParentOrgId = null;
        }
        if ($newOwnerOrgId == "") {
            $newOwnerOrgId = null;
        }

        if ($newParentOrgId) {
            $oldParentOrgs = $this->readParentOrg($orgId);
            $newParentOrgs = $this->readParentOrg($newParentOrgId);

            $newParentOrg = $this->sdoFactory->read("organization/organization", $newParentOrgId);
            if ($newParentOrg->isOrgUnit) {
                for ($i = 0; $i < count($newParentOrgs); $i++) {
                    if (!$newParentOrgs[$i]->isOrgUnit) {
                        $newParentOrg = $newParentOrgs[$i];
                        break;
                    }
                }
            }

            for ($i = 0; $i < count($oldParentOrgs); $i++) {
                if (!$oldParentOrgs[$i]->isOrgUnit) {
                    $oldParentOrg = $oldParentOrgs[$i];
                    break;
                }
            }

            if ($oldParentOrg->orgId === null
                || ($oldParentOrg->orgId !== null
                    && $oldParentOrg->orgId != $newParentOrg->orgId
                )
            ) {
                throw new \core\Exception("Organization can''t be moved to an other organization");
            }
        }

        $organization = $this->sdoFactory->read("organization/organization", $orgId);
        $descendants = $this->sdoFactory->readDescendants("organization/organization", $organization);

        $transactionControl = !$this->sdoFactory->inTransaction();

        if ($transactionControl) {
            $this->sdoFactory->beginTransaction();
        }

        try {
            $organization->parentOrgId = $newParentOrgId;
            $organization->ownerOrgId = $newOwnerOrgId;

            if (!$newOwnerOrgId) {
                $newOwnerOrgId = $orgId;
            }

            foreach ($descendants as $descendantOrg) {
                if ((string)$descendantOrg->orgId == $organization->orgId) {
                    throw new \bundle\organization\Exception\orgMoveException("Organization can't be moved to a descendent organization");
                }

                if ($descendantOrg->isOrgUnit && $descendantOrg->ownerOrgId != $newOwnerOrgId) {
                    $descendantOrg->ownerOrgId = $newOwnerOrgId;
                    $this->sdoFactory->update($descendantOrg, 'organization/organization');
                }
            }

            $this->sdoFactory->update($organization);
        } catch (\Exception $e) {
            throw $e;
        }

        if ($transactionControl) {
            $this->sdoFactory->commit();
        }

        return true;
    }

    /**
     * Delete an organization
     * @param string $orgId The organization id
     *
     * @return boolean The restult of the operation
     */
    public function delete($orgId)
    {
        $organization = $this->sdoFactory->read("organization/organization", $orgId);
        if ($organization->isOrgUnit) {
            $this->accountController->isAuthorized(['func_admin', 'user']);
        } else {
            $this->accountController->isAuthorized('gen_admin');
        }

        $transactionControl = !$this->sdoFactory->inTransaction();

        if ($transactionControl) {
            $this->sdoFactory->beginTransaction();
        }

        try {
            if ($this->isUsed($organization->registrationNumber)) {
                throw new \core\Exception\ForbiddenException(
                    "The organization %s is used in archives.",
                    403,
                    null,
                    [$organization->registrationNumber]
                );
            }

            $controlAuthorities = $this->sdoFactory->find(
                'medona/controlAuthority',
                "originatorOrgUnitId = '$orgId' OR controlAuthorityOrgUnitId = '$orgId'"
            );
            if (count($controlAuthorities) > 0) {
                throw new \core\Exception\ForbiddenException(
                    "The organization %s is used in control authority.",
                    403,
                    null,
                    [$organization->registrationNumber]
                );
            }

            $children = $this->sdoFactory->readChildren("organization/organization", $organization);
            $users = $this->sdoFactory->readChildren("organization/userPosition", $organization);
            $services = $this->sdoFactory->readChildren("organization/servicePosition", $organization);
            $contacts = $this->sdoFactory->readChildren("organization/orgContact", $organization);
            $this->sdoFactory->deleteChildren("organization/archivalProfileAccess", $organization);

            foreach ($contacts as $contact) {
                $this->deleteContactPosition($contact->contactId, (string)$organization->orgId);
            }

            foreach ($children as $child) {
                $controlAuthorities = $this->sdoFactory->find(
                    'medona/controlAuthority',
                    "originatorOrgUnitId = '$child->orgId' OR controlAuthorityOrgUnitId = '$child->orgId'"
                );
                if (count($controlAuthorities) > 0) {
                    throw new \core\Exception\ForbiddenException(
                        "The child organization is used in control authority.",
                        403,
                        null
                    );
                }
                $this->delete($child->orgId);
            }

            foreach ($users as $user) {
                $this->sdoFactory->delete($user);
            }
            foreach ($services as $service) {
                $this->sdoFactory->delete($service);
            }

            $this->sdoFactory->delete($organization);
        } catch (\Exception $exception) {
            if ($transactionControl) {
                $this->sdoFactory->rollback();
            }

            throw $exception;
        }

        if ($transactionControl) {
            $this->sdoFactory->commit();
        }



        return true;
    }

    /**
     * Add a user position to an organization
     * @param string $userAccountId The user account identifier
     * @param string $orgId         The organization identifier
     * @param string $function      The function of the user
     *
     * @return boolean The result of the operation
     */
    public function addUserPosition($userAccountId, $orgId, $function = null)
    {
        $this->accountController->isAuthorized('func_admin');

        $userPosition = \laabs::newInstance('organization/userPosition');
        $userPosition->userAccountId = $userAccountId;
        $userPosition->orgId = $orgId;
        $userPosition->function = $function;
        $userPosition->default = false;
        $userDefaultPosition = $this->sdoFactory->find(
            'organization/userPosition',
            "userAccountId = '$userAccountId' AND default = true"
        );

        if (empty($userDefaultPosition)) {
            $userPosition->default = true;
        }

        return $this->sdoFactory->create($userPosition, 'organization/userPosition');
    }

    /**
     * Delete an archival pofile accesss from every organization
     * @param string $userAccountId The user account identifier
     * @param string $orgId         The organization identifier
     *
     * @return bool The result of the operation
     */
    public function updateUserPosition($userAccountId, $orgId = null)
    {
        $this->accountController->isAuthorized('func_admin');

        $userPositions = $this->sdoFactory->find("organization/userPosition", "userAccountId='$userAccountId'");
        $default = null;

        foreach ($userPositions as $userPosition) {
            if ($userPosition->default) {
                $default = $userPosition->orgId;
            }
        }

        try {
            if ($userPositions) {
                $this->sdoFactory->deleteCollection($userPositions, "organization/userPosition");
            }

            foreach ($orgId as $id) {
                $userPosition = \laabs::newInstance('organization/userPosition');
                $userPosition->userAccountId = $userAccountId;
                $userPosition->orgId = $id;

                if ($id == $default) {
                    $userPosition->default = true;
                } else {
                    $userPosition->default = false;
                }

                $userPosition = $this->sdoFactory->create($userPosition, 'organization/userPosition');
            }
        } catch (Exception $e) {
            $this->sdoFactory->rollback();
            throw $e;
        }

        return $userPosition;
    }



    /**
     * Add a service position to an organization
     * @param string $orgId            The organization identifier
     * @param string $serviceAccountId The service account identifier
     *
     * @return boolean The result of the operation
     */
    public function addServicePosition($orgId, $serviceAccountId)
    {
        $servicePosition = \laabs::newInstance('organization/servicePosition');
        $servicePosition->serviceAccountId = $serviceAccountId;
        $servicePosition->orgId = $orgId;

        return $this->sdoFactory->create($servicePosition);
    }

    /**
     * Set default user position for an user
     * @param string $orgId         The organization identifier
     * @param string $userAccountId The service account identifier
     *
     * @return boolean The result of the operation
     */
    public function setDefaultUserPosition($orgId, $userAccountId)
    {
        $previousDefaultUserPosition = $this->sdoFactory->find(
            'organization/userPosition', "userAccountId='$userAccountId' AND default=true");

        if (!empty($previousDefaultUserPosition)) {
            $previousDefaultUserPosition = $previousDefaultUserPosition[0];
            $previousDefaultUserPosition->default = false;
            $this->sdoFactory->update($previousDefaultUserPosition, 'organization/userPosition');
        }

        $userPosition = $this->sdoFactory->read(
            "organization/userPosition",
            array("userAccountId" => $userAccountId, "orgId" => $orgId)
        );
        $userPosition->default = true;

        return $this->sdoFactory->update($userPosition, 'organization/userPosition');
    }

    /**
     * Remove a user's position
     * @param string $userAccountId The user account identifier
     * @param string $orgId         The organization account identifier
     *
     * @return boolean The result of the operation
     */
    public function deleteUserPosition($userAccountId, $orgId)
    {
        $this->accountController->isAuthorized('func_admin');

        $userPosition = $this->sdoFactory->read(
            "organization/userPosition",
            array("userAccountId" => $userAccountId, "orgId" => $orgId)
        );

        if ($userPosition->default) {
            $newDefaultUserPosition = $this->sdoFactory->find(
                'organization/userPosition',
                "userAccountId='$userAccountId'"
            );

            if (!empty($newDefaultUserPosition)) {
                $newDefaultUserPosition = $newDefaultUserPosition[0];
                $newDefaultUserPosition->default = true;

                $this->sdoFactory->update($newDefaultUserPosition, 'organization/userPosition');
            }
        }

        return $this->sdoFactory->delete($userPosition);
    }

    /**
     * Remove a contact's position
     * @param string $contactId The user account identifier
     * @param string $orgId     The organization account identifier
     *
     * @return boolean The result of the operation
     */
    public function deleteContactPosition($contactId, $orgId)
    {
        $contactPosition = $this->sdoFactory->read(
            "organization/orgContact",
            array("contactId" => $contactId, "orgId" => $orgId)
        );

        $contactController = \laabs::newController('contact/contact');
        $this->sdoFactory->delete($contactPosition);

        return $contactController->delete($contactId);
    }

    /**
     * Remove a service's position
     * @param string $orgId            The organization account identifier
     * @param string $serviceAccountId The service account identifier
     *
     * @return boolean The result of the operation
     */