Module.php

<?php
namespace Teams;

use Collecting\Api\Adapter\CollectingItemAdapter;
use Omeka\Api\Adapter\AssetAdapter;
use Omeka\Api\Adapter\UserAdapter;
use Omeka\Entity\Resource;
use Omeka\Mvc\Controller\Plugin\Messenger;
use Doctrine\ORM\QueryBuilder;
use Omeka\Api\Exception;
use Doctrine\ORM\Query\Expr;
use Omeka\Api\Adapter\ResourceTemplateAdapter;
use Omeka\Api\Adapter\SiteAdapter;
use Omeka\Entity\EntityInterface;
use Omeka\Permissions\Acl;
use Omeka\Permissions\Assertion\AssertionNegation;
use Omeka\Permissions\Assertion\IsSelfAssertion;
use Omeka\Permissions\Assertion\OwnsEntityAssertion;
use Teams\Acl\TeamRolePermissionAssertion;
use Teams\Entity\Team;
use Teams\Entity\TeamAsset;
use Teams\Entity\TeamResource;
use Teams\Entity\TeamResourceTemplate;
use Teams\Entity\TeamSite;
use Teams\Entity\TeamUser;
use Teams\Form\ConfigForm;
use Teams\Form\Element\AllSiteSelectOrdered;
use Teams\Form\Element\AllTeamSelect;
use Teams\Form\Element\BlankTeamSelect;
use Teams\Form\Element\RoleSelect;
use Teams\Form\Element\TeamSelect;
use Omeka\Api\Adapter\ItemAdapter;
use Omeka\Api\Adapter\ItemSetAdapter;
use Omeka\Api\Adapter\MediaAdapter;
use Omeka\Api\Representation\AbstractEntityRepresentation;
use Omeka\Module\AbstractModule;
use Laminas\EventManager\Event;
use Laminas\EventManager\SharedEventManagerInterface;
use Laminas\Mvc\Controller\AbstractController;
use Laminas\Mvc\MvcEvent;
use Laminas\ServiceManager\ServiceLocatorInterface;
use Laminas\View\Renderer\PhpRenderer;
use Teams\Mvc\Controller\Plugin\TeamAuth;

class Module extends AbstractModule
{
    public function getConfig()
    {
        return include __DIR__ . '/config/module.config.php';
    }

    public function onBootstrap(MvcEvent $event)
    {
        parent::onBootstrap($event);
        $this->addAclRules();
    }

    public function install(ServiceLocatorInterface $serviceLocator)
    {
        $globalSettings = $serviceLocator->get('Omeka\Settings');
        $globalSettings->set('teams_filter_bypass_roles', ["global_admin"]);

        $conn = $serviceLocator->get('Omeka\Connection');

        $conn->exec('
CREATE TABLE team (id INT AUTO_INCREMENT NOT NULL, name VARCHAR(240) NOT NULL, description LONGTEXT NOT NULL, UNIQUE INDEX UNIQ_C4E0A61F5E237E06 (name), PRIMARY KEY(id)) DEFAULT CHARACTER SET utf8mb4 COLLATE `utf8mb4_unicode_ci` ENGINE = InnoDB;');
        $conn->exec('
CREATE TABLE team_user (team_id INT NOT NULL, user_id INT NOT NULL, role_id INT DEFAULT NULL, is_current TINYINT(1) DEFAULT NULL, id INT NOT NULL AUTO_INCREMENT, UNIQUE INDEX UNIQ_5C722232BF396750 (id), INDEX IDX_5C722232296CD8AE (team_id), INDEX IDX_5C722232A76ED395 (user_id), INDEX IDX_5C722232D60322AC (role_id), UNIQUE INDEX active_team (is_current, user_id), PRIMARY KEY(team_id, user_id)) DEFAULT CHARACTER SET utf8mb4 COLLATE `utf8mb4_unicode_ci` ENGINE = InnoDB;');
        $conn->exec('
CREATE TABLE team_role (id INT AUTO_INCREMENT NOT NULL, name VARCHAR(240) NOT NULL, can_add_users TINYINT(1) DEFAULT NULL, can_add_items TINYINT(1) DEFAULT NULL, can_add_itemsets TINYINT(1) DEFAULT NULL, can_modify_resources TINYINT(1) DEFAULT NULL, can_delete_resources TINYINT(1) DEFAULT NULL, can_add_site_pages TINYINT(1) DEFAULT NULL, comment LONGTEXT DEFAULT NULL, UNIQUE INDEX UNIQ_86887E115E237E06 (name), PRIMARY KEY(id)) DEFAULT CHARACTER SET utf8mb4 COLLATE `utf8mb4_unicode_ci` ENGINE = InnoDB;');
        $conn->exec('
CREATE TABLE team_asset (team_id INT NOT NULL, asset_id INT NOT NULL, INDEX IDX_C5A9131C296CD8AE (team_id), INDEX IDX_C5A9131C5DA1941 (asset_id), PRIMARY KEY(team_id, asset_id)) DEFAULT CHARACTER SET utf8mb4 COLLATE `utf8mb4_unicode_ci` ENGINE = InnoDB;');
        $conn->exec('
CREATE TABLE team_resource_template (team_id INT NOT NULL, resource_template_id INT NOT NULL, INDEX IDX_75325B72296CD8AE (team_id), INDEX IDX_75325B7216131EA (resource_template_id), PRIMARY KEY(team_id, resource_template_id)) DEFAULT CHARACTER SET utf8mb4 COLLATE `utf8mb4_unicode_ci` ENGINE = InnoDB;');
        $conn->exec('
CREATE TABLE team_site (team_id INT NOT NULL, site_id INT NOT NULL, is_current TINYINT(1) DEFAULT NULL, INDEX IDX_B8A2FD9F296CD8AE (team_id), INDEX IDX_B8A2FD9FF6BD1646 (site_id), UNIQUE INDEX active_team (is_current, site_id), PRIMARY KEY(team_id, site_id)) DEFAULT CHARACTER SET utf8mb4 COLLATE `utf8mb4_unicode_ci` ENGINE = InnoDB;');
        $conn->exec('
CREATE TABLE team_resource (team_id INT NOT NULL, resource_id INT NOT NULL, INDEX IDX_4D32868296CD8AE (team_id), INDEX IDX_4D3286889329D25 (resource_id), PRIMARY KEY(team_id, resource_id)) DEFAULT CHARACTER SET utf8mb4 COLLATE `utf8mb4_unicode_ci` ENGINE = InnoDB;');
        $conn->exec('
ALTER TABLE team_user ADD CONSTRAINT FK_5C722232296CD8AE FOREIGN KEY (team_id) REFERENCES team (id) ON DELETE CASCADE;');
        $conn->exec('
ALTER TABLE team_user ADD CONSTRAINT FK_5C722232A76ED395 FOREIGN KEY (user_id) REFERENCES user (id) ON DELETE CASCADE;');
        $conn->exec('
ALTER TABLE team_user ADD CONSTRAINT FK_5C722232D60322AC FOREIGN KEY (role_id) REFERENCES team_role (id);');
        $conn->exec('
ALTER TABLE team_asset ADD CONSTRAINT FK_C5A9131C296CD8AE FOREIGN KEY (team_id) REFERENCES team (id) ON DELETE CASCADE;');
        $conn->exec('
ALTER TABLE team_asset ADD CONSTRAINT FK_C5A9131C5DA1941 FOREIGN KEY (asset_id) REFERENCES asset (id) ON DELETE CASCADE;');
        $conn->exec('
ALTER TABLE team_resource_template ADD CONSTRAINT FK_75325B72296CD8AE FOREIGN KEY (team_id) REFERENCES team (id) ON DELETE CASCADE;');
        $conn->exec('
ALTER TABLE team_resource_template ADD CONSTRAINT FK_75325B7216131EA FOREIGN KEY (resource_template_id) REFERENCES resource_template (id) ON DELETE CASCADE;');
        $conn->exec('
ALTER TABLE team_site ADD CONSTRAINT FK_B8A2FD9F296CD8AE FOREIGN KEY (team_id) REFERENCES team (id) ON DELETE CASCADE;');
        $conn->exec('
ALTER TABLE team_site ADD CONSTRAINT FK_B8A2FD9FF6BD1646 FOREIGN KEY (site_id) REFERENCES site (id) ON DELETE CASCADE;');
        $conn->exec('
ALTER TABLE team_resource ADD CONSTRAINT FK_4D32868296CD8AE FOREIGN KEY (team_id) REFERENCES team (id) ON DELETE CASCADE;');
        $conn->exec('
ALTER TABLE team_resource ADD CONSTRAINT FK_4D3286889329D25 FOREIGN KEY (resource_id) REFERENCES resource (id) ON DELETE CASCADE;');
    }

    public function uninstall(ServiceLocatorInterface $serviceLocator)
    {
        $conn = $serviceLocator->get('Omeka\Connection');
        $conn->exec('DROP TABLE IF EXISTS team_asset');
        $conn->exec('DROP TABLE IF EXISTS team_user');
        $conn->exec('DROP TABLE IF EXISTS team_role');
        $conn->exec('DROP TABLE IF EXISTS team_resource');
        $conn->exec('DROP TABLE IF EXISTS team_resource_template');
        $conn->exec('DROP TABLE IF EXISTS team_site');
        $conn->exec('DROP TABLE IF EXISTS team');
    }

    public function upgrade($oldVersion, $newVersion, ServiceLocatorInterface $serviceLocator)
    {
        if (version_compare($oldVersion, '1.0.0', '<')) {
            $connection = $serviceLocator->get('Omeka\Connection');

            /*
             * use replace because it is possible for an item and a site to belong to two teams and therefore show up
             * together twice in the join and result in an integrity constraint violation on duplicate primary key in
             * team_site table using insert
             */

            $userSettings = $serviceLocator->get('Omeka\Settings\User');
            $team_users = $connection->fetchAll('select user_id, site_id from team_user tu join team_site ts on ts.team_id = tu.team_id where tu.is_current = true;');
            $user_sites = [];
            foreach ($team_users as $user) {
                if (array_key_exists($user['user_id'], $user_sites)) {
                    array_push($user_sites[$user['user_id']], $user['site_id']);
                } else {
                    $user_sites[$user['user_id']] = [$user['site_id']];
                }
            }

            foreach ($user_sites as $user => $sites) {
                $userSettings->set('default_item_sites', $sites, $user);
            }
            $connection->exec('replace item_site select resource_id, site_id from team_resource tr join team_site ts on tr.team_id = ts.team_id where resource_id in (select * from item)');
        }
        if (version_compare($oldVersion, '2.0.0', '<')) {
            //add the team asset table and foriegn keys
            $conn = $serviceLocator->get('Omeka\Connection');
            $conn->exec('
CREATE TABLE team_asset (team_id INT NOT NULL, asset_id INT NOT NULL, INDEX IDX_C5A9131C296CD8AE (team_id), INDEX IDX_C5A9131C5DA1941 (asset_id), PRIMARY KEY(team_id, asset_id)) DEFAULT CHARACTER SET utf8mb4 COLLATE `utf8mb4_unicode_ci` ENGINE = InnoDB;');
            $conn->exec('
ALTER TABLE team_asset ADD CONSTRAINT FK_C5A9131C296CD8AE FOREIGN KEY (team_id) REFERENCES team (id) ON DELETE CASCADE;');
            $conn->exec('
ALTER TABLE team_asset ADD CONSTRAINT FK_C5A9131C5DA1941 FOREIGN KEY (asset_id) REFERENCES asset (id) ON DELETE CASCADE;');

            /*
             * Create entries for existing assets:
             * There are two objects that use assets as thumbnails, sites and resources. If an asset is being used as a
             * thumbnail, then it needs to have at least one team in common with the site or resource
            */
            $conn = $serviceLocator->get('Omeka\Connection');

            $sql = <<<'SQL'
select asset_id, team_id
from (select asset.id asset_id, team_site.team_id team_id 
		from asset 
        join site 
        on asset.id = site.thumbnail_id 
        join team_site 
        on team_site.site_id = site.id) as site_assets
union
select asset_id, team_id
from (select asset.id asset_id, team_resource.team_id team_id 
		from asset 
        join resource 
        on asset.id = resource.thumbnail_id 
        join team_resource 
        on team_resource.resource_id = resource.id) as resource_assets
        
group by asset_id, team_id;
SQL;
            $res = $conn->fetchAll($sql);
            foreach ($res as $entry) {
                $conn->insert('team_asset', $entry);
            }
        }
        //version naming conventions changed to mirror release versions/core omeka versions
        if (version_compare($oldVersion, '4.0.0', '<')) {
            $conn = $serviceLocator->get('Omeka\Connection');
            $conn->exec('ALTER TABLE team_user MODIFY id INT NOT NULL AUTO_INCREMENT');
        }
        if (version_compare($oldVersion, '4.1.0', '<')) {
            //add global admin to the list of settings for bypass team users
            $globalSettings = $serviceLocator->get('Omeka\Settings');
            $globalSettings->set('teams_filter_bypass_roles', ["global_admin"]);
        }
    }

    public function updateAllUserSites()
    {
        $em = $this->getServiceLocator()->get('Omeka\EntityManager');
        $active_users = $em->getRepository('Teams\Entity\TeamUser')->findAllBy(['is_active' => true]);

        foreach ($active_users as $user) {
            $this->updateUserSites($user->getUser()->getId());
        }
    }

    public function handleConfigForm(AbstractController $controller)
    {
        $globalSettings = $this->getServiceLocator()->get('Omeka\Settings');

        $params = $controller->params()->fromPost();

        $globalSettings->set('teams_site_admin_make_site', $params['teams_site_admin_make_site']);
        $globalSettings->set('teams_editor_make_site', $params['teams_editor_make_site']);
        $globalSettings->set('teams_site_admin_make_user', $params['teams_site_admin_make_user']);
        $globalSettings->set('teams_filter_bypass_roles', $params['teams_filter_bypass_roles']);

    }

    public function getConfigForm(PhpRenderer $renderer)
    {
        $html = '';

        $formElementManager = $this->getServiceLocator()->get('FormElementManager');
        $form = $formElementManager->get(ConfigForm::class, []);
        $html .= $renderer->formCollection($form, false);

        return $html;
    }

    public function createNamedParameter(
        QueryBuilder $qb,
        $value,
        $prefix = 'omeka_'
    ) {
        $index = 0;
        $placeholder = $prefix . $index;
        $index++;
        $qb->setParameter($placeholder, $value);
        return ":$placeholder";
    }

    //TODO need to refactor to normalize and condense
    protected function addAclRules()
    {
        $serviceLocator = $this->getServiceLocator();
        $acl = $serviceLocator->get('Omeka\Acl');
        
        // Get our new service from the service manager
        $aclRuleManager = $serviceLocator->get(\Teams\Service\AclRuleManager::class);

        // Delegate the complex task to our new, testable service
        $aclRuleManager->applyRules($acl);

        // This remaining logic can also be moved to a service in a future refactoring
        $globalSettings = $this->getServiceLocator()->get('Omeka\Settings');
        if (!$globalSettings->get('teams_site_admin_make_site')) {
            $acl->deny('site_admin', \Omeka\Entity\Site::class, 'create');
        }
        if (!$globalSettings->get('teams_editor_make_site')) {
            $acl->deny('editor', \Omeka\Entity\Site::class, 'create');
        }
    }
    /**
     * @param Event $event
     * The default teams behavior is to filter API class, including the ones that populate the available sites in forms.
     * This replaces the default site selector with one that is fully populated with all sites on the user form and adds
     * an option to use teams for default sites instead of manually selecting them.
     */
    public function addDefaultSitesUserForm(Event $event)
    {
        $form = $event->getTarget();
        $settingsFieldset = $form->get('user-settings');
        $userId = $form->getOption('user_id');
        $userSettings = $this->getServiceLocator()->get('Omeka\Settings\User');
        $informationFieldset = $form->get('user-information');

        $settingsFieldset->remove('default_item_sites');

        //ideally we would just swap out the 'type' from the original element, if possible.
        $settingsFieldset->add([
            'name' => 'default_item_sites',
            'type' => AllSiteSelectOrdered::class,
            'attributes' => [
                'value' => $userId ? $userSettings->get('default_item_sites', null, $userId) : [],
                'class' => 'chosen-select',
                'data-placeholder' => 'Select sites', // @translate
                'multiple' => true,
                'id' => 'default_sites',
            ],
            'options' => [
                'label' => 'Default sites for items', // @translate
                'empty_option' => '',

            ],
        ]);
        //        $informationFieldset->add([
        //            'name' => 'update_default_sites',
        //            'type' => 'checkbox',
        //            'options' => [
        //                'label' => 'Use Teams for default sites?', // @translate
        //                'info' => 'Default sites for this user will be those in the selected teams(s) above.', // @translate
        //
        //            ],
        //            'attributes' => [
        //                'id' => 'update_default_sites',
        //                'value' => false,
        //
        //            ],
        //        ]);
    }

    /**
     * Add a tab to section navigation of a admin view.
     *
     * @param Event $event
     */
    public function addTab(Event $event)
    {
        $sectionNav = $event->getParam('section_nav');
        $sectionNav['teams'] = 'Teams'; // @translate
        $event->setParam('section_nav', $sectionNav);
    }

    public function removeTab(Event $event)
    {
        $sectionNav = $event->getParam('section_nav');
        unset($sectionNav['item-pool']);
        $event->setParam('section_nav', $sectionNav);
    }

    /**
     * Displays the teams that a resource belongs to for admin pages.
     *
     * @param Event $event
     */
    public function adminShowTeams(Event $event)
    {
        $resource = $event->getTarget()->vars()->resource;

        $new_item = null;

        $resource_type = $resource->getControllerName();
        $associated_teams = $this->listTeams($resource);

        echo '<div id="teams" class="section"><p>';
        //get the partial and pass it whatever variables it needs

        echo $event->getTarget()->partial(
            'teams/partial/resource-show-teams',
            [
                'teams' => $associated_teams,
                'resource_type' => $resource_type,
            ]
        );

        echo '</div>';
    }

    /**
     * Populates the list of teams users can choose from
     * for the selector on top of browse/index type pages.
     * The selector filters the results on  the page by team.
     *
     * @param Event $event
     */
    public function teamSelectorBrowse(Event $event)
    {
        $identity = $this->getUser();
        $user_id = $identity->getId();
        $view = $event->getTarget();
        $vars = $view->vars();

        if (is_array($vars->resources) && count($vars->resources) > 0) {
            $resource_type = $vars->resources[0]->getControllerName() . 's';
        } elseif (is_array($vars->sites) && count($vars->sites)) {
            $resource_type = 'sites';
        } else {
            $resource_type = null;
        }

        $entityManager = $this->getServiceLocator()->get('Omeka\EntityManager');
        $team_user = $entityManager->getRepository('Teams\Entity\TeamUser');
        $user_teams = $team_user->findBy(['user' => $user_id]);
        $current_team = $team_user->findOneBy(['user' => $user_id,'is_current' => true]);
        if ($current_team) {
            $current_team = $current_team->getTeam()->getName();
        } elseif ($user_teams) {
            $current_team = $team_user->findOneBy(['user' => $user_id]);
            $current_team->setCurrent(true);
            $entityManager->flush();
            $current_team = $current_team->getTeam()->getName();
        } else {
            $current_team = null;
        }

        echo $event->getTarget()->partial(
            'teams/partial/team-selector',
            ['user_teams' => $user_teams, 'current_team' => $current_team, 'resource_type' => $resource_type]
        );
    }
    //TODO need to change language on results page so it is clear which team is being searched against
    /**
     * Populates a team selector on the admin advanced search page for resources
     *
     * @param Event $event
     */
    public function teamSelectorAdvancedSearch(Event $event)
    {
        $identity = $this->getUser();
        $user_id = $identity->getId();

        $entityManager = $this->getServiceLocator()->get('Omeka\EntityManager');
        $team_user = $entityManager->getRepository('Teams\Entity\TeamUser');
        $user_teams = $team_user->findBy(['user' => $user_id]);
        $current_team = $team_user->findOneBy(['user' => $user_id,'is_current' => true]);
        if ($current_team) {
            $current_team = $current_team->getTeam()->getName();
        } else {
            $current_team = null;
        }

        echo $event->getTarget()->partial(
            'teams/partial/team-selector-adv-search',
            ['user_teams' => $user_teams, 'current_team' => $current_team]
        );
    }

    /**
     * Get all the teams a resource belongs to
     *
     * @param AbstractEntityRepresentation|null $resource
     * @return array
     */
    protected function listTeams(AbstractEntityRepresentation $resource = null)
    {
        $result = [];

        $entityManager = $this->getServiceLocator()->get('Omeka\EntityManager');

        $team_resource = $entityManager->getRepository('Teams\Entity\TeamResource')
            ->findBy(['resource' => $resource->id()]);

        foreach ($team_resource as $tr):
            $result[$tr->getTeam()->getName()] = $tr->getTeam();
        endforeach;

        return  $result;
    }

    public function displayUserForm(Event $event)
    {
        $vars = $event->getTarget()->vars();
        $vars->offsetSet('team-members', 'test');
    }

    public function displayTeamForm(Event $event)
    {
        $vars = $event->getTarget()->vars();
        $view = $event->getTarget();
        // Manage add/edit form.
        if (isset($vars->item)) {
            $vars->offsetSet('resource', $vars->item);
        } elseif (isset($vars->itemSet)) {
            $vars->offsetSet('resource', $vars->itemSet);
        } elseif (isset($vars->media)) {
            $vars->offsetSet('resource', $vars->media);
        } else {
            $vars->offsetSet('resource', null);
            $vars->offsetSet('teams', []);
        }
        if ($vars->resource) {
            $vars->offsetSet('teams', $this->listTeams($vars->resource, 'representation'));
        }
        echo $event->getTarget()->partial(
            'teams/partial/team-form',
        );
    }

    /**
     * Allows users to add teams to resources on edit or create.
     * Adds the right side panel selector + options and pass selections to the submission form
     *
     * @param Event $event
     */
    public function displayTeamFormNoId(Event $event)
    {
        $view = $event->getTarget();
        $vars = $event->getTarget()->vars();
        // Manage add/edit form.
        if (isset($vars->item)) {
            $vars->offsetSet('resource', $vars->item);
        } elseif (isset($vars->itemSet)) {
            $vars->offsetSet('resource', $vars->itemSet);
        } elseif (isset($vars->media)) {
            $vars->offsetSet('resource', $vars->media);
        } else {
            $vars->offsetSet('resource', null);
            $vars->offsetSet('teams', []);
        }
        if ($vars->resource) {
            $vars->offsetSet('teams', $this->listTeams($vars->resource, 'representation'));
        }
        $identity = $this->getUser();
        $user_id = $identity->getId();
        $default_team = $this->currentTeam();
        if (! $default_team) {
            $messanger = new Messenger();
            $messanger->addError("You can only make a new resource after you have been added to a team");
            echo '<script>$(\'button:contains("Add")\').prop("disabled",true);</script>';
        }
        $view->headScript()->appendFile($view->assetUrl('js/add-team-to-resource.js', 'Teams'));
        $view->headLink()->appendStylesheet($view->assetUrl('css/teams.css', 'Teams'));
        echo $event->getTarget()->partial(
            'teams/partial/team-form-no-id',
            ['user_id' => $user_id, 'default_team' => $default_team]
        );
    }

    /**
     * Displays a message where the site pool. Not currently used.
     *
     * @param Event $event
     */
    public function displaySitePoolMsg(Event $event)
    {
        echo '
<p class="section" id="team">Site Pools superseded by the Teams Module. This site will have access to all associated Team Resources.</p>
';
    }

    /**
     * Adds the teams partial the the list partials for the advanced search for resources form.
     * Each partial is a form field
     *
     * @param Event $event
     */
    public function advancedSearch(Event $event)
    {
        $partials = $event->getParams()['partials'];
        $partials[] = 'teams/partial/advanced-search';
        $event->setParam('partials', $partials);
    }

    //TODO: refactor to use the currentTeam() function
    //need to use the currentTeam() function

    /**
     * Adds the team selector to the admin navigation
     *
     * @param Event $event
     */
    public function teamSelectorNav(Event $event)
    {
        if (!$this->getServiceLocator()->get('Omeka\Status')->isSiteRequest()) {
            if ($identity = $this->getUser()) {
                $user_id = $identity->getId();
            } else {
                $user_id = null;
            }
            $entityManager = $this->getServiceLocator()->get('Omeka\EntityManager');
            $tu = $entityManager->getRepository('Teams\Entity\TeamUser');
            $ct = $tu->findOneBy(['is_current' => true, 'user' => $user_id]);

            if ($ct) {
                $ct = $ct->getTeam();
            } else {
                $ct = 'None';
            }
            echo $event->getTarget()->partial(
                'teams/partial/team-nav-selector',
                ['current_team' => $ct]
            );
        }
    }

    public function bypassTeamsSortSelector(Event $event)
    {
        $globalSettings = $this->getServiceLocator()->get('Omeka\Settings');
        $roles = $globalSettings->get('teams_filter_bypass_roles');

        if (!is_array($roles)) {
            $roles[] = $roles;
        }

        $user = $this->getUser();
        if ($user && in_array($user->getRole(), $roles)) {
            $view = $event->getTarget();
            $params = $view->params();
            $bypassTeams = $params->fromQuery('bypass_team_filter');
            $view->headScript()->appendFile($view->assetUrl('js/append-sort-selector.js', 'Teams'));
            echo $view->partial('teams/common/sort-selector-bypass-teams', ['bypassTeams' => $bypassTeams]);
        }

    }

    //injects into AbstractEntityAdapter where queries are structured for the api
    public function currentTeam()
    {
        $entityManager = $this->getServiceLocator()->get('Omeka\EntityManager');
        $identity = $this->getUser();
        //TODO add handeling for user not logged-in !!!this current solution would not work
        if (!$identity) {
            $user_id = null;
            return null;
        } else {
            $user_id = $identity->getId();
        }

        //look for their current team
        $team_user = $entityManager->getRepository('Teams\Entity\TeamUser')->findOneBy(['user' => $user_id, 'is_current' => 1]);
        if (!$team_user) {
            $team_user = $entityManager->getRepository('Teams\Entity\TeamUser')->findOneBy(['user' => $user_id]);

            if ($team_user) {
                $team_user->setCurrent('1');
                $entityManager->merge($team_user);
                $entityManager->flush();
            } else {
                return null;
            }
        }
        if ($team_user) {
            $current_team = $team_user->getTeam();
            $team_id = $current_team->getId();
        } else {
            $current_team = null;
            $team_id = 0;
        }
        return $current_team;
    }

    /**
     * Gets team ids to use for filtering that are appropriate for the context. For users browsing resources, the
     * relevant team is the user's current team. For sites, the relevant team(s) are those that the site belongs to.
     *
     * @param $query
     * @param Event $event
     * @return array
     */
    public function getTeamContext($query, Event $event)
    {

        //if the query explicitly asks for a team, that trumps all
        if (isset($query['team_id'])) {
            if (!is_array($query['team_id'])) {
                $team_id = [$query['team_id']];
            }
            foreach ($query['team_id'] as $id):
                if (is_int($id)) {
                    $team_id[] = $id;
                } else {
                    throw new Exception\BadRequestException(sprintf(
                        'team id has to be an integer',
                    ));
                }
            endforeach;
        } elseif ($this->getServiceLocator()->get('Omeka\Status')->isSiteRequest()) { //Logged-in or not, if it is a public site use the TeamSite
            $entityManager = $this->getServiceLocator()->get('Omeka\EntityManager');
            if (isset($query['site_id'])) {
                $team = $entityManager->getRepository('Teams\Entity\TeamSite')
                    ->findBy(['site' => $query['site_id']]);
                if ($team) {
                    foreach ($team as $t):
                        $team_id[] = $t->getTeam()->getId();
                    endforeach;
                } else {
                    $team_id = [0];
                }
            } else {
                $team_id = [0];
            }
        } elseif ($this->getUser() != null) {
            if (isset($query['all_user_teams'])) {
                $userId = $this->getUser()->getId();
                $api = $this->getServiceLocator()->get('Omeka\ApiManager');
                $userTeams = $api->search('team-user', ['user' => $userId], ['returnScalar' => 'team'])->getContent();
                $team_id = array_values($userTeams);
            } elseif (($this->currentTeam())) {
                $team_id[] = $this->currentTeam()->getId();
            }
        }
        return $team_id ?? [0];
    }
    /**
     * Adds a join to API calls for resources and sites to filter results by teams
     *
     * @param Event $event
     */
    public function filterByTeam(Event $event)
    {
        $qb = $event->getParam('queryBuilder');
        $query = $event->getParam('request')->getContent();
        $entityClass = $event->getTarget()->getEntityClass();
        $alias = 'omeka_root';
        $em = $this->getServiceLocator()->get('Omeka\EntityManager');
        $isSiteRequest = $this->getServiceLocator()->get('Omeka\Status')->isSiteRequest();


        //fist, catch some cases where we shouldn't filter by team

        //catch REST queries
        if ($this->getUser() === null) {
            return;
        }

        //most site calls are handled by the site-item relationships, but this is for the list-of-sites block.
        if ($event->getParam('request')->getResource() === 'sites' &&
            $event->getParam('request')->getOperation() === 'search' &&
            $isSiteRequest
        ) {
            //get the id for the current site
            $siteSlug = $this->getServiceLocator()->get('Omeka\Status')->getRouteMatch()->getParam('site-slug');
            $siteId = $em->getRepository('Omeka\Entity\Site')->findOneBy(['slug' => $siteSlug])->getId();

            //get the teams of the current site because we only want to show sites within its teams.
            $teams = $em->getRepository('Teams\Entity\TeamSite')->findBy(['site' => $siteId]);
            $teamIds = [];

            foreach ($teams as $team):
                $teamIds[] = $team->getTeam()->getId();
            endforeach;

            //only get sites that share a team with the current site
            $qb->join('Teams\Entity\TeamSite', 'ts', Expr\Join::WITH, $alias . '.id = ts.site')
                ->andWhere('ts.team IN (:team_ids)')
                ->setParameter('team_ids', $teamIds);
            return;
        }
        // other site requests can be handled by site settings
        if ($isSiteRequest) {
            return true;
        }

        //catch cases where bypass_team_filter is passes, and it is a valid flag for the user's access level or the context,
        // e.g. certain non-admin site requests
        $globalSettings = $this->getServiceLocator()->get('Omeka\Settings');
        $bypassTeamsRilterRoles = $globalSettings->get('teams_filter_bypass_roles');

        if (!is_array($bypassTeamsRilterRoles)) {
            $bypassTeamsRilterRoles[] = $bypassTeamsRilterRoles;
        } else {
            $bypassTeamsRilterRoles = ['global_admin'];
        }
        if (isset($query['bypass_team_filter'])
            && $query['bypass_team_filter']
            && in_array($this->getUser()->getRole(), $bypassTeamsRilterRoles)
        ) {
            return;
        }
        if (isset($query['bypass_team_filter']) && $isSiteRequest) {
            return;
        }
        if (isset($query['resource_class_id']) && $isSiteRequest) {
            return;
        }
        if (isset($query['resource_template_id']) && $isSiteRequest) {
            return;
        }

        //Omeka sets up a way to specifically assign item sets to sites for the Browse by Item Set block.
        //for now just ignoring team filter on that
        //TODO replace the site_item_set with TR join itemset
        if (isset($query['site_id'])) {
            if ($entityClass == 'Omeka\Entity\ItemSet') {
                return;
            } else {
                $team_site = $em->getRepository('Teams\Entity\TeamSite')->findBy(['site' => $query['site_id']]);
                foreach ($team_site as $ts):
                    $team_id[] = $ts->getTeam()->getId();
                endforeach;
                $qb->leftJoin('Teams\Entity\TeamResource', 'tr_si', Expr\Join::WITH, $alias . '.id = tr_si.resource')
                    ->andWhere('tr_si.team = :team_id')
                    ->setParameter('team_id', $team_id[0]);

                if (count($team_id) > 1) {
                    $orX = $qb->expr()->orX();
                    $i = 0;
                    foreach ($team_id as $value) {
                        $orX->add($qb->expr()->eq('tr_si.team', ':name' . $i));
                        $qb->setParameter('name' . $i, $value);
                        $i++;
                    }
                    $qb->orWhere($orX);
                }
            }
            return;
        }

        $team_id = $this->getTeamContext($query, $event);
        if ($team_id === [0]) {
            return;
        }
        if (is_array($team_id)) {
            if ($entityClass == \Omeka\Entity\Site::class) {
                $teamAlias = 'ts';
                $joinCol = 'site';
                $teamsEntityClass = \Teams\Entity\TeamSite::class;
            } elseif ($entityClass == \Omeka\Entity\ResourceTemplate::class) {
                $teamAlias = 'trt';
                $joinCol = 'resource_template';
                $teamsEntityClass = \Teams\Entity\TeamResourceTemplate::class;
            } elseif ($entityClass == \Omeka\Entity\User::class) {
                $teamAlias = 'tu';
                $joinCol = 'user';
                $teamsEntityClass = \Teams\Entity\TeamUser::class;
            } elseif ($entityClass == \Omeka\Entity\Vocabulary::class) {
                return;
            } elseif ($entityClass == \Omeka\Entity\Asset::class) {
                $teamAlias = 'ta';
                $joinCol = 'asset';
                $teamsEntityClass = \Teams\Entity\TeamAsset::class;
            } else {
                $teamAlias = 'tr';
                $teamsEntityClass = \Teams\Entity\TeamResource::class;
                $joinCol = 'resource';
            }
            $qb->leftJoin($teamsEntityClass, $teamAlias, Expr\Join::WITH, "{$alias}.id = {$teamAlias}.{$joinCol}")
                ->andWhere($teamAlias . '.team = :team_id')
                ->setParameter('team_id', $team_id[0]);
            if (count($team_id) > 1) {
                $orX = $qb->expr()->orX();
                $i = 0;
                foreach ($team_id as $value) {
                    $orX->add($qb->expr()->eq("{$teamAlias}.team", ':name' . $i));
                    $qb->setParameter('name' . $i, $value);
                    $i++;
                }
                $qb->orWhere($orX);
            }

        }
    }

    public function getOrphans(Event $event)
    {
        $request = $event->getParam('request')->getContent();
        if(array_key_exists('orphans', $request)) {
            $qb = $event->getParam('queryBuilder');
            $sub = $this->getServiceLocator()->get('Omeka\EntityManager')
                ->createQueryBuilder()
                ->select('tr')
                ->from('Teams\Entity\TeamResource', 'tr');
            $q = $sub->getQuery()->getResult(\Doctrine\ORM\Query::HYDRATE_SCALAR);
            $resource_ids = array_column($q, 'tr_resource_id');
            $qb->andWhere($qb->expr()->notIn('omeka_root.id', $resource_ids));
        }
    }

    /**
     * Adds user's teams to the user view page
     *
     * @param Event $event
     */
    public function userTeamsView(Event $event)
    {
        $view = $event->getTarget();
        $user_id = $view->vars()->user->id();
        $entityManager = $this->getServiceLocator()->get('Omeka\EntityManager');
        $team_users = $entityManager->getRepository('Teams\Entity\TeamUser')->findBy(['user' => $user_id]);

        echo $view->partial('teams/partial/user/view', ['team_users' => $team_users]);
    }

    /**
     * Adds user teams+roles to the user edit form
     *
     * @param Event $event
     */
    public function userTeamsEdit(Event $event)
    {
        //send the form data for processing by module controller to add teamUser
        $view = $event->getTarget();
        $user_id = $view->vars()->user->id();
        $entityManager = $this->getServiceLocator()->get('Omeka\EntityManager');
        $user_teams = $entityManager->getRepository('Teams\Entity\TeamUser')->findBy(['user' => $user_id]);
        $team_ids = [];
        foreach ($user_teams as $user_team):
            $team_ids[] = $user_team->getTeam()->getId();
        endforeach;
        echo $view->partial('teams/partial/user/edit', ['user_teams' => $user_teams, 'team_ids' => $team_ids]);
    }

    //at one point this was fixing a bug but no longer needed. Keeping for reference for now.
    //    /**
    //     * @param Event $event
    //     */
    //    public function userFormEdit(Event $event)
    //    {
    //        $view = $event->getTarget();
    //        echo $view->partial('teams/partial/return_url', 'Teams');
    //    }

    //TODO: make at least one team the user's 'active' team.
    /**
     * When user is created, gets team+role info from the form and creates new TeamUser(s)
     *
     * @param Event $event
     */
    public function userCreate(Event $event)
    {
        $request = $event->getParam('request');
        $operation = $request->getOperation();
        $em = $this->getServiceLocator()->get('Omeka\EntityManager');
        $global = $this->getUser()->getRole() === 'global_admin';

        if ($operation == 'create') {
            $messanger = new Messenger();
            $response = $event->getParam('response');
            $resource = $response->getContent();
            $user_id = $resource->getId();
            $user = $em->getRepository('Omeka\Entity\User')->findOneBy(['id' => $user_id]);
            $teams = $em->getRepository('Teams\Entity\Team');

            $team_ids = $request->getContent()['o-module-teams:Team'];

            //format is  {team_id => role_id}
            $team_role_ids = $request->getContent()['o-module-teams:TeamRole'];
            $default_team = $request->getContent()['o-module-teams:DefaultTeam'];

            foreach ($team_ids as $team_id) {
                $team_id = (int) $team_id;
                //handle new team added via form
                if ($team_id === -1) {
                    if ($global) {
                        $u_name = $request->getContent()['o:name'];
                        $team_name = sprintf("%s's team", $u_name);
                        $team_exists = $em->getRepository('Teams\Entity\Team')->findOneBy(['name' => $team_name]);
                        if ($team_exists) {
                            $messanger->addWarning("The team you tried to add already exists. Added user to the team.");
                            $team = $team_exists;
                        } else {
                            $team = new Team();
                            $team->setName($team_name);
                            $team->setDescription(sprintf('A team automatically generated for new user %s', $u_name));
                            $em->persist($team);
                            $em->flush();
                            if ($default_team == -1) {
                                $default_team = $team->getId();
                            }
                        }
                    } else {
                        $messanger->addError("Only global admins can make new teams");
                    }
                } else {
                    $team = $teams->findOneBy(['id' => $team_id]);
                    if (!$global) {
                        $supervisor_id = $this->getUser()->getId();
                        $auth = $em->getRepository('Teams\Entity\TeamUser')
                            ->findOneBy(['user' => $supervisor_id, 'team' => $team_id])
                            ->getRole()
                            ->getCanAddUsers();
                        if (!$auth) {
                            $messanger->addError(sprintf("You don't have permission to add users to that team %s", $team->getName()));
                            continue;
                        }
                    }
                }
                $role_id = $team_role_ids[$team_id];
                $role = $em->getRepository('Teams\Entity\TeamRole')
                    ->findOneBy(['id' => $role_id]);
                $team_user_exists = $em->getRepository('Teams\Entity\TeamUser')
                    ->findOneBy(['team' => $team->getId(), 'user' => $user_id]);
                if (!$team_user_exists) {
                    $team_user = new TeamUser($team, $user, $role);
                    $em->persist($team_user);
                }
            }
            $em->flush();
            if ($default_team) {
                $em->getRepository('Teams\Entity\TeamUser')
                    ->findOneBy(['team' => $default_team, 'user' => $user_id])
                    ->setCurrent(true)
                ;
                $em->flush();
            }

            //handle user sites
            if ($request->getContent()['update_default_sites']) {

                //handle user sites
                $this->updateUserSites($user_id);
            }
        }
    }

    public function updateItemSites($item_id)
    {
        $em = $this->getServiceLocator()->get('Omeka\EntityManager');

        //get current item sites
        $item = $em->getRepository('Omeka\Entity\Item')
            ->findOneBy(['id' => $item_id]);
        if ($item) {
            //get all teams for the item
            //get all sites associated with those teams
            $item_teams = $em->getRepository('Teams\Entity\TeamResource')->findBy(['resource' => $item_id]);

            $current_teams = [];
            foreach ($item_teams as $team) {
                $current_teams[] = $team->getTeam()->getId();
            }

            $current_team_sites = [];
            foreach ($current_teams as $team) {
                $team_sites = $em->getRepository('Teams\Entity\TeamSite')->findBy(['team' => $team]);

                foreach ($team_sites as $team_site) {
                    $current_team_sites[] = $team_site->getSite()->getId();
                }
            }

            //sync teams and item sites

            $item_sites = $item->getSites();

            $current_item_sites = [];

            foreach ($item_sites as $site) {
                $current_item_sites[] = $site->getId();
            }

            //generate needed changes
            $remove_sites = array_diff($current_item_sites, $current_team_sites);
            $add_sites = array_diff($current_team_sites, $current_item_sites);

            //update item sites
            foreach ($remove_sites as $site) {
                $target_site = $item_sites->get($site);
                $item_sites->removeElement($target_site);
            }

            $siteAdapter = $this->getServiceLocator()->get('Omeka\ApiAdapterManager')->get('sites');
            foreach ($add_sites as $site) {
                $add_site = $siteAdapter->findEntity($site);
                $item_sites->set($add_site->getId(), $add_site);
            }
            $em->flush();
        }
    }

    public function updateUserSites($user_id)
    {
        $em = $this->getServiceLocator()->get('Omeka\EntityManager');

        $userSettings = $this->getServiceLocator()->get('Omeka\Settings\User');

        $site_ids = [];
        $settingId = 'default_item_sites';

        $active_team = $em->getRepository('Teams\Entity\TeamUser')
            ->findOneBy(['user' => $user_id, 'is_current' => true]);
        if ($active_team) {
            $active_team = $active_team->getTeam();

            $team_sites = $active_team->getTeamSites();

            foreach ($team_sites as $team_site):
                $site_ids[] = $team_site->getSite()->getId();
            endforeach;

            //update default sites
            $userSettings->set($settingId, $site_ids, $user_id);
        }
    }

    /**
     * Sets the default value for AutoAssignNewItems to false
     * @param Event $event
     */
    public function siteCreateAutoAssignValue(Event $event)
    {
        $entity = $event->getParam('entity');
        $entity->setAssignNewItems(false);
        $event->setParam('entity', $entity);
    }

    public function assetCreate(Event $event)
    {
        $request = $event->getParam('request');
        $operation = $request->getOperation();
        $em = $this->getServiceLocator()->get('Omeka\EntityManager');
        $response = $event->getParam('response');

        if ($operation == 'create') {
            $resource = $response->getContent();
            $asset_id = $resource->getId();
            $asset = $em->getRepository('Omeka\Entity\Asset')->findOneBy(['id' => $asset_id]);
            $teams = $em->getRepository('Teams\Entity\Team');

            //because this is a sidebar instead of a full form, keeping this simple and just using the current team
            $team = $teams->findOneBy(['id' => $this->currentTeam()]);
            if ($team && $asset) {
                $team_asset = new TeamAsset($team, $asset);
                $em->persist($team_asset);
                $em->flush();
            }
        }
    }

    //    public function assetDelete(Event $event)
    //    {
    //        $request = $event->getParam('request');
    //        $operation = $request->getOperation();
    //        $em = $this->getServiceLocator()->get('Omeka\EntityManager');
    //        $logger = $this->getServiceLocator()->get('Omeka\Logger');
    //
    //        $request->getId();
    //
    //        $response = $event->getParam('response');
    //
    //        if ($operation == 'delete'){
    //            $resource =  $response->getContent();
    //            $asset_id =  $resource->getId();
    //            $asset  = $em->getRepository('Omeka\Entity\Asset')->findOneBy(['id'=>$asset_id]);
    //            $teams =  $em->getRepository('Teams\Entity\Team');
    //
    //            //because this is a sidebar instead of a full form, keeping this simple and just using the current team
    //            $team = $teams->findOneBy(['id' => $this->currentTeam()]);
    //            if ($team && $asset){
    //                $team_asset = new TeamAsset($team, $asset);
    //                $em->persist($team_asset);
    //                $em->flush();
    //            }
    //        }
    //    }

    public function assetDetail(Event $event)
    {
        $view = $event->getTarget();
        $entity = $event->getParam('entity');
        $asset_id = $entity->id();
        $em = $this->getServiceLocator()->get('Omeka\EntityManager');
        $teams = $em->getRepository('Teams\Entity\TeamAsset')->findBy(['asset' => $asset_id]);
        $view->headScript()->prependFile($view->assetUrl('js/asset-delete-warning.js', 'Teams'));
        echo $view->partial(
            'teams/partial/asset/detail',
            [
                'teams' => $teams,
            ]
        );
    }

    public function siteCreate(Event $event)
    {
        $request = $event->getParam('request');
        $operation = $request->getOperation();
        $em = $this->getServiceLocator()->get('Omeka\EntityManager');

        if ($operation === 'create') {
            $response = $event->getParam('response');
            $resource = $response->getContent();
            $site_id = $resource->getId();
            $site = $em->getRepository('Omeka\Entity\Site')->findOneBy(['id' => $site_id]);
            $teams = $em->getRepository('Teams\Entity\Team');

            $team_ids = $request->getContent()['team'];

            $all_teams_users = [];
            $all_team_resources = [];

            //add team sites
            foreach ($team_ids as $team_id):
                $team = $teams->findOneBy(['id' => $team_id]);
                $team_site = new TeamSite($team, $site);
                $em->persist($team_site);

                //get team users
                $all_teams_users[] = $team->getTeamUsers();

                //get team items
                $all_team_resources[] = $team->getTeamResources();

            endforeach;
            $em->flush();

            //update current team users to include new site in their default sites
            foreach ($all_teams_users as $team_users):
                foreach ($team_users as $team_user):
                    if ($team_user->getCurrent()) {
                        $user_id = $team_user->getUser()->getId();
                        $this->updateUserSites($user_id);
                    }

                endforeach;
            endforeach;

            //update all item-site to include all items from the site's teams
            $siteAdapter = $this->getServiceLocator()->get('Omeka\ApiAdapterManager')->get('sites');
            foreach ($all_team_resources as $team_resources):
                foreach ($team_resources as $team_resource):
                    $item = $team_resource->getResource();
                    if ($item->getResourceName() == 'items') {
                        $item_sites = $item->getSites();
                        $site = $siteAdapter->findEntity($site_id);
                        $item_sites->set($site_id, $site);
                    }
                endforeach;
            endforeach;
            $em->flush();
        }
    }

    /**
     * On Team Update, remove all TeamUser entities with user id and generates new ones based. Makes sure user has one
     * team that is set to 'active'.
     *
     * @param Event $event
     */
    public function userUpdate(Event $event)
    {
        $em = $this->getServiceLocator()->get('Omeka\EntityManager');
        $request = $event->getParam('request');
        $target_user = $request->getId();
        $current_user = $this->getUser();

        $operation = $request->getOperation();
        $error_store = $event->getParam('errorStore');

        if ($operation == 'update') {
            $user_id = $request->getId();
            $response = $event->getParam('response');

            //stop if teams aren't part of the update
            if (array_key_exists('o-module-teams:Team', $request->getContent())) {
                //array of team ids

                if ($current_user->getRole() == 'global_admin') {//remove the user's teams
                    $user = $em->getRepository('Omeka\Entity\User')->findOneBy(['id' => $user_id]);

                    $pre_teams = $em->getRepository('Teams\Entity\TeamUser')->findBy(['user' => $user_id]);

                    foreach ($pre_teams as $pre_team):
                        if ($pre_team->getCurrent()) {
                            $current_team_id = $pre_team->getTeam()->getId();
                        }
                        $em->remove($pre_team);
                    endforeach;
                    $em->flush();
                    $current_team_id ??= 0;

                    //add the teams from the form
                    $teams = $em->getRepository('Teams\Entity\Team');
                    $team_ids = [];
                    foreach ($request->getContent()['o-module-teams:Team'] as $team_id):
                        $team_ids[] = (int) $team_id;

                        //adding new team from the user form, indicated by an id of 0
                        if ($team_id == -1) {
                            $u_name = $request->getContent()['o:name'];
                            $team_name = sprintf("%s's team", $u_name);
                            $team_exists = $em->getRepository('Teams\Entity\Team')->findOneBy(['name' => $team_name]);
                            if ($team_exists) {
                                $messanger = new Messenger();
                                $messanger->addWarning("The team you tried to add already exists. Added user to the team.");
                                $team = $team_exists;
                            } else {
                                $team = new Team();
                                $team->setName($team_name);
                                $team->setDescription(sprintf('A team automatically generated for new user %s', $u_name));
                                $em->persist($team);
                                $em->flush();
                            }
                        } else {
                            $team = $teams->findOneBy(['id' => $team_id]);
                        }

                        //get it this way because the roles are added dynamically as js and not part of pre-baked form
                        $role_id = $request->getContent()['o-module-teams:TeamRole'][$team_id];
                        $role = $em->getRepository('Teams\Entity\TeamRole')
                                ->findOneBy(['id' => $role_id]);

                        $team_user_exists = $em->getRepository('Teams\Entity\TeamUser')
                                ->findOneBy(['team' => $team->getId(), 'user' => $user_id]);
                        //TODO: review this section
                        if ($team_user_exists) {
                            echo $team_user_exists->getId();
                        } else {
                            $team_user = new TeamUser($team, $user, $role);
                            $em->persist($team_user);
                            if ($team_id == $current_team_id) {
                                $team_user->setCurrent(true);
                            }
                            $em->persist($team_user);

                            //this is not ideal to flush each iteration, but it is how to check to make sure they didn't
                            //TODO: catch this in chosen-trigger.js instead
                            $em->flush();
                        }

                    endforeach;

                    $em->flush();
                }
                if (array_key_exists('o-module-teams:DefaultTeam', $request->getContent())) {
                    if ($current_user->getRole() == 'global_admin' or $current_user->getId() == $target_user) {
                        $default_team = $request->getContent()['o-module-teams:DefaultTeam'];
                        $new_default_team = $em->getRepository('Teams\Entity\TeamUser')->findOneBy(['user' => $user_id, 'team' => $default_team]);
                        if ($new_default_team) {
                            if ($new_default_team->getCurrent() == null) {

                                //unset the current default team
                                $old_default_team = $em->getRepository('Teams\Entity\TeamUser')
                                    ->findOneBy(['user' => $user_id, 'is_current' => true]);

                                if ($old_default_team) {
                                    //must use null instead of false to keep integrity check for unique user_id+is_current
                                    $old_default_team->setCurrent(null);
                                    $em->persist($old_default_team);
                                    $em->flush();
                                }

                                //set new default
                                $new_default_team->setCurrent(true);
                                $em->persist($new_default_team);
                                $em->flush();
                            }

                        }
                    }
                }

            }
        }

        return;
    }
    public function assetUpdate(Event $event)
    {
        $em = $this->getServiceLocator()->get('Omeka\EntityManager');
        $entity = $event->getParam('entity');
        $request = $event->getParam('request');
        $operation = $request->getOperation();
        $error_store = $event->getParam('errorStore');

        if ($operation === 'update' && array_key_exists('o-module-teams:Team', $request->getContent())) {

            //teams from the form
            $form_teams = $request->getContent()['o-module-teams:Team'];
            $asset_id = $request->getId();

            //teams that asset is a member of
            $team_assets = $em->getRepository('Teams\Entity\TeamAsset')->findBy(['asset' => $asset_id]);

            //array of existing teams ids
            $existing_teams = array_map(function ($team_assets) {
                return $team_assets->getTeam()->getId();
            }, $team_assets);

            $added_teams = array_diff($form_teams, $existing_teams);
            $removed_teams = array_diff($existing_teams, $form_teams);

            foreach ($team_assets as $team_asset):
                if (in_array($team_asset->getTeam()->getId(), $removed_teams)) {
                    $em->remove($team_asset);
                }
            endforeach;
            $em->flush();

            //add teams to the site for each new team listed in the form
            foreach ($added_teams as $team):
                $team_asset = new TeamAsset(
                    $em->getRepository('Teams\Entity\Team')->findOneBy(['id' => $team]),
                    $em->getRepository('Omeka\Entity\Asset')->findOneBy(['id' => $asset_id])
                );
                $em->persist($team_asset);
            endforeach;
            $em->flush();
        }
    }
    public function siteUpdate(Event $event)
    {
        $em = $this->getServiceLocator()->get('Omeka\EntityManager');
        $entity = $event->getParam('entity');
        $request = $event->getParam('request');
        $operation = $request->getOperation();
        $error_store = $event->getParam('errorStore');

        //entity not validated till after this event, so to avoid flushing them with invalid changes, validate here
        $site_entity = new SiteAdapter();

        //point to service locator
        $site_entity->setServiceLocator($this->getServiceLocator());

        //validate hydrated entity
        $site_entity->validateEntity($entity, $error_store);
        if ($error_store->hasErrors()) {
            $validationException = new Exception\ValidationException;
            $validationException->setErrorStore($error_store);
            throw $validationException;
        } else {
            if ($operation === 'update' && array_key_exists('team', $request->getContent())) {
                //teams from the form
                $form_teams = $request->getContent()['team'];
                $site_id = $request->getId();

                //teams that site is a member of
                $team_sites = $em->getRepository('Teams\Entity\TeamSite')->findBy(['site' => $site_id]);

                //array of existing teams ids
                $existing_teams = array_map(function ($team_site) {
                    return $team_site->getTeam()->getId();
                }, $team_sites);

                $added_teams = array_diff($form_teams, $existing_teams);
                $removed_teams = array_diff($existing_teams, $form_teams);

                foreach ($team_sites as $team_site):
                    if (in_array($team_site->getTeam()->getId(), $removed_teams)) {
                        $em->remove($team_site);
                    }
                endforeach;
                $em->flush();

                //add teams to the site for each new team listed in the form
                foreach ($added_teams as $team):
                    $team_site = new TeamSite(
                        $em->getRepository('Teams\Entity\Team')->findOneBy(['id' => $team]),
                        $em->getRepository('Omeka\Entity\Site')->findOneBy(['id' => $site_id])
                    );
                    $em->persist($team_site);
                endforeach;
                $em->flush();

                //get any items or users that need to be updated
                //by either removing or adding item-sits or user default site
                $delta_item_site = [];
                $delta_user_site = [];
                foreach (array_merge($added_teams, $removed_teams) as $team_id) {
                    $delta_item_site[] = $em->getRepository('Teams\Entity\Team')
                        ->findOneBy(['id' => $team_id])
                        ->getTeamResources();
                    $delta_user_site[] = $em->getRepository('Teams\Entity\Team')
                        ->findOneBy(['id' => $team_id])
                        ->getTeamUsers();
                }

                //update current team users to include new site in their default sites
                foreach ($delta_user_site as $team_users) {
                    foreach ($team_users as $team_user) {
                        $user_id = $team_user->getUser()->getId();
                        $this->updateUserSites($user_id);
                    }
                }
                foreach ($delta_item_site as $team_item_collection) {
                    foreach ($team_item_collection as $team_item) {
                        $this->updateItemSites($team_item->getResource()->getId());
                    }
                }
            }
        }
    }

    //Handle Item Sets

    /**
     * Gets the teams submitted in the item set create team and creates new TeamResource entities to represent the
     * relationship between team and item set. Does NOT recursively go through the items and add them as well.
     *
     * @param Event $event
     */
    public function itemSetCreate(Event $event)
    {
        $request = $event->getParam('request');
        $operation = $request->getOperation();
        $em = $this->getServiceLocator()->get('Omeka\EntityManager');

        if ($operation == 'create') {
            $response = $event->getParam('response');

            $resource = $response->getContent();

            $teams = $request->getContent()['add_team'];

            foreach ($teams as $team_id):
                $team = $em->getRepository('Teams\Entity\Team')->findOneBy(['id' => $team_id]);
                $tr = new TeamResource($team, $resource);
                $em->persist($tr);
            endforeach;
            $em->flush();
        }
    }

    //TODO: add validation and report errors
    /**
     * On Item Set update, deletes all TeamResources with item set id and creates new TeamResources based on form data
     *
     * @param Event $event
     */
    public function itemSetUpdate(Event $event)
    {
        $em = $this->getServiceLocator()->get('Omeka\EntityManager');
        $entity = $event->getParam('entity');
        $request = $event->getParam('request');
        $operation = $request->getOperation();
        $error_store = $event->getParam('errorStore');
        $logger = $this->getServiceLocator()->get('Omeka\Logger');

        $teamAuth = new TeamAuth($em, $logger);

        if ($operation == 'update') {
            $resource_id = $request->getId();
            foreach ($request->getContent()['remove_team'] as $team_id) {
                if ($teamAuth->teamAuthorized($this->getUser(), 'delete', 'resource', $team_id)) {
                    $team_resource = $em->getRepository('Teams\Entity\TeamResource')
                        ->findOneBy(['team' => $team_id, 'resource' => $resource_id]);
                    if ($team_resource) {
                        $em->remove($team_resource);
                    }
                }
            }
            $em->flush();
            foreach ($request->getContent()['add_team'] as $team_id) {
                //if the user is authorized to add items to that team
                if ($teamAuth->teamAuthorized($this->getUser(), 'add', 'resource', $team_id)) {
                    $team = $em->getRepository('Teams\Entity\Team')->findOneBy(['id' => $team_id]);
                    if ($team) {
                        $resource = $em->getRepository('Omeka\Entity\Resource')->findOneBy(['id' => $resource_id]);
                        if ($resource) {
                            $team_resource = new TeamResource($team, $resource);
                            $em->persist($team_resource);
                        }
                    }
                }
            }
            $em->flush();

        }
    }

    //Handle Resource Templates. Because Resource templates are not extended from the Resource entity, they are represented
    // by a separate tables in Teams as well.

    /**
     * On create, get teams from Resource Template create form and add new TeamResourceTemplate entities
     *
     * @param Event $event
     */
    public function resourceTemplateCreate(Event $event)
    {
        $request = $event->getParam('request');
        $operation = $request->getOperation();
        $em = $this->getServiceLocator()->get('Omeka\EntityManager');

        if ($operation == 'create') {
            $resource_template = $event->getParam('entity');
            $teams = $em->getRepository('Teams\Entity\Team');
            if (array_key_exists('o-module-teams:Team', $request->getContent())) {
                foreach ($request->getContent()['o-module-teams:Team'] as $team_id) {
                    $team = $teams->findOneBy(['id' => $team_id]);
                    $trt = new TeamResourceTemplate($team, $resource_template);
                    $em->persist($trt);
                    //note: don't flush here or the validation is bypassed, which can cause duplicate name icv, see #146
                }
            } else { # for imports where there is no event triggered, use the users current team
                $team = $em->getRepository('Teams\Entity\Team')->findOneBy(['id' => $this->currentTeam()]);
                $trt = new TeamResourceTemplate($team, $resource_template);
                $em->persist($trt);
                $em->flush();

                $messenger = new Messenger();
                $messenger->addSuccess("Resource Template Imported for your current team");
            }
        }
    }

    /**
     * On update, remove all TeamResourceTemplate entities with ResourceTemplate id and generate new entities based on
     * form data
     *
     * @param Event $event
     */
    public function resourceTemplateUpdate(Event $event)
    {
        $em = $this->getServiceLocator()->get('Omeka\EntityManager');
        $entity = $event->getParam('entity');
        $request = $event->getParam('request');
        $operation = $request->getOperation();
        $error_store = $event->getParam('errorStore');

        if ($operation == 'update') {
            $resource_template_id = $request->getId();
            $resource_template = $em->getRepository('Omeka\Entity\ResourceTemplate')
                ->findOneBy(['id' => $resource_template_id]);

            $pre_teams = $em->getRepository('Teams\Entity\TeamResourceTemplate')
                ->findBy(['resource_template' => $resource_template_id]);

            foreach ($pre_teams as $pre_team):
                $em->remove($pre_team);
            endforeach;
            $em->flush();

            $teams = $em->getRepository('Teams\Entity\Team');
            foreach ($request->getContent()['o-module-teams:Team'] as $team_id):
                $team = $teams->findOneBy(['id' => $team_id]);
                $trt = new TeamResourceTemplate($team, $resource_template);
                $em->persist($trt);
            endforeach;
            $em->flush();
        }
    }

    /**
     * Adds resource template teams to the edit form
     *
     * @param Event $event
     */
    public function resourceTemplateTeamsEdit(Event $event)
    {
        $view = $event->getTarget();
        $rt_id = $view->vars()->resourceTemplate->id();
        $entityManager = $this->getServiceLocator()->get('Omeka\EntityManager');
        $rt_teams = $entityManager->getRepository('Teams\Entity\TeamResourceTemplate')->findBy(['resource_template' => $rt_id]);

        $team_ids = [];
        foreach ($rt_teams as $rt_team):
            $team_ids[] = $rt_team->getTeam()->getId();
        endforeach;
        echo $view->partial('teams/partial/resource-template/edit', ['rt_teams' => $rt_teams, 'team_ids' => $team_ids]);
    }

    /**
     * Adds team field to the resource template add form. Warns users if they don't currently belong to a team
     *
     * @param Event $event
     */
    public function resourceTemplateTeamsAdd(Event $event)
    {
        $view = $event->getTarget();

        if ($has_team = $this->currentTeam()) {
            $team_id = $has_team->getId();
        } else {
            $messanger = new Messenger();
            $messanger->addError("You can only make a resource template after you have been added to a team");
            $team_id = 0;
            echo '<script>$(\'button:contains("Add")\').prop("disabled",true);</script>';
        }
        echo $view->partial('teams/partial/resource-template/add', ['team_id' => $team_id]);
    }

    public function itemDelete(Event $event)
    {
        $itemIds = [];
        if ($event->getParam('resource_ids')) {
            $itemIds = $event->getParam('resource_ids');
        } else {
            $itemIds[] = $event->getParam('entity')->getResource()->getId();
        }

        foreach ($itemIds as $itemId) {
            $this->updateItemSites($itemId);
        }
    }

    /**
     * On update, remove all TeamResources associated with item and associated media, and generate new TeamResources
     * based on form data
     *
     * @param Event $event
     */
    public function itemUpdate(Event $event)
    {
        $em = $this->getServiceLocator()->get('Omeka\EntityManager');
        $entity = $event->getParam('entity');
        $request = $event->getParam('request');
        $operation = $request->getOperation();
        $logger = $this->getServiceLocator()->get('Omeka\Logger');
        $teamAuth = new TeamAuth($em, $logger);
        if ($operation == 'update') {
            if(array_key_exists('remove_team', $request->getContent())) {
                if (!is_array($request->getContent()['remove_team'])) {
                    $remove = [$request->getContent()['remove_team']];
                } else {
                    $remove = $request->getContent()['remove_team'];
                }
            } else {
                $remove = [];
            }

            if(array_key_exists('add_team', $request->getContent())) {
                if (!is_array($request->getContent()['add_team'])) {
                    $add = [$request->getContent()['add_team']];
                } else {
                    $add = $request->getContent()['add_team'];
                }
            } else {
                $add = [];
            }
            if (array_key_exists('remove_team', $request->getContent()) ||
                array_key_exists('add_team', $request->getContent())) {

                //get ids for the item and all of its media
                $resource_ids = [];
                $resource_ids[$request->getId()] = true;
                foreach ($entity->getMedia() as $media) {
                    $resource_ids[$media->getId()] = true;
                }
                foreach ($add as $team_id) {
                    //if the user is authorized to add items to that team
                    if ($teamAuth->teamAuthorized($this->getUser(), 'add', 'resource', $team_id)) {
                        $team = $em->getRepository('Teams\Entity\Team')->findOneBy(['id' => $team_id]);
                        if ($team) {
                            foreach (array_keys($resource_ids) as $resource_id) {
                                $resource = $em->getRepository('Omeka\Entity\Resource')->findOneBy(['id' => $resource_id]);
                                if ($resource) {
                                    $team_resource = new TeamResource($team, $resource);
                                    $em->persist($team_resource);
                                }
                            }
                        }
                    }
                }
                $em->flush();

                foreach ($remove as $team_id) {
                    if ($teamAuth->teamAuthorized($this->getUser(), 'delete', 'resource', $team_id)) {
                        foreach (array_keys($resource_ids) as $resource_id) {
                            $team_resource = $em->getRepository('Teams\Entity\TeamResource')
                                    ->findOneBy(['team' => $team_id, 'resource' => $resource_id]);
                            if ($team_resource) {
                                $em->remove($team_resource);
                            }
                        }
                    }
                    $em->flush();
                }
                //once teams are updated, sync item-site
                $this->updateItemSites($request->getId());
            }
        }
    }

    //for batch update, just use the owner of the resource to get the team
    public function itemBatchCreate(Event $event)
    {
        $request = $event->getParam('request');
        $operation = $request->getOperation();
        $em = $this->getServiceLocator()->get('Omeka\EntityManager');

        if ($operation == 'batch_create') {
            $response = $event->getParam('response');
            $entityManager = $this->getServiceLocator()->get('Omeka\EntityManager');

            $resource = $response->getContent();
            foreach ($resource as $r) {
                $res = $entityManager->getRepository('Omeka\Entity\Resource')->findOneBy(['id' => $r->getId()]);
                $owner = $r->getOwner()->getId();
                $team = $entityManager->getRepository('Teams\Entity\TeamUser')
                    ->findOneBy(['user' => $owner, 'is_current' => 1])->getTeam();

                //todo: don't fail silently
                if ($res && $owner && $team) {
                    $tr = new TeamResource($team, $res);
                    $em->persist($tr);
                    if ($request->getResource() == 'item') {
                        $media = $r->getMedia();
                        //if there is media, add those to the team as well
                        if (count($media) > 0) {
                            foreach ($media as $m):
                                $r = $entityManager->getRepository('Omeka\Entity\Resource')
                                    ->findOneBy(['id' => $m->getId()]);
                                $tr = new TeamResource($team, $r);
                                $em->persist($tr);
                            endforeach;
                        }
                    }

                    $em->flush();
                }
            }
        }
    }

    /**
     * On create, add TeamResource entities for item and associated media based on form data
     *
     * @param Event $event
     */
    public function itemCreate(Event $event)
    {
        $request = $event->getParam('request');
        $operation = $request->getOperation();
        $em = $this->getServiceLocator()->get('Omeka\EntityManager');

        if ($operation == 'create') {
            $response = $event->getParam('response');
            $resource = $response->getContent();
            $team_key = '';
            if (array_key_exists('team', $request->getContent())) {
                $team_key = 'team';
            } elseif (array_key_exists('add_team', $request->getContent())) {
                $team_key = 'add_team';
            }

            if ($team_key) {
                $teams = $request->getContent()[$team_key];
                if (!is_array($teams)) {
                    $teams = [$teams];
                }
                //add items to team
                foreach ($teams as $team_id) {
                    $team = $em->getRepository('Teams\Entity\Team')->findOneBy(['id' => $team_id]);
                    $tr = new TeamResource($team, $resource);
                    $em->persist($tr);

                    //if there is media, add those to the team as well
                    $media = $resource->getMedia();
                    if (count($media) > 0) {
                        foreach ($media as $m):
                            $tr = new TeamResource($team, $m);
                            $em->persist($tr);
                        endforeach;
                    }
                }
                $em->flush();
            }
        }
    }

    public function addTeam(Resource $resource, array $teams)
    {
        $em = $this->getServiceLocator()->get('Omeka\EntityManager');

        foreach (array_keys($teams) as $team_id):
            $team = $em->getRepository('Teams\Entity\Team')->findOneBy(['id' => $team_id]);
            $tr = new TeamResource($team, $resource);
            $em->persist($tr);

            //if there is media, add those to the team as well

            $media = $resource->getMedia();

            if (count($media) > 0) {
                foreach ($media as $m):
                    $tr = new TeamResource($team, $m);
                    $em->persist($tr);
                endforeach;
            }
        endforeach;
        $em->flush();
    }

    public function collectingItemCreate(Event $event)
    {
        $request = $event->getParam('request');
        $em = $this->getServiceLocator()->get('Omeka\EntityManager');
        $services = $this->getServiceLocator();
        $itemId = $request->getContent()['o:item']['o:id'];
        $item = $em->getRepository('Omeka\Entity\Resource')->findOneBy(['id' => $itemId]);
        $sites = $item->getSites();
        $teams = [];

        if ($sites) {
            foreach ($sites as $site) {
                $siteId = $site->getId();
                $teamSites = $em->getRepository('Teams\Entity\TeamSite')->findBy(['site' => $siteId]);
                foreach ($teamSites as $teamSite) {
                    $teamId = $teamSite->getTeam()->getId();
                    $teams[$teamId] = true;
                }
            }
            $this->addTeam($item, $teams);
        }
    }

    //Handle media

    //TODO: should this make sure that media and its associated item don't belong to different teams?
    /**
     * On create, add TeamResource based on information from the form
     *
     * @param Event $event
     */
    public function addMedia(Event $event)
    {
        $request = $event->getParam('request');
        $operation = $request->getOperation();
        $em = $this->getServiceLocator()->get('Omeka\EntityManager');
        $entity = $event->getParam('entity');

        if ($operation == 'create') {
            $item_id = $entity->getItem()->getId();

            $team_resources = $em->getRepository('Teams\Entity\TeamResource')->findBy(['resource' => $item_id]);
            foreach ($team_resources as $team_resource):
                $team = $team_resource->getTeam();
                $tr = new TeamResource($team, $entity);
                $em->persist($tr);
            endforeach;
            $em->flush();
        }
    }

    //Handle sites

    /**
     * Adds team field to the create site form
     *
     * @param Event $event
     */
    public function siteFormAdd(Event $event)
    {
        if ($has_team = $this->currentTeam()) {
            $team_id = $has_team->getId();
        } else {
            $messanger = new Messenger();
            $messanger->addError("You can only make a site after you have been added to a team");
            $team_id = 0;
        }
        $view = $event->getTarget();
        echo $view->partial('teams/partial/site-admin/add.phtml', ['team_ids' => $team_id]);
    }

    /**
     *Adds team field to the edit site form
     *
     * @param Event $event
     */
    public function siteEdit(Event $event)
    {
        $view = $event->getTarget();
        $site_id = $view->vars()->site->id();
        $entityManager = $this->getServiceLocator()->get('Omeka\EntityManager');
        $site_teams = $entityManager->getRepository('Teams\Entity\TeamSite')->findBy(['site' => $site_id]);
        $team_ids = [];
        foreach ($site_teams as $site_team):
            $team_ids[] = $site_team->getTeam()->getId();
        endforeach;
        echo $view->partial('teams/partial/site-admin/edit', ['site_teams' => $site_teams, 'team_ids' => $team_ids]);
    }


    public function getModules()
    {
        $manager = $this->getServiceLocator()->get('Omeka\ModuleManager');
    }

    public function getUser()
    {
        if ($this->getServiceLocator()
            ->get('Omeka\AuthenticationService')->getIdentity()) {
            return $this->getServiceLocator()
                ->get('Omeka\AuthenticationService')->getIdentity();
        } else {
            return null;
        }
    }

    /**
     * Disable the auto-add field on the site edit form. Teams manages this by automatically adding items to the
     * appropriate team.
     * @param Event $event
     */
    public function siteSettingsRemoveAutoAssign(Event $event)
    {
        $event->getTarget()
            ->get('o:assign_new_items')
            ->setOption('info', 'The Teams Module manages how items become associated with sites, so this has been disabled.');
    }

    //Add Team options to Batch Edit

    /**
     * Add  "Add Team" and "Remove Team" select elements to the batch edit form
     * @param Event $event
     */
    public function addTeamToBatchEditForm(Event $event)
    {
        $form = $event->getTarget();
        if ('item' !== $form->getOption('resource_type')) {
            return; // Include elements only on item batch edit.
        }

        $groups = $form->getOption('element_groups');
        $groups['teams'] = 'Teams'; // @translate
        $form->setOption('element_groups', $groups);
        $form->add([
            'type' => TeamSelect::class,
            'name' => 'add_team',
            'options' => [
                'element_group' => 'teams',
                'label' => 'Add resource to Teams', // @translate
                'empty_option' => 'Select a team',
                'chosen' => true,
            ],
            'attributes' => [
                'multiple' => true,
                'data-collection-action' => 'append',
            ],

        ]);
        $form->add([
            'type' => TeamSelect::class,
            'name' => 'remove_team',
            'options' => [
                'element_group' => 'teams',
                'label' => 'Remove resources from teams', // @translate
                'chosen' => true,
            ],
            'attributes' => [
                'multiple' => true,
                'data-collection-action' => 'append',

            ],
        ]);
        $inputFilter = $form->getInputFilter();
        $inputFilter->add([
            'name' => 'remove_team',
            'required' => false,
        ]);
        $inputFilter->add([
            'name' => 'add_team',
            'required' => false,
        ]);
    }

    public function processTeamBatchEditData(Event $event)
    {
        $logger = $this->getServiceLocator()->get('Omeka\Logger');
        $data = $event->getParam('data');
        $rawData = $event->getParam('request')->getContent();

        //add first then remove
        $targets = ['add_team', 'remove_team'];

        foreach ($targets as $teamData) {
            if (isset($rawData[$teamData])) {
                $data[$teamData] = $rawData[$teamData];
            }
        }

        $event->setParam('data', $data);
    }

    public function bypassTeamFilterOnAdvancedSearch(Event $event)
    {
        $globalSettings = $this->getServiceLocator()->get('Omeka\Settings');
        $roles = $globalSettings->get('teams_filter_bypass_roles');

        if (!is_array($roles)) {
            $roles[] = $roles;
        }

        $user = $this->getUser();
        if ($user && in_array($user->getRole(), $roles)) {
            $partials = $event->getParam('partials');
            $partials[] = 'teams/partial/bypass-team-filter-advanced-search-selector';
            $event->setParam('partials', $partials);
        }

    }

    public function attachListeners(SharedEventManagerInterface $sharedEventManager)
    {
        $services = $this->getServiceLocator();

        $sharedEventManager->attach(
            'Omeka\Controller\Admin\Item',
            'view.advanced_search',
            [$this,'bypassTeamFilterOnAdvancedSearch']
        );
        $sharedEventManager->attach(
            'Omeka\Controller\Admin\Query',
            'view.advanced_search',
            [$this, 'bypassTeamFilterOnAdvancedSearch']
        );

        $sharedEventManager->attach(
            \Omeka\Form\UserForm::class,
            'form.add_elements',
            [$this, 'addDefaultSitesUserForm']
        );
        $sharedEventManager->attach(
            '*',
            'view.layout',
            [$this, 'teamSelectorNav']
        );
        $teamFilterable = [
            'Omeka\Controller\Admin\Item',
            'Omeka\Controller\Admin\ItemSet',
            'Omeka\Controller\Admin\ResourceTemplate',
            'Omeka\Controller\Admin\Media',
            'Omeka\Controller\Admin\Asset',
            'Omeka\Controller\Admin\User',
            'Omeka\Controller\SiteAdmin\Index',

        ];
        foreach ($teamFilterable as $controller) {
            $sharedEventManager->attach(
                $controller,
                'view.browse.before',
                [$this, 'bypassTeamsSortSelector']
            );
        }

        $sharedEventManager->attach(
            'Omeka\Controller\Admin\User',
            'view.edit.after',
            [$this, 'userTeamsEdit']
        );

        //        $sharedEventManager->attach(
        //            'Omeka\Controller\Admin\User',
        //            'view.edit.form.after',
        //            [$this, 'userFormEdit']
        //        );

        $sharedEventManager->attach(
            'Omeka\Controller\Admin\User',
            'view.show.after',
            [$this, 'userTeamsView']
        );

        $sharedEventManager->attach(
            'Omeka\Controller\SiteAdmin\Index',
            'view.add.before',
            [$this, 'siteFormAdd']
        );

        $adapters = [
            ItemSetAdapter::class,
            ItemAdapter::class,
            MediaAdapter::class,
            SiteAdapter::class,
            ResourceTemplateAdapter::class,
            AssetAdapter::class,
            UserAdapter::class,

        ];
        foreach ($adapters as $adapter):

            // Add the group filter to the search.
            $sharedEventManager->attach(
                $adapter,
                'api.search.query',
                [$this, 'filterByTeam']
            );

        endforeach;

        $sharedEventManager->attach(
            ItemAdapter::class,
            'api.search.query',
            [$this, 'getOrphans']
        );

        $sharedEventManager->attach(
            'Teams\Controller\Index',
            'view.browse.before',
            [$this, 'teamSelectorBrowse']
        );

        $sharedEventManager->attach(
            ItemSetAdapter::class,
            'api.execute.post',
            [$this, 'itemSetCreate']
        );

        $sharedEventManager->attach(
            ItemAdapter::class,
            'api.execute.post',
            [$this, 'itemCreate']
        );

        //testing for collecting

        $sharedEventManager->attach(
            CollectingItemAdapter::class,
            'api.hydrate.pre',
            [$this, 'collectingItemCreate']
        );

        $sharedEventManager->attach(
            ItemAdapter::class,
            'api.execute.post',
            [$this, 'itemBatchCreate']
        );

        //        $sharedEventManager->attach(
        //            AssetAdapter::class,
        //            'api.delete.pre',
        //            [$this, 'assetDelete']
        //        );

        $sharedEventManager->attach(
            'Omeka\Controller\Admin\Asset',
            'view.details',
            [$this, 'assetDetail']
        );

        $sharedEventManager->attach(
            ItemSetAdapter::class,
            'api.execute.post',
            [$this, 'itemBatchCreate']
        );

        $sharedEventManager->attach(
            UserAdapter::class,
            'api.execute.post',
            [$this, 'userCreate']
        );

        $sharedEventManager->attach(
            SiteAdapter::class,
            'api.execute.post',
            [$this, 'siteCreate']
        );

        $sharedEventManager->attach(
            AssetAdapter::class,
            'api.execute.post',
            [$this, 'assetCreate']
        );

        $sharedEventManager->attach(
            SiteAdapter::class,
            'api.hydrate.post',
            [$this, 'siteCreateAutoAssignValue']
        );

        //only make changes after checking team authority . . . should these two be combined?
        //seems like they probably should because they are looking at similar things . . .
        //unless I really need it to be pre and post hydration . . . which maybe I do?
        $sharedEventManager->attach(
            ItemSetAdapter::class,
            'api.hydrate.post',
            [$this, 'itemSetUpdate']
        );

        $sharedEventManager->attach(
            SiteAdapter::class,
            'api.hydrate.post',
            [$this, 'siteUpdate']
        );

        $sharedEventManager->attach(
            AssetAdapter::class,
            'api.hydrate.post',
            [$this, 'assetUpdate']
        );

        $sharedEventManager->attach(
            UserAdapter::class,
            'api.execute.post',
            [$this, 'userUpdate']
        );

        $sharedEventManager->attach(
            ResourceTemplateAdapter::class,
            'api.execute.post',
            [$this, 'resourceTemplateUpdate']
        );

        $sharedEventManager->attach(
            ResourceTemplateAdapter::class,
            'api.hydrate.post',
            [$this, 'resourceTemplateCreate']
        );

        $sharedEventManager->attach(
            MediaAdapter::class,
            'api.hydrate.post',
            [$this, 'itemSetUpdate']
        );

        $sharedEventManager->attach(
            ItemAdapter::class,
            'api.hydrate.post',
            [$this, 'itemUpdate']
        );

        $sharedEventManager->attach(
            'Teams\Controller\IndexController',
            'api.execute.post',
            [$this, 'itemDelete']
        );

        $sharedEventManager->attach(
            MediaAdapter::class,
            'api.hydrate.post',
            [$this, 'addMedia']
        );

        $sharedEventManager->attach(
            'Teams\Controller\Add',
            'view.add.section_nav',
            [$this, 'displayUserForm']
        );

        //Edit pages//
        //Item//
        $sharedEventManager->attach(
            'Omeka\Controller\Admin\Item',
            'view.edit.section_nav',
            [$this, 'addTab']
        );
        $sharedEventManager->attach(
            'Omeka\Controller\Admin\Item',
            'view.edit.form.after',
            [$this, 'displayTeamForm']
        );

        $sharedEventManager->attach(
            'Omeka\Controller\Admin\Asset',
            'view.edit.form.before',
            [$this, 'addAssetFormElement']
        );

        $sharedEventManager->attach(
            'Omeka\Controller\SiteAdmin\Index',
            'view.add.section_nav',
            [$this, 'removeTab']
        );

        //ItemSet//
        $sharedEventManager->attach(
            'Omeka\Controller\Admin\ItemSet',
            'view.edit.form.after',
            [$this, 'displayTeamForm']
        );
        $sharedEventManager->attach(
            'Omeka\Controller\Admin\ItemSet',
            'view.edit.section_nav',
            [$this, 'addTab']
        );
        //Media//
        $sharedEventManager->attach(
            'Omeka\Controller\Admin\Media',
            'view.edit.form.after',
            [$this, 'displayTeamForm']
        );
        $sharedEventManager->attach(
            'Omeka\Controller\Admin\Media',
            'view.edit.section_nav',
            [$this, 'addTab']
        );
        //            ResourceTemplate//
        $sharedEventManager->attach(
            'Omeka\Controller\Admin\ResourceTemplate',
            'view.add.form.before',
            [$this, 'resourceTemplateForm']
        );
        $sharedEventManager->attach(
            'Omeka\Controller\Admin\ResourceTemplate',
            'view.import.form.before',
            [$this, 'resourceTemplateForm']
        );
        $sharedEventManager->attach(
            'Omeka\Controller\Admin\ResourceTemplate',
            'view.edit.form.before',
            [$this, 'resourceTemplateForm']
        );

        $sharedEventManager->attach(
            'Omeka\Controller\Admin\ResourceTemplate',
            'view.edit.form.before',
            [$this, 'resourceTemplateTeamsEdit']
        );

        $sharedEventManager->attach(
            'Omeka\Controller\Admin\ResourceTemplate',
            'view.add.form.after',
            [$this, 'resourceTemplateTeamsAdd']
        );

        // Show pages //
        //Item//
        $sharedEventManager->attach(
            'Omeka\Controller\Admin\Item',
            'view.show.section_nav',
            [$this, 'addTab']
        );
        $sharedEventManager->attach(
            'Omeka\Controller\Admin\Item',
            'view.show.after',
            [$this, 'adminShowTeams']
        );
        //ItemSet//
        $sharedEventManager->attach(
            'Omeka\Controller\Admin\ItemSet',
            'view.show.section_nav',
            [$this, 'addTab']
        );
        $sharedEventManager->attach(
            'Omeka\Controller\Admin\ItemSet',
            'view.show.after',
            [$this, 'adminShowTeams']
        );
        //Media//
        $sharedEventManager->attach(
            'Omeka\Controller\Admin\Media',
            'view.show.section_nav',
            [$this, 'addTab']
        );
        $sharedEventManager->attach(
            'Omeka\Controller\Admin\Media',
            'view.show.after',
            [$this, 'adminShowTeams']
        );

        //Browse pages//
        //Item//
        $sharedEventManager->attach(
            'Omeka\Controller\Admin\Item',
            'view.browse.before',
            [$this, 'teamSelectorBrowse']
        );
        //ItemSet//
        $sharedEventManager->attach(
            'Omeka\Controller\Admin\ItemSet',
            'view.browse.before',
            [$this, 'teamSelectorBrowse']
        );
        //Media//
        $sharedEventManager->attach(
            'Omeka\Controller\Admin\Media',
            'view.browse.before',
            [$this, 'teamSelectorBrowse']
        );
        //ResourceTemplate//
        $sharedEventManager->attach(
            'Omeka\Controller\Admin\ResourceTemplate',
            'view.browse.before',
            [$this, 'teamSelectorBrowse']
        );
        //Site//
        $sharedEventManager->attach(
            'Omeka\Controller\SiteAdmin\Index',
            'view.browse.before',
            [$this, 'teamSelectorBrowse']
        );

        $sharedEventManager->attach(
            'Omeka\Controller\Admin\Asset',
            'view.browse.before',
            [$this, 'teamSelectorBrowse']
        );

        $sharedEventManager->attach(
            'Omeka\Controller\Admin\User',
            'view.browse.before',
            [$this, 'teamSelectorBrowse']
        );

        //Add pages//
        //ItemSet//
        $sharedEventManager->attach(
            'Omeka\Controller\Admin\ItemSet',
            'view.add.form.after',
            [$this, 'displayTeamFormNoId']
        );
        $sharedEventManager->attach(
            'Omeka\Controller\Admin\ItemSet',
            'view.add.section_nav',
            [$this, 'addTab']
        );
        //Item//
        $sharedEventManager->attach(
            'Omeka\Controller\Admin\Item',
            'view.add.section_nav',
            [$this, 'addTab']
        );

        $sharedEventManager->attach(
            'Omeka\Controller\SiteAdmin\Index',
            'view.add.form.before',
            [$this, 'displaySitePoolMsg']
        );

        $sharedEventManager->attach(
            'Omeka\Controller\Admin\Item',
            'view.add.form.after',
            [$this, 'displayTeamFormNoId']
        );

        //        $sharedEventManager->attach(
        //            'Omeka\Controller\Admin\Item',
        //            'view.add.form.after',
        //            [$this, 'addItemSite']
        //        );

        //Advanced Search//
        $sharedEventManager->attach(
            'Omeka\Controller\Admin\Item',
            'view.advanced_search',
            [$this, 'advancedSearch']
        );

        $sharedEventManager->attach(
            'Omeka\Form\SiteSettingsForm',
            'form.add_elements',
            [$this, 'siteSettingsRemoveAutoAssign']
        );

        $sharedEventManager->attach(
            'Omeka\Controller\Admin\Item',
            'teams.advanced_search',
            [$this, 'teamSelectorAdvancedSearch']
        );

        //Site Pool Item Pool//

        //Advanced Search//
        $sharedEventManager->attach(
            'Omeka\Controller\SiteAdmin\Index',
            'view.advanced_search',
            [$this, 'advancedSearch']
        );

        $sharedEventManager->attach(
            'Omeka\Controller\SiteAdmin\Index',
            'teams.advanced_search',
            [$this, 'teamSelectorAdvancedSearch']
        );

        $sharedEventManager->attach(
            'Omeka\Controller\SiteAdmin\Index',
            'view.edit.after',
            [$this, 'siteEdit']
        );

        //put the roles data in the user page

        $sharedEventManager->attach(
            'Omeka\Controller\Admin\User',
            'view.add.before',
            [$this, 'addRoleFormTemplate']
        );

        $sharedEventManager->attach(
            'Omeka\Controller\Admin\User',
            'view.edit.before',
            [$this, 'addRoleFormTemplate']
        );

        //         Add the team element form to the user form.
        $sharedEventManager->attach(
            \Omeka\Form\UserForm::class,
            'form.add_elements',
            [$this, 'addUserFormElement']
        );

        $sharedEventManager->attach(
            \Omeka\Form\SiteForm::class,
            'form.add_elements',
            [$this, 'addSiteFormElement']
        );

        // Add teams to batch update
        $sharedEventManager->attach(
            'Omeka\Form\ResourceBatchUpdateForm',
            'form.add_elements',
            [$this, 'addTeamToBatchEditForm']
        );

        $sharedEventManager->attach(
            'Omeka\Api\Adapter\ItemAdapter',
            'api.preprocess_batch_update',
            [$this, 'processTeamBatchEditData']
        );
    }

    /**
     * Add team element to the resource template form
     *
     * @param Event $event
     */
    public function resourceTemplateForm(Event $event)
    {
        $form = $event->getTarget()->vars()->form;
        $form->add([

            'name' => 'o-module-teams:Team',
            'type' => TeamSelect::class,
            'options' => [
                'label' => 'Teams', // @translate
                'chosen' => true,
            ],
            'attributes' => [
                'multiple' => true,
                'id' => 'team',
            ],

        ]);
    }

    /**
     * Add team element to the user form
     * @param Event $event
     */
    public function addUserFormElement(Event $event)
    {
        $api = $this->getServiceLocator()->get('Omeka\ApiManager');
        $teams_exist = $api->search('team')->getTotalResults() > 0;
        $roles_exist = $api->search('team-role')->getTotalResults() > 0;

        $user_role = $this->getUser()->getRole();
        $has_team = (bool) $this->currentTeam();
        $global_admin = $user_role === 'global_admin';
        $form = $event->getTarget();

        //don't add the form fields if there are no roles or teams
        if ($teams_exist && $roles_exist) {
            $form->get('user-information')->add([
                'name' => 'o-module-teams:Team',
                'type' => $global_admin ? AllTeamSelect::class : TeamSelect::class,
                'options' => [
                    'label' => 'Teams', // @translate
                    'chosen' => true,
                ],
                'attributes' => [
                    'multiple' => true,
                    'id' => 'team',
                    'required' => $has_team,
                    'data-mutable' => $global_admin,
                ],
            ]);
            $form->get('user-information')->add([
                'name' => 'o-module-teams:DefaultTeam',
                'type' => BlankTeamSelect::class,
                'options' => [
                    'label' => 'Default Team', // @translate
                    'chosen' => true,
                    'info' => 'This is the team the user will see next time they log in. Options are available only after adding Team(s) for the the user.',
                ],
                'attributes' => [
                    'id' => 'default_team',
                    'required' => $has_team,
                ],
            ]);
            $form->get('user-information')->add([
                'name' => 'update_default_sites',
                'type' => 'checkbox',
                'options' => [
                    'label' => 'Use Teams for default sites?', // @translate
                    'info' => 'Default sites for this user will be those in their default team, above.', // @translate

                ],
                'attributes' => [
                    'id' => 'update_default_sites',
                    'value' => true,

                ],
            ]);
            //            this needs to be in here so that the form will push the jQuery created team roles into the request object
            $form->get('user-information')->add([
                'name' => 'o-module-teams:TeamRole',
                'type' => RoleSelect::class,
                'options' => [
                    'label' => ' ', // @translate
                ],
                'attributes' => [
                    'multiple' => true,
                    'id' => 'team_role',
                    'hidden' => 'hidden',
                    'class' => 'hidden_no_value',
                ],
            ]);
        }

        //adjust validation for cases where a user doesn't need to belong to or hasn't yet been added to a team
        if (!$has_team or $global_admin) {
            $inputFilter = $form->getInputFilter();

            $inputFilter->get('user-information')->add([
                'name' => 'o-module-teams:TeamRole',
                'allow_empty' => true,
            ]);
            $inputFilter->get('user-information')->add([
                'name' => 'o-module-teams:DefaultTeam',
                'allow_empty' => true,
            ]);
            $inputFilter->get('user-information')->add([
                'name' => 'o-module-teams:Team',
                'allow_empty' => true,
            ]);

        }

    }

    public function addAssetFormElement(Event $event)
    {
        $asset = $event->getTarget()->vars()->asset;
        $form = $event->getTarget()->vars()->form;
        $em = $this->getServiceLocator()->get('Omeka\EntityManager');
        $assetTeams = $em->getRepository('Teams\Entity\TeamAsset')->findBy(['asset' => $asset->id()]);
        $assetTeamIds = [];
        foreach ($assetTeams as $team) {
            $assetTeamIds[] = $team->getTeam()->getId();
        }

        $form->add([
            'name' => 'o-module-teams:Team',
            'type' => TeamSelect::class,
            'options' => [
                'label' => 'Teams', // @translate
                'chosen' => true,
            ],
            'attributes' => [
                'multiple' => true,
                'id' => 'team',
                'required' => true,
                'value' => $assetTeamIds, //set the actual option for this element
                'data-placeholder' => 'No Teams Assigned Yet',

            ],
        ]);
    }
    /**
     * Add team element to the site form
     *
     * @param Event $event
     */
    public function addSiteFormElement(Event $event)
    {
        $form = $event->getTarget();
        $form->add([
            'name' => 'team',
            'type' => TeamSelect::class,
            'options' => [
                'label' => 'Teams', // @translate
                'chosen' => true,
            ],
            'attributes' => [
                'multiple' => true,
                'id' => 'team_selected',
            ],
        ]);
    }

    /**
     * Add TeamRoles to from
     *
     * @param Event $event
     */
    public function addRoleFormTemplate(Event $event)
    {
        $entityManager = $this->getServiceLocator()->get('Omeka\EntityManager');
        $roles = $entityManager->getRepository('Teams\Entity\TeamRole')->findAll();

        if (count($roles) > 0) {

            //this seems to encode the ids as characters

            foreach ($roles as $role):
                $role_array[$role->getId()] = $role->getName();
            endforeach;
            echo '<script> let role_array = ' . json_encode($role_array) . ' </script>';
            $view = $event->getTarget();

            $view->headScript()->prependFile($view->assetUrl('js/chosen-trigger.js', 'Teams'));
        }
    }
}