diff --git a/docker/docker-compose.dev.yml b/docker/docker-compose.dev.yml
index 92ed06742c..ab6b26bccf 100644
--- a/docker/docker-compose.dev.yml
+++ b/docker/docker-compose.dev.yml
@@ -1,12 +1,112 @@
 ---
+networks:
+  solr:
+
 volumes:
   elasticsearch_data:
   percona_data:
   composer_deps:
   npm_deps:
+  solr-data:
 
 services:
 
+  zoo1:
+    image: zookeeper
+    container_name: zoo1
+    restart: always
+    hostname: zoo1
+    ports:
+      - 2181:2181
+      - 7001:7000
+    environment:
+      ZOO_MY_ID: 1
+      ZOO_SERVERS: server.1=zoo1:2888:3888;2181 server.2=zoo2:2888:3888;2181 server.3=zoo3:2888:3888;2181
+      ZOO_4LW_COMMANDS_WHITELIST: mntr, conf, ruok
+      ZOO_CFG_EXTRA: "metricsProvider.className=org.apache.zookeeper.metrics.prometheus.PrometheusMetricsProvider metricsProvider.httpPort=7000 metricsProvider.exportJvmInfo=true"
+    networks:
+      - solr
+
+  zoo2:
+    image: zookeeper
+    container_name: zoo2
+    restart: always
+    hostname: zoo2
+    ports:
+      - 2182:2181
+      - 7002:7000
+    environment:
+      ZOO_MY_ID: 2
+      ZOO_SERVERS: server.1=zoo1:2888:3888;2181 server.2=zoo2:2888:3888;2181 server.3=zoo3:2888:3888;2181
+      ZOO_4LW_COMMANDS_WHITELIST: mntr, conf, ruok
+      ZOO_CFG_EXTRA: "metricsProvider.className=org.apache.zookeeper.metrics.prometheus.PrometheusMetricsProvider metricsProvider.httpPort=7000 metricsProvider.exportJvmInfo=true"
+    networks:
+      - solr
+
+  zoo3:
+    image: zookeeper
+    container_name: zoo3
+    restart: always
+    hostname: zoo3
+    ports:
+      - 2183:2181
+      - 7003:7000
+    environment:
+      ZOO_MY_ID: 3
+      ZOO_SERVERS: server.1=zoo1:2888:3888;2181 server.2=zoo2:2888:3888;2181 server.3=zoo3:2888:3888;2181
+      ZOO_4LW_COMMANDS_WHITELIST: mntr, conf, ruok
+      ZOO_CFG_EXTRA: "metricsProvider.className=org.apache.zookeeper.metrics.prometheus.PrometheusMetricsProvider metricsProvider.httpPort=7000 metricsProvider.exportJvmInfo=true"
+    networks:
+      - solr
+
+  solr1:
+    image: solr
+    container_name: solr1
+    ports:
+     - "8981:8983"
+    environment:
+      - ZK_HOST=zoo1:2181,zoo2:2181,zoo3:2181
+    networks:
+      - solr
+    depends_on:
+      - zoo1
+      - zoo2
+      - zoo3
+    volumes:
+      - solr-data:/var/solr
+
+  solr2:
+    image: solr
+    container_name: solr2
+    ports:
+     - "8982:8983"
+    environment:
+      - ZK_HOST=zoo1:2181,zoo2:2181,zoo3:2181
+    networks:
+      - solr
+    depends_on:
+      - zoo1
+      - zoo2
+      - zoo3
+    volumes:
+      - solr-data:/var/solr
+
+  solr3:
+    image: solr
+    container_name: solr3
+    ports:
+     - "8983:8983"
+    environment:
+      - ZK_HOST=zoo1:2181,zoo2:2181,zoo3:2181
+    networks:
+      - solr
+    depends_on:
+      - zoo1
+      - zoo2
+      - zoo3
+    volumes:
+      - solr-data:/var/solr
+
   atom:
     build: ..
     env_file: etc/environment
@@ -16,6 +116,8 @@ services:
       - composer_deps:/atom/src/vendor/composer
       - npm_deps:/atom/src/node_modules
       - ..:/atom/src:rw
+    networks:
+      - solr
 
   atom_worker:
     build: ..
@@ -31,6 +133,8 @@ services:
       - composer_deps:/atom/src/vendor/composer
       - npm_deps:/atom/src/node_modules
       - ..:/atom/src:rw
+    networks:
+      - solr
 
   nginx:
     image: nginx:latest
@@ -41,6 +145,8 @@ services:
       - ./etc/nginx/nginx.conf:/etc/nginx/nginx.conf:ro
     ports:
       - "63001:80"
+    networks:
+      - solr
 
   elasticsearch:
     image: docker.elastic.co/elasticsearch/elasticsearch:5.6.16
@@ -53,6 +159,8 @@ services:
       - elasticsearch_data:/usr/share/elasticsearch/data
     ports:
       - "127.0.0.1:63002:9200"
+    networks:
+      - solr
 
   percona:
     image: percona:8.0
@@ -62,14 +170,20 @@ services:
       - ./etc/mysql/mysqld.cnf:/etc/my.cnf.d/mysqld.cnf:ro
     ports:
       - "127.0.0.1:63003:3306"
+    networks:
+      - solr
 
   memcached:
     image: memcached
     command: -p 11211 -m 128 -u memcache
     ports:
       - "127.0.0.1:63004:11211"
+    networks:
+      - solr
 
   gearmand:
     image: artefactual/gearmand
     ports:
       - "127.0.0.1:63005:4730"
+    networks:
+      - solr
diff --git a/lib/search/QubitSearch.class.php b/lib/search/QubitSearch.class.php
index 6c2e4c508a..3feaede32d 100644
--- a/lib/search/QubitSearch.class.php
+++ b/lib/search/QubitSearch.class.php
@@ -23,16 +23,51 @@
 class QubitSearch
 {
     protected static $instance;
+    protected static $solrInstance;
 
     // protected function __construct() { }
     // protected function __clone() { }
 
+    public static function getSolrInstance(array $options = [])
+    {
+        $configuration = ProjectConfiguration::getActive();
+        if (!$configuration->isPluginEnabled('arSolrPlugin')) {
+            return false;
+        }
+
+        if (!isset(self::$solrInstance)) {
+            self::$solrInstance = new arSolrPlugin($options);
+        }
+
+        return self::$solrInstance;
+    }
+
+    public static function disableSolr()
+    {
+        if (!isset(self::$solrInstance)) {
+            self::$solrInstance = self::getSolrInstance(['initialize' => false]);
+        }
+
+        self::$solrInstance->disable();
+    }
+
+    public static function enableSolr()
+    {
+        self::$solrInstance = self::getSolrInstance();
+
+        self::$solrInstance->enable();
+    }
+
     public static function getInstance(array $options = [])
     {
         if (!isset(self::$instance)) {
             // Using arElasticSearchPlugin but other classes could be
             // implemented, for example: arSphinxSearchPlugin
             self::$instance = new arElasticSearchPlugin($options);
+            //$configuration = ProjectConfiguration::getActive();
+            //if ($configuration->isPluginEnabled('arSolrPlugin')) {
+              //self::$solr = new arSolrPlugin($options);
+            //}
         }
 
         return self::$instance;
diff --git a/lib/search/QubitSolrSearchPager.class.php b/lib/search/QubitSolrSearchPager.class.php
new file mode 100644
index 0000000000..27558cdc19
--- /dev/null
+++ b/lib/search/QubitSolrSearchPager.class.php
@@ -0,0 +1,63 @@
+<?php
+
+/*
+ * This file is part of the Access to Memory (AtoM) software.
+ *
+ * Access to Memory (AtoM) is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Access to Memory (AtoM) is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Access to Memory (AtoM).  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+class QubitSolrSearchPager extends sfPager
+{
+    protected $nbResults;
+    protected $resultSet;
+
+    public function __construct(arSolrResultSet $resultSet)
+    {
+        $this->resultSet = $resultSet;
+    }
+
+    /**
+     * @see sfPager
+     */
+    public function init()
+    {
+        $this->setNbResults($this->resultSet->getTotalHits());
+
+        if (0 == $this->getPage() || 0 == $this->getMaxPerPage()) {
+            $this->setLastPage(0);
+        } else {
+            $this->setLastPage(ceil($this->getNbResults() / $this->getMaxPerPage()));
+        }
+    }
+
+    /**
+     * @see sfPager
+     */
+    public function getResults()
+    {
+        // Note: to get results here beyond page 1, you'll need to call $resultSet->setFrom()
+        // prior to this pager's creation.
+        return $this->resultSet->getResults();
+    }
+
+    /**
+     * @see sfPager
+     *
+     * @param mixed $offset
+     */
+    public function retrieveObject($offset)
+    {
+        return array_slice($this->getResults, $offset, 1);
+    }
+}
diff --git a/lib/task/search/arSolrPopulateTask.class.php b/lib/task/search/arSolrPopulateTask.class.php
new file mode 100644
index 0000000000..1c275ca8cb
--- /dev/null
+++ b/lib/task/search/arSolrPopulateTask.class.php
@@ -0,0 +1,108 @@
+<?php
+
+/*
+ * This file is part of the Access to Memory (AtoM) software.
+ *
+ * Access to Memory (AtoM) is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Access to Memory (AtoM) is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Access to Memory (AtoM).  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * Populate search index.
+ */
+class arSolrPopulateTask extends sfBaseTask
+{
+    public function execute($arguments = [], $options = [])
+    {
+        sfContext::createInstance($this->configuration);
+        sfConfig::add(QubitSetting::getSettingsArray());
+
+        // If show-types flag set, show types available to index
+        //if (!empty($options['show-types'])) {
+        //$this->log(sprintf('Available document types that can be excluded: %s', implode(', ', $this->availableDocumentTypes())));
+        //$this->ask('Press the Enter key to continue indexing or CTRL-C to abort...');
+        //}
+
+        new sfDatabaseManager($this->configuration);
+
+        $solr = QubitSearch::getSolrInstance();
+
+        // Index by slug, if specified, or all indexable resources except those with an excluded type
+        //if ($options['slug']) {
+        //$logMessage = (false !== $this->attemptIndexBySlug($options)) ? 'Slug indexed.' : 'Slug not found.';
+        //$this->log($logMessage);
+        //} else {
+        //$populateOptions = [];
+        //$populateOptions['excludeTypes'] = (!empty($options['exclude-types'])) ? explode(',', strtolower($options['exclude-types'])) : null;
+        //$populateOptions['update'] = $options['update'];
+
+        //QubitSearch::getInstance()->populate($populateOptions);
+        //}
+        $populateOptions = [];
+        $populateOptions['excludeTypes'] = (!empty($options['exclude-types'])) ? explode(',', strtolower($options['exclude-types'])) : null;
+        $populateOptions['update'] = $options['update'];
+        $solr->populate($populateOptions);
+    }
+
+    protected function configure()
+    {
+        $this->addOptions([
+            new sfCommandOption('application', null, sfCommandOption::PARAMETER_OPTIONAL, 'The application name', 'qubit'),
+            new sfCommandOption('env', null, sfCommandOption::PARAMETER_REQUIRED, 'The environment', 'cli'),
+            //new sfCommandOption('slug', null, sfCommandOption::PARAMETER_OPTIONAL, 'Slug of resource to index (ignoring exclude-types option).'),
+            //new sfCommandOption('ignore-descendants', null, sfCommandOption::PARAMETER_NONE, "Don't index resource's descendants (applies to --slug option only)."),
+            new sfCommandOption('exclude-types', null, sfCommandOption::PARAMETER_OPTIONAL, 'Exclude document type(s) (command-separated) from indexing'),
+            //new sfCommandOption('show-types', null, sfCommandOption::PARAMETER_NONE, 'Show available document type(s), that can be excluded, before indexing'),
+            new sfCommandOption('update', null, sfCommandOption::PARAMETER_NONE, "Don't delete existing records before indexing."),
+        ]);
+
+        $this->namespace = 'solr';
+        $this->name = 'populate';
+
+        $this->briefDescription = 'Populates the search index';
+        $this->detailedDescription = <<<'EOF'
+The [solr:populate|INFO] task empties, populates, and optimizes the index
+in the current project. It may take quite a while to run.
+
+To exclude a document type, use the --exclude-types option. For example:
+
+  php symfony solr:populate --exclude-types="term,actor"
+
+To see a list of available document types that can be excluded use the --show-types option.
+EOF;
+    }
+
+    //private function availableDocumentTypes()
+    //{
+        //$types = array_keys(QubitSearch::getInstance()->loadMappings()->asArray());
+        //sort($types);
+
+        //return $types;
+    //}
+
+    //private function attemptIndexBySlug($options)
+    //{
+        //// Abort if resource doesn't exist for the provided slug
+        //if (null == $resource = QubitObject::getBySlug($options['slug'])) {
+            //return false;
+        //}
+
+        //// For information objects, allow optional skipping of descendants
+        //if ($resource instanceof QubitInformationObject) {
+            //$options = ['updateDescendants' => !$options['ignore-descendants']];
+            //QubitSearch::getInstance()->update($resource, $options);
+        //} else {
+            //QubitSearch::getInstance()->update($resource);
+        //}
+    //}
+}
diff --git a/lib/task/search/arSolrSearchTask.class.php b/lib/task/search/arSolrSearchTask.class.php
new file mode 100644
index 0000000000..46c8298b88
--- /dev/null
+++ b/lib/task/search/arSolrSearchTask.class.php
@@ -0,0 +1,140 @@
+<?php
+
+/*
+ * This file is part of the Access to Memory (AtoM) software.
+ *
+ * Access to Memory (AtoM) is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Access to Memory (AtoM) is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Access to Memory (AtoM).  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * Populate search index.
+ */
+class arSolrSearchTask extends sfBaseTask
+{
+    public function execute($arguments = [], $options = [])
+    {
+        sfContext::createInstance($this->configuration);
+        sfConfig::add(QubitSetting::getSettingsArray());
+
+        new sfDatabaseManager($this->configuration);
+
+        $solr = new arSolrPlugin($options);
+
+        $this->runSolrQuery($solr, $arguments['query'], (int) $options['rows'], (int) $options['start'], $options['fields'], $options['type']);
+    }
+
+    protected function configure()
+    {
+        $this->addArguments([
+            new sfCommandArgument('query', sfCommandArgument::OPTIONAL, 'Search query.'),
+        ]);
+
+        $this->addOptions([
+            new sfCommandOption('application', null, sfCommandOption::PARAMETER_OPTIONAL, 'The application name', 'qubit'),
+            new sfCommandOption('env', null, sfCommandOption::PARAMETER_REQUIRED, 'The environment', 'cli'),
+            new sfCommandOption('start', null, sfCommandOption::PARAMETER_OPTIONAL, 'Offset for the result set output. 0 by default', 0),
+            new sfCommandOption('rows', null, sfCommandOption::PARAMETER_OPTIONAL, 'Number of rows to return in the results', 5),
+            new sfCommandOption('fields', null, sfCommandOption::PARAMETER_OPTIONAL, 'Fields to query("comma seperated")', null),
+            new sfCommandOption('type', null, sfCommandOption::PARAMETER_OPTIONAL, 'Query type', null),
+        ]);
+
+        $this->namespace = 'solr';
+        $this->name = 'search';
+
+        $this->briefDescription = 'Search the search index for a result';
+        $this->detailedDescription = <<<'EOF'
+The [solr:search] task runs a search query on solr. Usage:
+  php symfony solr:search <query>
+
+To get paginated results, use rows and start. For example:
+  php symfony solr:search fonds --rows=5 --start=10
+
+This wll get 5 search results starting from the 10th result
+
+To search specific fields use the --fields option. For example:
+  php symfony solr:search fonds --fields=QubitInformationObject.i18n.%s.title^10,QubitInformationObject.identifier^5
+
+This will search only i18n.(language code).title and identifier fields and
+boost them by 10 and 5 respectively
+
+EOF;
+    }
+
+    private function createQuery($queryText, $fields)
+    {
+        $query = new arSolrStringQuery(arSolrPluginUtil::escapeTerm($queryText));
+        if ($fields) {
+            $fieldsArr = explode(',', $fields);
+            $newFields = [];
+            foreach ($fieldsArr as $field) {
+                $newField = explode('^', $field);
+                $fieldName = $newField[0];
+                $fieldBoost = $newField[1];
+                if (!$fieldBoost) {
+                    $fieldBoost = 1;
+                }
+                $newFields[$fieldName] = (int) $fieldBoost;
+            }
+            $query->setFields(arSolrPluginUtil::getBoostedSearchFields($newFields));
+        } else {
+            $fields = arSolrPluginUtil::getAllFields('informationObject');
+            $query->setFields(arSolrPluginUtil::getBoostedSearchFields($fields));
+        }
+
+        return $query;
+    }
+
+    private function runSolrQuery($solrInstance, $queryText, $rows, $start, $fields, $type)
+    {
+        $modelType = 'QubitInformationObject';
+        if ('matchall' === $type) {
+            $query = new arSolrMatchAllQuery();
+            $modelType = null;
+        } elseif ('term' === $type) {
+            $term = explode(',', $queryText);
+            $query = new arSolrTermQuery([$term[0] => $term[1]]);
+            $query->setType($modelType);
+        } elseif ('match' === $type) {
+            $queryField = explode(',', $queryText);
+            $query = new arSolrMatchQuery([$queryField[0] => $queryField[1]]);
+            $query->setType($modelType);
+        } elseif ('bool' === $type) {
+            $query = new arSolrBoolQuery();
+            $mustClause = $this->createQuery($queryText, $fields);
+            $mustClause->setType($modelType);
+            $query->addMust($mustClause);
+        } else {
+            $query = $this->createQuery($queryText, $fields);
+            $query->setType($modelType);
+        }
+        $query->setSize($rows);
+        $query->setOffset($start);
+
+        $resultSet = $solrInstance->search($query, $modelType);
+        if ($resultSet->count() > 0) {
+            $docs = $resultSet->getDocuments();
+            foreach ($docs as $resp) {
+                $this->log(sprintf('%s - %s', $resp['id'][0], $resp['i18n']['en']['title']));
+
+                // print entire object if no title is present
+                if (!$resp['i18n']['en']['title']) {
+                    $this->log(var_export($resp, true));
+                }
+            }
+        } else {
+            $this->log('No results found');
+            $this->log(print_r($resultSet->getResults(), true));
+        }
+    }
+}
diff --git a/plugins/arDominionB5Plugin/templates/_header.php b/plugins/arDominionB5Plugin/templates/_header.php
index 88fe6d5e4b..994cfb6c02 100644
--- a/plugins/arDominionB5Plugin/templates/_header.php
+++ b/plugins/arDominionB5Plugin/templates/_header.php
@@ -1,9 +1,13 @@
+<?php if ($sf_context->getConfiguration()->isPluginEnabled('arSolrPlugin')) { ?>
+  <?php include 'plugins/arSolrPlugin/modules/solrPanel/templates/solrMenu.php'; ?>
+<?php } ?>
+
 <div class="visually-hidden-focusable p-3 border-bottom">
   <a class="btn btn-sm btn-secondary" href="#main-column">
     <?php echo __('Skip to main content'); ?>
   </a>
 </div>
-    
+
 <?php echo get_component('default', 'privacyMessage'); ?>
 
 <?php echo get_component('default', 'updateCheck'); ?>
@@ -27,8 +31,8 @@
       </a>
     <?php } ?>
     <button class="navbar-toggler atom-btn-secondary my-2 me-1 px-1" type="button" data-bs-toggle="collapse" data-bs-target="#navbar-content" aria-controls="navbar-content" aria-expanded="false">
-      <i 
-        class="fas fa-2x fa-fw fa-bars" 
+      <i
+        class="fas fa-2x fa-fw fa-bars"
         data-bs-toggle="tooltip"
         data-bs-placement="bottom"
         title="<?php echo __('Toggle navigation'); ?>"
diff --git a/plugins/arSolrPlugin/config/arSolrPluginConfiguration.class.php b/plugins/arSolrPlugin/config/arSolrPluginConfiguration.class.php
new file mode 100644
index 0000000000..793ab24a69
--- /dev/null
+++ b/plugins/arSolrPlugin/config/arSolrPluginConfiguration.class.php
@@ -0,0 +1,60 @@
+<?php
+
+/*
+ * This file is part of the Access to Memory (AtoM) software.
+ *
+ * Access to Memory (AtoM) is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Access to Memory (AtoM) is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Access to Memory (AtoM).  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * arSolrPlugin configuration.
+ */
+class arSolrPluginConfiguration extends sfPluginConfiguration
+{
+    public static $summary = 'Search index plugin that uses Solr to provide search.';
+    public static $version = '1.0.0';
+    public static $configPath = 'plugins/arSolrPlugin/config/search.yml';
+    public static $config;
+    public static $mappingPath = 'config/mapping.yml';
+    public static $mapping;
+
+    /**
+     * @see sfPluginConfiguration
+     */
+    public function initialize()
+    {
+        // Enable arOidcPlugin module
+        $enabledModules = sfConfig::get('sf_enabled_modules');
+        $enabledModules[] = 'arSolrPlugin';
+        sfConfig::set('sf_enabled_modules', $enabledModules);
+
+        if ($this->configuration instanceof sfApplicationConfiguration) {
+            // Use config cache in application context
+            $configCache = $this->configuration->getConfigCache();
+            $configCache->registerConfigHandler(self::$configPath, 'arSolrConfigHandler');
+
+            self::$config = include $configCache->checkConfig(self::$configPath);
+        } else {
+            // Live parsing (task context)
+            self::reloadConfig($this->configuration);
+        }
+    }
+
+    public static function reloadConfig($configuration)
+    {
+        $configPaths = $configuration->getConfigPaths(self::$configPath);
+
+        self::$config = arSolrConfigHandler::getConfiguration($configPaths);
+    }
+}
diff --git a/plugins/arSolrPlugin/config/search.yml b/plugins/arSolrPlugin/config/search.yml
new file mode 100644
index 0000000000..b3c0fc567e
--- /dev/null
+++ b/plugins/arSolrPlugin/config/search.yml
@@ -0,0 +1,311 @@
+all:
+
+  solr:
+
+    # Server defaults to localhost:9200 if omitted
+    host: 'solr1'
+    port: 8983
+    username: 'solr'
+    password: ''
+    collection: 'atom'
+
+  index:
+
+    # This is the name of the index; must be unique
+    name: atom
+
+    configuration:
+
+      number_of_shards: 4
+      number_of_replicas: 1
+      index.mapping.total_fields.limit: 3000
+      index.max_result_window: 10000
+
+      analysis:
+
+        analyzer:
+          text_ar:
+            filter: [lowercase, asciifolding, arabic_normalize, arabic_stem, arabic_stop]
+            tokenizer: solr.StandardTokenizerFactory
+          text_hy:
+            filter: [lowercase, asciifolding, armenian_porter, armenian_stop]
+            tokenizer: solr.StandardTokenizerFactory
+          text_eu:
+            filter: [lowercase, asciifolding, basque_porter, basque_stop]
+            tokenizer: solr.StandardTokenizerFactory
+          text_bg:
+            filter: [lowercase, asciifolding, bulgarian_stem, bulgarian_stop]
+            tokenizer: solr.StandardTokenizerFactory
+          text_ca:
+            filter: [lowercase, asciifolding, catalan_elision, catalan_porter, catalan_stop]
+            tokenizer: solr.StandardTokenizerFactory
+          text_cz:
+            filter: [lowercase, asciifolding, czech_stem, czech_stop]
+            tokenizer: solr.StandardTokenizerFactory
+          text_da:
+            filter: [lowercase, asciifolding, danish_porter, danish_stop]
+            tokenizer: solr.StandardTokenizerFactory
+          text_nl:
+            filter: [lowercase, asciifolding, dutch_porter, dutch_stem, dutch_stop]
+            tokenizer: solr.StandardTokenizerFactory
+          text_en:
+            filter: [lowercase, asciifolding, english_synonyms, english_possessive, english_keyword, english_porter, english_stop]
+            tokenizer: solr.StandardTokenizerFactory
+          text_fi:
+            filter: [lowercase, asciifolding, finnish_porter, finnish_stop]
+            tokenizer: solr.StandardTokenizerFactory
+          text_fr:
+            filter: [lowercase, asciifolding, french_elision, french_stem, french_stop, french_engram]
+            tokenizer: solr.StandardTokenizerFactory
+          text_gl:
+            filter: [lowercase, asciifolding, galician_stem, galician_stop]
+            tokenizer: solr.StandardTokenizerFactory
+          text_de:
+            filter: [lowercase, asciifolding, german_normalize, german_stem, german_stop]
+            tokenizer: solr.StandardTokenizerFactory
+          text_el:
+            filter: [greek_lowercase, asciifolding, greek_stem, greek_stop]
+            tokenizer: solr.StandardTokenizerFactory
+          text_hi:
+            filter: [lowercase, asciifolding, hindi_normalize, hindi_stem, hindi_stop]
+            tokenizer: solr.StandardTokenizerFactory
+          text_hu:
+            filter: [lowercase, asciifolding, hungarian_porter, hungarian_stop]
+            tokenizer: solr.StandardTokenizerFactory
+          text_id:
+            filter: [lowercase, asciifolding, indonesian_stem, indonesian_stop]
+            tokenizer: solr.StandardTokenizerFactory
+          text_it:
+            filter: [lowercase, asciifolding, italian_stem, italian_elision, italian_stop]
+            tokenizer: solr.StandardTokenizerFactory
+          text_no:
+            filter: [lowercase, asciifolding, norwegian_porter, norwegian_stop]
+            tokenizer: solr.StandardTokenizerFactory
+          text_fa:
+            filter: [lowercase, asciifolding, persian_normalize, arabic_normalize, arabic_stop]
+            tokenizer: solr.StandardTokenizerFactory
+          text_pt:
+            filter: [lowercase, asciifolding, portuguese_stem, portuguese_stop]
+            tokenizer: solr.StandardTokenizerFactory
+          text_ro:
+            filter: [lowercase, asciifolding, romanian_porter, romanian_stop]
+            tokenizer: solr.StandardTokenizerFactory
+          text_ru:
+            filter: [lowercase, asciifolding, russian_porter, russian_stop]
+            tokenizer: solr.StandardTokenizerFactory
+          text_es:
+            filter: [lowercase, asciifolding, spanish_stem, spanish_stop]
+            tokenizer: solr.StandardTokenizerFactory
+          text_sv:
+            filter: [lowercase, asciifolding, swedish_porter, swedish_stop]
+            tokenizer: solr.StandardTokenizerFactory
+          text_tr:
+            filter: [lowercase, asciifolding, turkish_porter, turkish_stop]
+            tokenizer: solr.StandardTokenizerFactory
+
+        filter:
+          lowercase:
+            class: solr.LowerCaseFilterFactory
+          asciifolding:
+            class: solr.ASCIIFoldingFilterFactory
+          arabic_normalize:
+            class: solr.ArabicNormalizationFilterFactory
+          arabic_stem:
+            class: solr.ArabicStemFilterFactory
+          arabic_stop:
+            class: solr.StopFilterFactory
+            words: lang/stopwords_ar.txt
+          armenian_porter:
+            class: solr.SnowballPorterFilterFactory
+            language: Armenian
+          armenian_stop:
+            class: solr.StopFilterFactory
+            words: lang/stopwords_hy.txt
+          basque_porter:
+            class: solr.SnowballPorterFilterFactory
+            language: Basque
+          basque_stop:
+            class: solr.StopFilterFactory
+            words: lang/stopwords_eu.txt
+          bulgarian_stem:
+            class: solr.BulgarianStemFilterFactory
+          bulgarian_stop:
+            class: solr.StopFilterFactory
+            words: lang/stopwords_bg.txt
+          catalan_elision:
+            class: solr.ElisionFilterFactory
+            articles: lang/contractions_ca.txt
+          catalan_porter:
+            class: solr.SnowballPorterFilterFactory
+            language: Catalan
+          catalan_stop:
+            class: solr.StopFilterFactory
+            words: lang/stopwords_ca.txt
+          czech_stem:
+            class: solr.CzechStemFilterFactory
+          czech_stop:
+            class: solr.StopFilterFactory
+            words: lang/stopwords_cz.txt
+          danish_porter:
+            class: solr.SnowballPorterFilterFactory
+            language: Danish
+          danish_stop:
+            class: solr.StopFilterFactory
+            words: lang/stopwords_da.txt
+          dutch_porter:
+            class: solr.SnowballPorterFilterFactory
+            language: Dutch
+          dutch_stem:
+            class: solr.StemmerOverrideFilterFactory
+            dictionary: lang/stemdict_nl.txt
+          dutch_stop:
+            class: solr.StopFilterFactory
+            words: lang/stopwords_nl.txt
+          english_synonyms:
+            class: solr.SynonymGraphFilterFactory
+            synonyms: synonyms.txt
+            ignoreCase: true
+          english_possessive:
+            class: solr.EnglishPossessiveFilterFactory
+          english_keyword:
+            class: solr.KeywordMarkerFilterFactory
+            protected: protwords.txt
+          english_porter:
+            class: solr.PorterStemFilterFactory
+          english_stop:
+            class: solr.StopFilterFactory
+            words: lang/stopwords_en.txt
+          finnish_porter:
+            class: solr.SnowballPorterFilterFactory
+            language: Finnish
+          finnish_stop:
+            class: solr.StopFilterFactory
+            words: lang/stopwords_fi.txt
+          french_elision:
+            class: solr.ElisionFilterFactory
+            articles: lang/contractions_fr.txt
+          french_stem:
+            class: solr.FrenchLightStemFilterFactory
+          french_stop:
+            class: solr.StopFilterFactory
+            words: lang/stopwords_fr.txt
+            format: snowball
+          french_engram:
+            class: solr.EdgeNGramFilterFactory
+            minGramSize: 3
+            maxGramSize: 10
+          galician_stem:
+            class: solr.GalicianStemFilterFactory
+          galician_stop:
+            class: solr.StopFilterFactory
+            words: lang/stopwords_gl.txt
+          german_normalize:
+            class: solr.GermanNormalizationFilterFactory
+          german_stem:
+            class: solr.GermanStemFilterFactory
+          german_stop:
+            class: solr.StopFilterFactory
+            words: lang/stopwords_de.txt
+          greek_stem:
+            class: solr.GreekStemFilterFactory
+          greek_lowercase:
+            class: solr.GreekLowerCaseFilterFactory
+          greek_stop:
+            class: solr.StopFilterFactory
+            words: lang/stopwords_el.txt
+          hindi_normalize:
+            class: solr.HindiNormalizationFilterFactory
+          hindi_stem:
+            class: solr.HindiStemFilterFactory
+          hindi_stop:
+            class: solr.StopFilterFactory
+            words: lang/stopwords_hi.txt
+          hungarian_porter:
+            class: solr.SnowballPorterFilterFactory
+            language: Hungarian
+          hungarian_stop:
+            class: solr.StopFilterFactory
+            words: lang/stopwords_hu.txt
+          indonesian_stem:
+            class: solr.IndonesianStemFilterFactory
+            stemDerivational: true
+          indonesian_stop:
+            class: solr.StopFilterFactory
+            words: lang/stopwords_id.txt
+          italian_stem:
+            class: solr.ItalianLightStemFilterFactory
+          italian_elision:
+            class: solr.ElisionFilterFactory
+            articles: lang/contractions_it.txt
+          italian_stop:
+            class: solr.StopFilterFactory
+            words: lang/stopwords_it.txt
+            format: snowball
+          norwegian_porter:
+            class: solr.SnowballPorterFilterFactory
+            language: Norwegian
+          norwegian_stop:
+            class: solr.StopFilterFactory
+            words: lang/stopwords_no.txt
+          persian_normalize:
+            class: solr.PersianNormalizationFilterFactory
+          persian_stop:
+            class: solr.StopFilterFactory
+            words: lang/stopwords_fa.txt
+          portuguese_stem:
+            class: solr.PortugueseLightStemFilterFactory
+          portuguese_stop:
+            class: solr.StopFilterFactory
+            words: lang/stopwords_pt.txt
+          romanian_porter:
+            class: solr.SnowballPorterFilterFactory
+            language: Romanian
+          romanian_stop:
+            class: solr.StopFilterFactory
+            words: lang/stopwords_ro.txt
+          russian_porter:
+            class: solr.SnowballPorterFilterFactory
+            language: Russian
+          russian_stop:
+            class: solr.StopFilterFactory
+            words: lang/stopwords_ru.txt
+          spanish_stem:
+            class: solr.SpanishLightStemFilterFactory
+          spanish_stop:
+            class: solr.StopFilterFactory
+            words: lang/stopwords_es.txt
+          swedish_porter:
+            class: solr.SnowballPorterFilterFactory
+            language: Swedish
+          swedish_stop:
+            class: solr.StopFilterFactory
+            words: lang/stopwords_sv.txt
+          turkish_porter:
+            class: solr.SnowballPorterFilterFactory
+            language: Turkish
+          turkish_stop:
+            class: solr.StopFilterFactory
+            words: lang/stopwords_tr.txt
+
+        char_filter:
+          # This char_filter is added to all analyzers when the index is created
+          # and the app_markdown_enabled setting is set to true. Ideally, the
+          # Markdown tags should be removed with several regex like
+          # in this example: https://github.com/stiang/remove-markdown.
+          # But processing all those regex could run very slowly, so
+          # we're replacing the following punctuation chars by spaces:
+          #     *_#![]()->`+\~:|^=
+          strip_md:
+            class: solr.PatternReplaceFilterFactory
+            pattern: '[\*_#!\[\]\(\)\->`\+\\~:\|\^=]'
+            replacement: ' '
+
+          # Strip punctation from a string
+          punctuation_filter:
+            class: solr.PatternReplaceFilterFactory
+            pattern: '["''_\-\?!\.\(\)\[\]#\*`:;]'
+            replacement: ''
+
+      # Disable dynamic creation of mappings for unmapped types
+      mapper:
+        dynamic: false
diff --git a/plugins/arSolrPlugin/config/solrSchema.yml b/plugins/arSolrPlugin/config/solrSchema.yml
new file mode 100644
index 0000000000..5a146bb27f
--- /dev/null
+++ b/plugins/arSolrPlugin/config/solrSchema.yml
@@ -0,0 +1,636 @@
+# Mapping types
+# http://www.elasticsearch.org/guide/reference/mapping/
+mapping:
+
+  # Special attributes (_attributes):
+  # - i18n: the i18n fields will be added automatically (it is optional)
+  # - i18nExtra: to inherit i18n fields from other table
+  # - autocompleteFields: a list of fields that will be analyzed with edgengram
+  # - rawFields: a list of i18n fields that will include an untouched version (not_analyzed)
+  # - timestamp: adds created_at and updated_at properties
+  # - nested_only: the type will be ignored but embedded within other objects
+
+  # Other notes:
+  # - Field names are camelized
+  # - Objects can be embedded using _foreign_types, allowing hierarchal data within a document:
+  #   note that if a "child" type itself embeds other types then the "child" type must be defined
+  #   in this file before the "parent" type or the ElasticSearch mapping won't be properly set
+  #   and indexing errors may result
+  # - Objects can be embedded using _patial_foreign_types, specifying properties and i18n fields
+  # - The other matters, embedded types must be defined first
+
+  #
+  # Nested only (they are not considered types)
+  #
+
+  contact_information:
+    _attributes:
+      rawFields: [region, city]
+      i18n: true
+      i18nExtra: [actor]
+      timestamp: true
+      nested_only: true
+    dynamic: strict
+    properties:
+      contact_person: { type: keyword, multivalue: true }
+      street_address: { type: text, index: false, multivalue: true }
+      postal_code: { type: text, include_in_all: false, multivalue: true }
+      country_code: { type: keyword, include_in_all: false, multivalue: true }
+      location: { type: geo_point, multivalue: true }
+
+  other_name:
+    _attributes:
+      i18n: true
+      nested_only: true
+    _partial_foreign_types:
+      type:
+        _i18nFields: [name]
+        dynamic: strict
+    dynamic: strict
+    properties:
+      source_culture: { type: text, multivalue: true }
+
+  note:
+    _attributes:
+      i18n: true
+      nested_only: true
+    dynamic: strict
+
+  event:
+    _attributes:
+      i18n: true
+      nested_only: true
+    dynamic: strict
+    type: nested
+    properties:
+      start_date: { type: date, include_in_all: false, multivalue: true }
+      end_date: { type: date, include_in_all: false, multivalue: true }
+      start_date_string: { type: keyword, multivalue: true }
+      end_date_string: { type: keyword, multivalue: true }
+      type_id: { type: integer, include_in_all: false, multivalue: true }
+      actor_id: { type: integer, include_in_all: false, multivalue: true }
+
+  relation:
+    _attributes:
+      nested_only: true
+    dynamic: strict
+    type: nested
+    properties:
+      object_id: { type: integer, include_in_all: false, multivalue: true }
+      subject_id: { type: integer, include_in_all: false, multivalue: true }
+      type_id: { type: integer, include_in_all: false, multivalue: true }
+
+  accession_event:
+    _attributes:
+      i18n: true
+      nested_only: true
+    _partial_foreign_types:
+      type:
+        _i18nFields: [name]
+        dynamic: strict
+      notes:
+        _i18nFields: [content]
+        dynamic: strict
+    dynamic: strict
+    properties:
+      date: { type: date, include_in_all: false, multivalue: true }
+      date_string: { type: keyword, multivalue: true }
+
+  donor:
+    _attributes:
+      i18n: true
+      i18nExtra: [actor]
+      nested_only: true
+    _foreign_types: { contact_informations: contact_information }
+    dynamic: strict
+    properties:
+      slug: { type: keyword }
+
+  basis_right:
+    _attributes:
+      nested_only: true
+    dynamic: strict
+    properties:
+      basis: { type: text, include_in_all: false }
+      start_date: { type: date, include_in_all: false }
+      end_date: { type: date, include_in_all: false }
+      copyright_status: { type: text, include_in_all: false }
+      rights_holder: { type: text, include_in_all: false }
+      rights_note: { type: text, include_in_all: false }
+      license_terms: { type: text, include_in_all: false }
+
+  act_right:
+    _attributes:
+      nested_only: true
+    dynamic: strict
+    properties:
+      act: { type: text, include_in_all: false }
+      restriction: { type: text, include_in_all: false }
+      start_date: { type: date, include_in_all: false }
+      end_date: { type: date, include_in_all: false }
+
+  mediainfo_track:
+    _attributes:
+      nested_only: true
+    dynamic: strict
+    properties:
+      count: { type: integer, include_in_all: false }
+      video_format_list: { type: keyword, include_in_all: false }
+      video_format_with_hint_list: { type: keyword, include_in_all: false }
+      codecs_video: { type: keyword, include_in_all: false }
+      video_language_list: { type: keyword, include_in_all: false }
+      audio_format_list: { type: keyword, include_in_all: false }
+      audio_format_with_hint_list: { type: keyword, include_in_all: false }
+      audio_codecs: { type: keyword, include_in_all: false }
+      audio_language_list: { type: keyword, include_in_all: false }
+      complete_name: { type: keyword, include_in_all: false }
+      file_name: { type: keyword, include_in_all: false }
+      file_extension: { type: keyword, include_in_all: false }
+      format: { type: keyword, include_in_all: false }
+      format_info: { type: keyword, include_in_all: false }
+      format_url: { type: keyword, include_in_all: false }
+      format_profile: { type: keyword, include_in_all: false }
+      format_settings: { type: keyword, include_in_all: false }
+      format_settings_cabac: { type: keyword, include_in_all: false }
+      format_settings_re_frames: { type: integer, include_in_all: false }
+      format_settings_gop: { type: keyword, include_in_all: false }
+      format_extensions_usually_used: { type: keyword, include_in_all: false }
+      commercial_name: { type: keyword, include_in_all: false }
+      internet_media_type: { type: keyword, include_in_all: false }
+      codec_id: { type: keyword, include_in_all: false }
+      codec_id_info: { type: keyword, include_in_all: false }
+      codec_id_url: { type: keyword, include_in_all: false }
+      codec: { type: keyword, include_in_all: false }
+      codec_family: { type: keyword, include_in_all: false }
+      codec_info: { type: keyword, include_in_all: false }
+      codec_url: { type: keyword, include_in_all: false }
+      codec_cc: { type: keyword, include_in_all: false }
+      codec_profile: { type: keyword, include_in_all: false }
+      codec_settings: { type: keyword, include_in_all: false }
+      codec_settings_cabac: { type: keyword, include_in_all: false }
+      codec_settings_ref_frames: { type: integer, include_in_all: false }
+      codec_extensions_usually_used: { type: keyword, include_in_all: false }
+      file_size: { type: long, include_in_all: false }
+      duration: { type: integer, include_in_all: false }
+      bit_rate: { type: integer, include_in_all: false }
+      bit_rate_mode: { type: keyword, include_in_all: false }
+      overall_bit_rate: { type: integer, include_in_all: false }
+      channels: { type: integer, include_in_all: false }
+      channel_positions: { type: keyword, include_in_all: false }
+      sampling_rate: { type: integer, include_in_all: false }
+      samples_count: { type: integer, include_in_all: false }
+      compression_mode: { type: keyword, include_in_all: false }
+      width: { type: integer, include_in_all: false }
+      height: { type: integer, include_in_all: false }
+      pixel_aspect_ratio: { type: float, include_in_all: false }
+      display_aspect_ratio: { type: keyword, include_in_all: false }
+      rotation: { type: float, include_in_all: false }
+      frame_rate_mode: { type: keyword, include_in_all: false }
+      frame_rate: { type: float, include_in_all: false }
+      frame_count: { type: integer, include_in_all: false }
+      resolution: { type: integer, include_in_all: false }
+      colorimetry: { type: keyword, include_in_all: false }
+      color_space: { type: keyword, include_in_all: false }
+      chroma_subsampling: { type: keyword, include_in_all: false }
+      bit_depth: { type: integer, include_in_all: false }
+      scan_type: { type: keyword, include_in_all: false }
+      interlacement: { type: keyword, include_in_all: false }
+      bits_pixel_frame: { type: float, include_in_all: false }
+      stream_size: { type: long, include_in_all: false }
+      proportion_of_this_stream: { type: float, include_in_all: false }
+      header_size: { type: long, include_in_all: false }
+      data_size: { type: long, include_in_all: false }
+      footer_size: { type: long, include_in_all: false }
+      language: { type: keyword, include_in_all: false }
+      color_primaries: { type: keyword, include_in_all: false }
+      transfer_characteristics: { type: keyword, include_in_all: false }
+      matrix_coefficients: { type: keyword, include_in_all: false }
+      is_streamable: { type: boolean, include_in_all: false }
+      writing_application: { type: keyword, include_in_all: false }
+      file_last_modification_date: { type: date, include_in_all: false }
+      file_last_modification_date_local: { type: date, include_in_all: false }
+
+  mediainfo:
+    _attributes:
+      nested_only: true
+    _foreign_types:
+      general_tracks: mediainfo_track
+      video_tracks: mediainfo_track
+      audio_tracks: mediainfo_track
+
+  mets_data:
+    _attributes:
+      nested_only: true
+    _foreign_types:
+      mediainfo: mediainfo
+    dynamic: strict
+    properties:
+      puid: { type: keyword, include_in_all: false }
+      filename: { type: keyword, include_in_all: false }
+      last_modified: { type: date, include_in_all: false }
+      date_ingested: { type: date, include_in_all: false }
+      size: { type: long, include_in_all: false }
+      mime_type: { type: keyword, include_in_all: false }
+      audio:
+        type: object
+        properties:
+          bit_depth: { type: integer, include_in_all: false }
+          sample_rate: { type: keyword, include_in_all: false }
+          channels: { type: integer, include_in_all: false }
+          data_encoding: { type: keyword, include_in_all: false }
+          offset: { type: integer, include_in_all: false }
+          byte_order: { type: keyword, include_in_all: false }
+      document:
+        type: object
+        properties:
+          title: { type: keyword, include_in_all: false }
+          author: { type: keyword, include_in_all: false }
+          page_count: { type: integer, include_in_all: false }
+          word_count: { type: integer, include_in_all: false }
+          character_count: { type: integer, include_in_all: false }
+          language: { type: keyword, include_in_all: false }
+          is_protected: { type: boolean, include_in_all: false }
+          is_rights_managed: { type: boolean, include_in_all: false }
+          is_tagged: { type: boolean, include_in_all: false }
+          has_outline: { type: boolean, include_in_all: false }
+          has_annotations: { type: boolean, include_in_all: false }
+          has_forms: { type: boolean, include_in_all: false }
+      text:
+        type: object
+        properties:
+          linebreak: { type: keyword, include_in_all: false }
+          charset: { type: keyword, include_in_all: false }
+          markup_basis: { type: keyword, include_in_all: false }
+          markup_basis_version: { type: keyword, include_in_all: false }
+          markup_language: { type: keyword, include_in_all: false }
+      format_identification_event:
+        type: object
+        properties:
+          type: { type: keyword, include_in_all: false }
+          dateTime: { type: date, include_in_all: false }
+          detail: { type: keyword, include_in_all: false }
+          outcome: { type: keyword, include_in_all: false }
+          outcomeDetailNote: { type: keyword, include_in_all: false }
+          linkingAgentIdentifier:
+            type: object
+            properties:
+              type: { type: keyword, include_in_all: false }
+              value: { type: keyword, include_in_all: false }
+      other_events:
+        type: object
+        properties:
+          type: { type: keyword, include_in_all: false }
+          dateTime: { type: date, include_in_all: false }
+          detail: { type: keyword, include_in_all: false }
+          outcome: { type: keyword, include_in_all: false }
+          outcomeDetailNote: { type: keyword, include_in_all: false }
+          linkingAgentIdentifier:
+            type: object
+            properties:
+              type: { type: keyword, include_in_all: false }
+              value: { type: keyword, include_in_all: false }
+      agents:
+        type: object
+        properties:
+          identifier_type: { type: keyword, include_in_all: false }
+          identifier_value: { type: keyword, include_in_all: false }
+          name: { type: keyword, include_in_all: false }
+          type: { type: keyword, include_in_all: false }
+      format:
+        type: object
+        properties:
+          name: { type: keyword, include_in_all: false }
+          version: { type: keyword, include_in_all: false }
+          registry_name: { type: keyword, include_in_all: false }
+          registry_key: { type: keyword, include_in_all: false }
+
+  physical_object:
+    _attributes:
+      i18n: true
+      nested_only: true
+    dynamic: strict
+
+  property:
+    _attributes:
+      i18n: true
+      nested_only: true
+    dynamic: strict
+
+  premis_object:
+    _attributes:
+      nested_only: true
+    _foreign_types:
+      mets_data: mets_data
+
+  #
+  # Main types
+  #
+
+  aip:
+    _partial_foreign_types:
+      part_of:
+        _i18nFields: [title]
+        dynamic: strict
+    _foreign_types:
+      type: term
+      digital_objects: premis_object
+    dynamic: strict
+    properties:
+      uuid: { type: keyword, include_in_all: false }
+      filename: { type: keyword, include_in_all: false }
+      size_on_disk: { type: long, include_in_all: false }
+      digital_object_count: { type: integer, include_in_all: false }
+      created_at: { type: date, include_in_all: false }
+
+  term:
+    _attributes:
+      i18n: true
+      timestamp: true
+      autocompleteFields: [name]
+      rawFields:  [name]
+      sortFields: [name]
+    _foreign_types: { use_for: other_name, scope_notes: note }
+    dynamic: strict
+    properties:
+      slug: { type: keyword }
+      taxonomy_id: { type: integer, include_in_all: false, multivalue: true }
+      is_protected: { type: boolean, include_in_all: false, multivalue: true }
+      number_of_descendants: { type: integer, include_in_all: false, multivalue: true }
+
+  actor:
+    _attributes:
+      i18n: true
+      timestamp: true
+      autocompleteFields: [authorizedFormOfName]
+      rawFields:  [authorizedFormOfName]
+      sortFields: [authorizedFormOfName]
+    _foreign_types:
+      maintenance_notes: note
+      other_names: other_name
+      parallel_names: other_name
+      standardized_names: other_name
+      subjects: term
+      places: term
+      actor_relations: relation
+    _partial_foreign_types:
+      occupations:
+        _i18nFields: [name, content]
+        dynamic: strict
+        properties:
+          id: { type: integer, multivalue: true }
+    dynamic: strict
+    properties:
+      slug: { type: keyword }
+      description_identifier:
+        type: text
+        fields:
+          untouched:
+            type: keyword
+      corporate_body_identifiers: { type: keyword }
+      entity_type_id: { type: integer, include_in_all: false }
+      maintaining_repository_id: { type: integer, include_in_all: false }
+      direct_subjects: { type: integer, include_in_all: false }
+      direct_places: { type: integer, include_in_all: false }
+      actor_direct_relation_types: { type: integer, include_in_all: false, multivalue: true }
+      has_digital_object: { type: boolean, include_in_all: false }
+      digital_object:
+        type: object
+        properties:
+          media_type_id: { type: integer, include_in_all: false }
+          usage_id: { type: integer, include_in_all: false }
+          thumbnail_path: { type: keyword }
+          filename: { type: text }
+          digital_object_alt_text: { type: text }
+
+  accession:
+    _attributes:
+      i18n: true
+      timestamp: true
+      rawFields:  [title]
+      sortFields: [title]
+    _partial_foreign_types:
+      creators:
+        _i18nFields: [authorizedFormOfName]
+        dynamic: strict
+        properties:
+          id: { type: integer, multivalue: true }
+        _foreign_types:
+          other_names: other_name
+          parallel_names: other_name
+          standardized_names: other_name
+    _foreign_types:
+      accession_events: accession_event
+      alternative_identifiers: other_name
+      donors: donor
+    dynamic: strict
+    properties:
+      slug: { type: keyword }
+      identifier:
+        type: text
+        fields:
+          untouched:
+            type: keyword
+      date: { type: date, include_in_all: false }
+
+  repository:
+    _attributes:
+      i18n: true
+      i18nExtra: [actor, contact_information]
+      timestamp: true
+      autocompleteFields: [authorizedFormOfName]
+      rawFields:  [authorizedFormOfName, region, city]
+      sortFields: [authorizedFormOfName]
+    _foreign_types:
+      contact_informations: contact_information
+      other_names: other_name
+      parallel_names: other_name
+    dynamic: strict
+    properties:
+      slug: { type: keyword }
+      identifier:
+        type: text
+        fields:
+          untouched:
+            type: keyword
+      types: { type: integer, include_in_all: false, multivalue: true }
+      geographic_subregions: { type: integer, include_in_all: false, multivalue: true }
+      thematic_areas: { type: integer, include_in_all: false, multivalue: true }
+      logo_path: { type: keyword, include_in_all: false }
+
+  function_object:
+    _attributes:
+      i18n: true
+      timestamp: true
+      rawFields:  [authorizedFormOfName]
+    _foreign_types:
+      other_names: other_name
+      parallel_names: other_name
+    dynamic: strict
+    properties:
+      slug: { type: keyword }
+      description_status_id: { type: integer }
+      description_detail_id: { type: integer }
+      description_identifier:
+        type: text
+        fields:
+          untouched:
+            type: keyword
+
+  information_object:
+    _attributes:
+      i18n: true
+      timestamp: true
+      autocompleteFields: [title]
+      rawFields:  [title]
+      sortFields: [title]
+      # Select which foreign type i18n fields we'll include when searching _all
+      i18nIncludeInAll:
+        - repository.authorizedFormOfName
+        - names.authorizedFormOfName
+        - names.otherNames.name
+        - names.parallelNames.name
+        - names.standardizedNames.name
+        - creators.authorizedFormOfName
+        - creators.history
+        - creators.otherNames.name
+        - creators.parallelNames.name
+        - creators.standardizedNames.name
+        - inheritedCreators.authorizedFormOfName
+        - inheritedCreators.otherNames.name
+        - inheritedCreators.parallelNames.name
+        - inheritedCreators.standardizedNames.name
+        - subjects.name
+        - places.name
+        - genres.name
+        - generalNotes.content
+        - alphaNumericNotes.content
+        - conservationNotes.content
+        - physicalDescriptionNotes.content
+        - continuationOfTitleNotes.content
+        - archivistsNotes.content
+        - publicationNotes.content
+    _partial_foreign_types:
+      part_of:
+        _i18nFields: [title]
+        dynamic: strict
+        properties:
+          id: { type: integer }
+          slug: { type: keyword }
+      repository:
+        _i18nFields: [authorizedFormOfName]
+        _rawFields: [authorizedFormOfName]
+        dynamic: strict
+        properties:
+          id: { type: integer }
+          slug: { type: keyword }
+          identifier: { type: keyword }
+      names:
+        _i18nFields: [authorizedFormOfName]
+        dynamic: strict
+        properties:
+          id: { type: integer, multivalue: true }
+        _foreign_types:
+          other_names: other_name
+          parallel_names: other_name
+          standardized_names: other_name
+      creators:
+        _i18nFields: [authorizedFormOfName, history]
+        dynamic: strict
+        properties:
+          id: { type: integer, multivalue: true }
+        _foreign_types:
+          other_names: other_name
+          parallel_names: other_name
+          standardized_names: other_name
+      inherited_creators:
+        _i18nFields: [authorizedFormOfName]
+        dynamic: strict
+        properties:
+          id: { type: integer, multivalue: true }
+        _foreign_types:
+          other_names: other_name
+          parallel_names: other_name
+          standardized_names: other_name
+      subjects:
+        _i18nFields: [name]
+        dynamic: strict
+        properties:
+          id: { type: integer }
+      places:
+        _i18nFields: [name]
+        dynamic: strict
+        properties:
+          id: { type: integer, multivalue: true }
+      genres:
+        _i18nFields: [name]
+        dynamic: strict
+        properties:
+          id: { type: integer, multivalue: true }
+    _foreign_types:
+      dates: event
+      aip: aip
+      mets_data: mets_data
+      act_rights: act_right
+      basis_rights: basis_right
+      title_statement_of_responsibility: property
+      general_notes: note
+      alpha_numeric_notes: note
+      conservation_notes: note
+      physical_description_notes: note
+      continuation_of_title_notes: note
+      archivists_notes: note
+      publication_notes: note
+    dynamic: strict
+    properties:
+      slug: { type: keyword }
+      identifier:
+        type: text
+        fields:
+          untouched:
+            type: keyword
+      reference_code_without_country_and_repo: { type: keyword }
+      level_of_description_id: { type: integer }
+      lft: { type: integer }
+      publication_status_id: { type: integer }
+      parent_id: { type: integer, include_in_all: false }
+      ancestors: { type: integer, include_in_all: false, multivalue: true }
+      children: { type: integer, include_in_all: false, multivalue: true }
+      copyright_status_id: { type: integer, include_in_all: false }
+      material_type_id: { type: integer, include_in_all: false, multivalue: true }
+      transcript: { type: text, include_in_all: true }
+      direct_subjects: { type: integer, include_in_all: false, multivalue: true }
+      direct_places: { type: integer, include_in_all: false, multivalue: true }
+      direct_genres: { type: integer, include_in_all: false, multivalue: true }
+      has_digital_object: { type: boolean, include_in_all: false }
+      finding_aid:
+        type: object
+        properties:
+          transcript: { type: text, include_in_all: true }
+          status: { type: integer, include_in_all: false }
+      digital_object:
+        type: object
+        properties:
+          media_type_id: { type: integer, include_in_all: false }
+          usage_id: { type: integer, include_in_all: false }
+          thumbnail_path: { type: keyword }
+          filename: { type: text }
+          digital_object_alt_text: { type: text }
+      alternative_identifiers:
+        type: object
+        properties:
+          label: { type: text, multivalue: true }
+          identifier: { type: text, multivalue: true }
+      reference_code:
+        type: text
+        fields:
+          untouched:
+            type: keyword
+          autocomplete:
+            type: text
+            analyzer: autocomplete
+            store: true
+            search_analyzer: standard
+            term_vector: with_positions_offsets
+      # Not nested date fields for sorting
+      start_date_sort: { type: date, include_in_all: false }
+      end_date_sort: { type: date, include_in_all: false }
diff --git a/plugins/arSolrPlugin/lib/arSolrConfigHandler.class.php b/plugins/arSolrPlugin/lib/arSolrConfigHandler.class.php
new file mode 100644
index 0000000000..52f9087843
--- /dev/null
+++ b/plugins/arSolrPlugin/lib/arSolrConfigHandler.class.php
@@ -0,0 +1,52 @@
+<?php
+
+/*
+ * This file is part of the Access to Memory (AtoM) software.
+ *
+ * Access to Memory (AtoM) is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Access to Memory (AtoM) is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Access to Memory (AtoM).  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * arSolrConfigHandler.
+ */
+class arSolrConfigHandler extends sfYamlConfigHandler
+{
+    /**
+     * Executes this configuration handler.
+     *
+     * @param array $configFiles An array of absolute filesystem path to a configuration file
+     *
+     * @return string Data to be written to a cache file
+     */
+    public function execute($configFiles)
+    {
+        // Parse the yaml
+        $config = self::getConfiguration($configFiles);
+
+        // Compile data
+        $retval = "<?php\n"
+            ."// auto-generated by %s\n"
+            ."// date: %s\nreturn %s;\n";
+
+        return sprintf($retval, __CLASS__, date('Y/m/d H:i:s'), var_export($config, true));
+    }
+
+    /**
+     * @see sfConfigHandler
+     */
+    public static function getConfiguration(array $configFiles)
+    {
+        return self::replaceConstants(self::flattenConfigurationWithEnvironment(self::parseYamls($configFiles)));
+    }
+}
diff --git a/plugins/arSolrPlugin/lib/arSolrMapping.class.php b/plugins/arSolrPlugin/lib/arSolrMapping.class.php
new file mode 100644
index 0000000000..49c077347f
--- /dev/null
+++ b/plugins/arSolrPlugin/lib/arSolrMapping.class.php
@@ -0,0 +1,580 @@
+<?php
+
+/*
+ * This file is part of Qubit Toolkit.
+ *
+ * Qubit Toolkit is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Qubit Toolkit is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Qubit Toolkit.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+class arSolrMapping
+{
+    /**
+     * Inner objects.
+     *
+     * @return array
+     */
+    protected $nestedTypes;
+
+    /**
+     * Associative array that maps iso639-1 language codes to the different
+     * analyzers that have been defined in search.yml for each stopword list
+     * provided by Solr.
+     */
+    private static $analyzers = [
+        'ar' => 'arabic',
+        'hy' => 'armenian',
+        'ba' => 'basque',
+        'br' => 'brazilian',
+        'bg' => 'bulgarian',
+        'ca' => 'catalan',
+        'cz' => 'czech',
+        'da' => 'danish',
+        'nl' => 'dutch',
+        'en' => 'english',
+        'fi' => 'finnish',
+        'fr' => 'french',
+        'gl' => 'galician',
+        'ge' => 'german',
+        'el' => 'greek',
+        'hi' => 'hindi',
+        'hu' => 'hungarian',
+        'id' => 'indonesian',
+        'it' => 'italian',
+        'no' => 'norwegian',
+        'fa' => 'persian',
+        'pt' => 'portuguese',
+        'ro' => 'romanian',
+        'ru' => 'russian',
+        'es' => 'spanish',
+        'sv' => 'swedish',
+        'tr' => 'turkish',
+    ];
+
+    /**
+     * Dumps schema as array.
+     *
+     * @return array
+     */
+    public function asArray()
+    {
+        return $this->mapping;
+    }
+
+    /**
+     * Load mapping from array.
+     *
+     * @param array $mapping_array
+     */
+    public function loadArray($mapping_array)
+    {
+        if (is_array($mapping_array) && !empty($mapping_array)) {
+            if (count($mapping_array) > 1) {
+                throw new sfException('A mapping.yml must only contain 1 entry.');
+            }
+
+            // Direct access to mapping
+            $this->mapping = $mapping_array['mapping'];
+
+            $this->camelizeFieldNames();
+
+            $this->fixYamlShorthands();
+
+            $this->excludeNestedOnlyTypes();
+
+            $this->addMultivalueExceptions();
+        }
+    }
+
+    /**
+     * Load mapping from YAML file.
+     *
+     * @param string $file
+     */
+    public function loadYAML($file)
+    {
+        $mapping_array = sfYaml::load($file);
+
+        if (!is_array($mapping_array)) {
+            return; // No defined schema here, skipping
+        }
+
+        $this->loadArray($mapping_array);
+    }
+
+    /**
+     * Clean YAML shorthands recursively.
+     *
+     * We have some special YAML properties in mapping.yml that we only use internally
+     * to indicate foreign types, special attributes, etc. This method will remove those
+     * from the mappings array, which is necessary since when we generate our ES schema
+     * we don't want to send those special properties in the mapping.
+     *
+     * @param array mapping  A reference to our ES YAML mappings
+     * @param null|mixed $mapping
+     */
+    public function cleanYamlShorthands(&$mapping = null)
+    {
+        // If no parameter is passed, $this->mapping will be used
+        if (null === $mapping) {
+            $mapping = &$this->mapping;
+        }
+
+        foreach ($mapping as $key => &$value) {
+            switch ($key) {
+                case '_attributes':
+                case '_foreign_types':
+                case '_partial_foreign_types':
+                case '_i18nFields':
+                    unset($mapping[$key]);
+
+                    break;
+
+                default:
+                    if (is_array($value)) {
+                        $this->cleanYamlShorthands($value);
+                    }
+
+                    break;
+            }
+        }
+    }
+
+    /*
+     * Given a class name (eg. Repository or QubitRepostiroy), returns
+     * an array of i18n fields
+     */
+    public static function getI18nFields($class)
+    {
+        // Use table maps to find existing i18n columns
+        $className = str_replace('Qubit', '', $class).'I18nTableMap';
+
+        // Ignore models without i18n table that will include i18nExtra (donors)
+        if (!class_exists($className)) {
+            return [];
+        }
+
+        $map = new $className();
+
+        $fields = [];
+        foreach ($map->getColumns() as $column) {
+            if (!$column->isPrimaryKey() && !$column->isForeignKey()) {
+                $colName = $column->getPhpName();
+
+                $fields[] = $colName;
+            }
+        }
+
+        return $fields;
+    }
+
+    public static function getAnalyzer($culture)
+    {
+        if (isset(self::$analyzers[$culture])) {
+            return self::$analyzers[$culture];
+        }
+
+        // Default to standard analyzer
+        return 'standard';
+    }
+
+    /**
+     * Camelize field names by creating and unsetting array items recursively.
+     * Only properties are camelized, other attributes are ignored.
+     *
+     * @param null|mixed $mapping
+     */
+    protected function camelizeFieldNames(&$mapping = null)
+    {
+        // If no parameter is passed, $this->mapping will be used
+        if (null === $mapping) {
+            $mapping = &$this->mapping;
+        }
+
+        foreach ($mapping as $key => &$value) {
+            $camelized = lcfirst(sfInflector::camelize($key));
+
+            // Rename only if the camelized version is different
+            // Also, omit first recursion (type names)
+            if ($camelized != $key) {
+                // Create new item with the camelized version of the key
+                $mapping[$camelized] = $value;
+
+                // Drop the old item from the array
+                unset($mapping[$key]);
+            }
+
+            // Recurse this function over narrow items if available
+            if (isset($value['properties'])) {
+                $this->camelizeFieldNames($value['properties']);
+            }
+        }
+    }
+
+    /**
+     * Fixes YAML shorthands.
+     */
+    protected function fixYamlShorthands()
+    {
+        // First, process special attributes
+        foreach ($this->mapping as $typeName => &$typeProperties) {
+            $this->processPropertyAttributes($typeName, $typeProperties);
+        }
+
+        // Next iteration to embed partial foreign types
+        foreach ($this->mapping as $typeName => &$typeProperties) {
+            $this->processPartialForeignTypes($typeProperties);
+        }
+
+        // Next iteration to embed nested types
+        foreach ($this->mapping as $typeName => &$typeProperties) {
+            $this->processForeignTypes($typeProperties);
+        }
+    }
+
+    /**
+     * Given a mapping, it parses its special attributes and update it accordingly.
+     *
+     * @param mixed $typeName
+     */
+    protected function processPropertyAttributes($typeName, array &$typeProperties)
+    {
+        // Stop execution if any special attribute was set
+        if (!isset($typeProperties['_attributes'])) {
+            return;
+        }
+
+        // Look for special attributes like i18n or timestamp and update the
+        // mapping accordingly. For example, 'timestamp' adds the created_at
+        // and updated_at fields each time is used.
+        foreach ($typeProperties['_attributes'] as $attributeName => $attributeValue) {
+            switch ($attributeName) {
+                case 'i18n':
+                    $languages = sfConfig::get('app_i18n_languages');
+                    if (1 > count($languages)) {
+                        throw new sfException('No i18n_languages in database settings.');
+                    }
+
+                    $this->setIfNotSet($typeProperties['properties'], 'sourceCulture', ['type' => 'keyword', 'include_in_all' => false]);
+
+                    // We are using the same mapping for all the i18n fields
+                    $nestedI18nFields = [];
+                    foreach ($this->getI18nFields(lcfirst(sfInflector::camelize($typeName))) as $fieldName) {
+                        $nestedI18nFields[$fieldName] = $this->getI18nFieldMapping($fieldName);
+                    }
+
+                    if (isset($typeProperties['_attributes']['i18nExtra'])) {
+                        foreach ($typeProperties['_attributes']['i18nExtra'] as $extraClass) {
+                            foreach ($this->getI18nFields(lcfirst(sfInflector::camelize($extraClass))) as $fieldName) {
+                                $nestedI18nFields[$fieldName] = $this->getI18nFieldMapping($fieldName);
+                            }
+                        }
+                    }
+
+                    if (isset($typeProperties['_attributes']['autocompleteFields'])) {
+                        foreach ($typeProperties['_attributes']['autocompleteFields'] as $item) {
+                            $nestedI18nFields[$item]['fields']['autocomplete'] = [
+                                'type' => 'text',
+                                'analyzer' => 'autocomplete',
+                                'search_analyzer' => 'standard',
+                                'store' => 'true',
+                                'term_vector' => 'with_positions_offsets',
+                            ];
+                        }
+                    }
+
+                    if (isset($typeProperties['_attributes']['rawFields'])) {
+                        foreach ($typeProperties['_attributes']['rawFields'] as $item) {
+                            $nestedI18nFields[$item]['fields']['untouched'] = ['type' => 'keyword'];
+                        }
+                    }
+
+                    $nestedI18nFields = $this->addSortFields($nestedI18nFields, $typeProperties);
+
+                    // i18n documents (one per culture)
+                    $nestedI18nObjects = $this->getNestedI18nObjects($languages, $nestedI18nFields);
+
+                    // Main i18n object
+                    $this->setIfNotSet($typeProperties['properties'], 'i18n', [
+                        'type' => 'object',
+                        'dynamic' => 'strict',
+                        'include_in_root' => true,
+                        'properties' => $nestedI18nObjects,
+                    ]);
+
+                    break;
+
+                case 'timestamp':
+                    $this->setIfNotSet($typeProperties['properties'], 'createdAt', ['type' => 'date']);
+                    $this->setIfNotSet($typeProperties['properties'], 'updatedAt', ['type' => 'date']);
+
+                    break;
+            }
+        }
+    }
+
+    /**
+     * Given a mapping, adds other objects within it.
+     */
+    protected function processForeignTypes(array &$typeProperties)
+    {
+        // Stop execution if any foreign type was assigned
+        if (!isset($typeProperties['_foreign_types'])) {
+            return;
+        }
+
+        foreach ($typeProperties['_foreign_types'] as $fieldName => $foreignTypeName) {
+            $fieldNameCamelized = lcfirst(sfInflector::camelize($fieldName));
+            $foreignTypeNameCamelized = lcfirst(sfInflector::camelize($foreignTypeName));
+
+            if (!isset($this->mapping[$foreignTypeNameCamelized])) {
+                throw new sfException("{$foreignTypeName} could not be found within the mappings.");
+            }
+
+            $mapping = $this->mapping[$foreignTypeNameCamelized];
+
+            // Add id of the foreign resource
+            $mapping['properties']['id'] = ['type' => 'integer', 'include_in_all' => 'false'];
+
+            $typeProperties['properties'][$fieldNameCamelized] = $mapping;
+        }
+    }
+
+    /**
+     * Given a mapping, adds partial foreign objects within it.
+     */
+    protected function processPartialForeignTypes(array &$typeProperties)
+    {
+        // Stop execution if any partial foreign type was assigned
+        if (!isset($typeProperties['_partial_foreign_types'])) {
+            return;
+        }
+
+        foreach ($typeProperties['_partial_foreign_types'] as $fieldName => $mapping) {
+            $fieldNameCamelized = lcfirst(sfInflector::camelize($fieldName));
+
+            if (isset($mapping['_i18nFields'])) {
+                $languages = sfConfig::get('app_i18n_languages');
+                if (1 > count($languages)) {
+                    throw new sfException('The database settings do not contain any languages.');
+                }
+
+                // Add source culture property
+                $this->setIfNotSet($mapping['properties'], 'sourceCulture', ['type' => 'keyword', 'include_in_all' => false]);
+
+                $nestedI18nFields = [];
+                foreach ($mapping['_i18nFields'] as $i18nFieldName) {
+                    $i18nFieldNameCamelized = lcfirst(sfInflector::camelize($i18nFieldName));
+
+                    // Create mapping for i18n field
+                    $nestedI18nFields[$i18nFieldNameCamelized] = $this->getI18nFieldMapping($i18nFieldNameCamelized);
+                }
+
+                // Add 'untouched' when _rawFields specified in _partial_foreign_types section
+                if (isset($mapping['_rawFields'])) {
+                    foreach ($mapping['_rawFields'] as $item) {
+                        $nestedI18nFields[$item]['fields']['untouched'] = ['type' => 'keyword'];
+                    }
+                    unset($mapping['_rawFields']);
+                }
+
+                // i18n documents (one per culture)
+                $nestedI18nObjects = $this->getNestedI18nObjects($languages, $nestedI18nFields);
+
+                // Main i18n object
+                $this->setIfNotSet($mapping['properties'], 'i18n', [
+                    'type' => 'object',
+                    'dynamic' => 'strict',
+                    'include_in_root' => true,
+                    'properties' => $nestedI18nObjects,
+                ]);
+            }
+
+            if (isset($mapping['_foreign_types'])) {
+                $this->processForeignTypes($mapping);
+            }
+
+            // Add id of the partial foreign resource
+            // TODO: Fix multivalue property to be only added to the partial foreign types that have this set to true in the yml
+            $mapping['properties']['id'] = ['type' => 'integer', 'include_in_all' => 'false', 'multivalue' => true];
+
+            $typeProperties['properties'][$fieldNameCamelized] = $mapping;
+        }
+    }
+
+    /**
+     * Exclude nested types if there are not root objects using them.
+     */
+    protected function excludeNestedOnlyTypes()
+    {
+        // Iterate over types (actor, information_object, ...)
+        foreach ($this->mapping as $typeName => $typeProperties) {
+            // Pass if nested_only is not set
+            if (!isset($typeProperties['_attributes']['nested_only'])) {
+                continue;
+            }
+
+            unset($this->mapping[$typeName]);
+        }
+    }
+
+    /**
+     * Sets entry if not set.
+     *
+     * @param string $entry
+     * @param string $key
+     * @param string $value
+     */
+    protected function setIfNotSet(&$entry, $key, $value)
+    {
+        if (!isset($entry[$key])) {
+            $entry[$key] = $value;
+        }
+    }
+
+    protected function getI18nFieldMapping($fieldName)
+    {
+        return [
+            'type' => 'text',
+            'include_in_all' => true,
+        ];
+    }
+
+    protected function getNestedI18nObjects($languages, $nestedI18nFields)
+    {
+        $mapping = [];
+        foreach ($languages as $culture) {
+            // Iterate each field and assign a custom standard analyzer (e.g.
+            // std_french in search.yml) based in the language being used. The default
+            // analyzer is standard, which does not provide a stopwords list.
+            foreach ($nestedI18nFields as $fn => &$fv) {
+                $fv['analyzer'] = self::getAnalyzer($culture);
+            }
+            unset($fv);
+
+            $mapping[$culture] = [
+                'type' => 'object',
+                'dynamic' => 'strict',
+                'include_in_parent' => false,
+                'properties' => $nestedI18nFields,
+            ];
+        }
+
+        // Create a list of languages for aggregations
+        $mapping['languages'] = ['type' => 'keyword'];
+
+        return $mapping;
+    }
+
+    /**
+     * Add "alphasort" Elasticsearch fields.
+     *
+     * Add i18n "alphasort" keyword field that is lowercase, has punctation
+     * stripped, and is ASCII folded to allow more natural alphabetic sorting
+     *
+     * @param mixed $nestedI18nFields
+     * @param mixed $typeProperties
+     */
+    protected function addSortFields($nestedI18nFields, $typeProperties)
+    {
+        if (!isset($typeProperties['_attributes']['sortFields'])) {
+            return $nestedI18nFields;
+        }
+
+        foreach ($typeProperties['_attributes']['sortFields'] as $item) {
+            $nestedI18nFields[$item]['fields']['alphasort'] = [
+                'type' => 'keyword',
+                'normalizer' => 'alphasort',
+                'include_in_all' => false,
+            ];
+        }
+
+        return $nestedI18nFields;
+    }
+
+    protected function addMultivalueExceptions()
+    {
+        $multivalueFields = [
+            'QubitInformationObject.dates.sourceCulture',
+            'QubitInformationObject.names.otherNames.sourceCulture',
+            'QubitInformationObject.creators.otherNames.sourceCulture',
+            'QubitInformationObject.inheritedCreators.otherNames.sourceCulture',
+            'QubitInformationObject.generalNotes.sourceCulture',
+            'QubitActor.otherNames.sourceCulture',
+            'QubitRepository.contactInformations.sourceCulture',
+            'QubitActor.otherNames.i18n.*.name',
+            'QubitActor.occupations.i18n.*.name',
+            'QubitActor.occupations.i18n.*.content',
+            'QubitActor.parallelNames.i18n.*.name',
+            'QubitActor.standardizedNames.i18n.*.name',
+            'QubitRepository.contactInformations.i18n.*.contactType',
+            'QubitRepository.contactInformations.i18n.*.city',
+            'QubitRepository.contactInformations.i18n.*.region',
+            'QubitInformationObject.creators.i18n.*.authorizedFormOfName',
+            'QubitInformationObject.creators.i18n.*.history',
+            'QubitInformationObject.creators.otherNames.i18n.*.name',
+            'QubitInformationObject.genres.i18n.*.name',
+            'QubitInformationObject.places.i18n.*.name',
+            'QubitInformationObject.subjects.i18n.*.name',
+            'QubitInformationObject.inheritedCreators.i18n.*.authorizedFormOfName',
+            'QubitInformationObject.inheritedCreators.otherNames.i18n.*.name',
+            'QubitInformationObject.names.otherNames.i18n.*.name',
+            'QubitInformationObject.generalNotes.i18n.*.content',
+            'QubitInformationObject.names.i18n.*.authorizedFormOfName',
+            'QubitInformationObject.dates.i18n.*.date',
+        ];
+
+        foreach ($multivalueFields as $field) {
+            $properties = explode('.', $field);
+            $properties[0] = str_replace('Qubit', '', $properties[0]);
+            $properties[0] = lcfirst($properties[0]);
+
+            if ('*' == $properties[count($properties) - 2]) {
+                foreach (sfConfig::get('app_i18n_languages') as $lang) {
+                    $path = [];
+                    foreach ($properties as $property) {
+                        if ('*' == $property) {
+                            array_push($path, $lang);
+                        } else {
+                            array_push($path, $property);
+                        }
+                        array_push($path, 'properties');
+                    }
+                    array_pop($path);
+                    $this->setMultivalueException($path);
+                }
+            } else {
+                $path = [];
+                foreach ($properties as $property) {
+                    array_push($path, $property);
+                    array_push($path, 'properties');
+                }
+
+                array_pop($path);
+                $this->setMultivalueException($path);
+            }
+        }
+    }
+
+    protected function setMultivalueException($keypath)
+    {
+        $mapping = &$this->mapping;
+        foreach ($keypath as $key) {
+            if (!array_key_exists($key, $mapping)) {
+                $mapping[$key] = [];
+            }
+            $mapping = &$mapping[$key];
+        }
+        $mapping['multivalue'] = 'true';
+    }
+}
diff --git a/plugins/arSolrPlugin/lib/arSolrPlugin.class.php b/plugins/arSolrPlugin/lib/arSolrPlugin.class.php
new file mode 100644
index 0000000000..4d9e76e08f
--- /dev/null
+++ b/plugins/arSolrPlugin/lib/arSolrPlugin.class.php
@@ -0,0 +1,671 @@
+<?php
+
+/*
+ * This file is part of the Access to Memory (AtoM) software.
+ *
+ * Access to Memory (AtoM) is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Access to Memory (AtoM) is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Access to Memory (AtoM).  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * arSolrPlugin main class.
+ */
+class arSolrPlugin extends QubitSearchEngine
+{
+    public $lang_codes = ['ar', 'hy', 'ba', 'br', 'bg', 'ca', 'cz', 'da', 'nl', 'en', 'fi', 'fr', 'gl', 'ge', 'el', 'hi', 'hu', 'id', 'it', 'no', 'fa', 'pt', 'ro', 'ru', 'es', 'sv', 'tr'];
+
+    public $langs = [];
+
+    public $client;
+
+    /**
+     * Mappings configuration, mapping.yml.
+     *
+     * @var mixed defaults to null
+     */
+    protected $mappings;
+
+    /**
+     * If false, this plugin will perform a trial run with no changes made.
+     *
+     * @var mixed defaults to true
+     */
+    protected $enabled = true;
+
+    /**
+     * This array will be used to store documents to add in a batch.
+     *
+     * @var array
+     */
+    private $batchAddDocs = [];
+
+    /**
+     * This array will be used to store documents to delete in a batch.
+     *
+     * @var array
+     */
+    private $batchDeleteDocs = [];
+
+    /**
+     * Constructor.
+     */
+    public function __construct(array $options = [])
+    {
+        parent::__construct();
+
+        $this->config = arSolrPluginConfiguration::$config;
+
+        $this->client = new arSolrClient($this->config['solr']);
+
+        // Load batch mode configuration
+        $this->batchMode = true === $this->config['batch_mode'];
+        $this->batchSize = $this->config['batch_size'];
+
+        $this->initialize();
+    }
+
+    public function __destruct()
+    {
+        if (!$this->enabled) {
+            return;
+        }
+    }
+
+    public static function loadMappings()
+    {
+        // Find mapping.yml
+        $finder = sfFinder::type('file')->name('solrSchema.yml');
+        $files = array_unique(
+            array_merge(
+                $finder->in(sfConfig::get('sf_config_dir')),
+                $finder->in(ProjectConfiguration::getActive()->getPluginSubPaths('/config'))
+            )
+        );
+
+        if (!count($files)) {
+            throw new sfException('You must create a mapping.xml file.');
+        }
+
+        // Load first mapping.yml file found
+        $solrMapping = new arSolrMapping();
+        $solrMapping->loadYAML(array_shift($files));
+
+        return $solrMapping;
+    }
+
+    public function loadDiacriticsMappings()
+    {
+        // Find diacritics_mapping.yml
+        $diacriticsFinder = sfFinder::type('file')->name('diacritics_mapping.yml');
+        $diacriticsFiles = array_unique(
+            array_merge(
+                $diacriticsFinder->in(sfConfig::get('sf_upload_dir')),
+            )
+        );
+
+        if (!count($diacriticsFiles)) {
+            throw new sfException('You must create a diacritics_mapping.yml file.');
+        }
+
+        return $diacriticsFiles;
+    }
+
+    public function flush()
+    {
+        try {
+            $this->client->flushIndex();
+        } catch (Exception $e) {
+            $this->log('Error flushing index');
+        }
+
+        $this->initialize();
+    }
+
+    /*
+     * Flush batch of documents if we're in batch mode.
+     *
+     * We process additions before deletions to avoid an error due to deleting a
+     * document that hasn't been created yet.
+     */
+    public function flushBatch()
+    {
+        if ($this->batchMode) {
+            // Batch add documents, if any
+            if (count($this->batchAddDocs) > 0) {
+                try {
+                    $response = $this->client->addDocuments($this->batchAddDocs);
+
+                    if ($response->error) {
+                        $this->log(var_export($response->error, true));
+                        $this->log(json_encode($this->batchAddDocs));
+                    }
+                } catch (Exception $e) {
+                    // Clear batchAddDocs if something went wrong too
+                    $this->batchAddDocs = [];
+
+                    throw $e;
+                }
+
+                $this->batchAddDocs = [];
+            }
+
+            // Batch delete documents, if any
+            if (count($this->batchDeleteDocs) > 0) {
+                try {
+                    $response = $this->client->deleteDocuments($this->batchDeleteDocs);
+
+                    if ($response->error) {
+                        $this->log(var_export($response->error, true));
+                        $this->log(json_encode($this->batchDeleteDocs));
+                    }
+                } catch (Exception $e) {
+                    // Clear batchDeleteDocs if something went wrong too
+                    $this->batchDeleteDocs = [];
+
+                    throw $e;
+                }
+
+                $this->batchDeleteDocs = [];
+            }
+        }
+    }
+
+    /**
+     * Populate index.
+     *
+     * @param mixed $options
+     */
+    public function populate($options = [])
+    {
+        $excludeTypes = (!empty($options['excludeTypes'])) ? $options['excludeTypes'] : [];
+        $update = (!empty($options['update'])) ? $options['update'] : false;
+
+        // Delete index and initialize again if all document types are to be
+        // indexed and not updating
+        if (!count($excludeTypes) && !$update) {
+            $this->flush();
+            $this->log('Index erased.');
+
+            // Load mappings
+            $this->loadAndNormalizeMappings();
+        } else {
+            // Initialize index if necessary
+            $this->initialize();
+
+            // Load mappings if index initialization wasn't needed
+            $this->loadAndNormalizeMappings();
+        }
+
+        // If we're indexing IOs or Actors we'll cache a term id => parent id
+        // array with all terms from the needed taxonomies in sfConfig. This
+        // array will be used to obtain the related terms ancestor ids without
+        // hitting the DB in arElasticSearchModelBase.
+        $indexingIos = !in_array('informationobject', $excludeTypes);
+        $indexingActors = !in_array('actor', $excludeTypes);
+
+        if ($indexingIos || $indexingActors) {
+            $taxonomies = [QubitTaxonomy::SUBJECT_ID, QubitTaxonomy::PLACE_ID];
+
+            if ($indexingIos) {
+                $taxonomies[] = QubitTaxonomy::GENRE_ID;
+            }
+
+            sfConfig::set(
+                'term_parent_list',
+                QubitTerm::loadTermParentList($taxonomies)
+            );
+        }
+
+        $this->log('Populating index...');
+
+        // Document counter, timer and errors
+        $total = 0;
+        $timer = new QubitTimer();
+        $errors = [];
+        $showErrors = false;
+
+        foreach ($this->mappings as $typeName => $typeProperties) {
+            if (!in_array(strtolower($typeName), $excludeTypes)) {
+                $camelizedTypeName = sfInflector::camelize($typeName);
+                $className = 'arSolr'.$camelizedTypeName;
+
+                $class = new $className();
+                $class->setTimer($timer);
+
+                $typeErrors = $class->populate();
+                if (count($typeErrors) > 0) {
+                    $showErrors = true;
+                    $errors = array_merge($errors, $typeErrors);
+                }
+
+                $total += $class->getCount();
+            }
+        }
+
+        // Add the last batch of documents
+        $this->flushBatch();
+
+        $this->addAutoCompleteConfigs();
+        $this->setAnalyzers();
+
+        $this->log(
+            vsprintf(
+                'Index populated with %s documents in %s seconds.',
+                [$total, $timer->elapsed()]
+            )
+        );
+
+        if (!$showErrors) {
+            return;
+        }
+
+        // Log errors
+        $this->log('The following errors have been encountered:');
+        foreach ($errors as $error) {
+            $this->log($error);
+        }
+        $this->log('Please, contact an administrator.');
+    }
+
+    public function enable()
+    {
+        $this->enabled = true;
+    }
+
+    public function disable()
+    {
+        $this->enabled = false;
+    }
+
+    /**
+     * Centralize document addition to keep control of the batch queue.
+     *
+     * @param mixed $data
+     * @param mixed $type
+     */
+    public function addDocument($data, $type)
+    {
+        if (!isset($data['id'])) {
+            throw new sfException('Failed to parse id field.');
+        }
+
+        if ($this->batchMode) {
+            // Add this document to the batch add queue
+            $document = [
+                $type => $data,
+            ];
+            array_push($this->batchAddDocs, $document);
+
+            // If we have a full batch, send additions and deletions in bulk
+            if (count($this->batchAddDocs) >= $this->batchSize) {
+                $this->flushBatch();
+            }
+        } else {
+            $response = $this->client->addDocument([$type => $data]);
+
+            if ($response->error) {
+                $this->log(var_export($response->error, true));
+                $this->log(json_encode([$type => $data]));
+            }
+        }
+    }
+
+    public function partialUpdate($object, $data)
+    {
+        if (!$this->enabled) {
+            return;
+        }
+
+        if ($object instanceof QubitUser) {
+            return;
+        }
+
+        $type = get_class($object);
+        $response = $this->client->updateDocument([$type => $data]);
+
+        if ($response->error) {
+            $this->log(var_export($response->error, true));
+        }
+    }
+
+    public function partialUpdateById(string $className, int $id, array $data)
+    {
+        if (!$this->enabled) {
+            return;
+        }
+
+        if (0 == strcmp($className, 'QubitUser')) {
+            return;
+        }
+
+        $response = $this->client->updateById($id, $className, $data);
+
+        if ($response->error) {
+            $this->log(var_export($response->error, true));
+        }
+    }
+
+    public function delete($object)
+    {
+        if (!$this->enabled) {
+            return;
+        }
+
+        if ($object instanceof QubitUser) {
+            return;
+        }
+
+        if ($this->batchMode) {
+            // The document being deleted may not have been added to the index yet (if it's
+            // still queued up in $this->batchAddDocs) so create a document object representing
+            // the document to be deleted and add this document object to the batch delete
+            // queue.
+            $document = $this->client->createDocumentWithId($object->id, get_class($object));
+
+            $this->batchDeleteDocs[] = $document;
+
+            // If we have a full batch, send additions and deletions in bulk
+            if (count($this->batchDeleteDocs) >= $this->batchSize) {
+                $this->flushBatch();
+            }
+        } else {
+            try {
+                $this->client->deleteById($object->id, get_class($object));
+            } catch (Exception $e) {
+                // Ignore
+            }
+        }
+    }
+
+    public function search($query, $type)
+    {
+        return $this->client->search($query);
+    }
+
+    /**
+     * Initialize Solr index if it does not exist.
+     */
+    protected function initialize()
+    {
+        if (false !== $this->client->checkCollectionExists()) {
+            $this->log('Collection found. Not initializing');
+        } else {
+            $this->log('Initializing Solr Index');
+
+            $this->log('Creating Solr Collection');
+            $this->client->createCollection();
+
+            $topLevelProperties = [];
+            $subProperties = [];
+
+            // Load and normalize mappings
+            $this->loadAndNormalizeMappings();
+
+            // Iterate over types (actor, informationobject, ...)
+            foreach ($this->mappings as $typeName => $typeProperties) {
+                $typeName = 'Qubit'.sfInflector::camelize($typeName);
+                array_push($topLevelProperties, $this->getFieldQuery($typeName, '_nest_path_', true));
+
+                $this->addSubProperties($typeProperties['properties'], $subProperties, $typeName, $typeProperties['properties']);
+            }
+
+            $this->client->addFields($topLevelProperties);
+            $this->client->addFields($subProperties);
+
+            $this->addAutoCompleteFields();
+        }
+    }
+
+    private function addAutoCompleteFields()
+    {
+        // list should also include QubitInformationObject.referenceCode but
+        // since this field does not include a language code, it is added to
+        // $addCopyField manually
+        $autocompleteFields = [
+            'QubitRepository.i18n.%s%.authorizedFormOfName',
+            'QubitInformationObject.aip.type.i18n.%s%.name',
+            'QubitInformationObject.i18n.%s%.title',
+            'QubitActor.i18n.%s%.authorizedFormOfName',
+            'QubitActor.places.i18n.%s%.name',
+            'QubitActor.subjects.i18n.%s%.name',
+            'QubitTerm.i18n.%s%.name',
+            'QubitAip.type.i18n.%s%.name',
+        ];
+
+        $fields = [];
+        $copyFields = [];
+
+        foreach ($this->langs as $lang) {
+            $langField = [
+                'name' => "autocomplete_{$lang}",
+                'type' => "text_{$lang}",
+                'stored' => 'true',
+                'multiValued' => 'true',
+            ];
+
+            $refField = [
+                'source' => 'QubitInformationObject.referenceCode',
+                'dest' => "autocomplete_{$lang}",
+            ];
+
+            array_push($fields, $langField);
+            array_push($copyFields, $refField);
+
+            foreach ($autocompleteFields as $field) {
+                $field = str_replace('%s%', $lang, $field);
+                array_push($copyFields, [
+                    'source' => $field,
+                    'dest' => "autocomplete_{$lang}",
+                ]);
+            }
+        }
+
+        $this->client->addFields($fields);
+        $this->client->addCopyFields($copyFields);
+    }
+
+    private function addAutoCompleteConfigs()
+    {
+        foreach ($this->langs as $lang) {
+            $this->client->modifyConfigParams('add-searchComponent', [
+                'name' => "autocomplete_{$lang}",
+                'class' => 'solr.SuggestComponent',
+                'suggester' => [
+                    'name' => "autocomplete_{$lang}",
+                    'field' => "autocomplete_{$lang}",
+                    'lookupImpl' => 'FuzzyLookupFactory',
+                    'dictionaryImpl' => 'DocumentDictionaryFactory',
+                    'suggestAnalyzerFieldType' => "text_{$lang}",
+                ],
+            ]);
+            $this->client->modifyConfigParams('add-requestHandler', [
+                'name' => "/autocomplete_{$lang}",
+                'class' => 'solr.SearchHandler',
+                'components' => ["autocomplete_{$lang}"],
+                'defaults' => [
+                    'suggest' => 'true',
+                    'suggest.count' => 5,
+                    'suggest.dictionary' => "autocomplete_{$lang}",
+                ],
+            ]);
+        }
+    }
+
+    private function addSubProperties($properties, &$propertyFields, $parentType = '', $parentProperties = null)
+    {
+        if (!$parentProperties) {
+            $parentProperties = $properties;
+        }
+
+        $atomicTypes = ['keyword', 'string', 'text', 'text_general', 'date', 'pdate', 'pdates', 'long', 'plongs', 'integer', 'boolean', 'location'];
+        foreach ($properties as $propertyName => $value) {
+            $fieldName = $parentType ? "{$parentType}.{$propertyName}" : $propertyName;
+
+            $fields = explode('.', $fieldName);
+            $lang = $fields[count($fields) - 2];
+            if (in_array($lang, $this->lang_codes) && !in_array($lang, $this->langs)) {
+                array_push($this->langs, $lang);
+            }
+
+            $i18nIndex = array_search('i18n', $fields);
+            if ('languages' == $propertyName || ($value['multivalue'] && false == $i18nIndex)) {
+                $multiValue = true;
+            } else {
+                $multiValue = $this->getMultiValue($fieldName);
+            }
+
+            if (in_array($value['type'], $atomicTypes)) {
+                if ('text' === $value['type']) {
+                    $typeName = $this->setLanguageType($fieldName);
+                } else {
+                    $typeName = $this->setType($value['type']);
+                }
+                $field = $this->getFieldQuery($fieldName, $typeName, $multiValue);
+                array_push($propertyFields, $field);
+            } elseif ('object' == $value['type']) {
+                $field = $this->getFieldQuery($fieldName, '_nest_path_', true);
+                array_push($propertyFields, $field);
+            }
+
+            if ($value['properties']) {
+                $this->addSubProperties($value['properties'], $propertyFields, $fieldName, $parentProperties);
+            }
+        }
+    }
+
+    private function getMultiValue($fieldName)
+    {
+        $properties = explode('.', $fieldName);
+        $properties[0] = str_replace('Qubit', '', $properties[0]);
+        $properties[0] = lcfirst($properties[0]);
+
+        $path = [];
+        foreach ($properties as $property) {
+            array_push($path, $property);
+            array_push($path, 'properties');
+        }
+
+        array_pop($path);
+
+        $mapping = &$this->mappings;
+        foreach ($path as $key) {
+            if (!array_key_exists($key, $mapping)) {
+                $mapping[$key] = [];
+            }
+            $mapping = &$mapping[$key];
+        }
+
+        if (array_key_exists('multivalue', $mapping)) {
+            return true;
+        }
+
+        return false;
+    }
+
+    private function setLanguageType($fieldName)
+    {
+        $substrings = explode('.', $fieldName);
+        $lang = $substrings[count($substrings) - 2];
+
+        if (in_array($lang, $this->lang_codes)) {
+            return 'text_'.$lang;
+        }
+        if ('pt_BR' === $lang) {
+            return 'text_pt';
+        }
+
+        return 'text_en';
+    }
+
+    private function setType($type)
+    {
+        if ('integer' === $type) {
+            return 'pint';
+        }
+        if ('date' === $type) {
+            return 'pdate';
+        }
+        if ('long' === $type) {
+            return 'plong';
+        }
+        if ('keyword' === $type) {
+            return 'string';
+        }
+        if ('geo_point' === $type) {
+            return 'location';
+        }
+
+        return $type;
+    }
+
+    private function getFieldQuery($field, $type, $multiValue, $stored = true)
+    {
+        $stored = $stored ? 'true' : 'false';
+        $multiValue = $multiValue ? 'true' : 'false';
+        $addFieldQuery = [
+            'name' => $field,
+            'stored' => $stored,
+            'type' => $type,
+            'indexed' => 'true',
+            'multiValued' => $multiValue,
+        ];
+        $this->log(sprintf('Defining mapping %s...', $field));
+
+        return $addFieldQuery;
+    }
+
+    private function setAnalyzers()
+    {
+        foreach ($this->config['index']['configuration']['analysis']['analyzer'] as $key => $analyzer) {
+            $charFilters = [];
+            $filters = [];
+
+            foreach ($this->config['index']['configuration']['analysis']['char_filter'] as $charFilter) {
+                array_push($charFilters, $charFilter);
+            }
+
+            foreach ($this->config['index']['configuration']['analysis']['analyzer'][$key]['filter'] as $filter) {
+                array_push($filters, $this->config['index']['configuration']['analysis']['filter'][$filter]);
+            }
+
+            if (sfConfig::get('app_diacritics')) {
+                $diacritics = $this->loadDiacriticsMappings();
+                array_push($charFilters, [
+                    'class' => 'solr.MappingCharFilterFactory',
+                    'mapping' => $diacritics[0],
+                ]);
+            }
+
+            $analyzerParams = [
+                'name' => $key,
+                'class' => 'solr.TextField',
+                'analyzer' => [
+                    'tokenizer' => ['class' => $analyzer['tokenizer']],
+                    'charFilters' => $charFilters,
+                    'filters' => $filters,
+                ],
+            ];
+
+            $this->client->replaceFieldType($analyzerParams);
+        }
+    }
+
+    private function loadAndNormalizeMappings()
+    {
+        if (null === $this->mappings) {
+            $mappings = self::loadMappings();
+            $mappings->cleanYamlShorthands(); // Remove _attributes, _foreign_types, etc.
+            $this->mappings = $mappings->asArray();
+        }
+    }
+}
diff --git a/plugins/arSolrPlugin/lib/arSolrPluginQuery.class.php b/plugins/arSolrPlugin/lib/arSolrPluginQuery.class.php
new file mode 100644
index 0000000000..394937085b
--- /dev/null
+++ b/plugins/arSolrPlugin/lib/arSolrPluginQuery.class.php
@@ -0,0 +1,677 @@
+<?php
+
+/*
+ * This file is part of the Access to Memory (AtoM) software.
+ *
+ * Access to Memory (AtoM) is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Access to Memory (AtoM) is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Access to Memory (AtoM).  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+class arSolrPluginQuery
+{
+    public $query;
+    public $queryBool;
+    public $filters;
+    public $criteria;
+    public $params;
+
+    /**
+     * Constructor.
+     *
+     * @param int $limit how many results should be returned
+     * @param int $skip  how many results should be skipped
+     */
+    public function __construct($limit = 10, $skip = 0)
+    {
+        // TODO: update usage of the query param
+        // across arSolrPluginQuery and AtoM
+        $this->queryBool = new arSolrBoolQuery();
+        $this->queryBool->setSize($limit);
+        $this->queryBool->setOffset($skip);
+    }
+
+    /**
+     * Translate internal representation of aggregations
+     * to Solr API, adding them to the query.
+     *
+     * @param array $aggs search aggregations
+     */
+    public function addAggs($aggs)
+    {
+        foreach ($aggs as $name => $item) {
+            switch ($item['type']) {
+                case 'term':
+                    $agg = [
+                        $name => [
+                            'type' => 'terms',
+                            'field' => $item['field'],
+                        ],
+                    ];
+
+                    break;
+
+                case 'filter':
+                    $agg = [
+                        $name => [
+                            'type' => 'query',
+                            'q' => $item['field'],
+                        ],
+                    ];
+
+                    break;
+            }
+
+            // Sets the amount of terms to be returned
+            if (isset($item['size'])) {
+                $agg[$name]['limit'] = $item['size'];
+            }
+
+            $this->queryBool->setAggregations($agg);
+        }
+    }
+
+    /**
+     * Add filters from aggregations to the query.
+     *
+     * @param array $aggs   search aggregations
+     * @param array $params search filters from aggregations
+     */
+    public function addAggFilters($aggs, $params)
+    {
+        $this->filters = [];
+
+        // Filter languages only if the languages aggregation
+        // is being used and languages is set in the request
+        if (isset($aggs['languages'], $params['languages'])) {
+            $this->filters['languages'] = $params['languages'];
+            $term = new arSolrTermQuery(
+                [$aggs['languages']['field'] => $params['languages']]
+            );
+
+            $this->queryBool->addMust($term);
+        }
+
+        // Add agg selections as search criteria
+        foreach ($params as $param => $value) {
+            if (
+                'languages' == $param
+                || !array_key_exists($param, $aggs)
+                || ('repos' == $param && (!ctype_digit($value)
+                || null === QubitRepository::getById($value)))
+                || 1 === preg_match('/^[\s\t\r\n]*$/', $value)
+            ) {
+                continue;
+            }
+
+            $this->filters[$param] = $value;
+
+            $query = new arSolrTermQuery(
+                [$aggs[$param]['field'] => $value]
+            );
+
+            // Collection agg must select all descendants and itself
+            if ('collection' == $param) {
+                $collection = QubitInformationObject::getById($value);
+
+                $querySelf = new arSolrMatchQuery();
+                $querySelf->setFieldQuery('slug', $collection->slug);
+
+                $queryBool = new arSolrBoolQuery();
+                $queryBool->addShould($query);
+                $queryBool->addShould($querySelf);
+
+                $query = $queryBool;
+            }
+
+            $this->queryBool->addMust($query);
+        }
+    }
+
+    /**
+     * Add criteria to query based on advanced search form and other params.
+     *
+     * @param mixed $fieldNames
+     * @param mixed $params
+     * @param mixed $archivalStandard
+     */
+    public function addAdvancedSearchFilters(
+        $fieldNames, $params, $archivalStandard
+    ) {
+        // Build query with the boolean criteria
+        if (
+            null !== $criteria = $this->parseQuery($params, $archivalStandard)
+        ) {
+            $this->queryBool->addMust($criteria);
+        }
+
+        // Process advanced search form fields
+        // Some of them have the same name as a aggregation, this creates query
+        // duplication but allows as to keep aggs and adv. search form
+        // synchronized
+        foreach ($fieldNames as $name) {
+            if (
+                isset($params[$name])
+                && strlen(trim($params[$name])) > 0
+                && (
+                    null !== $criteria = $this->fieldCriteria(
+                        $name, $params[$name]
+                    )
+                )
+            ) {
+                $this->queryBool->addMust($criteria);
+            }
+        }
+
+        if (null !== $criteria = $this->getDateRangeQuery($params)) {
+            $this->queryBool->addMust($criteria);
+        }
+
+        // Default to show only top level descriptions
+        if (
+            'isaar' != $archivalStandard
+            && (
+                !isset($params['topLod'])
+                || filter_var($params['topLod'], FILTER_VALIDATE_BOOLEAN)
+            )
+        ) {
+            $this->queryBool->addMust(
+                new arSolrTermQuery(
+                    ['parentId' => QubitInformationObject::ROOT_ID]
+                )
+            );
+        }
+
+        // Show descriptions related to an actor by an event type,
+        // this parameters come from the actor related IOs lists
+        if (
+            isset($params['actorId'])
+            && ctype_digit($params['actorId'])
+            && isset($params['eventTypeId'])
+            && ctype_digit($params['eventTypeId'])
+        ) {
+            $queryBool = new arSolrBoolQuery();
+            $queryBool->addMust(
+                new arSolrTermQuery(
+                    ['dates.actorId' => $params['actorId']]
+                )
+            );
+            $queryBool->addMust(
+                new arSolrTermQuery(
+                    ['dates.typeId' => $params['eventTypeId']]
+                )
+            );
+
+            // TODO: Remove ES nested query
+            // // Use nested query and mapping object to allow querying
+            // // over the actor and event ids from the same event
+            // $queryNested = new arSolrNestedQuery();
+            // $queryNested->setPath('dates');
+            // $queryNested->setQuery($queryBool);
+
+            // $this->queryBool->addMust($queryNested);
+        }
+
+        // Show descendants from resource
+        if (isset($params['ancestor']) && ctype_digit($params['ancestor'])) {
+            $this->queryBool->addMust(
+                new arSolrTermQuery(['ancestors' => $params['ancestor']])
+            );
+        }
+    }
+
+    /**
+     * Returns the query.
+     *
+     * @param bool $allowEmpty   get all or none if the query is empty
+     * @param bool $filterDrafts filter draft records
+     *
+     * @return arSolrBoolQuery
+     */
+    public function getQuery($allowEmpty = false, $filterDrafts = false)
+    {
+        if (!$allowEmpty && 1 > count($this->queryBool->getParams())) {
+            $this->queryBool->addMust(new arSolrMatchAllQuery());
+        }
+
+        if ($filterDrafts) {
+            QubitSolrAclSearch::filterDrafts($this->queryBool);
+        }
+
+        return $this->queryBool;
+    }
+
+    /**
+     * Translate array of search parameters to query criteria.
+     *
+     * Modified version of parseQuery method in the SearchAdvancedAction class
+     *
+     * Each set of parameters is numbered, starting at zero, and includes three
+     * properties: query text (prefixed by "sq"), operation (prefixed by "so":
+     * "and" or "or"), and fields (prefixed by "sf") to return (defaulting to
+     * "_all").
+     *
+     * For example:
+     *
+     *   $this->searchParams = array(
+     *     'so0' => 'and',
+     *     'sq0' => 'cats',
+     *     'sf0' => ''
+     *   );
+     *
+     * @param mixed $params
+     * @param mixed $archivalStandard
+     *
+     * @return object arSolrBoolQuery instance
+     */
+    protected function parseQuery($params, $archivalStandard)
+    {
+        $this->criteria = [];
+        $queryBool = new arSolrBoolQuery();
+        $count = 0;
+
+        while (isset($params['sq'.$count])) {
+            $query = $params['sq'.$count];
+
+            if (!empty($query)) {
+                $field = '_all';
+                if (!empty($params['sf'.$count])) {
+                    $field = $params['sf'.$count];
+                }
+
+                $operator = 'and';
+                if (!empty($params['so'.$count])) {
+                    $operator = $params['so'.$count];
+                }
+
+                $queryField = $this->queryField(
+                    $field, $query, $archivalStandard
+                );
+                $this->addToQueryBool($queryBool, $operator, $queryField);
+
+                $this->criteria[] = [
+                    'query' => $query,
+                    'field' => $field,
+                    'operator' => $operator,
+                ];
+            }
+
+            ++$count;
+        }
+
+        if (0 == count($queryBool->getParams())) {
+            return;
+        }
+
+        return $queryBool;
+    }
+
+    /**
+     * Constructor.
+     *
+     * @param string $field
+     * @param string $query
+     * @param string $archivalStandard
+     *
+     * @return array
+     */
+    protected function queryField($field, $query, $archivalStandard)
+    {
+        switch ($field) {
+            case 'identifier':
+            case 'referenceCode':
+            case 'descriptionIdentifier':
+                $fields = [$field => 1];
+
+                break;
+
+            case 'title':
+            case 'scopeAndContent':
+            case 'extentAndMedium':
+            case 'authorizedFormOfName':
+            case 'datesOfExistence':
+            case 'history':
+            case 'legalStatus':
+            case 'generalContext':
+            case 'institutionResponsibleIdentifier':
+            case 'sources':
+            case 'places':
+                $fields = ['i18n.%s.'.$field => 1];
+
+                break;
+
+            case 'archivalHistory':
+                ProjectConfiguration::getActive()->loadHelpers(
+                    ['Asset', 'Qubit']
+                );
+
+                // Check archival history visibility
+                if (
+                    ('rad' == $archivalStandard && !check_field_visibility('app_element_visibility_rad_archival_history'))
+                    || ('isad' == $archivalStandard && !check_field_visibility('app_element_visibility_isad_archival_history'))
+                ) {
+                    return;
+                }
+
+                $fields = ['i18n.%s.archivalHistory' => 1];
+
+                break;
+
+            case 'genre':
+                $fields = ['genres.i18n.%s.name' => 1];
+
+                break;
+
+            case 'subject':
+                $fields = ['subjects.i18n.%s.name' => 1];
+
+                break;
+
+            case 'name':
+                $fields = ['names.i18n.%s.authorizedFormOfName' => 1];
+
+                break;
+
+            case 'creator':
+                $fields = [
+                    'creators.i18n.%s.authorizedFormOfName' => 1,
+                    'inheritedCreators.i18n.%s.authorizedFormOfName' => 1,
+                ];
+
+                break;
+
+            case 'place':
+                $fields = [
+                    'places.i18n.%s.name' => 1,
+                    'places.useFor.i18n.%s.name' => 1,
+                ];
+
+                break;
+
+            case 'findingAidTranscript':
+                $fields = ['findingAid.transcript' => 1];
+
+                break;
+
+            case 'digitalObjectTranscript':
+                $fields = ['transcript' => 1];
+
+                break;
+
+            case 'allExceptFindingAidTranscript':
+                $fields = arSolrPluginUtil::getAllFields(
+                    'informationObject',
+                    ['findingAid.transcript']
+                );
+
+                break;
+
+            case 'parallelNames':
+            case 'otherNames':
+            case 'occupations':
+                $fields = [$field.'.i18n.%s.name' => 1];
+
+                break;
+
+            case 'occupationNotes':
+                $fields = ['occupations.i18n.%s.content' => 1];
+
+                break;
+
+            case 'maintenanceNotes':
+                $fields = ['maintenanceNotes.i18n.%s.content' => 1];
+
+                break;
+
+            case '_all':
+            default:
+                if ('isaar' == $archivalStandard) {
+                    $documentType = 'actor';
+                } else {
+                    $documentType = 'informationObject';
+                }
+
+                $fields = arSolrPluginUtil::getAllFields($documentType);
+
+                break;
+        }
+
+        return arSolrPluginUtil::generateQueryString(
+            $query, $fields
+        );
+    }
+
+    protected function addToQueryBool(&$queryBool, $operator, $queryField)
+    {
+        switch ($operator) {
+            case 'not':
+                $queryBool->addMustNot($queryField);
+
+                break;
+
+            case 'or':
+                // Build boolean query with all the previous queries
+                // and the new one as 'shoulds'
+                $queryOr = new arSolrBoolQuery();
+                $queryOr->addShould($queryBool);
+                $queryOr->addShould($queryField);
+
+                $queryBool = new arSolrBoolQuery();
+                $queryBool->addMust($queryOr);
+
+                break;
+
+            case 'and':
+            default: // First criteria falls here
+                $queryBool->addMust($queryField);
+
+                break;
+        }
+    }
+
+    protected function fieldCriteria($name, $value)
+    {
+        switch ($name) {
+            case 'copyrightStatus':
+                // Get unknown copyright status term
+                $criteria = new Criteria();
+                $criteria->addJoin(QubitTerm::ID, QubitTermI18n::ID);
+                $criteria->add(
+                    QubitTerm::TAXONOMY_ID, QubitTaxonomy::COPYRIGHT_STATUS_ID
+                );
+                $criteria->add(QubitTermI18n::NAME, 'Unknown');
+                $term = QubitTerm::getOne($criteria);
+
+                // If the user selected "Unknown copyright" make sure that we
+                // are matching documents that either (1) copyright status is
+                // unknown or (2) copyright status is not set.
+                if (isset($term) && $term->id == $value) {
+                    // Query for documents without copyright status
+                    $exists = new arSolrExistsQuery('copyrightStatusId');
+                    $queryBoolMissing = new arSolrBoolQuery();
+                    $queryBoolMissing->addMustNot($exists);
+
+                    // Query for unknown copyright status
+                    $query = new arSolrTermQuery();
+                    $query->setTerm('copyrightStatusId', $value);
+
+                    $queryBool = new arSolrBoolQuery();
+                    $queryBool->addShould($query);
+                    $queryBool->addShould($queryBoolMissing);
+
+                    return $queryBool;
+                }
+
+                $query = new arSolrTermQuery();
+                $query->setTerm('copyrightStatusId', $value);
+
+                return $query;
+
+            case 'onlyMedia':
+                $query = new arSolrTermQuery();
+                $query->setTerm('hasDigitalObject', filter_var(
+                    $value, FILTER_VALIDATE_BOOLEAN)
+                );
+
+                return $query;
+
+            case 'materialType':
+                $query = new arSolrTermQuery();
+                $query->setTerm('materialTypeId', $value);
+
+                return $query;
+
+            case 'findingAidStatus':
+                switch ($value) {
+                    case 'yes':
+                        $query = new arSolrExistsQuery(
+                            'findingAid.status'
+                        );
+
+                        return $query;
+
+                    case 'no':
+                        $exists = new arSolrExistsQuery(
+                            'findingAid.status'
+                        );
+                        $query = new arSolrBoolQuery();
+                        $query->addMustNot($exists);
+
+                        return $query;
+
+                    case 'generated':
+                        $query = new arSolrTermQuery();
+                        $query->setTerm(
+                            'findingAid.status',
+                            QubitFindingAid::GENERATED_STATUS
+                        );
+
+                        return $query;
+
+                    case 'uploaded':
+                        $query = new arSolrTermQuery();
+                        $query->setTerm(
+                            'findingAid.status',
+                            QubitFindingAid::UPLOADED_STATUS
+                        );
+
+                        return $query;
+                }
+
+                return;
+        }
+    }
+
+    /*
+     * Greate date range boolean query based on the dates and type.
+     * Types:
+     * - 'inclusive': the event must be active inside the range (it may overlap)
+     * - 'exact' (or others): the event must be active only inside range
+     */
+    protected function getDateRangeQuery($params)
+    {
+        if (empty($params['startDate']) && empty($params['endDate'])) {
+            return;
+        }
+
+        // Process date range, defaults to inclusive
+        $type = $params['rangeType'];
+        if (empty($type)) {
+            $type = 'inclusive';
+        }
+
+        $query = new arSolrBoolQuery();
+        $range = [];
+
+        if (!empty($params['startDate'])) {
+            $range['gte'] = $params['startDate'];
+
+            if ('inclusive' == $type) {
+                // Start date before range and end date missing
+                $queryBool = new arSolrBoolQuery();
+                $start = new arSolrRangeQuery(
+                    'dates.startDate',
+                    ['lt' => $params['startDate']]
+                );
+                $exists = new arSolrExistsQuery('dates.endDate');
+                $queryBool->addMust($start);
+                $queryBool->addMustNot($exists);
+
+                $query->addShould($queryBool);
+            }
+        }
+
+        if (!empty($params['endDate'])) {
+            $range['lte'] = $params['endDate'];
+
+            if ('inclusive' == $type) {
+                // End date after range and start date missing
+                $queryBool = new arSolrBoolQuery();
+                $end = new arSolrRangeQuery(
+                    'dates.endDate', ['gt' => $params['endDate']]
+                );
+                $exists = new arSolrExistsQuery('dates.startDate');
+                $queryBool->addMust($end);
+                $queryBool->addMustNot($exists);
+
+                $query->addShould($queryBool);
+            }
+        }
+
+        if (
+            !empty($params['startDate'])
+            && !empty($params['endDate'])
+            && 'inclusive' == $type
+        ) {
+            // Start date before range and end date after range
+            $queryBool = new arSolrBoolQuery();
+            $queryBool->addMust(
+                new arSolrRangeQuery(
+                    'dates.startDate', ['lt' => $params['startDate']]
+                )
+            );
+            $queryBool->addMust(
+                new arSolrRangeQuery(
+                    'dates.endDate', ['gt' => $params['endDate']]
+                )
+            );
+
+            $query->addShould($queryBool);
+        }
+
+        if ('inclusive' == $type) {
+            // Any event date inside the range
+            $query->addShould(
+                new arSolrRangeQuery('dates.startDate', $range)
+            );
+            $query->addShould(
+                new arSolrRangeQuery('dates.endDate', $range)
+            );
+        } else {
+            // Both event dates inside the range
+            $query->addMust(
+                new arSolrRangeQuery('dates.startDate', $range)
+            );
+            $query->addMust(new arSolrRangeQuery('dates.endDate', $range));
+        }
+
+        // TODO: Update ES nested query use
+        // // Use nested query and mapping object to allow querying
+        // // over the start and end dates from the same event
+        // $queryNested = new arSolrNestedQuery();
+        // $queryNested->setPath('dates');
+        // $queryNested->setQuery($query);
+
+        // return $queryNested;
+        return $query;
+    }
+}
diff --git a/plugins/arSolrPlugin/lib/arSolrPluginUtil.class.php b/plugins/arSolrPlugin/lib/arSolrPluginUtil.class.php
new file mode 100644
index 0000000000..7c92feba97
--- /dev/null
+++ b/plugins/arSolrPlugin/lib/arSolrPluginUtil.class.php
@@ -0,0 +1,721 @@
+<?php
+
+/*
+ * This file is part of the Access to Memory (AtoM) software.
+ *
+ * Access to Memory (AtoM) is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Access to Memory (AtoM) is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Access to Memory (AtoM).  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * arSolrPluginUtil.
+ */
+class arSolrPluginUtil
+{
+    /**
+     * Scroll per-page limit to use for bulk queries.
+     */
+    public const SCROLL_SIZE = 1000;
+
+    public static function convertDate($date)
+    {
+        if (is_null($date)) {
+            return;
+        }
+
+        if ($date instanceof DateTime) {
+            return $date->format('Y-m-d\TH:i:s\Z');
+        }
+
+        if (is_int($date)) {
+            $timestamp = $date;
+        } else {
+            $timestamp = strtotime($date);
+        }
+
+        return date('Y-m-d\TH:i:s\Z', $timestamp);
+    }
+
+    /**
+     * Given a date string in the format YYYY-MM-DD, if either MM or DD is
+     * set to 00 (such as when indexing a MySQL date with *only* the year filled
+     * in), fill in the blank MM or DD with 01s. e.g. 2014-00-00 -> 2014-01-01.
+     *
+     * @param  string  date  The date string
+     * @param  bool  endDate  If this is set to true, use 12-31 instead
+     * @param mixed $date
+     * @param mixed $endDate
+     *
+     * @return mixed a string indicating the normalized date in YYYY-MM-DD format,
+     *               otherwise null indicating an invalid date string was given
+     */
+    public static function normalizeDateWithoutMonthOrDay($date, $endDate = false)
+    {
+        if (!strlen($date)) {
+            return null;
+        }
+
+        $dateParts = explode('-', $date);
+
+        if (3 !== count($dateParts)) {
+            throw new sfException("Invalid date string given: {$date}. Must be in format YYYY-MM-DD");
+        }
+
+        list($year, $month, $day) = $dateParts;
+
+        // Invalid year. Return null now since cal_days_in_month will fail
+        // with year 0000. See #8796
+        if (0 === (int) $year) {
+            return null;
+        }
+
+        if (0 === (int) $month) {
+            $month = $endDate ? '12' : '01';
+        }
+
+        if (0 === (int) $day) {
+            $day = $endDate ? cal_days_in_month(CAL_GREGORIAN, $month, $year) : '01';
+        }
+
+        return implode('-', [$year, $month, $day]);
+    }
+
+    /**
+     * Gets all string fields for a given index type, removing those hidden for public users
+     * and those included in the except array. Returns a key/value array with the field names
+     * as key and the boost as value, i18n fields will contain "%s" as culture placeholder, which
+     * will need to be replaced/extended with the required cultures before query.
+     *
+     * Tried to add the result fields to the cache but APC (our default caching engine) uses separate
+     * memory spaces for web/cli and the cached fields can't be removed in arSearchPopulateTask
+     *
+     * @param mixed $indexType
+     * @param mixed $except
+     */
+    public static function getAllFields($indexType, $except = [])
+    {
+        // Load ES mappings
+        $mappings = arSolrPlugin::loadMappings()->asArray();
+
+        if (!isset($mappings[$indexType])) {
+            throw new sfException('Unrecognized index type: '.$indexType);
+        }
+
+        $i18nIncludeInAll = null;
+
+        if ('informationObject' === $indexType) {
+            $i18nIncludeInAll = $mappings[$indexType]['_attributes']['i18nIncludeInAll'];
+        }
+
+        // Get all string fields included in _all for the index type
+        $allFields = self::getAllObjectStringFields(
+            $indexType,
+            $mappings[$indexType],
+            $prefix = '',
+            false,
+            $i18nIncludeInAll
+        );
+
+        // Remove fields in except (use array_values() because array_diff() adds keys)
+        if (count($except) > 0) {
+            $allFields = array_values(array_diff($allFields, $except));
+        }
+
+        // Check information object hidden fields for unauthenticated users
+        if ('informationObject' == $indexType && !sfContext::getInstance()->user->isAuthenticated()) {
+            // Remove hidden fields from ES mapping fields (use array_values() because array_diff() adds keys)
+            $allFields = array_values(array_diff($allFields, self::getHiddenFields()));
+        }
+
+        return self::setBoostValues($indexType, $allFields);
+    }
+
+    /**
+     * Expands i18n field names into various specified cultures.
+     *
+     * @param array $fields   Which fields to expand. For example, 'i18n.%s.title' will expand to 'i18n.en.title',
+     *                        'i18n.fr.title', 'i18n.es.title', etc.
+     * @param array $cultures An array specifying which cultures to expand to. If not specified, we look up which
+     *                        cultures are active in AtoM and go off that.
+     */
+    public static function getI18nFieldNames($fields, $cultures = null)
+    {
+        // Get all available cultures if $cultures isn't set
+        if (empty($cultures)) {
+            $cultures = sfConfig::get('app_i18n_languages');
+        }
+
+        // Make sure fields is an array
+        if (!is_array($fields)) {
+            $fields = [$fields];
+        }
+
+        $i18nFieldNames = [];
+
+        // Format fields
+        foreach ($cultures as $culture) {
+            foreach ($fields as $field) {
+                $i18nFieldNames[] = sprintf($field, $culture);
+            }
+        }
+
+        return $i18nFieldNames;
+    }
+
+    /**
+     * Generate a solr query.
+     *
+     * @param string $query    unescaped search term
+     * @param array  $fields   fields to search (including culture if needed)
+     * @param string $operator default query operator (AND/OR), default: AND
+     *
+     * @return arSolrStringQuery the generated solr query
+     */
+    public static function generateQuery(
+        $query, $fields, $operator = 'AND'
+    ) {
+        $solrQuery = new arSolrStringQuery(self::escapeTerm($query));
+        $solrQuery->setDefaultOperator($operator);
+        $solrQuery->setFields(self::getBoostedSearchFields($fields));
+
+        return $solrQuery;
+    }
+
+    public static function getBoostedSearchFields($fields)
+    {
+        $searchFields = [];
+        $cultures = sfConfig::get('app_i18n_languages');
+
+        foreach ($fields as $field => $boost) {
+            if (1 != $boost) {
+                $field .= '^'.$boost;
+            }
+
+            if (false !== strpos($field, '%s')) {
+                foreach ($cultures as $culture) {
+                    $searchFields[] = sprintf($field, $culture);
+                }
+            } else {
+                $searchFields[] = $field;
+            }
+        }
+
+        return $searchFields;
+    }
+
+    // Gets all premis data related to an information object
+    public static function getPremisData($ioId, $conn)
+    {
+        $premisData = [];
+
+        $sql = 'SELECT *
+            FROM '.QubitPremisObject::TABLE_NAME.' premis
+            WHERE premis.information_object_id = ?';
+
+        $statement = $conn->prepare($sql);
+        $statement->execute([$ioId]);
+        $row = $statement->fetch();
+
+        // Return if no results found
+        if (empty($row)) {
+            return;
+        }
+
+        foreach ($row as $field => $value) {
+            if (empty($value)) {
+                continue;
+            }
+
+            switch ($field) {
+                case 'last_modified':
+                    $premisData['lastModified'] = arSolrPluginUtil::convertDate($value);
+
+                    break;
+
+                case 'date_ingested':
+                    $premisData['dateIngested'] = arSolrPluginUtil::convertDate($value);
+
+                    break;
+
+                case 'mime_type':
+                    $premisData['mimeType'] = $value;
+
+                    break;
+
+                case 'size':
+                    $premisData['size'] = $value;
+
+                    break;
+
+                case 'filename':
+                    $premisData['filename'] = $value;
+
+                    break;
+
+                case 'puid':
+                    $premisData['puid'] = $value;
+
+                    break;
+            }
+        }
+
+        $sql = 'SELECT property.name, i18n.value
+            FROM '.QubitProperty::TABLE_NAME.' property
+            JOIN '.QubitPropertyI18n::TABLE_NAME.' i18n
+            ON property.id = i18n.id
+            WHERE property.scope = "premisData"
+            AND property.source_culture = i18n.culture
+            AND property.object_id = ?';
+
+        $statement = $conn->prepare($sql);
+        $statement->execute([$ioId]);
+
+        foreach ($statement->fetchAll(PDO::FETCH_OBJ) as $property) {
+            $value = unserialize($property->value);
+
+            switch ($property->name) {
+                case 'fitsAudio':
+                    $premisData['audio'] = $value;
+
+                    break;
+
+                case 'fitsDocument':
+                    $premisData['document'] = $value;
+
+                    break;
+
+                case 'fitsText':
+                    $premisData['text'] = $value;
+
+                    break;
+
+                case 'mediainfoGeneralTrack':
+                    $premisData['mediainfo']['generalTracks'][] = $value;
+
+                    break;
+
+                case 'mediainfoVideoTrack':
+                    $premisData['mediainfo']['videoTracks'][] = $value;
+
+                    break;
+
+                case 'mediainfoAudioTrack':
+                    $premisData['mediainfo']['audioTracks'][] = $value;
+
+                    break;
+
+                case 'format':
+                    $premisData['format'] = $value;
+
+                    break;
+
+                case 'formatIdentificationEvent':
+                    $premisData['formatIdentificationEvent'] = $value;
+
+                    break;
+
+                case 'otherEvent':
+                    $premisData['otherEvents'][] = $value;
+
+                    break;
+
+                case 'agent':
+                    $premisData['agents'][] = $value;
+
+                    break;
+            }
+        }
+
+        if (!empty($premisData)) {
+            return $premisData;
+        }
+    }
+
+    /**
+     * Escapes the special chars specified in the "escape_queries" setting.
+     *
+     * @param string $term Query term to escape
+     *
+     * @return string Escaped query term
+     */
+    public static function escapeTerm($term)
+    {
+        $specialChars = trim(sfConfig::get('app_escape_queries', ''));
+
+        // Return term directly if the setting is empty
+        if (empty($specialChars)) {
+            return $term;
+        }
+
+        // Split into array removing whitespaces
+        $specialChars = preg_split('/\s*,\s*/', $specialChars);
+
+        // Escaping \ has to be first
+        if (in_array('\\', $specialChars)) {
+            $term = str_replace('\\', '\\\\', $term);
+        }
+
+        foreach ($specialChars as $char) {
+            // Ignore empty chars and \
+            if (empty($char) || '\\' == $char) {
+                continue;
+            }
+
+            $term = str_replace($char, '\\'.$char, $term);
+        }
+
+        return $term;
+    }
+
+    /**
+     * Scroll through search, returning hit IDs as an array.
+     *
+     * Scrolled queries are a way to return search result sets larger than the limit
+     * index.max_result_window sets. Scrolled results, however, by default expire
+     * fairly quickly to free Elasticsearch resources. Returning these results as an
+     * array allows the results to be processed even after the scroll result expires.
+     *
+     * @param \Elastica\Search $search Search to cache
+     *
+     * @return array Array of IDs
+     */
+    public static function getScrolledSearchResultIdentifiers($search)
+    {
+        $hitIds = [];
+
+        // TODO - CONVERT TO SOLR PAGINATION EQUIVALENT
+        // Create scroll of search
+        $scroll = new \Elastica\Scroll($search);
+
+        // Scroll and add hit IDs to array
+        foreach ($scroll as $resultSet) {
+            foreach ($resultSet as $hit) {
+                array_push($hitIds, $hit->getId());
+            }
+        }
+
+        return $hitIds;
+    }
+
+    /**
+     * Gets all string fields included in _all from a mapping object array and cultures.
+     *
+     * This function will be called recursively on foreign types and nested fields.
+     *
+     * @param string $rootIndexType The current, top level index type we're adding fields to, e.g. "informationObject".
+     *
+     *                               Note that since we recursively call getAllObjectStringFields to get foreign type
+     *                               fields, this value may not be the "current" index being parsed, e.g. when adding
+     *                               creators.name actor fields inside informationObject.
+     * @param array  $object           an array containing the current object mappings
+     * @param string $prefix           The current prefix for the prop name, e.g. "informationObject." in "informationObject.slug"
+     * @param bool   $foreignType      Whether or not this field in question is being parsed for a foreign type,
+     *                                 e.g. inside informationObject.creators
+     * @param array  $i18nIncludeInAll A list of i18n fields to be allowed when searching _all
+     */
+    protected static function getAllObjectStringFields(
+        $rootIndexType,
+        $object,
+        $prefix,
+        $foreignType = false,
+        $i18nIncludeInAll = null
+    ) {
+        $fields = [];
+
+        if (isset($object['properties'])) {
+            foreach ($object['properties'] as $propertyName => $propertyProperties) {
+                // Get i18n fields, they're always included in _all
+                if ('i18n' == $propertyName) {
+                    // Get the fields from a single culture and format them with
+                    // 'i18n.%s.' to set the required cultures at query time.
+                    foreach ($propertyProperties['properties'] as $culture => $cultureProperties) {
+                        if ('languages' == $culture) {
+                            continue;
+                        }
+
+                        foreach ($cultureProperties['properties'] as $fieldName => $fieldProperties) {
+                            self::handleI18nStringFields(
+                                $rootIndexType,
+                                $fields,
+                                $prefix,
+                                $fieldName,
+                                $foreignType,
+                                $i18nIncludeInAll
+                            );
+                        }
+
+                        break;
+                    }
+                }
+                // Get nested objects fields
+                elseif (isset($propertyProperties['type']) && 'object' == $propertyProperties['type']) {
+                    $nestedFields = self::getAllObjectStringFields(
+                        $rootIndexType,
+                        $object['properties'][$propertyName],
+                        $prefix.$propertyName.'.'
+                    );
+
+                    $fields = array_merge($fields, $nestedFields);
+                }
+                // Get foreign objects fields (couldn't find a better way than checking the dynamic property)
+                elseif (isset($propertyProperties['dynamic'])) {
+                    $foreignObjectFields = self::getAllObjectStringFields(
+                        $rootIndexType,
+                        $object['properties'][$propertyName],
+                        $prefix.$propertyName.'.',
+                        true,
+                        $i18nIncludeInAll
+                    );
+
+                    $fields = array_merge($fields, $foreignObjectFields);
+                }
+                // Get string fields included in _all
+                elseif (
+                    (
+                        !isset($propertyProperties['include_in_all'])
+                        || $propertyProperties['include_in_all']
+                    ) && (
+                        isset($propertyProperties['type'])
+                        && 'text' == $propertyProperties['type']
+                    )
+                ) {
+                    self::handleNonI18nStringFields($rootIndexType, $fields, $prefix, $propertyName, $foreignType);
+                }
+            }
+        }
+
+        return $fields;
+    }
+
+    /**
+     * Retrieve the default template type given a specified ES index type.
+     *
+     * @param mixed $indexType
+     *
+     * @return string The default template (e.g. isad)
+     */
+    private static function getTemplate($indexType)
+    {
+        switch ($indexType) {
+            case 'informationObject':
+                $infoObjectTemplate = QubitSetting::getByNameAndScope('informationobject', 'default_template');
+                if (isset($infoObjectTemplate)) {
+                    return $infoObjectTemplate->getValue(['sourceCulture' => true]);
+                }
+
+            // TODO: Other index types (actor, term, etc)
+        }
+    }
+
+    /**
+     * Retrieve a list of fields that are set to hidden in the visible elements settings.
+     *
+     * @return array an array specifying which fields are to be hidden from anonymous users
+     */
+    private static function getHiddenFields()
+    {
+        // Create array with relations (hidden field => ES mapping field) for the actual template
+        $relations = [];
+
+        if (null !== $template = self::getTemplate('informationObject')) {
+            switch ($template) {
+                case 'isad':
+                    $relations = [
+                        'isad_archival_history' => 'i18n.%s.archivalHistory',
+                        'isad_immediate_source' => 'i18n.%s.acquisition',
+                        'isad_appraisal_destruction' => 'i18n.%s.appraisal',
+                        'isad_notes' => '',
+                        'isad_physical_condition' => 'i18n.%s.physicalCharacteristics',
+                        'isad_control_description_identifier' => '',
+                        'isad_control_institution_identifier' => 'i18n.%s.institutionResponsibleIdentifier',
+                        'isad_control_rules_conventions' => 'i18n.%s.rules',
+                        'isad_control_status' => '',
+                        'isad_control_level_of_detail' => '',
+                        'isad_control_dates' => 'i18n.%s.revisionHistory',
+                        'isad_control_languages' => '',
+                        'isad_control_scripts' => '',
+                        'isad_control_sources' => 'i18n.%s.sources',
+                        'isad_control_archivists_notes' => '',
+                    ];
+
+                    break;
+
+                case 'rad':
+                    $relations = [
+                        'rad_archival_history' => 'i18n.%s.archivalHistory',
+                        'rad_physical_condition' => 'i18n.%s.physicalCharacteristics',
+                        'rad_immediate_source' => 'i18n.%s.acquisition',
+                        'rad_general_notes' => '',
+                        'rad_conservation_notes' => '',
+                        'rad_control_description_identifier' => '',
+                        'rad_control_institution_identifier' => 'i18n.%s.institutionResponsibleIdentifier',
+                        'rad_control_rules_conventions' => 'i18n.%s.rules',
+                        'rad_control_status' => '',
+                        'rad_control_level_of_detail' => '',
+                        'rad_control_dates' => 'i18n.%s.revisionHistory',
+                        'rad_control_language' => '',
+                        'rad_control_script' => '',
+                        'rad_control_sources' => 'i18n.%s.sources',
+                    ];
+
+                    break;
+                // TODO: Other templates (dacs, dc, isaar, etc)
+            }
+        }
+
+        // Obtain hidden fields
+        $hiddenFields = [];
+
+        foreach (QubitSetting::getByScope('element_visibility') as $setting) {
+            if (
+                !(bool) $setting->getValue(['sourceCulture' => true])
+                && isset($relations[$setting->name])
+                && '' != $relations[$setting->name]
+            ) {
+                $hiddenFields[] = $relations[$setting->name];
+            }
+        }
+
+        return $hiddenFields;
+    }
+
+    /**
+     * Based on indexType, set the boost values for each field.
+     *
+     * @param string $indexType which index type we're setting the field boost values for
+     * @param array  $fields    the fields we're setting the boost values on
+     *
+     * @return array key/value array with fieldname/boost
+     */
+    private static function setBoostValues($indexType, $fields)
+    {
+        $boost = $boostedFields = [];
+
+        switch ($indexType) {
+            case 'informationObject':
+                $boost = [
+                    'i18n.%s.title' => 10,
+                    'creators.i18n.%s.authorizedFormOfName' => 6,
+                    'identifier' => 5,
+                    'subjects.i18n.%s.name' => 5,
+                    'i18n.%s.scopeAndContent' => 5,
+                    'names.i18n.%s.authorizedFormOfName' => 3,
+                    'places.i18n.%s.name' => 3,
+                ];
+
+                break;
+        }
+
+        foreach ($fields as $field) {
+            if (isset($boost[$field])) {
+                $boostedFields[$field] = $boost[$field];
+            } else {
+                $boostedFields[$field] = 1;
+            }
+        }
+
+        return $boostedFields;
+    }
+
+    /**
+     * Check whether an i18n field should be included in the list of fields for an _all search.
+     *
+     * @param string $prefix           The current prefix for the field name, e.g. "creators." for "creators.name"
+     * @param string $fieldName        The current field name, e.g. "name" in "creators.name"
+     * @param array  $i18nIncludeInAll A list of i18n fields to be allowed when searching _all
+     *
+     * @return bool true if we should include this field in the _all search, false otherwise
+     */
+    private static function checkI18nIncludeInAll($prefix, $fieldName, $i18nIncludeInAll)
+    {
+        if (!$i18nIncludeInAll) {
+            return; // Return and skip this check, no i18nIncludeInAll _attribute present.
+        }
+
+        return in_array($prefix.$fieldName, $i18nIncludeInAll);
+    }
+
+    /**
+     * Handle adding i18n fields to our fields list. This is a helper function for getAllObjectStringFields().
+     *
+     * Depending on the index type, there may be special rules we need to check before adding i18n fields to
+     * our fields list.
+     *
+     * @param string $rootIndexType The current, top level index type we're adding fields to, e.g. "informationObject".
+     *
+     *                               Note that since we recursively call getAllObjectStringFields to get foreign type
+     *                               fields, this value may not be the "current" index being parsed, e.g. when adding
+     *                               creators.name actor fields inside informationObject.
+     * @param array  &$fields          A reference to our list of fields we're searching over with our _all query
+     * @param string $prefix           The current prefix for the field name, e.g. "creators." for "creators.name"
+     * @param string $fieldName        The current field name, e.g. "name" in "creators.name"
+     * @param bool   $foreignType      Whether or not this field in question is being parsed for a foreign type,
+     *                                 e.g. inside informationObject.creators
+     * @param array  $i18nIncludeInAll A list of i18n fields to be allowed when searching _all
+     */
+    private static function handleI18nStringFields(
+        $rootIndexType,
+        &$fields,
+        $prefix,
+        $fieldName,
+        $foreignType,
+        $i18nIncludeInAll
+    ) {
+        // We may add special rules for other index types in the future
+        switch ($rootIndexType) {
+            case 'informationObject':
+                if ($foreignType && false === self::checkI18nIncludeInAll($prefix, $fieldName, $i18nIncludeInAll)) {
+                    return; // Skip field
+                }
+
+                break;
+        }
+
+        // Concatenate object name ($prefix), culture placeholder and field name
+        $fields[] = $prefix.'i18n.%s.'.$fieldName;
+    }
+
+    /**
+     * Handle adding non-i18n string properties to our fields list. This is a helper function for
+     * getAllObjectStringFields().
+     *
+     * Depending on the index type, there may be special rules we need to check before adding string fields to
+     * our fields list.
+     *
+     * @param string $rootIndexType The current, top level index type we're adding fields to, e.g. "informationObject".
+     *
+     *                               Note that since we recursively call getAllObjectStringFields to get foreign type
+     *                               fields, this value may not be the "current" index being parsed, e.g. when adding
+     *                               creators.name actor fields inside informationObject.
+     * @param array  &$fields      A reference to our list of fields we're searching over with our _all query
+     * @param string $prefix       The current prefix for the prop name, e.g. "informationObject." in "informationObject.slug"
+     * @param string $propertyName The current property name, e.g. "slug" in "informationObject.slug"
+     * @param bool   $foreignType  Whether or not this field in question is being parsed for a foreign type,
+     *                             e.g. inside informationObject.creators
+     */
+    private static function handleNonI18nStringFields($rootIndexType, &$fields, $prefix, $propertyName, $foreignType)
+    {
+        // We may add special rules for other index types in the future
+        switch ($rootIndexType) {
+            case 'informationObject':
+                if ($foreignType) {
+                    return; // Skip all foreign type non-i18n string fields for info objects
+                }
+
+                break;
+        }
+
+        // Concatenate object name ($prefix) and field name
+        $fields[] = $prefix.$propertyName;
+    }
+}
diff --git a/plugins/arSolrPlugin/lib/client/arSolrAbstractQuery.class.php b/plugins/arSolrPlugin/lib/client/arSolrAbstractQuery.class.php
new file mode 100644
index 0000000000..bc33281bb9
--- /dev/null
+++ b/plugins/arSolrPlugin/lib/client/arSolrAbstractQuery.class.php
@@ -0,0 +1,103 @@
+<?php
+
+/*
+ * This file is part of the Access to Memory (AtoM) software.
+ *
+ * Access to Memory (AtoM) is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Access to Memory (AtoM) is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Access to Memory (AtoM).  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+class arSolrAbstractQuery
+{
+    /**
+     * Number of results to fetch.
+     *
+     * @var number defaults to 10
+     */
+    protected $size = 10;
+
+    /**
+     * Offset for search results.
+     *
+     * @var number defaults to 0
+     */
+    protected $offset = 0;
+
+    /**
+     * Sets (overwrites) the value at the given key.
+     *
+     * @param string $key   Key to set
+     * @param mixed  $value Key Value
+     *
+     * @return $this
+     */
+    public function setParam($key, $value)
+    {
+        $this->params[$key] = $value;
+
+        return $this;
+    }
+
+    /**
+     * Adds a single param or an array of params to the list.
+     *
+     * @param string $key   Param key
+     * @param mixed  $value Value to set
+     *
+     * @return $this
+     */
+    public function addParam($key, $value, ?string $subKey = null)
+    {
+        if (null !== $subKey) {
+            $this->params[$key][$subKey] = $value;
+        } else {
+            $this->params[$key][] = $value;
+        }
+
+        return $this;
+    }
+
+    /**
+     * Sets (overwrites) all params of this object.
+     *
+     * @param array $params Parameter list
+     *
+     * @return $this
+     */
+    public function setParams(array $params)
+    {
+        $this->params = $params;
+
+        return $this;
+    }
+
+    /**
+     * Returns the params array.
+     *
+     * @return array Params
+     */
+    public function getParams()
+    {
+        return $this->params;
+    }
+
+    public function setSize($size)
+    {
+        $this->size = $size;
+    }
+
+    public function setOffset($offset)
+    {
+        $this->offset = $offset;
+    }
+}
diff --git a/plugins/arSolrPlugin/lib/client/arSolrBoolQuery.class.php b/plugins/arSolrPlugin/lib/client/arSolrBoolQuery.class.php
new file mode 100644
index 0000000000..3eab1e8586
--- /dev/null
+++ b/plugins/arSolrPlugin/lib/client/arSolrBoolQuery.class.php
@@ -0,0 +1,306 @@
+<?php
+
+/*
+ * This file is part of the Access to Memory (AtoM) software.
+ *
+ * Access to Memory (AtoM) is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Access to Memory (AtoM) is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Access to Memory (AtoM).  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+class arSolrBoolQuery extends arSolrAbstractQuery
+{
+    /**
+     * Field type.
+     *
+     * @var string
+     */
+    protected ?string $type = null;
+
+    /**
+     * Assemble BoolQuery.
+     *
+     * @return arSolrBoolQuery object
+     */
+    public function generateQueryParams()
+    {
+        $params = $this->getParams();
+        $sort = $this->getSort();
+
+        $mustQuery = [];
+        $mustNotQuery = [];
+        $shouldQuery = [];
+        $facetQuery = [];
+        $postFilterQuery = [];
+
+        $boolQuery = [
+            'query' => [],
+            'offset' => $this->offset,
+            'limit' => $this->size,
+        ];
+
+        foreach ($params['must'] as $query) {
+            $mustQueryParams = $query->getQueryParams();
+            $mustClause = $mustQueryParams['query'];
+            array_push($mustQuery, $mustClause);
+        }
+
+        foreach ($params['must_not'] as $query) {
+            $mustNotQueryParams = $query->getQueryParams();
+            $mustNotClause = $mustNotQueryParams['query'];
+            array_push($mustNotQuery, $mustNotClause);
+        }
+
+        foreach ($params['should'] as $query) {
+            $shouldQueryParams = $query->getQueryParams();
+            $shouldClause = $mustNotQueryParams['query'];
+            array_push($shouldQuery, $shouldClause);
+        }
+
+        foreach ($params['post_filter'] as $query) {
+            $postFilterParams = $query->getQueryParams();
+            $postFilterClause = $postFilterParams['query'];
+            array_push($postFilterQuery, $postFilterClause);
+        }
+
+        foreach ($params['aggregations'] as $name => $agg) {
+            $facet = $this->_generateFacetFromAggregation($name, $agg);
+            array_push($facetQuery, $facet);
+        }
+
+        if ($shouldQuery) {
+            $boolQuery['query']['bool']['should'] = $shouldQuery;
+        }
+
+        if ($mustQuery) {
+            $boolQuery['query']['bool']['must'] = $mustQuery;
+        }
+
+        if ($mustNotQuery) {
+            $boolQuery['query']['bool']['must_not'] = $mustNotQuery;
+        }
+
+        if ($postFilterQuery) {
+            $boolQuery['filter'] = $postFilterQuery;
+        }
+
+        if ($facetQuery) {
+            $boolQuery['facet'] = $facetQuery;
+        }
+
+        if ($sort) {
+            $sortArray = [];
+            foreach ($sort as $field => $direction) {
+                array_push($sortArray, "{$field} {$direction}");
+            }
+            $sortString = implode(',', $sortArray);
+            $boolQuery['sort'] = $sortString;
+        }
+
+        $this->query = $boolQuery;
+    }
+
+    public function setAggregations($agg)
+    {
+        return $this->addParam('aggregations', $agg);
+    }
+
+    public function setPostFilter($filter)
+    {
+        return $this->addParam('post_filter', $filter);
+    }
+
+    public function setSort($sort)
+    {
+        foreach ($sort as $field => $direction) {
+            if ('asc' !== $direction && 'dsc' !== $direction) {
+                throw new Exception('Invalid sort direction. Acceptable values are: asc, dsc');
+            }
+        }
+        $this->setParam('sort', $sort);
+    }
+
+    public function addSort($sort)
+    {
+        $sortArray = $this->getSort();
+
+        if (!$sortArray) {
+            $this->setSort($sort);
+
+            return;
+        }
+
+        array_push($sortArray, $sort);
+        $this->setSort($sortArray);
+    }
+
+    public function getSort()
+    {
+        $params = $this->getParams();
+
+        return $params['sort'];
+    }
+
+    /**
+     * Add must for BoolQuery.
+     *
+     * @param mixed $args
+     */
+    public function addMust($args): self
+    {
+        return $this->_addQuery('must', $args);
+    }
+
+    /**
+     * Add must not for BoolQuery.
+     *
+     * @param mixed $args
+     */
+    public function addMustNot($args): self
+    {
+        return $this->_addQuery('must_not', $args);
+    }
+
+    /**
+     * Set minimum match (mm) query for BoolQuery.
+     *
+     * @param mixed $args
+     */
+    public function addShould($args): self
+    {
+        return $this->_addQuery('should', $args);
+    }
+
+    public function getQueryParams()
+    {
+        $this->generateQueryParams();
+
+        return $this->query;
+    }
+
+    public function setFrom($offset)
+    {
+        return $this->setOffset($offset);
+    }
+
+    public function setType($type)
+    {
+        $params = $this->getParams();
+
+        foreach ($params['must'] as $query) {
+            $this->_setTypeForQuery($query, $type);
+        }
+
+        foreach ($params['must_not'] as $query) {
+            $this->_setTypeForQuery($query, $type);
+        }
+
+        foreach ($params['should'] as $query) {
+            $this->_setTypeForQuery($query, $type);
+        }
+
+        foreach ($params['post_filter'] as $query) {
+            $this->_setTypeForQuery($query, $type);
+        }
+
+        $this->type = $type;
+    }
+
+    public function getType()
+    {
+        return $this->type;
+    }
+
+    public function removeMustWithTermField($field)
+    {
+        $params = $this->getParams();
+        $mustParams = [];
+
+        foreach ($params['must'] as $query) {
+            if ($query instanceof arSolrTermQuery && $query->getTermField() === $field) {
+                continue;
+            }
+
+            array_push($mustParams, $params['must']);
+        }
+
+        $this->setParams('must', $mustParams);
+    }
+
+    protected function _addQuery(string $type, $args): self
+    {
+        if (!\is_array($args) && !($args instanceof arSolrAbstractQuery)) {
+            throw new Exception('Invalid parameter. Has to be array or instance of arSolrAbstractQuery');
+        }
+
+        return $this->addParam($type, $args);
+    }
+
+    private function _generateFacetFromAggregation($name, $agg)
+    {
+        $type = $this->getType();
+        if (!$type) {
+            throw new Exception("Field 'type' must be set if using aggregations.");
+        }
+
+        $facet = [
+            $name => [
+                'type' => $agg['type'],
+            ],
+        ];
+
+        if (isset($agg['limit'])) {
+            $facet[$name]['limit'] = $agg['limit'];
+        }
+
+        switch ($agg['type']) {
+            case 'terms':
+                $facet = [
+                    $name => [
+                        'field' => "{$type}.{$agg['field']}",
+                    ],
+                ];
+
+                break;
+
+            case 'query':
+                foreach ($agg['field'] as $field => $value) {
+                    $facet = [
+                        $name => [
+                            'q' => "{$type}.{$field}:{$value}",
+                        ],
+                    ];
+                }
+
+                break;
+        }
+
+        return $facet;
+    }
+
+    private function _setTypeForQuery($query, $type)
+    {
+        if (!($query instanceof arSolrAbstractQuery)) {
+            throw new Exception('Invalid Query. Has to be array or instance of arSolrAbstractQuery');
+        }
+
+        // MatchAll queries have no type since they're run on all fields
+        if ($query instanceof arSolrMatchAllQuery) {
+            return;
+        }
+
+        // Only set the type for another arSolrBoolQuery or if it is not already set
+        if (!$query->getType()) {
+            $query->setType($type);
+        }
+    }
+}
diff --git a/plugins/arSolrPlugin/lib/client/arSolrClient.class.php b/plugins/arSolrPlugin/lib/client/arSolrClient.class.php
new file mode 100644
index 0000000000..54d68b8c8f
--- /dev/null
+++ b/plugins/arSolrPlugin/lib/client/arSolrClient.class.php
@@ -0,0 +1,196 @@
+<?php
+
+require 'plugins/arSolrPlugin/lib/client/arSolrHelper.php';
+
+/*
+ * This file is part of the Access to Memory (AtoM) software.
+ *
+ * Access to Memory (AtoM) is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Access to Memory (AtoM) is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Access to Memory (AtoM).  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * arSolrClient main class.
+ */
+class arSolrClient
+{
+    private array $config;
+
+    /**
+     * Constructor.
+     */
+    public function __construct(array $config = [])
+    {
+        if (!$config['host']) {
+            throw new Exception('Solr config must contain host.');
+        }
+
+        if (!$config['port']) {
+            throw new Exception('Solr config must contain port.');
+        }
+
+        if (!$config['collection']) {
+            throw new Exception('Solr config must contain collection.');
+        }
+
+        $this->config = $config;
+        $this->config['path'] = '/solr/'.$this->config['collection'];
+        $this->config['api_url'] = 'http://'.$this->config['host'].':'.$this->config['port'];
+    }
+
+    public function flushIndex()
+    {
+        $url = "{$this->config['api_url']}/solr/{$this->config['collection']}/update/";
+        $query = '{"delete": {"query": "*:*"}}';
+
+        return makeHttpRequest($url, 'POST', $query);
+    }
+
+    public function search($query)
+    {
+        $url = "{$this->config['api_url']}/solr/{$this->config['collection']}/query";
+        $response = makeHttpRequest($url, 'POST', json_encode($query->getQueryParams()));
+
+        return new arSolrResultSet($response);
+    }
+
+    public function addDocument($document)
+    {
+        $url = "{$this->config['api_url']}/solr/{$this->config['collection']}/update/json/docs";
+
+        return makeHttpRequest($url, 'POST', json_encode($document));
+    }
+
+    public function updateDocument($document)
+    {
+        // Add document endpoint is able to perform updates
+        // automatically if the document already exists
+        return $this->addDocument($document);
+    }
+
+    /**
+     * Update specific fields for a document id with new values.
+     *
+     * @param int    $id
+     * @param string $type
+     * @param array  $document Document array containing key value pairs for fields and updated values
+     */
+    public function updateById($id, $type, $document)
+    {
+        $url = "{$this->config['api_url']}/solr/{$this->config['collection']}/update";
+
+        $documentUpdateCommand = [
+            "{$type}.id" => $id,
+        ];
+        foreach ($document as $field => $data) {
+            $documentUpdateCommand["{$type}.{$field}"] = [
+                'set' => $data,
+            ];
+        }
+
+        return makeHttpRequest($url, 'POST', json_encode($documentUpdateCommand));
+    }
+
+    public function addDocuments($documents)
+    {
+        $url = "{$this->config['api_url']}/solr/{$this->config['collection']}/update/json/docs";
+
+        return makeHttpRequest($url, 'POST', json_encode($documents));
+    }
+
+    public function deleteDocuments($documents)
+    {
+        $url = "{$this->config['api_url']}/solr/{$this->config['collection']}/update";
+
+        return makeHttpRequest($url, 'POST', json_encode([
+            'delete' => $documents,
+        ]));
+    }
+
+    public function deleteById($id, $type)
+    {
+        $document = $this->createDocumentWithId($id, $type);
+
+        return $this->deleteDocuments($document);
+    }
+
+    public function deleteByQuery($query)
+    {
+        $queryParams = $query->getQueryParams();
+
+        // Ignore offset, size, and additional params when deleting by query
+        return $this->deleteDocuments([
+            'query' => $queryParams['query'],
+        ]);
+    }
+
+    public function createDocumentWithId($id, $type)
+    {
+        return ["{$type}.id" => $id];
+    }
+
+    public function getCollections()
+    {
+        $url = "{$this->config['api_url']}/solr/admin/collections?action=LIST";
+        $response = makeHttpRequest($url);
+
+        return $response->collections;
+    }
+
+    public function checkCollectionExists()
+    {
+        return array_search($this->config['collection'], $this->getCollections());
+    }
+
+    public function createCollection($numShards = 2, $replicationFactor = 1)
+    {
+        $url = "{$this->config['api_url']}/solr/admin/collections?action=CREATE&name={$this->config['collection']}&numShards={$numShards}&replicationFactor={$replicationFactor}&wt=json";
+
+        return makeHttpRequest($url);
+    }
+
+    public function modifyConfigParams($paramName, $configParams)
+    {
+        $url = "{$this->config['api_url']}/api/collections/{$this->config['collection']}/config/";
+        $jsonReqeustHandler = json_encode([
+            $paramName => $configParams,
+        ]);
+
+        return makeHttpRequest($url, 'POST', $jsonReqeustHandler);
+    }
+
+    public function addFields($fields)
+    {
+        $addQuery = ['add-field' => $fields];
+        $url = "{$this->config['api_url']}/solr/{$this->config['collection']}/schema/";
+
+        return makeHttpRequest($url, 'POST', json_encode($addQuery));
+    }
+
+    public function addCopyFields($fields)
+    {
+        $addQuery = ['add-copy-field' => $fields];
+        $url = "{$this->config['api_url']}/solr/{$this->config['collection']}/schema/";
+
+        return makeHttpRequest($url, 'POST', json_encode($addQuery));
+    }
+
+    public function replaceFieldType($fieldParams)
+    {
+        $replaceFieldQuery = ['replace-field-type' => $fieldParams];
+
+        $url = "{$this->config['api_url']}/solr/{$this->config['collection']}/schema/";
+
+        return makeHttpRequest($url, 'POST', json_encode($replaceFieldQuery));
+    }
+}
diff --git a/plugins/arSolrPlugin/lib/client/arSolrExistsQuery.class.php b/plugins/arSolrPlugin/lib/client/arSolrExistsQuery.class.php
new file mode 100644
index 0000000000..3ce8cbc1ad
--- /dev/null
+++ b/plugins/arSolrPlugin/lib/client/arSolrExistsQuery.class.php
@@ -0,0 +1,104 @@
+<?php
+
+/*
+ * This file is part of the Access to Memory (AtoM) software.
+ *
+ * Access to Memory (AtoM) is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Access to Memory (AtoM) is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Access to Memory (AtoM).  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+class arSolrExistsQuery extends arSolrAbstractQuery
+{
+    /**
+     * Query Params.
+     */
+    protected array $query = [];
+
+    /**
+     * Field to be queried.
+     */
+    protected ?string $field = null;
+
+    /**
+     * Type of query.
+     */
+    protected ?string $type = null;
+
+    /**
+     * Constructor.
+     *
+     * @param string $field
+     */
+    public function __construct($field)
+    {
+        $this->setField($field);
+    }
+
+    public function setField($field)
+    {
+        if (empty($field)) {
+            return;
+        }
+
+        $this->field = $field;
+    }
+
+    public function getField()
+    {
+        return $this->field;
+    }
+
+    public function setType($type)
+    {
+        if (empty($type)) {
+            return;
+        }
+
+        $this->type = $type;
+    }
+
+    public function getType()
+    {
+        return $this->type;
+    }
+
+    public function getQueryParams()
+    {
+        $this->generateQueryParams();
+
+        return $this->query;
+    }
+
+    protected function generateQueryParams()
+    {
+        $field = $this->getField();
+        if (!isset($field)) {
+            throw new Exception('Field is not set.');
+        }
+
+        $type = $this->getType();
+        if (!isset($type)) {
+            throw new Exception("Field 'type' is not set.");
+        }
+
+        $this->query = [
+            'query' => [
+                'lucene' => [
+                    'query' => "{$type}.{$field}:*",
+                ],
+            ],
+            'offset' => $this->offset,
+            'limit' => $this->size,
+        ];
+    }
+}
diff --git a/plugins/arSolrPlugin/lib/client/arSolrHelper.php b/plugins/arSolrPlugin/lib/client/arSolrHelper.php
new file mode 100644
index 0000000000..1b1b0b7811
--- /dev/null
+++ b/plugins/arSolrPlugin/lib/client/arSolrHelper.php
@@ -0,0 +1,33 @@
+<?php
+
+/*
+ * This file is part of the Access to Memory (AtoM) software.
+ *
+ * Access to Memory (AtoM) is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Access to Memory (AtoM) is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Access to Memory (AtoM).  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+function makeHttpRequest($url, $method = 'GET', $body = null)
+{
+    $curlSession = curl_init($url);
+    if ($body) {
+        curl_setopt($curlSession, CURLOPT_POST, 1);
+        curl_setopt($curlSession, CURLOPT_POSTFIELDS, $body);
+    }
+    curl_setopt($curlSession, CURLOPT_HTTPHEADER, ['Content-Type: application/json']);
+    curl_setopt($curlSession, CURLOPT_RETURNTRANSFER, true);
+    $result = curl_exec($curlSession);
+    curl_close($curlSession);
+
+    return json_decode($result);
+}
diff --git a/plugins/arSolrPlugin/lib/client/arSolrIdsQuery.class.php b/plugins/arSolrPlugin/lib/client/arSolrIdsQuery.class.php
new file mode 100644
index 0000000000..4bada8dabf
--- /dev/null
+++ b/plugins/arSolrPlugin/lib/client/arSolrIdsQuery.class.php
@@ -0,0 +1,69 @@
+<?php
+
+/*
+ * This file is part of the Access to Memory (AtoM) software.
+ *
+ * Access to Memory (AtoM) is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Access to Memory (AtoM) is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Access to Memory (AtoM).  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+class arSolrIdsQuery extends arSolrTermsQuery
+{
+    /**
+     * Constructor.
+     *
+     * @param mixed      $searchQuery
+     * @param null|mixed $term
+     * @param null|mixed $ids
+     */
+    public function __construct($ids = null)
+    {
+        $this->setIds($ids);
+    }
+
+    public function setIds($ids)
+    {
+        $this->termField = 'id';
+        $this->termValues = $ids;
+    }
+
+    public function getIds()
+    {
+        return $this->termValues;
+    }
+
+    protected function generateQueryParams()
+    {
+        $termField = $this->getTermField();
+        $ids = $this->getIds();
+        if (!isset($ids) || 0 == count($ids)) {
+            throw new Exception('Ids are not set.');
+        }
+
+        $type = $this->getType();
+        if (!isset($type)) {
+            throw new Exception("Field 'type' is not set.");
+        }
+
+        $queryString = implode(' OR ', $ids);
+        $this->query = [
+            'query' => [
+                'edismax' => [
+                    'query' => "{$type}.{$termField}:({$queryString})",
+                ],
+            ],
+            'offset' => $this->offset,
+            'limit' => $this->size,
+        ];
+    }
+}
diff --git a/plugins/arSolrPlugin/lib/client/arSolrMatchAllQuery.class.php b/plugins/arSolrPlugin/lib/client/arSolrMatchAllQuery.class.php
new file mode 100644
index 0000000000..feb75de9fe
--- /dev/null
+++ b/plugins/arSolrPlugin/lib/client/arSolrMatchAllQuery.class.php
@@ -0,0 +1,101 @@
+<?php
+
+/*
+ * This file is part of the Access to Memory (AtoM) software.
+ *
+ * Access to Memory (AtoM) is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Access to Memory (AtoM) is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Access to Memory (AtoM).  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+class arSolrMatchAllQuery extends arSolrAbstractQuery
+{
+    /**
+     * Query Params.
+     *
+     * @var mixed
+     */
+    protected array $query = [];
+
+    /**
+     * Default operator.
+     *
+     * @var string defaults to 'AND'
+     */
+    protected string $operator = 'AND';
+
+    /**
+     * Search query.
+     */
+    protected string $searchQuery = '*:*';
+
+    /**
+     * Params.
+     */
+    protected array $params = [];
+
+    /**
+     * Constructor.
+     *
+     * @param mixed $searchQuery
+     */
+    public function __construct()
+    {
+        $this->generateQueryParams();
+    }
+
+    public function getDefaultOperator()
+    {
+        return $this->operator;
+    }
+
+    public function setDefaultOperator($operator)
+    {
+        if ('AND' !== $operator && 'OR' !== $operator) {
+            throw new Exception('Invalid operator. AND and OR are the only acceptable operator types.');
+        }
+
+        $this->operator = $operator;
+    }
+
+    public function getSearchQuery()
+    {
+        return $this->searchQuery;
+    }
+
+    public function setSearchQuery($searchQuery)
+    {
+        $this->searchQuery = $searchQuery;
+    }
+
+    public function getQueryParams()
+    {
+        $this->generateQueryParams();
+
+        return $this->query;
+    }
+
+    public function generateQueryParams()
+    {
+        $this->query = [
+            'query' => [
+                'lucene' => [
+                    'q.op' => $this->operator,
+                    'stopwords' => 'true',
+                    'query' => $this->searchQuery,
+                ],
+            ],
+            'offset' => $this->offset,
+            'limit' => $this->size,
+        ];
+    }
+}
diff --git a/plugins/arSolrPlugin/lib/client/arSolrMatchQuery.class.php b/plugins/arSolrPlugin/lib/client/arSolrMatchQuery.class.php
new file mode 100644
index 0000000000..9183d77cee
--- /dev/null
+++ b/plugins/arSolrPlugin/lib/client/arSolrMatchQuery.class.php
@@ -0,0 +1,59 @@
+<?php
+
+/*
+ * This file is part of the Access to Memory (AtoM) software.
+ *
+ * Access to Memory (AtoM) is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Access to Memory (AtoM) is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Access to Memory (AtoM).  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+class arSolrMatchQuery extends arSolrTermQuery
+{
+    /**
+     * Params.
+     */
+    protected array $params = [];
+
+    public function setFieldQuery($field, $value)
+    {
+        $this->setTerm($field, $value);
+    }
+
+    public function generateQueryParams()
+    {
+        $matchField = $this->getTermField();
+        if (!isset($matchField)) {
+            throw new Exception('Match field is not set.');
+        }
+
+        $matchValue = $this->getTermValue();
+        if (!isset($matchValue)) {
+            throw new Exception('Match value is not set.');
+        }
+
+        $type = $this->getType();
+        if (!isset($type)) {
+            throw new Exception("Match 'type' is not set.");
+        }
+
+        $this->query = [
+            'query' => [
+                'edismax' => [
+                    'query' => "{$type}.{$matchField}:{$matchValue}~",
+                ],
+            ],
+            'offset' => $this->offset,
+            'limit' => $this->size,
+        ];
+    }
+}
diff --git a/plugins/arSolrPlugin/lib/client/arSolrRangeQuery.class.php b/plugins/arSolrPlugin/lib/client/arSolrRangeQuery.class.php
new file mode 100644
index 0000000000..70738896af
--- /dev/null
+++ b/plugins/arSolrPlugin/lib/client/arSolrRangeQuery.class.php
@@ -0,0 +1,175 @@
+<?php
+
+/*
+ * This file is part of the Access to Memory (AtoM) software.
+ *
+ * Access to Memory (AtoM) is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Access to Memory (AtoM) is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Access to Memory (AtoM).  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+class arSolrRangeQuery extends arSolrAbstractQuery
+{
+    /**
+     * Query Params.
+     *
+     * @var mixed
+     */
+    protected $range;
+
+    /**
+     * Array of fields to be queried.
+     *
+     * @var array
+     */
+    protected $field;
+
+    /**
+     * Type.
+     *
+     * @var string
+     */
+    protected ?string $type = null;
+
+    /**
+     * Array of Query Params.
+     */
+    protected array $query = [];
+
+    /**
+     * Search query.
+     */
+    protected string $computedRange = '*';
+
+    /**
+     * Constructor.
+     *
+     * @param mixed $field
+     * @param mixed $range
+     */
+    public function __construct($field, $range = '*')
+    {
+        $this->setField($field);
+        $this->setRange($range);
+    }
+
+    public function setField($field)
+    {
+        $this->field = $field;
+    }
+
+    public function getField()
+    {
+        return $this->field;
+    }
+
+    public function getComputedRange()
+    {
+        return $this->computedRange;
+    }
+
+    public function setComputedRange($range)
+    {
+        $computedRange = '';
+        if ($range['lte']) {
+            $computedRange = "[{$range['lte']} TO ";
+        } elseif ($range['lt']) {
+            $computedRange = "{{$range['lte']} TO ";
+        } else {
+            $computedRange = '[* TO ';
+        }
+
+        if ($range['gte']) {
+            $computedRange .= "{$range['gte']}]";
+        } elseif ($range['gt']) {
+            $computedRange .= "{$range['gt']}}";
+        } else {
+            $computedRange .= '*]';
+        }
+
+        $this->computedRange = $computedRange;
+    }
+
+    public function getRange()
+    {
+        return $this->range;
+    }
+
+    public function validateRange($range)
+    {
+        $keys = array_keys($range);
+        $d = DateTime::createFromFormat('Y-m-d', $range[$keys[0]]);
+        $y = DateTime::createFromFormat('Y', $range[$keys[0]]);
+        if (false !== $d && $d->format('Y-m-d') === $range[$keys[0]]) {
+            return true;
+        }
+        if (false !== $y && $y->format('Y') === $range[$keys[0]]) {
+            return true;
+        }
+
+        return false;
+    }
+
+    public function setRange($range)
+    {
+        if (!is_array($range) || !$this->validateRange($range)) {
+            throw new Exception('Invalid range date format. Range date must be formatted as YYYY-MM-DD or YYYY.');
+        }
+
+        $this->range = $range;
+        $this->setComputedRange($range);
+    }
+
+    public function getQueryParams()
+    {
+        $this->generateQueryParams();
+
+        return $this->query;
+    }
+
+    public function setType($type)
+    {
+        if (empty($type)) {
+            return;
+        }
+
+        $this->type = $type;
+    }
+
+    public function getType()
+    {
+        return $this->type;
+    }
+
+    public function generateQueryParams()
+    {
+        $field = $this->getField();
+        if (!isset($field)) {
+            throw new Exception('Field is not set.');
+        }
+
+        $type = $this->getType();
+        if (!isset($type)) {
+            throw new Exception("Field 'type' is not set.");
+        }
+
+        $this->query = [
+            'query' => [
+                'lucene' => [
+                    'query' => "{$type}.{$field}:{$this->computedRange}",
+                ],
+            ],
+            'offset' => $this->offset,
+            'limit' => $this->size,
+        ];
+    }
+}
diff --git a/plugins/arSolrPlugin/lib/client/arSolrResult.class.php b/plugins/arSolrPlugin/lib/client/arSolrResult.class.php
new file mode 100644
index 0000000000..2871cf9d00
--- /dev/null
+++ b/plugins/arSolrPlugin/lib/client/arSolrResult.class.php
@@ -0,0 +1,181 @@
+<?php
+
+/*
+ * This file is part of the Access to Memory (AtoM) software.
+ *
+ * Access to Memory (AtoM) is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Access to Memory (AtoM) is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Access to Memory (AtoM).  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+class arSolrResult
+{
+    protected $_hit = [];
+
+    public function __construct($hit)
+    {
+        $this->_hit = $this->getStructuredDoc($hit);
+    }
+
+    /**
+     * Magic function to directly access keys inside the result.
+     *
+     * Returns null if key does not exist
+     *
+     * @param string $key Key name
+     *
+     * @return mixed Key value
+     */
+    public function __get($key)
+    {
+        $source = $this->getData();
+
+        return array_key_exists($key, $source) ? $source[$key] : null;
+    }
+
+    /**
+     * Magic function to support isset() calls.
+     *
+     * @param string $key Key name
+     *
+     * @return bool
+     */
+    public function __isset($key)
+    {
+        $source = $this->getData();
+
+        return array_key_exists($key, $source) && null !== $source[$key];
+    }
+
+    public function getParam($name)
+    {
+        if (isset($this->_hit[$name])) {
+            return $this->_hit[$name];
+        }
+
+        return [];
+    }
+
+    /**
+     * Test if a param from the result hit is set.
+     *
+     * @param string $name Param name to test
+     *
+     * @return bool True if the param is set, false otherwise
+     */
+    public function hasParam($name)
+    {
+        return isset($this->_hit[$name]);
+    }
+
+    /**
+     * Returns the hit id.
+     *
+     * @return string Hit id
+     */
+    public function getId()
+    {
+        return $this->getParam('_id');
+    }
+
+    /**
+     * Returns the type of the result.
+     *
+     * @return string Result type
+     */
+    public function getType()
+    {
+        return $this->getParam('_type');
+    }
+
+    /**
+     * Returns the raw hit array.
+     *
+     * @return array Hit array
+     */
+    public function getHit()
+    {
+        return $this->_hit;
+    }
+
+    /**
+     * Returns the version information from the hit.
+     *
+     * @return int|string Document version
+     */
+    public function getVersion()
+    {
+        return $this->getParam('_version');
+    }
+
+    /**
+     * Sets a parameter on the hit.
+     *
+     * @param string $param
+     * @param mixed  $value
+     */
+    public function setParam($param, $value)
+    {
+        $this->_hit[$param] = $value;
+    }
+
+    /**
+     * Alias for getData.
+     *
+     * @return Document
+     */
+    public function getDocument()
+    {
+        return $this->getData();
+    }
+
+    public function getData()
+    {
+        return $this->_hit;
+    }
+
+    public function getStructuredDoc($hit)
+    {
+        $structuredDoc = [];
+        foreach ($hit as $propertyName => $value) {
+            if (str_starts_with($propertyName, 'autocomplete_')) {
+                $structuredDoc[$propertyName] = $value;
+
+                continue;
+            }
+            if ('_version_' === $propertyName) {
+                $structuredDoc['_version'] = $value;
+
+                continue;
+            }
+            if (!str_contains($propertyName, '.')) {
+                $structuredDoc["_{$propertyName}"] = $value;
+
+                continue;
+            }
+
+            $fields = explode('.', $propertyName);
+            $structuredDoc['_type'] = $fields[0];
+            $docRef = &$structuredDoc;
+            $numFields = count($fields);
+            for ($i = 1; $i < $numFields; ++$i) {
+                if (!isset($docRef[$fields[$i]])) {
+                    $docRef[$fields[$i]] = [];
+                }
+                $docRef = &$docRef[$fields[$i]];
+            }
+            $docRef = $value;
+        }
+
+        return $structuredDoc;
+    }
+}
diff --git a/plugins/arSolrPlugin/lib/client/arSolrResultSet.class.php b/plugins/arSolrPlugin/lib/client/arSolrResultSet.class.php
new file mode 100644
index 0000000000..a9c0d758be
--- /dev/null
+++ b/plugins/arSolrPlugin/lib/client/arSolrResultSet.class.php
@@ -0,0 +1,216 @@
+<?php
+
+/*
+ * This file is part of the Access to Memory (AtoM) software.
+ *
+ * Access to Memory (AtoM) is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Access to Memory (AtoM) is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Access to Memory (AtoM).  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+class arSolrResultSet implements ArrayAccess, Countable, Iterator
+{
+    /**
+     * Response.
+     *
+     * @var null|array
+     */
+    protected $_response;
+
+    /**
+     * Current position.
+     *
+     * @var int Current position
+     */
+    private $_position = 0;
+
+    /**
+     * Results.
+     *
+     * @var Result[] Results
+     */
+    private $_results = [];
+
+    /**
+     * Constructs ResultSet object.
+     *
+     * @param Response $response Response object
+     * @param Query    $query    Query object
+     * @param Result[] $results
+     */
+    public function __construct($response)
+    {
+        $this->_response = $response->response;
+
+        $results = [];
+        foreach ($this->_response->docs as $responseDoc) {
+            array_push($results, new arSolrResult($responseDoc));
+        }
+        $this->_results = $results;
+    }
+
+    public function getResults()
+    {
+        return $this->_results;
+    }
+
+    public function getTotalHits()
+    {
+        return isset($this->_response['numFound']) ? (int) $this->_response['numFound'] : 0;
+    }
+
+    public function getMaxScore()
+    {
+        return isset($this->_response['maxScore']) ? (float) $this->_response['maxScore'] : 0;
+    }
+
+    public function getDocuments()
+    {
+        $documents = [];
+        foreach ($this->_results as $doc) {
+            $documents[] = $doc->getDocument();
+        }
+
+        return $documents;
+    }
+
+    /**
+     * Returns size of current set.
+     *
+     * @return int Size of set
+     */
+    public function count()
+    {
+        return count($this->_results);
+    }
+
+    /**
+     * Returns the current object of the set.
+     *
+     * @return arSolrResult|false Set object or false if not valid (no more entries)
+     */
+    public function current()
+    {
+        if ($this->valid()) {
+            return $this->_results[$this->key()];
+        }
+
+        return false;
+    }
+
+    /**
+     * Sets pointer (current) to the next item of the set.
+     */
+    public function next()
+    {
+        ++$this->_position;
+
+        return $this->current();
+    }
+
+    /**
+     * Returns the position of the current entry.
+     *
+     * @return int Current position
+     */
+    public function key()
+    {
+        return $this->_position;
+    }
+
+    /**
+     * Check if an object exists at the current position.
+     *
+     * @return bool True if object exists
+     */
+    public function valid()
+    {
+        return isset($this->_results[$this->key()]);
+    }
+
+    /**
+     * Resets position to 0, restarts iterator.
+     */
+    public function rewind()
+    {
+        $this->_position = 0;
+    }
+
+    /**
+     * Whether a offset exists.
+     *
+     * @see http://php.net/manual/en/arrayaccess.offsetexists.php
+     *
+     * @param int $offset
+     *
+     * @return bool true on success or false on failure
+     */
+    public function offsetExists($offset)
+    {
+        return isset($this->_results[$offset]);
+    }
+
+    /**
+     * Offset to retrieve.
+     *
+     * @see http://php.net/manual/en/arrayaccess.offsetget.php
+     *
+     * @param int $offset
+     *
+     * @throws Exception\InvalidException If offset doesn't exist
+     *
+     * @return null|Result
+     */
+    public function offsetGet($offset)
+    {
+        if ($this->offsetExists($offset)) {
+            return $this->_results[$offset];
+        }
+
+        throw new InvalidException('Offset does not exist.');
+    }
+
+    /**
+     * Offset to set.
+     *
+     * @see http://php.net/manual/en/arrayaccess.offsetset.php
+     *
+     * @param int    $offset
+     * @param Result $value
+     *
+     * @throws Exception\InvalidException
+     */
+    public function offsetSet($offset, $value)
+    {
+        if (!($value instanceof Result)) {
+            throw new InvalidException('ResultSet is a collection of Result only.');
+        }
+
+        if (!isset($this->_results[$offset])) {
+            throw new InvalidException('Offset does not exist.');
+        }
+
+        $this->_results[$offset] = $value;
+    }
+
+    /**
+     * Offset to unset.
+     *
+     * @see http://php.net/manual/en/arrayaccess.offsetunset.php
+     *
+     * @param int $offset
+     */
+    public function offsetUnset($offset)
+    {
+        unset($this->_results[$offset]);
+    }
+}
diff --git a/plugins/arSolrPlugin/lib/client/arSolrStringQuery.class.php b/plugins/arSolrPlugin/lib/client/arSolrStringQuery.class.php
new file mode 100644
index 0000000000..a9542e23a4
--- /dev/null
+++ b/plugins/arSolrPlugin/lib/client/arSolrStringQuery.class.php
@@ -0,0 +1,193 @@
+<?php
+
+/*
+ * This file is part of the Access to Memory (AtoM) software.
+ *
+ * Access to Memory (AtoM) is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Access to Memory (AtoM) is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Access to Memory (AtoM).  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * arSolrStringQuery.
+ */
+class arSolrStringQuery extends arSolrAbstractQuery
+{
+    /**
+     * Query Params.
+     *
+     * @var mixed
+     */
+    protected $query;
+
+    /**
+     * Array of fields to be queried.
+     *
+     * @var array
+     */
+    protected $fields;
+
+    /**
+     * Default operator.
+     *
+     * @var string defaults to 'AND'
+     */
+    protected ?string $operator = 'AND';
+
+    /**
+     * Search query.
+     *
+     * @var string
+     */
+    protected ?string $searchQuery;
+
+    /**
+     * Aggregations.
+     */
+    protected array $aggregations = [];
+
+    /**
+     * Field type.
+     *
+     * @var string
+     */
+    protected ?string $type = null;
+
+    /**
+     * Constructor.
+     *
+     * @param mixed $searchQuery
+     */
+    public function __construct($searchQuery)
+    {
+        $this->setSearchQuery($searchQuery);
+    }
+
+    public function setFields($fields)
+    {
+        $this->fields = $fields;
+    }
+
+    public function getDefaultOperator()
+    {
+        return $this->operator;
+    }
+
+    public function setDefaultOperator($operator)
+    {
+        if ('AND' !== $operator && 'OR' !== $operator) {
+            throw new Exception('Invalid operator. AND and OR are the only acceptable operator types.');
+        }
+
+        $this->operator = $operator;
+    }
+
+    public function setSearchQuery($searchQuery)
+    {
+        $this->searchQuery = $searchQuery;
+    }
+
+    public function getFields()
+    {
+        return $this->fields;
+    }
+
+    public function getSearchQuery()
+    {
+        return $this->searchQuery;
+    }
+
+    public function getQueryParams()
+    {
+        $this->generateQueryParams();
+
+        return $this->query;
+    }
+
+    public function getAggregations()
+    {
+        return $this->aggregations;
+    }
+
+    public function setAggregations($aggregations)
+    {
+        $this->aggregations = $aggregations;
+    }
+
+    public function generateQueryParams()
+    {
+        $fields = $this->getFields();
+        if (!isset($fields)) {
+            throw new Exception('Fields not set.');
+        }
+
+        $type = $this->getType();
+        if (!isset($type)) {
+            throw new Exception("Field 'type' is not set.");
+        }
+
+        $typedFields = [];
+        foreach ($fields as $field) {
+            array_push($typedFields, "{$type}.{$field}");
+        }
+
+        if ($this->aggregations) {
+            $aggregationField = "{$type}.{$this->aggregations['field']}";
+            $this->query = [
+                'query' => [
+                    'edismax' => [
+                        'q.op' => $this->operator,
+                        'stopwords' => 'true',
+                        'query' => "{$this->searchQuery}~",
+                        'qf' => implode(' ', $typedFields),
+                    ],
+                ],
+                'facet' => [
+                    'categories' => [
+                        'type' => 'terms',
+                        'field' => $aggregationField,
+                        'limit' => $this->aggregations['size'],
+                    ],
+                ],
+                'offset' => $this->offset,
+                'limit' => $this->size,
+            ];
+        } else {
+            $this->query = [
+                'query' => [
+                    'edismax' => [
+                        'q.op' => $this->operator,
+                        'stopwords' => 'true',
+                        'query' => "{$this->searchQuery}~",
+                        'qf' => implode(' ', $typedFields),
+                    ],
+                ],
+                'offset' => $this->offset,
+                'limit' => $this->size,
+            ];
+        }
+    }
+
+    public function setType($type)
+    {
+        if (empty($type)) {
+            return;
+        }
+
+        $this->type = $type;
+    }
+
+    public function getType()
+    {
+        return $this->type;
+    }
+}
diff --git a/plugins/arSolrPlugin/lib/client/arSolrTermQuery.class.php b/plugins/arSolrPlugin/lib/client/arSolrTermQuery.class.php
new file mode 100644
index 0000000000..b15729d93f
--- /dev/null
+++ b/plugins/arSolrPlugin/lib/client/arSolrTermQuery.class.php
@@ -0,0 +1,129 @@
+<?php
+
+/*
+ * This file is part of the Access to Memory (AtoM) software.
+ *
+ * Access to Memory (AtoM) is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Access to Memory (AtoM) is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Access to Memory (AtoM).  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+class arSolrTermQuery extends arSolrAbstractQuery
+{
+    /**
+     * Query Params.
+     *
+     * @var mixed
+     */
+    protected array $query = [];
+
+    /**
+     * Query Term Field.
+     *
+     * @var string
+     */
+    protected ?string $termField = null;
+
+    /**
+     * Query Term Value.
+     *
+     * @var string
+     */
+    protected ?string $termValue = null;
+
+    /**
+     * Field type.
+     *
+     * @var string
+     */
+    protected ?string $type = null;
+
+    /**
+     * Constructor.
+     *
+     * @param mixed      $searchQuery
+     * @param null|mixed $term
+     */
+    public function __construct($term = null)
+    {
+        if ($term) {
+            foreach ($term as $field => $value) {
+                $this->setTerm($field, $value);
+            }
+        }
+    }
+
+    public function setTerm($field, $value)
+    {
+        $this->termField = $field;
+        $this->termValue = $value;
+    }
+
+    public function getTermValue()
+    {
+        return $this->termValue;
+    }
+
+    public function getTermField()
+    {
+        return $this->termField;
+    }
+
+    public function getQueryParams()
+    {
+        $this->generateQueryParams();
+
+        return $this->query;
+    }
+
+    public function setType($type)
+    {
+        if (empty($type)) {
+            return;
+        }
+
+        $this->type = $type;
+    }
+
+    public function getType()
+    {
+        return $this->type;
+    }
+
+    protected function generateQueryParams()
+    {
+        $termField = $this->getTermField();
+        if (!isset($termField)) {
+            throw new Exception('Term field is not set.');
+        }
+
+        $termValue = $this->getTermValue();
+        if (!isset($termValue)) {
+            throw new Exception('Term value is not set.');
+        }
+
+        $type = $this->getType();
+        if (!isset($type)) {
+            throw new Exception("Field 'type' is not set.");
+        }
+
+        $this->query = [
+            'query' => [
+                'edismax' => [
+                    'query' => "{$type}.{$termField}:{$termValue}",
+                ],
+            ],
+            'offset' => $this->offset,
+            'limit' => $this->size,
+        ];
+    }
+}
diff --git a/plugins/arSolrPlugin/lib/client/arSolrTermsQuery.class.php b/plugins/arSolrPlugin/lib/client/arSolrTermsQuery.class.php
new file mode 100644
index 0000000000..281b5373df
--- /dev/null
+++ b/plugins/arSolrPlugin/lib/client/arSolrTermsQuery.class.php
@@ -0,0 +1,130 @@
+<?php
+
+/*
+ * This file is part of the Access to Memory (AtoM) software.
+ *
+ * Access to Memory (AtoM) is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Access to Memory (AtoM) is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Access to Memory (AtoM).  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+class arSolrTermsQuery extends arSolrAbstractQuery
+{
+    /**
+     * Query Params.
+     *
+     * @var mixed
+     */
+    protected array $query = [];
+
+    /**
+     * Query Term Field.
+     *
+     * @var string
+     */
+    protected ?string $termField = null;
+
+    /**
+     * Query Term Value.
+     *
+     * @var array
+     */
+    protected ?array $termValues = null;
+
+    /**
+     * Field type.
+     *
+     * @var string
+     */
+    protected ?string $type = null;
+
+    /**
+     * Constructor.
+     *
+     * @param mixed      $searchQuery
+     * @param null|mixed $term
+     */
+    public function __construct($term = null)
+    {
+        if ($term) {
+            foreach ($term as $field => $values) {
+                $this->setTerms($field, $values);
+            }
+        }
+    }
+
+    public function setTerms($field, $values)
+    {
+        $this->termField = $field;
+        $this->termValues = $values;
+    }
+
+    public function getTermValues()
+    {
+        return $this->termValues;
+    }
+
+    public function getTermField()
+    {
+        return $this->termField;
+    }
+
+    public function getQueryParams()
+    {
+        $this->generateQueryParams();
+
+        return $this->query;
+    }
+
+    public function setType($type)
+    {
+        if (empty($type)) {
+            return;
+        }
+
+        $this->type = $type;
+    }
+
+    public function getType()
+    {
+        return $this->type;
+    }
+
+    protected function generateQueryParams()
+    {
+        $termField = $this->getTermField();
+        if (!isset($termField)) {
+            throw new Exception('Term field is not set.');
+        }
+
+        $termValues = $this->getTermValues();
+        if (!isset($termValues)) {
+            throw new Exception('Term values are not set.');
+        }
+
+        $type = $this->getType();
+        if (!isset($type)) {
+            throw new Exception("Field 'type' is not set.");
+        }
+
+        $queryString = implode(' OR ', $termValues);
+        $this->query = [
+            'query' => [
+                'edismax' => [
+                    'query' => "{$type}.{$termField}:({$queryString})",
+                ],
+            ],
+            'offset' => $this->offset,
+            'limit' => $this->size,
+        ];
+    }
+}
diff --git a/plugins/arSolrPlugin/lib/model/arSolrAccession.class.php b/plugins/arSolrPlugin/lib/model/arSolrAccession.class.php
new file mode 100644
index 0000000000..47a39c8287
--- /dev/null
+++ b/plugins/arSolrPlugin/lib/model/arSolrAccession.class.php
@@ -0,0 +1,184 @@
+<?php
+
+/*
+ * This file is part of the Access to Memory (AtoM) software.
+ *
+ * Access to Memory (AtoM) is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Access to Memory (AtoM) is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Access to Memory (AtoM).  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+class arSolrAccession extends arSolrModelBase
+{
+    protected static $statements;
+
+    public function load()
+    {
+        $accessionIds = QubitPdo::fetchAll(
+            'SELECT id FROM '.QubitAccession::TABLE_NAME,
+            [],
+            ['fetchMode' => PDO::FETCH_COLUMN]
+        );
+
+        $this->count = count($accessionIds);
+
+        return $accessionIds;
+    }
+
+    public function populate()
+    {
+        $errors = [];
+
+        foreach ($this->load() as $key => $id) {
+            try {
+                $data = self::serialize($id);
+
+                $this->search->addDocument($data, 'QubitAccession');
+
+                $this->logEntry($data['identifier'], $key + 1);
+            } catch (sfException $e) {
+                $errors[] = $e->getMessage();
+            }
+        }
+
+        return $errors;
+    }
+
+    public static function update($object)
+    {
+        $data = self::serialize($object->id);
+
+        QubitSearch::getSolrInstance()->addDocument($data, 'QubitAccession');
+
+        return true;
+    }
+
+    public static function getAccessionEvents($accessionId)
+    {
+        if (!isset(self::$statements['event'])) {
+            $sql = 'SELECT
+                event.id,
+                event.type_id,
+                event.date,
+                note.id AS note_id
+                FROM '.QubitAccessionEvent::TABLE_NAME.' event
+                INNER JOIN '.QubitNote::TABLE_NAME.' note
+                ON (event.id=note.object_id AND note.type_id=?)
+                WHERE event.accession_id = ?';
+
+            self::$statements['event'] = self::$conn->prepare($sql);
+        }
+
+        self::$statements['event']->execute([QubitTerm::ACCESSION_EVENT_NOTE_ID, $accessionId]);
+
+        $events = [];
+        foreach (self::$statements['event']->fetchAll(PDO::FETCH_ASSOC) as $item) {
+            $event = ['id' => $item['id']];
+
+            $event['date'] = arSolrPluginUtil::normalizeDateWithoutMonthOrDay($item['date']);
+            $event['dateString'] = Qubit::renderDate($item['date']);
+
+            // Serialize type term
+            if ($item['type_id']) {
+                $event['type'] = ['i18n' => arSolrModelBase::serializeI18ns(
+                    $item['type_id'],
+                    ['QubitTerm'],
+                    ['fields' => ['name']]
+                )];
+            }
+
+            // Serialize note
+            if ($item['note_id']) {
+                $event['notes'] = ['i18n' => arSolrModelBase::serializeI18ns(
+                    $item['note_id'],
+                    ['QubitNote'],
+                    ['fields' => ['content']]
+                )];
+            }
+
+            // Serialize accession event i18n data
+            $event['i18n'] = arSolrModelBase::serializeI18ns($item['id'], ['QubitAccessionEvent']);
+
+            $events[] = $event;
+        }
+
+        return $events;
+    }
+
+    private static function serialize($id)
+    {
+        if (!isset(self::$conn)) {
+            self::$conn = Propel::getConnection();
+        }
+
+        if (!isset(self::$statements['accession'])) {
+            $sql = 'SELECT acc.*, slug.slug
+                FROM '.QubitAccession::TABLE_NAME.' acc
+                JOIN '.QubitSlug::TABLE_NAME.' slug ON acc.id = slug.object_id
+                WHERE acc.id = :id';
+
+            self::$statements['accession'] = self::$conn->prepare($sql);
+        }
+
+        self::$statements['accession']->execute([':id' => $id]);
+        $data = self::$statements['accession']->fetch(PDO::FETCH_ASSOC);
+
+        if (false === $data) {
+            throw new sfException("Couldn't find accession (id: {$id})");
+        }
+
+        $serialized = [];
+        $serialized['id'] = $id;
+        $serialized['slug'] = $data['slug'];
+        $serialized['identifier'] = $data['identifier'];
+        $serialized['date'] = arSolrPluginUtil::convertDate($data['date']);
+        $serialized['createdAt'] = arSolrPluginUtil::convertDate($data['created_at']);
+        $serialized['updatedAt'] = arSolrPluginUtil::convertDate($data['updated_at']);
+        $serialized['sourceCulture'] = $data['source_culture'];
+        $serialized['i18n'] = self::serializeI18ns($id, ['QubitAccession']);
+
+        $sql = 'SELECT o.id, o.source_culture, o.type_id FROM '.QubitOtherName::TABLE_NAME." o \r
+            INNER JOIN ".QubitTerm::TABLE_NAME." t ON o.type_id=t.id \r
+            WHERE o.object_id = ? AND t.taxonomy_id= ?";
+        $params = [$id, QubitTaxonomy::ACCESSION_ALTERNATIVE_IDENTIFIER_TYPE_ID];
+
+        foreach (QubitPdo::fetchAll($sql, $params) as $item) {
+            $serialized['alternativeIdentifiers'][] = arSolrOtherName::serialize($item);
+        }
+
+        foreach (QubitRelation::getRelationsBySubjectId($id, ['typeId' => QubitTerm::DONOR_ID]) as $item) {
+            $serialized['donors'][] = arSolrDonor::serialize($item->object);
+        }
+
+        foreach (QubitRelation::getRelationsByObjectId($id, ['typeId' => QubitTerm::CREATION_ID]) as $item) {
+            $node = new arSolrActorPdo($item->subject->id);
+
+            $creators = [
+                'id' => $node->id,
+                'i18n' => arSolrModelBase::serializeI18ns(
+                    $node->id,
+                    ['QubitActor'],
+                    ['fields' => ['authorized_form_of_name']]
+                ),
+            ];
+
+            // Add other names, parallel names, and standardized names
+            $creators += $node->serializeAltNames();
+
+            $serialized['creators'][] = $creators;
+        }
+
+        $serialized['accessionEvents'] = self::getAccessionEvents($id);
+
+        return $serialized;
+    }
+}
diff --git a/plugins/arSolrPlugin/lib/model/arSolrActor.class.php b/plugins/arSolrPlugin/lib/model/arSolrActor.class.php
new file mode 100644
index 0000000000..844f1f5de9
--- /dev/null
+++ b/plugins/arSolrPlugin/lib/model/arSolrActor.class.php
@@ -0,0 +1,65 @@
+<?php
+
+/*
+ * This file is part of the Access to Memory (AtoM) software.
+ *
+ * Access to Memory (AtoM) is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Access to Memory (AtoM) is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Access to Memory (AtoM).  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+class arSolrActor extends arSolrModelBase
+{
+    public function load()
+    {
+        $sql = 'SELECT actor.id';
+        $sql .= ' FROM '.QubitActor::TABLE_NAME.' actor';
+        $sql .= ' JOIN '.QubitObject::TABLE_NAME.' object ON actor.id = object.id';
+        $sql .= ' WHERE actor.id != ? AND object.class_name = ?';
+
+        $actors = QubitPdo::fetchAll($sql, [QubitActor::ROOT_ID, 'QubitActor']);
+
+        $this->count = count($actors);
+
+        return $actors;
+    }
+
+    public function populate()
+    {
+        $errors = [];
+
+        // Loop through results, and add to search index
+        foreach ($this->load() as $key => $item) {
+            try {
+                $node = new arSolrActorPdo($item->id);
+                $data = $node->serialize();
+
+                QubitSearch::getSolrInstance()->addDocument($data, 'QubitActor');
+
+                $this->logEntry($data['i18n'][$data['sourceCulture']]['authorizedFormOfName'], $key + 1);
+            } catch (sfException $e) {
+                $errors[] = $e->getMessage();
+            }
+        }
+
+        return $errors;
+    }
+
+    public static function update($object)
+    {
+        $node = new arSolrActorPdo($object->id);
+
+        QubitSearch::getSolrInstance()->addDocument($node->serialize(), 'QubitActor');
+
+        return true;
+    }
+}
diff --git a/plugins/arSolrPlugin/lib/model/arSolrActorPdo.class.php b/plugins/arSolrPlugin/lib/model/arSolrActorPdo.class.php
new file mode 100644
index 0000000000..a9a3578c78
--- /dev/null
+++ b/plugins/arSolrPlugin/lib/model/arSolrActorPdo.class.php
@@ -0,0 +1,393 @@
+<?php
+
+/*
+ * This file is part of the Access to Memory (AtoM) software.
+ *
+ * Access to Memory (AtoM) is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Access to Memory (AtoM) is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Access to Memory (AtoM).  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * Manage actors in search index.
+ *
+ * @author     MJ Suhonos <mj@suhonos.ca>
+ */
+class arSolrActorPdo
+{
+    public $i18ns;
+
+    protected $data = [];
+
+    protected static $conn;
+    protected static $lookups;
+    protected static $statements;
+    protected static $converseTermIds;
+
+    /**
+     * METHODS.
+     *
+     * @param mixed $id
+     * @param mixed $options
+     */
+    public function __construct($id, $options = [])
+    {
+        if (isset($options['conn'])) {
+            self::$conn = $options['conn'];
+        }
+
+        if (!isset(self::$conn)) {
+            self::$conn = Propel::getConnection();
+        }
+
+        $this->loadData($id, $options);
+    }
+
+    public function __isset($name)
+    {
+        return isset($this->data[$name]);
+    }
+
+    public function __get($name)
+    {
+        if ('events' == $name && !isset($this->data[$name])) {
+            $this->data[$name] = $this->getEvents();
+        }
+
+        if (isset($this->data[$name])) {
+            return $this->data[$name];
+        }
+    }
+
+    public function __set($name, $value)
+    {
+        $this->data[$name] = $value;
+    }
+
+    public function getMimeType()
+    {
+        if (!$this->__isset('digital_object_id')) {
+            return;
+        }
+
+        if (null !== $digitalObject = QubitDigitalObject::getById($this->__get('digital_object_id'))) {
+            return $digitalObject->getMimeType();
+        }
+    }
+
+    public function getThumbnailPath()
+    {
+        if (!$this->__isset('digital_object_id')) {
+            return;
+        }
+
+        $criteria = new Criteria();
+        $criteria->add(QubitDigitalObject::PARENT_ID, $this->__get('digital_object_id'));
+        $criteria->add(QubitDigitalObject::USAGE_ID, QubitTerm::THUMBNAIL_ID);
+
+        if (null !== $thumbnail = QubitDigitalObject::getOne($criteria)) {
+            return $thumbnail->getFullPath();
+        }
+    }
+
+    public function getDigitalObjectAltText()
+    {
+        if (!$this->__isset('digital_object_id')) {
+            return;
+        }
+
+        $criteria = new Criteria();
+        $criteria->add(QubitDigitalObject::PARENT_ID, $this->__get('digital_object_id'));
+
+        if (null !== $do = QubitDigitalObject::getOne($criteria)) {
+            return $do->getDigitalObjectAltText();
+        }
+    }
+
+    public function serialize()
+    {
+        $serialized = [];
+
+        $serialized['id'] = $this->id;
+        $serialized['slug'] = $this->slug;
+
+        $serialized['entityTypeId'] = $this->entity_type_id;
+        $serialized['hasDigitalObject'] = !is_null($this->media_type_id);
+
+        $serialized['descriptionIdentifier'] = $this->description_identifier;
+        $serialized['corporateBodyIdentifiers'] = $this->corporate_body_identifiers;
+
+        // Add other names, parallel names, and standardized names
+        $serialized += $this->serializeAltNames();
+
+        if (false !== $maintainingRepositoryId = $this->getMaintainingRepositoryId()) {
+            $serialized['maintainingRepositoryId'] = (int) $maintainingRepositoryId;
+        }
+
+        foreach ($this->getOccupations() as $occupation) {
+            $occupationArray = [];
+
+            $i18nFields = arSolrModelBase::serializeI18ns(
+                $occupation->term_id,
+                ['QubitTerm'],
+                ['fields' => ['name']]
+            );
+
+            if (isset($occupation->note_id)) {
+                $i18nFields = arSolrModelBase::serializeI18ns(
+                    $occupation->note_id,
+                    ['QubitNote'],
+                    ['fields' => ['content'], 'merge' => $i18nFields]
+                );
+            }
+
+            $occupationArray['id'] = $occupation->term_id;
+            $occupationArray['i18n'] = $i18nFields;
+
+            $serialized['occupations'][] = $occupationArray;
+        }
+
+        // Related terms
+        $relatedTerms = arSolrModelBase::getRelatedTerms(
+            $this->id,
+            [QubitTaxonomy::PLACE_ID, QubitTaxonomy::SUBJECT_ID]
+        );
+
+        // Related objects
+        $serialized['actorRelations'] = self::serializeObjectRelations($this->id);
+        $serialized['actorDirectRelationTypes'] = self::serializeObjectDirectRelationTypes($this->id, $serialized['actorRelations']);
+
+        // Places
+        if (isset($relatedTerms[QubitTaxonomy::PLACE_ID])) {
+            $serialized['directPlaces'] = $relatedTerms[QubitTaxonomy::PLACE_ID];
+            $extendedPlaceIds = arSolrModelBase::extendRelatedTerms(
+                $relatedTerms[QubitTaxonomy::PLACE_ID]
+            );
+
+            foreach ($extendedPlaceIds as $id) {
+                $node = new arSolrTermPdo($id);
+                $serialized['places'][] = $node->serialize();
+            }
+        }
+
+        // Subjects
+        if (isset($relatedTerms[QubitTaxonomy::SUBJECT_ID])) {
+            $serialized['directSubjects'] = $relatedTerms[QubitTaxonomy::SUBJECT_ID];
+            $extendedSubjectIds = arSolrModelBase::extendRelatedTerms(
+                $relatedTerms[QubitTaxonomy::SUBJECT_ID]
+            );
+
+            foreach ($extendedSubjectIds as $id) {
+                $node = new arSolrTermPdo($id);
+                $serialized['subjects'][] = $node->serialize();
+            }
+        }
+
+        // Maintenance notes
+        $sql = 'SELECT id, source_culture FROM '.QubitNote::TABLE_NAME.' WHERE object_id = ? AND type_id = ?';
+        foreach (QubitPdo::fetchAll($sql, [$this->id, QubitTerm::MAINTENANCE_NOTE_ID]) as $item) {
+            $serialized['maintenanceNotes'][] = arSolrNote::serialize($item);
+        }
+
+        // Media
+        if ($this->media_type_id) {
+            $serialized['digitalObject']['mediaTypeId'] = $this->media_type_id;
+            $serialized['digitalObject']['usageId'] = $this->usage_id;
+            $serialized['digitalObject']['filename'] = $this->filename;
+            $serialized['digitalObject']['thumbnailPath'] = $this->getThumbnailPath();
+            $serialized['digitalObject']['digitalObjectAltText'] = $this->getDigitalObjectAltText();
+
+            $serialized['hasDigitalObject'] = true;
+        } else {
+            $serialized['hasDigitalObject'] = false;
+        }
+
+        $serialized['createdAt'] = arSolrPluginUtil::convertDate($this->created_at);
+        $serialized['updatedAt'] = arSolrPluginUtil::convertDate($this->updated_at);
+
+        $serialized['sourceCulture'] = $this->source_culture;
+        $serialized['i18n'] = arSolrModelBase::serializeI18ns($this->id, ['QubitActor']);
+
+        return $serialized;
+    }
+
+    public function serializeAltNames()
+    {
+        $serialized = [];
+
+        $sql = 'SELECT id, source_culture FROM '.QubitOtherName::TABLE_NAME.' WHERE object_id = ? AND type_id = ?';
+        foreach (QubitPdo::fetchAll($sql, [$this->id, QubitTerm::OTHER_FORM_OF_NAME_ID]) as $item) {
+            $serialized['otherNames'][] = arSolrOtherName::serialize($item);
+        }
+
+        $sql = 'SELECT id, source_culture FROM '.QubitOtherName::TABLE_NAME.' WHERE object_id = ? AND type_id = ?';
+        foreach (QubitPdo::fetchAll($sql, [$this->id, QubitTerm::PARALLEL_FORM_OF_NAME_ID]) as $item) {
+            $serialized['parallelNames'][] = arSolrOtherName::serialize($item);
+        }
+
+        $sql = 'SELECT id, source_culture FROM '.QubitOtherName::TABLE_NAME.' WHERE object_id = ? AND type_id = ?';
+        foreach (QubitPdo::fetchAll($sql, [$this->id, QubitTerm::STANDARDIZED_FORM_OF_NAME_ID]) as $item) {
+            $serialized['standardizedNames'][] = arSolrOtherName::serialize($item);
+        }
+
+        return $serialized;
+    }
+
+    public static function serializeObjectDirectRelationTypes($actorId, $relationData)
+    {
+        $relationTypeIds = [];
+
+        // Cycle through each relation an actor's involved in
+        foreach ($relationData as $relation) {
+            $typeId = $relation['typeId'];
+
+            if ($relation['objectId'] == $actorId) {
+                // Add type ID to array if it hasn't already been added
+                if (!in_array($typeId, $relationTypeIds)) {
+                    $relationTypeIds[] = $typeId;
+                }
+            } else {
+                // If actor is the subject of the relation then look up the converse of the type
+                if (isset(self::$converseTermIds[$typeId])) {
+                    // Get cached type ID
+                    $converseTermId = self::$converseTermIds[$typeId];
+                } else {
+                    // Look up converse term, if any
+                    $sql = 'SELECT IF(object_id=?, subject_id, object_id) AS converse_id
+                        FROM relation
+                        WHERE (object_id=? or subject_id=?)
+                        AND type_id=?';
+
+                    $result = QubitPdo::fetchColumn($sql, [$typeId, $typeId, $typeId, QubitTerm::CONVERSE_TERM_ID]);
+
+                    $converseTermId = !empty($result) ? $result : $typeId;
+
+                    // Cache result
+                    self::$converseTermIds[$typeId] = $converseTermId;
+                }
+
+                // Add type ID to array if it hasn't already been added
+                if (!in_array($converseTermId, $relationTypeIds)) {
+                    $relationTypeIds[] = $converseTermId;
+                }
+            }
+        }
+
+        return $relationTypeIds;
+    }
+
+    public static function serializeObjectRelations($actorId)
+    {
+        $sql = 'SELECT r.object_id AS objectId, r.subject_id AS subjectId, r.type_id AS typeId
+            FROM '.QubitRelation::TABLE_NAME.' r
+            INNER JOIN '.QubitTerm::TABLE_NAME.' t ON r.type_id=t.id
+            WHERE t.taxonomy_id='.QubitTaxonomy::ACTOR_RELATION_TYPE_ID.'
+            AND object_id=? OR r.subject_id=?';
+
+        return QubitPdo::fetchAll($sql, [$actorId, $actorId], ['fetchMode' => PDO::FETCH_ASSOC]);
+    }
+
+    protected function loadData($id)
+    {
+        if (!isset(self::$statements['actor'])) {
+            $sql = 'SELECT
+                actor.*,
+                slug.slug,
+                object.created_at,
+                object.updated_at,
+                do.id as digital_object_id,
+                do.media_type_id as media_type_id,
+                do.usage_id as usage_id,
+                do.name as filename
+                FROM '.QubitActor::TABLE_NAME.' actor
+                JOIN '.QubitSlug::TABLE_NAME.' slug
+                ON actor.id = slug.object_id
+                JOIN '.QubitObject::TABLE_NAME.' object
+                ON actor.id = object.id
+                LEFT JOIN '.QubitDigitalObject::TABLE_NAME.' do
+                ON actor.id = do.object_id
+                WHERE actor.id = :id';
+
+            self::$statements['actor'] = self::$conn->prepare($sql);
+        }
+
+        // Do select
+        self::$statements['actor']->execute([':id' => $id]);
+
+        // Get first result
+        $this->data = self::$statements['actor']->fetch(PDO::FETCH_ASSOC);
+
+        if (false === $this->data) {
+            throw new sfException("Couldn't find actor (id: {$id})");
+        }
+
+        self::$statements['actor']->closeCursor();
+
+        return $this;
+    }
+
+    protected function getMaintainingRepositoryId()
+    {
+        if (!isset(self::$statements['maintainingRepository'])) {
+            $sql = 'SELECT rel.subject_id';
+            $sql .= ' FROM '.QubitRelation::TABLE_NAME.' rel';
+            $sql .= ' WHERE rel.object_id = :object_id';
+            $sql .= '   AND rel.type_id = :type_id';
+
+            self::$statements['maintainingRepository'] = self::$conn->prepare($sql);
+        }
+
+        self::$statements['maintainingRepository']->execute([
+            ':object_id' => $this->id,
+            ':type_id' => QubitTerm::MAINTAINING_REPOSITORY_RELATION_ID,
+        ]);
+
+        return self::$statements['maintainingRepository']->fetchColumn();
+    }
+
+    protected function getOccupations()
+    {
+        if (!isset(self::$statements['occupations'])) {
+            $sql = 'SELECT term.id as term_id, note.id as note_id';
+            $sql .= ' FROM '.QubitObjectTermRelation::TABLE_NAME.' rel';
+            $sql .= ' JOIN '.QubitTerm::TABLE_NAME.' term
+                ON rel.term_id = term.id';
+            $sql .= ' LEFT JOIN '.QubitNote::TABLE_NAME.' note
+                ON rel.id = note.object_id
+                AND note.type_id = :type_id';
+            $sql .= ' WHERE rel.object_id = :object_id';
+            $sql .= ' AND term.taxonomy_id = :taxonomy_id';
+
+            self::$statements['occupations'] = self::$conn->prepare($sql);
+        }
+
+        self::$statements['occupations']->execute([
+            ':type_id' => QubitTerm::ACTOR_OCCUPATION_NOTE_ID,
+            ':object_id' => $this->id,
+            ':taxonomy_id' => QubitTaxonomy::ACTOR_OCCUPATION_ID,
+        ]);
+
+        return self::$statements['occupations']->fetchAll(PDO::FETCH_OBJ);
+    }
+
+    protected function getProperty($name)
+    {
+        $sql = 'SELECT prop.id, prop.source_culture';
+        $sql .= ' FROM '.QubitProperty::TABLE_NAME.' prop';
+        $sql .= ' WHERE prop.object_id = ? AND prop.name = ?';
+
+        self::$statements['property'] = self::$conn->prepare($sql);
+        self::$statements['property']->execute([$this->__get('id'), $name]);
+
+        return self::$statements['property']->fetch(PDO::FETCH_OBJ);
+    }
+}
diff --git a/plugins/arSolrPlugin/lib/model/arSolrAip.class.php b/plugins/arSolrPlugin/lib/model/arSolrAip.class.php
new file mode 100644
index 0000000000..b074411db2
--- /dev/null
+++ b/plugins/arSolrPlugin/lib/model/arSolrAip.class.php
@@ -0,0 +1,63 @@
+<?php
+
+/*
+ * This file is part of the Access to Memory (AtoM) software.
+ *
+ * Access to Memory (AtoM) is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Access to Memory (AtoM) is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Access to Memory (AtoM).  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+class arSolrAip extends arSolrModelBase
+{
+    public function load()
+    {
+        $sql = 'SELECT id';
+        $sql .= ' FROM '.QubitAip::TABLE_NAME;
+
+        $aips = QubitPdo::fetchAll($sql, ['QubitAip']);
+
+        $this->count = count($aips);
+
+        return $aips;
+    }
+
+    public function populate()
+    {
+        $errors = [];
+
+        // Loop through results, and add to search index
+        foreach ($this->load() as $key => $item) {
+            try {
+                $node = new arSolrAipPdo($item->id);
+                $data = $node->serialize();
+
+                QubitSearch::getSolrInstance()->addDocument($data, 'QubitAip');
+
+                $this->logEntry($data['filename'], $key + 1);
+            } catch (sfException $e) {
+                $errors[] = $e->getMessage();
+            }
+        }
+
+        return $errors;
+    }
+
+    public static function update($object)
+    {
+        $node = new arSolrAipPdo($object->id);
+
+        QubitSearch::getSolrInstance()->addDocument($node->serialize(), 'QubitAip');
+
+        return true;
+    }
+}
diff --git a/plugins/arSolrPlugin/lib/model/arSolrAipPdo.class.php b/plugins/arSolrPlugin/lib/model/arSolrAipPdo.class.php
new file mode 100644
index 0000000000..0595932bc2
--- /dev/null
+++ b/plugins/arSolrPlugin/lib/model/arSolrAipPdo.class.php
@@ -0,0 +1,146 @@
+<?php
+
+/*
+ * This file is part of the Access to Memory (AtoM) software.
+ *
+ * Access to Memory (AtoM) is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Access to Memory (AtoM) is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Access to Memory (AtoM).  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * Manage aips in search index.
+ */
+class arSolrAipPdo
+{
+    public $i18ns;
+
+    protected $data = [];
+
+    protected static $conn;
+    protected static $lookups;
+    protected static $statements;
+
+    /**
+     * METHODS.
+     *
+     * @param mixed $id
+     * @param mixed $options
+     */
+    public function __construct($id, $options = [])
+    {
+        if (isset($options['conn'])) {
+            self::$conn = $options['conn'];
+        }
+
+        if (!isset(self::$conn)) {
+            self::$conn = Propel::getConnection();
+        }
+
+        $this->loadData($id, $options);
+    }
+
+    public function __isset($name)
+    {
+        return isset($this->data[$name]);
+    }
+
+    public function __get($name)
+    {
+        if (isset($this->data[$name])) {
+            return $this->data[$name];
+        }
+    }
+
+    public function __set($name, $value)
+    {
+        $this->data[$name] = $value;
+    }
+
+    public function serialize()
+    {
+        $serialized = [];
+
+        $serialized['id'] = $this->id;
+        $serialized['uuid'] = $this->uuid;
+        $serialized['filename'] = $this->filename;
+        $serialized['sizeOnDisk'] = $this->size_on_disk;
+        $serialized['digitalObjectCount'] = $this->digital_object_count;
+        $serialized['createdAt'] = arSolrPluginUtil::convertDate($this->created_at);
+
+        if (null !== $this->type_id) {
+            $node = new arSolrTermPdo($this->type_id);
+            $serialized['type'] = $node->serialize();
+        }
+
+        if (null !== $digitalObjects = $this->getDigitalObjects()) {
+            $serialized['digitalObjects'] = $digitalObjects;
+        }
+
+        return $serialized;
+    }
+
+    protected function loadData($id)
+    {
+        if (!isset(self::$statements['aip'])) {
+            $sql = 'SELECT *';
+            $sql .= ' FROM '.QubitAip::TABLE_NAME;
+            $sql .= ' WHERE id = :id';
+
+            self::$statements['aip'] = self::$conn->prepare($sql);
+        }
+
+        // Do select
+        self::$statements['aip']->execute([':id' => $id]);
+
+        // Get first result
+        $this->data = self::$statements['aip']->fetch(PDO::FETCH_ASSOC);
+
+        if (false === $this->data) {
+            throw new sfException("Couldn't find aip (id: {$id})");
+        }
+
+        self::$statements['aip']->closeCursor();
+
+        return $this;
+    }
+
+    protected function getDigitalObjects()
+    {
+        $sql = 'SELECT
+            do.name,
+            do.byte_size,
+            do.mime_type,
+            obj.updated_at';
+        $sql .= ' FROM '.QubitDigitalObject::TABLE_NAME.' do';
+        $sql .= ' JOIN '.QubitRelation::TABLE_NAME.' relation
+            ON do.object_id = relation.object_id';
+        $sql .= ' JOIN '.QubitObject::TABLE_NAME.' obj
+            ON do.id = obj.id';
+        $sql .= ' WHERE relation.subject_id = ?
+            AND relation.type_id = ?';
+
+        self::$statements['do'] = self::$conn->prepare($sql);
+        self::$statements['do']->execute([$this->id, QubitTerm::AIP_RELATION_ID]);
+
+        $digitalObjects = [];
+        foreach (self::$statements['do']->fetchAll(PDO::FETCH_OBJ) as $item) {
+            if (null !== $premisData = arSolrPluginUtil::getPremisData($item->object_id, self::$conn)) {
+                $digitalObjects[] = ['metsData' => $premisData];
+            }
+        }
+
+        if (!empty($digitalObjects)) {
+            return $digitalObjects;
+        }
+    }
+}
diff --git a/plugins/arSolrPlugin/lib/model/arSolrContactInformation.class.php b/plugins/arSolrPlugin/lib/model/arSolrContactInformation.class.php
new file mode 100644
index 0000000000..d600a72e62
--- /dev/null
+++ b/plugins/arSolrPlugin/lib/model/arSolrContactInformation.class.php
@@ -0,0 +1,45 @@
+<?php
+
+/*
+ * This file is part of the Access to Memory (AtoM) software.
+ *
+ * Access to Memory (AtoM) is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Access to Memory (AtoM) is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Access to Memory (AtoM).  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+class arSolrContactInformation extends arSolrModelBase
+{
+    public static function serialize($object)
+    {
+        $serialized = [];
+
+        $serialized['contactPerson'] = $object->contactPerson;
+        $serialized['streetAddress'] = $object->streetAddress;
+        $serialized['postalCode'] = $object->postalCode;
+        $serialized['countryCode'] = $object->countryCode;
+
+        // geo point type
+        if (!empty($object->latitude) && !empty($object->longitude)) {
+            $serialized['location']['lat'] = $object->latitude;
+            $serialized['location']['lon'] = $object->longitude;
+        }
+
+        $serialized['sourceCulture'] = $object->sourceCulture;
+        $serialized['i18n'] = self::serializeI18ns(
+            $object->id,
+            ['QubitContactInformation', 'QubitActor']
+        );
+
+        return $serialized;
+    }
+}
diff --git a/plugins/arSolrPlugin/lib/model/arSolrDonor.class.php b/plugins/arSolrPlugin/lib/model/arSolrDonor.class.php
new file mode 100644
index 0000000000..ddb4ad14b2
--- /dev/null
+++ b/plugins/arSolrPlugin/lib/model/arSolrDonor.class.php
@@ -0,0 +1,46 @@
+<?php
+
+/*
+ * This file is part of the Access to Memory (AtoM) software.
+ *
+ * Access to Memory (AtoM) is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Access to Memory (AtoM) is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Access to Memory (AtoM).  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+class arSolrDonor extends arSolrModelBase
+{
+    public static function serialize($object)
+    {
+        $serialized = [];
+
+        $serialized['id'] = $object->id;
+        $serialized['slug'] = $object->slug;
+
+        foreach ($object->contactInformations as $contactInformation) {
+            $serialized['contactInformations'][] = arSolrContactInformation::serialize($contactInformation);
+        }
+
+        $serialized['i18n'] = self::serializeI18ns($object->id, ['QubitActor']);
+
+        return $serialized;
+    }
+
+    public static function update($object)
+    {
+        $data = self::serialize($object);
+
+        QubitSearch::getSolrInstance()->addDocument($data, 'QubitDonor');
+
+        return true;
+    }
+}
diff --git a/plugins/arSolrPlugin/lib/model/arSolrEvent.class.php b/plugins/arSolrPlugin/lib/model/arSolrEvent.class.php
new file mode 100644
index 0000000000..deaac2739d
--- /dev/null
+++ b/plugins/arSolrPlugin/lib/model/arSolrEvent.class.php
@@ -0,0 +1,47 @@
+<?php
+
+/*
+ * This file is part of the Access to Memory (AtoM) software.
+ *
+ * Access to Memory (AtoM) is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Access to Memory (AtoM) is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Access to Memory (AtoM).  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+class arSolrEvent extends arSolrModelBase
+{
+    public static function serialize($event)
+    {
+        $serialized = [];
+
+        if (isset($event->start_date)) {
+            $serialized['startDate'] = arSolrPluginUtil::normalizeDateWithoutMonthOrDay($event->start_date);
+            $serialized['startDateString'] = Qubit::renderDate($event->start_date);
+        }
+
+        if (isset($event->end_date)) {
+            $serialized['endDate'] = arSolrPluginUtil::normalizeDateWithoutMonthOrDay($event->end_date, true);
+            $serialized['endDateString'] = Qubit::renderDate($event->end_date);
+        }
+
+        if (isset($event->actor_id)) {
+            $serialized['actorId'] = $event->actor_id;
+        }
+
+        $serialized['typeId'] = $event->type_id;
+        $serialized['sourceCulture'] = $event->source_culture;
+
+        $serialized['i18n'] = self::serializeI18ns($event->id, ['QubitEvent']);
+
+        return $serialized;
+    }
+}
diff --git a/plugins/arSolrPlugin/lib/model/arSolrFunctionObject.class.php b/plugins/arSolrPlugin/lib/model/arSolrFunctionObject.class.php
new file mode 100644
index 0000000000..f5365267c1
--- /dev/null
+++ b/plugins/arSolrPlugin/lib/model/arSolrFunctionObject.class.php
@@ -0,0 +1,65 @@
+<?php
+
+/*
+ * This file is part of the Access to Memory (AtoM) software.
+ *
+ * Access to Memory (AtoM) is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Access to Memory (AtoM) is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Access to Memory (AtoM).  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+class arSolrFunctionObject extends arSolrModelBase
+{
+    public function load()
+    {
+        $sql = 'SELECT func.id';
+        $sql .= ' FROM '.QubitFunctionObject::TABLE_NAME.' func';
+        $sql .= ' JOIN '.QubitObject::TABLE_NAME.' object ON func.id = object.id';
+        $sql .= ' WHERE object.class_name = ?';
+
+        $actors = QubitPdo::fetchAll($sql, ['QubitFunctionObject']);
+
+        $this->count = count($actors);
+
+        return $actors;
+    }
+
+    public function populate()
+    {
+        $errors = [];
+
+        // Loop through results, and add to search index
+        foreach ($this->load() as $key => $item) {
+            try {
+                $node = new arSolrFunctionObjectPdo($item->id);
+                $data = $node->serialize();
+
+                QubitSearch::getSolrInstance()->addDocument($data, 'QubitFunctionObject');
+
+                $this->logEntry($data['i18n'][$data['sourceCulture']]['authorizedFormOfName'], $key + 1);
+            } catch (sfException $e) {
+                $errors[] = $e->getMessage();
+            }
+        }
+
+        return $errors;
+    }
+
+    public static function update($object)
+    {
+        $node = new arSolrFunctionObjectPdo($object->id);
+
+        QubitSearch::getSolrInstance()->addDocument($node->serialize(), 'QubitFunctionObject');
+
+        return true;
+    }
+}
diff --git a/plugins/arSolrPlugin/lib/model/arSolrFunctionObjectPdo.class.php b/plugins/arSolrPlugin/lib/model/arSolrFunctionObjectPdo.class.php
new file mode 100644
index 0000000000..e7b8c4ddcc
--- /dev/null
+++ b/plugins/arSolrPlugin/lib/model/arSolrFunctionObjectPdo.class.php
@@ -0,0 +1,132 @@
+<?php
+
+/*
+ * This file is part of the Access to Memory (AtoM) software.
+ *
+ * Access to Memory (AtoM) is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Access to Memory (AtoM) is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Access to Memory (AtoM).  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * Manage functions in search index.
+ *
+ * @author     Mike Cantelon <mike@artefactual.com>
+ */
+class arSolrFunctionObjectPdo
+{
+    public $i18ns;
+
+    protected $data = [];
+
+    protected static $conn;
+    protected static $lookups;
+    protected static $statements;
+
+    /**
+     * METHODS.
+     *
+     * @param mixed $id
+     * @param mixed $options
+     */
+    public function __construct($id, $options = [])
+    {
+        if (isset($options['conn'])) {
+            self::$conn = $options['conn'];
+        }
+
+        if (!isset(self::$conn)) {
+            self::$conn = Propel::getConnection();
+        }
+
+        $this->loadData($id, $options);
+    }
+
+    public function __isset($name)
+    {
+        return isset($this->data[$name]);
+    }
+
+    public function __get($name)
+    {
+        if (isset($this->data[$name])) {
+            return $this->data[$name];
+        }
+    }
+
+    public function __set($name, $value)
+    {
+        $this->data[$name] = $value;
+    }
+
+    public function serialize()
+    {
+        $serialized = [];
+
+        $serialized['id'] = $this->id;
+        $serialized['slug'] = $this->slug;
+        $serialized['descriptionStatusId'] = $this->description_status_id;
+        $serialized['descriptionDetailId'] = $this->description_detail_id;
+        $serialized['descriptionIdentifier'] = $this->description_identifier;
+
+        $sql = 'SELECT id, source_culture FROM '.QubitOtherName::TABLE_NAME.' WHERE object_id = ? AND type_id = ?';
+        foreach (QubitPdo::fetchAll($sql, [$this->id, QubitTerm::OTHER_FORM_OF_NAME_ID]) as $item) {
+            $serialized['otherNames'][] = arSolrOtherName::serialize($item);
+        }
+
+        $sql = 'SELECT id, source_culture FROM '.QubitOtherName::TABLE_NAME.' WHERE object_id = ? AND type_id = ?';
+        foreach (QubitPdo::fetchAll($sql, [$this->id, QubitTerm::PARALLEL_FORM_OF_NAME_ID]) as $item) {
+            $serialized['parallelNames'][] = arSolrOtherName::serialize($item);
+        }
+
+        $serialized['createdAt'] = arSolrPluginUtil::convertDate($this->created_at);
+        $serialized['updatedAt'] = arSolrPluginUtil::convertDate($this->updated_at);
+
+        $serialized['sourceCulture'] = $this->source_culture;
+        $serialized['i18n'] = arSolrModelBase::serializeI18ns($this->id, ['QubitFunctionObject']);
+
+        return $serialized;
+    }
+
+    protected function loadData($id)
+    {
+        if (!isset(self::$statements['function'])) {
+            $sql = 'SELECT
+                func.*,
+                slug.slug,
+                object.created_at,
+                object.updated_at
+                FROM '.QubitFunctionObject::TABLE_NAME.' func
+                JOIN '.QubitSlug::TABLE_NAME.' slug
+                ON func.id = slug.object_id
+                JOIN '.QubitObject::TABLE_NAME.' object
+                ON func.id = object.id
+                WHERE func.id = :id';
+
+            self::$statements['function'] = self::$conn->prepare($sql);
+        }
+
+        // Do select
+        self::$statements['function']->execute([':id' => $id]);
+
+        // Get first result
+        $this->data = self::$statements['function']->fetch(PDO::FETCH_ASSOC);
+
+        if (false === $this->data) {
+            throw new sfException("Couldn't find function (id: {$id})");
+        }
+
+        self::$statements['function']->closeCursor();
+
+        return $this;
+    }
+}
diff --git a/plugins/arSolrPlugin/lib/model/arSolrInformationObject.class.php b/plugins/arSolrPlugin/lib/model/arSolrInformationObject.class.php
new file mode 100644
index 0000000000..9554b6911e
--- /dev/null
+++ b/plugins/arSolrPlugin/lib/model/arSolrInformationObject.class.php
@@ -0,0 +1,162 @@
+<?php
+
+/*
+ * This file is part of the Access to Memory (AtoM) software.
+ *
+ * Access to Memory (AtoM) is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Access to Memory (AtoM) is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Access to Memory (AtoM).  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+class arSolrInformationObject extends arSolrModelBase
+{
+    protected static $conn;
+    protected static $statement;
+    protected static $counter = 0;
+
+    protected $errors = [];
+
+    public function load()
+    {
+        // Get count of all information objects
+        $sql = 'SELECT COUNT(*)';
+        $sql .= ' FROM '.QubitInformationObject::TABLE_NAME;
+        $sql .= ' WHERE id > ?';
+
+        $this->count = QubitPdo::fetchColumn($sql, [QubitInformationObject::ROOT_ID]);
+    }
+
+    public function populate()
+    {
+        $this->load();
+
+        // Pass root data to top-levels to avoid ancestors query
+        $ancestors = [[
+            'id' => QubitInformationObject::ROOT_ID,
+            'identifier' => null,
+            'repository_id' => null,
+        ]];
+
+        // Recursively descend down hierarchy
+        $this->recursivelyAddInformationObjects(
+            QubitInformationObject::ROOT_ID,
+            $this->count,
+            ['ancestors' => $ancestors]
+        );
+
+        return $this->errors;
+    }
+
+    public function recursivelyAddInformationObjects($parentId, $totalRows, $options = [])
+    {
+        // Loop through children and add to search index
+        foreach (self::getChildren($parentId) as $item) {
+            $ancestors = $inheritedCreators = [];
+            $repository = null;
+            ++self::$counter;
+
+            try {
+                $node = new arSolrInformationObjectPdo($item->id, $options);
+                $data = $node->serialize();
+
+                QubitSearch::getSolrInstance()->addDocument($data, 'QubitInformationObject');
+
+                $this->logEntry($data['i18n'][$data['sourceCulture']]['title'], self::$counter);
+
+                $ancestors = array_merge($node->getAncestors(), [[
+                    'id' => $node->id,
+                    'identifier' => $node->identifier,
+                    'repository_id' => $node->repository_id,
+                ]]);
+                $repository = $node->getRepository();
+                $inheritedCreators = array_merge($node->inheritedCreators, $node->creators);
+            } catch (sfException $e) {
+                $this->errors[] = $e->getMessage();
+            }
+
+            // Descend hierarchy
+            if (1 < ($item->rgt - $item->lft)) {
+                // Pass ancestors, repository and creators down to descendants
+                $this->recursivelyAddInformationObjects($item->id, $totalRows, [
+                    'ancestors' => $ancestors,
+                    'repository' => $repository,
+                    'inheritedCreators' => $inheritedCreators,
+                ]);
+            }
+        }
+    }
+
+    public static function update($object, $options = [])
+    {
+        // Update description
+        $node = new arSolrInformationObjectPdo($object->id);
+        QubitSearch::getSolrInstance()->addDocument($node->serialize(), 'QubitInformationObject');
+
+        // Update descendants if requested and they exists
+        if ($options['updateDescendants'] && $object->rgt - $object->lft > 1) {
+            self::updateDescendants($object);
+        }
+    }
+
+    public static function updateDescendants($object)
+    {
+        // Update synchronously in CLI tasks and jobs
+        $context = sfContext::getInstance();
+        $env = $context->getConfiguration()->getEnvironment();
+        if (in_array($env, ['cli', 'worker'])) {
+            foreach (self::getChildren($object->id) as $child) {
+                // TODO: Use partial updates to only get and add
+                // the fields that are inherited from the ancestors.
+                // Be aware that transient descendants are entirely
+                // added the first time to the search index in here
+                // and they will require a complete update.
+                self::update($child, ['updateDescendants' => true]);
+            }
+
+            return;
+        }
+
+        // Update asynchronously in other environments
+        $jobOptions = [
+            'ioIds' => [$object->id],
+            'updateIos' => false,
+            'updateDescendants' => true,
+            'objectId' => $object->id,
+        ];
+        QubitJob::runJob('arUpdateEsIoDocumentsJob', $jobOptions);
+
+        // Let user know descendants update has started
+        $jobsUrl = $context->routing->generate(null, ['module' => 'jobs', 'action' => 'browse']);
+        $message = $context->i18n->__('Your description has been updated. Its descendants are being updated asynchronously – check the <a class="alert-link" href="%1">job scheduler page</a> for status and details.', ['%1' => $jobsUrl]);
+        $context->user->setFlash('notice', $message);
+    }
+
+    public static function getChildren($parentId)
+    {
+        if (!isset(self::$conn)) {
+            self::$conn = Propel::getConnection();
+        }
+
+        if (!isset(self::$statement)) {
+            $sql = 'SELECT io.id, io.lft, io.rgt';
+            $sql .= ' FROM '.QubitInformationObject::TABLE_NAME.' io';
+            $sql .= ' WHERE io.parent_id = ?';
+            $sql .= ' ORDER BY io.lft';
+
+            self::$statement = self::$conn->prepare($sql);
+        }
+
+        self::$statement->execute([$parentId]);
+
+        return self::$statement->fetchAll(PDO::FETCH_OBJ);
+    }
+}
diff --git a/plugins/arSolrPlugin/lib/model/arSolrInformationObjectPdo.class.php b/plugins/arSolrPlugin/lib/model/arSolrInformationObjectPdo.class.php
new file mode 100644
index 0000000000..304e5272f0
--- /dev/null
+++ b/plugins/arSolrPlugin/lib/model/arSolrInformationObjectPdo.class.php
@@ -0,0 +1,1052 @@
+<?php
+
+/*
+ * This file is part of the Access to Memory (AtoM) software.
+ *
+ * Access to Memory (AtoM) is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Access to Memory (AtoM) is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Access to Memory (AtoM).  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * Manage information objects in search index.
+ *
+ * @author     David Juhasz <david@artefactual.com>
+ */
+class arSolrInformationObjectPdo
+{
+    public $ancestors;
+    public $doc;
+    public $repository;
+    public $sourceCulture;
+    public $creators = [];
+    public $inheritedCreators = [];
+
+    protected $data = [];
+    protected $events;
+
+    protected static $conn;
+    protected static $statements;
+
+    public function __construct($id, $options = [])
+    {
+        if (isset($options['conn'])) {
+            self::$conn = $options['conn'];
+        }
+
+        if (!isset(self::$conn)) {
+            self::$conn = Propel::getConnection();
+        }
+
+        $this->loadData($id, $options);
+
+        // Get inherited ancestors
+        if (isset($options['ancestors'])) {
+            $this->ancestors = $options['ancestors'];
+        }
+
+        // Get inherited repository, unless a repository is set at current level
+        if (isset($options['repository']) && !$this->__isset('repository_id')) {
+            $this->repository = $options['repository'];
+        }
+
+        // Get inherited creators
+        if (isset($options['inheritedCreators'])) {
+            $this->inheritedCreators = $options['inheritedCreators'];
+        }
+
+        // Get creators
+        $this->creators = $this->getActors(['typeId' => QubitTerm::CREATION_ID]);
+
+        // Ignore inherited creators if there are directly related creators
+        if (!empty($this->creators)) {
+            $this->inheritedCreators = [];
+        }
+        // Otherwise, get them from the options
+        elseif (isset($options['inheritedCreators'])) {
+            $this->inheritedCreators = $options['inheritedCreators'];
+        }
+        // Or from the closest ancestor
+        else {
+            $this->inheritedCreators = $this->getClosestCreators();
+        }
+    }
+
+    public function __isset($name)
+    {
+        if ('events' == $name) {
+            return isset($this->events);
+        }
+
+        return isset($this->data[$name]);
+    }
+
+    public function __get($name)
+    {
+        if ('events' == $name) {
+            return $this->events;
+        }
+
+        if (isset($this->data[$name])) {
+            return $this->data[$name];
+        }
+    }
+
+    public function __set($name, $value)
+    {
+        if ('events' == $name) {
+            $this->events = $value;
+
+            return;
+        }
+
+        $this->data[$name] = $value;
+    }
+
+    /**
+     * Return an array of ancestors.
+     *
+     * @return array of ancestors
+     */
+    public function getAncestors()
+    {
+        if (!isset($this->ancestors) && isset($this->parent_id)) {
+            $sql = 'WITH RECURSIVE cte AS
+                (
+                    SELECT io1.id, io1.parent_id, io1.identifier, io1.repository_id, 1 as lev
+                    FROM information_object io1 WHERE io1.id = ?
+                    UNION ALL
+                    SELECT io2.id, io2.parent_id, io2.identifier, io2.repository_id, cte.lev + 1
+                    FROM information_object io2 JOIN cte ON cte.parent_id=io2 .id
+                )
+                SELECT id, identifier, repository_id FROM cte ORDER BY lev DESC';
+
+            $this->ancestors = QubitPdo::fetchAll(
+                $sql,
+                [$this->parent_id],
+                ['fetchMode' => PDO::FETCH_ASSOC]
+            );
+        }
+
+        if (!isset($this->ancestors) || empty($this->ancestors)) {
+            throw new sfException(sprintf("%s: Couldn't find ancestors, please make sure parent_id values are correct", get_class($this)));
+        }
+
+        return $this->ancestors;
+    }
+
+    /**
+     * Return an array of children.
+     *
+     * @return array of children
+     */
+    public function getChildren()
+    {
+        if (!isset($this->children)) {
+            // Find children
+            $sql = 'SELECT node.id';
+            $sql .= ' FROM '.QubitInformationObject::TABLE_NAME.' node';
+            $sql .= ' WHERE node.parent_id = :id';
+            $sql .= ' ORDER BY lft';
+
+            $this->children = QubitPdo::fetchAll($sql, [':id' => $this->id]);
+        }
+
+        return $this->children;
+    }
+
+    /**
+     * Return the closest repository.
+     *
+     * @return QubitRepository
+     */
+    public function getRepository()
+    {
+        if (!isset($this->repository)) {
+            if ($this->__isset('repository_id')) {
+                $this->repository = QubitRepository::getById($this->__get('repository_id'));
+            } else {
+                foreach (array_reverse($this->getAncestors()) as $item) {
+                    if (isset($item['repository_id'])) {
+                        $this->repository = QubitRepository::getById($item['repository_id']);
+
+                        break;
+                    }
+                }
+            }
+        }
+
+        return $this->repository;
+    }
+
+    public function getClosestCreators()
+    {
+        $inheritedCreators = [];
+
+        if (!isset(self::$statements['inheritedCreators'])) {
+            $sql = 'SELECT event.actor_id as id';
+            $sql .= ' FROM '.QubitEvent::TABLE_NAME.' event';
+            $sql .= ' WHERE event.actor_id IS NOT NULL';
+            $sql .= ' AND event.object_id = ?';
+            $sql .= ' AND event.type_id = ?';
+
+            self::$statements['inheritedCreators'] = self::$conn->prepare($sql);
+        }
+
+        foreach (array_reverse($this->getAncestors()) as $ancestor) {
+            self::$statements['inheritedCreators']->execute([$ancestor['id'], QubitTerm::CREATION_ID]);
+
+            foreach (self::$statements['inheritedCreators']->fetchAll(PDO::FETCH_OBJ) as $creator) {
+                $inheritedCreators[] = $creator;
+            }
+
+            if (!empty($inheritedCreators)) {
+                break;
+            }
+        }
+
+        return $inheritedCreators;
+    }
+
+    /**
+     * Get full reference code, with optional country code and repository prefixes as well.
+     *
+     * @param bool $includeRepoAndCountry Whether or not to prepend country code and repository identifier
+     *
+     * @return string The full reference code
+     */
+    public function getReferenceCode($includeRepoAndCountry = true)
+    {
+        if (null == $this->__get('identifier')) {
+            return;
+        }
+
+        $refcode = '';
+        $this->repository = $this->getRepository();
+
+        if (isset($this->repository) && $includeRepoAndCountry) {
+            if (null != $cc = $this->repository->getCountryCode(['culture' => $this->__get('culture')])) {
+                $refcode .= $cc.' ';
+            }
+
+            if (isset($this->repository->identifier)) {
+                $refcode .= $this->repository->identifier.' ';
+            }
+        }
+
+        $identifiers = [];
+
+        foreach ($this->getAncestors() as $item) {
+            if (isset($item['identifier'])) {
+                $identifiers[] = $item['identifier'];
+            }
+        }
+
+        if (isset($this->identifier)) {
+            $identifiers[] = $this->identifier;
+        }
+
+        $refcode .= implode(sfConfig::get('app_separator_character', '-'), $identifiers);
+
+        return $refcode;
+    }
+
+    public function getActors($options = [])
+    {
+        $actors = [];
+
+        if (!isset(self::$statements['actor'])) {
+            $sql = 'SELECT actor.id, actor.entity_type_id, slug.slug';
+            $sql .= ' FROM '.QubitActor::TABLE_NAME.' actor';
+            $sql .= ' JOIN '.QubitSlug::TABLE_NAME.' slug
+                ON actor.id = slug.object_id';
+            $sql .= ' WHERE actor.id = ?';
+
+            self::$statements['actor'] = self::$conn->prepare($sql);
+        }
+
+        if (!empty($this->events)) {
+            foreach ($this->events as $item) {
+                if (isset($item->actor_id)) {
+                    // Filter by type
+                    if (isset($options['typeId']) && $options['typeId'] != $item->type_id) {
+                        continue;
+                    }
+
+                    self::$statements['actor']->execute([$item->actor_id]);
+
+                    if ($actor = self::$statements['actor']->fetch(PDO::FETCH_OBJ)) {
+                        $actors[] = $actor;
+                    }
+                }
+            }
+        }
+
+        return $actors;
+    }
+
+    public function getNameAccessPoints()
+    {
+        $names = [];
+
+        // Subject relations
+        if (!isset(self::$statements['actorRelation'])) {
+            $sql = 'SELECT actor.id';
+            $sql .= ' FROM '.QubitActor::TABLE_NAME.' actor';
+            $sql .= ' JOIN '.QubitRelation::TABLE_NAME.' relation
+                ON actor.id = relation.object_id';
+            $sql .= ' WHERE relation.subject_id = :resourceId
+                AND relation.type_id = :typeId';
+
+            self::$statements['actorRelation'] = self::$conn->prepare($sql);
+        }
+
+        self::$statements['actorRelation']->execute([
+            ':resourceId' => $this->__get('id'),
+            ':typeId' => QubitTerm::NAME_ACCESS_POINT_ID,
+        ]);
+
+        foreach (self::$statements['actorRelation']->fetchAll(PDO::FETCH_OBJ) as $item) {
+            $names[$item->id] = $item;
+        }
+
+        // Add actors in related, non-creation events
+        foreach ($this->events as $event) {
+            if (isset($event->actor_id) && QubitTerm::CREATION_ID != $event->type_id) {
+                $actor = new stdClass();
+                $actor->id = $event->actor_id;
+                $names[$actor->id] = $actor;
+            }
+        }
+
+        return $names;
+    }
+
+    public function getNotesByType($typeId)
+    {
+        $sql = 'SELECT
+            id, source_culture
+            FROM '.QubitNote::TABLE_NAME.
+            ' WHERE object_id = ? AND type_id = ?';
+
+        return QubitPdo::fetchAll($sql, [$this->__get('id'), $typeId]);
+    }
+
+    public function getTermIdByNameAndTaxonomy($name, $taxonomyId, $culture = 'en')
+    {
+        $sql = 'SELECT t.id
+            FROM term t
+            LEFT JOIN term_i18n ti
+            ON t.id=ti.id
+            WHERE t.taxonomy_id=? AND ti.name=? AND ti.culture=?';
+
+        return QubitPdo::fetchColumn($sql, [$taxonomyId, $name, $culture]);
+    }
+
+    public function getThumbnailPath()
+    {
+        if (!$this->__isset('digital_object_id')) {
+            return;
+        }
+
+        $criteria = new Criteria();
+        $criteria->add(QubitDigitalObject::PARENT_ID, $this->__get('digital_object_id'));
+        $criteria->add(QubitDigitalObject::USAGE_ID, QubitTerm::THUMBNAIL_ID);
+
+        if (null !== $thumbnail = QubitDigitalObject::getOne($criteria)) {
+            return $thumbnail->getFullPath();
+        }
+    }
+
+    public function getDigitalObjectAltText()
+    {
+        if (!$this->__isset('digital_object_id')) {
+            return;
+        }
+
+        $criteria = new Criteria();
+        $criteria->add(QubitDigitalObject::PARENT_ID, $this->__get('digital_object_id'));
+
+        if (null !== $do = QubitDigitalObject::getOne($criteria)) {
+            return $do->getDigitalObjectAltText();
+        }
+    }
+
+    public function getRights()
+    {
+        if (!isset(self::$statements['rights'])) {
+            $sql = 'SELECT rights.*, rightsi18n.*';
+            $sql .= ' FROM '.QubitRights::TABLE_NAME.' rights';
+            $sql .= ' JOIN '.QubitRightsI18n::TABLE_NAME.' rightsi18n
+                ON rights.id = rightsi18n.id';
+            $sql .= ' JOIN '.QubitRelation::TABLE_NAME.' rel
+                ON rights.id = rel.object_id';
+            $sql .= ' WHERE rel.subject_id = ?';
+            $sql .= ' AND rel.type_id = '.QubitTerm::RIGHT_ID;
+
+            self::$statements['rights'] = self::$conn->prepare($sql);
+        }
+
+        self::$statements['rights']->execute([
+            $this->__get('id'),
+        ]);
+
+        return self::$statements['rights']->fetchAll(PDO::FETCH_CLASS);
+    }
+
+    public function getGrantedRights()
+    {
+        if (!isset(self::$statements['grantedRights'])) {
+            $sql = 'SELECT gr.*';
+            $sql .= ' FROM '.QubitGrantedRight::TABLE_NAME.' gr';
+            $sql .= ' JOIN '.QubitRelation::TABLE_NAME.' rel
+                ON gr.rights_id = rel.object_id';
+            $sql .= ' WHERE rel.subject_id = ?';
+            $sql .= ' AND rel.type_id = '.QubitTerm::RIGHT_ID;
+
+            self::$statements['grantedRights'] = self::$conn->prepare($sql);
+        }
+
+        self::$statements['grantedRights']->execute([$this->__get('id')]);
+
+        return self::$statements['grantedRights']->fetchAll(PDO::FETCH_CLASS);
+    }
+
+    /**
+     * Get text transcript, if one exists.
+     */
+    public function getTranscript()
+    {
+        if (!$this->__isset('digital_object_id')) {
+            return false;
+        }
+
+        if (!isset(self::$statements['transcript'])) {
+            $sql = 'SELECT i18n.value
+                FROM '.QubitProperty::TABLE_NAME.' property
+                JOIN '.QubitPropertyI18n::TABLE_NAME.' i18n
+                ON property.id = i18n.id
+                WHERE property.name = "transcript"
+                AND property.source_culture = i18n.culture
+                AND property.object_id = ?';
+
+            self::$statements['transcript'] = self::$conn->prepare($sql);
+        }
+
+        self::$statements['transcript']->execute([$this->__get('digital_object_id')]);
+
+        return self::$statements['transcript']->fetchColumn();
+    }
+
+    /**
+     * Get finding aid text transcript, if one exists.
+     */
+    public function getFindingAidTranscript()
+    {
+        if (!isset(self::$statements['findingAidTranscript'])) {
+            $sql = 'SELECT i18n.value
+                FROM '.QubitProperty::TABLE_NAME.' property
+                JOIN '.QubitPropertyI18n::TABLE_NAME.' i18n
+                ON property.id = i18n.id
+                WHERE property.name = "findingAidTranscript"
+                AND property.source_culture = i18n.culture
+                AND property.object_id = ?';
+
+            self::$statements['findingAidTranscript'] = self::$conn->prepare($sql);
+        }
+
+        self::$statements['findingAidTranscript']->execute([$this->__get('id')]);
+
+        return self::$statements['findingAidTranscript']->fetchColumn();
+    }
+
+    /**
+     * Get finding aid status.
+     */
+    public function getFindingAidStatus()
+    {
+        if (!isset(self::$statements['findingAidStatus'])) {
+            $sql = 'SELECT i18n.value
+                FROM '.QubitProperty::TABLE_NAME.' property
+                JOIN '.QubitPropertyI18n::TABLE_NAME.' i18n
+                ON property.id = i18n.id
+                WHERE property.name = "findingAidStatus"
+                AND property.source_culture = i18n.culture
+                AND property.object_id = ?';
+
+            self::$statements['findingAidStatus'] = self::$conn->prepare($sql);
+        }
+
+        self::$statements['findingAidStatus']->execute([$this->__get('id')]);
+
+        return self::$statements['findingAidStatus']->fetchColumn();
+    }
+
+    public function serialize()
+    {
+        $serialized = [];
+
+        // Add default null values to allow document updates using partial data.
+        // To remove fields from the document is required the use of scripts, which
+        // requires global configuration changes or deployments headaches. If there
+        // is not a default value set in the mapping configuration, null values work
+        // the same as missing fields in almost every case and allow us to 'remove'
+        // fields without using scripts in partial updates.
+        $serialized['findingAid'] = [
+            'transcript' => null,
+            'status' => null,
+        ];
+
+        $serialized['id'] = $this->id;
+        $serialized['slug'] = $this->slug;
+        $serialized['parentId'] = $this->parent_id;
+        $serialized['identifier'] = $this->identifier;
+        $serialized['referenceCode'] = $this->getReferenceCode();
+        $serialized['referenceCodeWithoutCountryAndRepo'] = $this->getReferenceCode(false);
+        $serialized['levelOfDescriptionId'] = $this->level_of_description_id;
+        $serialized['lft'] = $this->lft;
+        $serialized['publicationStatusId'] = $this->publication_status_id;
+
+        // Alternative identifiers
+        $alternativeIdentifiers = $this->getAlternativeIdentifiers();
+        if (!empty($alternativeIdentifiers)) {
+            $serialized['alternativeIdentifiers'] = $alternativeIdentifiers;
+        }
+
+        // NB: this will include the ROOT_ID
+        $serialized['ancestors'] = array_column($this->getAncestors(), 'id');
+
+        // NB: this should be an ordered array
+        foreach ($this->getChildren() as $child) {
+            $serialized['children'][] = $child->id;
+        }
+
+        // Copyright status
+        $statusId = null;
+        foreach ($this->getRights() as $item) {
+            if (isset($item->copyright_status_id)) {
+                $statusId = $item->copyright_status_id;
+
+                break;
+            }
+        }
+        if (null !== $statusId) {
+            $serialized['copyrightStatusId'] = $statusId;
+        }
+
+        // Make sure that media_type_id gets a value in case that one was not
+        // assigned, which seems to be a possibility when using the offline usage.
+        if (null === $this->media_type_id && QubitTerm::OFFLINE_ID == $this->usage_id) {
+            $this->media_type_id = QubitTerm::OTHER_ID;
+        }
+
+        // Media
+        if ($this->media_type_id) {
+            $serialized['digitalObject']['mediaTypeId'] = $this->media_type_id;
+            $serialized['digitalObject']['usageId'] = $this->usage_id;
+            $serialized['digitalObject']['filename'] = $this->filename;
+            $serialized['digitalObject']['thumbnailPath'] = $this->getThumbnailPath();
+            $serialized['digitalObject']['digitalObjectAltText'] = $this->getDigitalObjectAltText();
+
+            $serialized['hasDigitalObject'] = true;
+        } else {
+            $serialized['hasDigitalObject'] = false;
+        }
+
+        // Dates
+        foreach ($this->events as $event) {
+            $serialized['dates'][] = arSolrEvent::serialize($event);
+
+            // The dates indexed above are nested objects and that complicates sorting.
+            // Additionally, we only show the first populated dates on the search
+            // results. Indexing the first populated dates on different fields makes
+            // sorting easier and more intuitive.
+            if (isset($serialized['startDateSort']) || isset($serialized['endDateSort'])) {
+                continue;
+            }
+
+            if (!empty($event->start_date)) {
+                $serialized['startDateSort'] = arSolrPluginUtil::normalizeDateWithoutMonthOrDay($event->start_date);
+            }
+
+            if (!empty($event->end_date)) {
+                $serialized['endDateSort'] = arSolrPluginUtil::normalizeDateWithoutMonthOrDay($event->end_date, true);
+            }
+        }
+
+        // Transcript
+        if (false !== $transcript = $this->getTranscript()) {
+            $serialized['transcript'] = $transcript;
+        }
+
+        // Finding aid transcript
+        if (false !== $findingAidTranscript = $this->getFindingAidTranscript()) {
+            $serialized['findingAid']['transcript'] = $findingAidTranscript;
+        }
+
+        // Finding aid status
+        if (false !== $findingAidStatus = $this->getFindingAidStatus()) {
+            $serialized['findingAid']['status'] = (int) $findingAidStatus;
+        }
+
+        // Repository
+        if (null !== $repository = $this->getRepository()) {
+            $serialized['repository']['id'] = $this->repository->id;
+            $serialized['repository']['slug'] = $this->repository->slug;
+            $serialized['repository']['identifier'] = $this->repository->identifier;
+
+            $serialized['repository']['i18n'] = arSolrModelBase::serializeI18ns(
+                $repository->id,
+                ['QubitActor'],
+                ['fields' => ['authorized_form_of_name']]
+            );
+        }
+
+        // Related terms
+        $relatedTerms = arSolrModelBase::getRelatedTerms(
+            $this->id,
+            [
+                QubitTaxonomy::MATERIAL_TYPE_ID,
+                QubitTaxonomy::PLACE_ID,
+                QubitTaxonomy::SUBJECT_ID,
+                QubitTaxonomy::GENRE_ID,
+            ]
+        );
+
+        // Material types
+        if (isset($relatedTerms[QubitTaxonomy::MATERIAL_TYPE_ID])) {
+            $serialized['materialTypeId'] = $relatedTerms[QubitTaxonomy::MATERIAL_TYPE_ID];
+        }
+
+        // Places
+        if (isset($relatedTerms[QubitTaxonomy::PLACE_ID])) {
+            $serialized['directPlaces'] = $relatedTerms[QubitTaxonomy::PLACE_ID];
+            $extendedPlaceIds = arSolrModelBase::extendRelatedTerms(
+                $relatedTerms[QubitTaxonomy::PLACE_ID]
+            );
+
+            foreach ($extendedPlaceIds as $id) {
+                $node = new arSolrTermPdo($id);
+
+                $places = [
+                    'id' => $node->id,
+                    'i18n' => arSolrModelBase::serializeI18ns(
+                        $node->id,
+                        ['QubitTerm'],
+                        ['fields' => ['name']]
+                    ),
+                ];
+
+                $serialized['places'][] = $places;
+            }
+        }
+
+        // Subjects
+        if (isset($relatedTerms[QubitTaxonomy::SUBJECT_ID])) {
+            $serialized['directSubjects'] = $relatedTerms[QubitTaxonomy::SUBJECT_ID];
+            $extendedSubjectIds = arSolrModelBase::extendRelatedTerms(
+                $relatedTerms[QubitTaxonomy::SUBJECT_ID]
+            );
+
+            foreach ($extendedSubjectIds as $id) {
+                $node = new arSolrTermPdo($id);
+
+                $subjects = [
+                    'id' => $node->id,
+                    'i18n' => arSolrModelBase::serializeI18ns(
+                        $node->id,
+                        ['QubitTerm'],
+                        ['fields' => ['name']]
+                    ),
+                ];
+
+                $serialized['subjects'][] = $subjects;
+            }
+        }
+
+        // Genres
+        if (isset($relatedTerms[QubitTaxonomy::GENRE_ID])) {
+            $serialized['directGenres'] = $relatedTerms[QubitTaxonomy::GENRE_ID];
+            $extendedGenreIds = arSolrModelBase::extendRelatedTerms(
+                $relatedTerms[QubitTaxonomy::GENRE_ID]
+            );
+
+            foreach ($extendedGenreIds as $id) {
+                $node = new arSolrTermPdo($id);
+
+                $genres = [
+                    'id' => $node->id,
+                    'i18n' => arSolrModelBase::serializeI18ns(
+                        $node->id,
+                        ['QubitTerm'],
+                        ['fields' => ['name']]
+                    ),
+                ];
+
+                $serialized['genres'][] = $genres;
+            }
+        }
+
+        // Name access points
+        foreach ($this->getNameAccessPoints() as $item) {
+            $node = new arSolrActorPdo($item->id);
+
+            $names = [
+                'id' => $node->id,
+                'i18n' => arSolrModelBase::serializeI18ns(
+                    $node->id,
+                    ['QubitActor'],
+                    ['fields' => ['authorized_form_of_name']]
+                ),
+            ];
+
+            // Add other names, parallel names, and standardized names
+            $names += $node->serializeAltNames();
+
+            $serialized['names'][] = $names;
+        }
+
+        // Creators
+        foreach ($this->creators as $item) {
+            $node = new arSolrActorPdo($item->id);
+
+            $creators = [
+                'id' => $node->id,
+                'i18n' => arSolrModelBase::serializeI18ns(
+                    $node->id,
+                    ['QubitActor'],
+                    ['fields' => ['authorized_form_of_name', 'history']]
+                ),
+            ];
+
+            // Add other names, parallel names, and standardized names
+            $creators += $node->serializeAltNames();
+
+            $serialized['creators'][] = $creators;
+        }
+
+        // Inherited creators
+        foreach ($this->inheritedCreators as $item) {
+            $node = new arSolrActorPdo($item->id);
+
+            $inheritedCreators = [
+                'id' => $node->id,
+                'i18n' => arSolrModelBase::serializeI18ns(
+                    $node->id,
+                    ['QubitActor'],
+                    ['fields' => ['authorized_form_of_name']]
+                ),
+            ];
+
+            // Add other names, parallel names, and standardized names
+            $inheritedCreators += $node->serializeAltNames();
+
+            $serialized['inheritedCreators'][] = $inheritedCreators;
+        }
+
+        // Notes
+        foreach ($this->getNotesByType(QubitTerm::GENERAL_NOTE_ID) as $item) {
+            $serialized['generalNotes'][] = arSolrNote::serialize($item);
+        }
+
+        // PREMIS data
+        if (null !== $premisData = arSolrPluginUtil::getPremisData($this->id, self::$conn)) {
+            $serialized['metsData'] = $premisData;
+        }
+
+        if (null !== $termId = $this->getTermIdByNameAndTaxonomy('Alpha-numeric designations', QubitTaxonomy::RAD_NOTE_ID)) {
+            foreach ($this->getNotesByType($termId) as $item) {
+                $serialized['alphaNumericNotes'][] = arSolrNote::serialize($item);
+            }
+        }
+
+        if (null !== $termId = $this->getTermIdByNameAndTaxonomy('Conservation', QubitTaxonomy::RAD_NOTE_ID)) {
+            foreach ($this->getNotesByType($termId) as $item) {
+                $serialized['conservationNotes'][] = arSolrNote::serialize($item);
+            }
+        }
+
+        if (null !== $termId = $this->getTermIdByNameAndTaxonomy('Physical description', QubitTaxonomy::RAD_NOTE_ID)) {
+            foreach ($this->getNotesByType($termId) as $item) {
+                $serialized['physicalDescriptionNotes'][] = arSolrNote::serialize($item);
+            }
+        }
+
+        if (null !== $termId = $this->getTermIdByNameAndTaxonomy('Continuation of title', QubitTaxonomy::RAD_TITLE_NOTE_ID)) {
+            foreach ($this->getNotesByType($termId) as $item) {
+                $serialized['continuationOfTitleNotes'][] = arSolrNote::serialize($item);
+            }
+        }
+
+        if (null !== $termId = $this->getTermIdByNameAndTaxonomy("Archivist's note", QubitTaxonomy::NOTE_TYPE_ID)) {
+            foreach ($this->getNotesByType($termId) as $item) {
+                $serialized['archivistsNotes'][] = arSolrNote::serialize($item);
+            }
+        }
+
+        if (null !== $termId = $this->getTermIdByNameAndTaxonomy('Publication note', QubitTaxonomy::NOTE_TYPE_ID)) {
+            foreach ($this->getNotesByType($termId) as $item) {
+                $serialized['publicationNotes'][] = arSolrNote::serialize($item);
+            }
+        }
+
+        if (false !== $item = $this->getProperty('titleStatementOfResponsibility')) {
+            $serialized['titleStatementOfResponsibility'] = arSolrProperty::serialize($item);
+        }
+
+        // Aips
+        foreach ($this->getAips() as $item) {
+            $node = new arSolrAipPdo($item->id);
+            $serialized['aip'][] = $node->serialize();
+        }
+
+        $serialized['actRights'] = $this->getActRights();
+        $serialized['basisRights'] = $this->getBasisRights();
+
+        $serialized['createdAt'] = arSolrPluginUtil::convertDate($this->created_at);
+        $serialized['updatedAt'] = arSolrPluginUtil::convertDate($this->updated_at);
+
+        $serialized['sourceCulture'] = $this->source_culture;
+        $serialized['i18n'] = arSolrModelBase::serializeI18ns($this->id, ['QubitInformationObject']);
+
+        // Add "Part of" information if this isn't a top level description
+        if (count($this->ancestors) > 1) {
+            $collectionRootId = $this->ancestors[1]['id'];
+            $rootSlug = QubitPdo::fetchColumn('SELECT slug FROM slug WHERE object_id=?', [$collectionRootId]);
+
+            if (!$rootSlug) {
+                throw new sfException("No slug found for information object {$collectionRootId}");
+            }
+
+            $rootSourceCulture = QubitPdo::fetchColumn(
+                'SELECT source_culture FROM information_object WHERE id=?',
+                [$collectionRootId]
+            );
+            if (!$rootSourceCulture) {
+                throw new sfException("No source culture found for information object {$collectionRootId}");
+            }
+
+            $i18nFields = arSolrModelBase::serializeI18ns(
+                $collectionRootId,
+                ['QubitInformationObject'],
+                ['fields' => ['title']]
+            );
+
+            $serialized['partOf']['id'] = $collectionRootId;
+            $serialized['partOf']['sourceCulture'] = $rootSourceCulture;
+            $serialized['partOf']['slug'] = $rootSlug;
+            $serialized['partOf']['i18n'] = $i18nFields;
+        }
+
+        return $serialized;
+    }
+
+    protected function loadData($id, $options = [])
+    {
+        if (!isset(self::$statements['informationObject'])) {
+            $sql = 'SELECT
+                io.*,
+                obj.created_at,
+                obj.updated_at,
+                slug.slug,
+                pubstat.status_id as publication_status_id,
+                do.id as digital_object_id,
+                do.media_type_id as media_type_id,
+                do.usage_id as usage_id,
+                do.name as filename
+                FROM '.QubitInformationObject::TABLE_NAME.' io
+                JOIN '.QubitObject::TABLE_NAME.' obj
+                ON io.id = obj.id
+                JOIN '.QubitSlug::TABLE_NAME.' slug
+                ON io.id = slug.object_id
+                JOIN '.QubitStatus::TABLE_NAME.' pubstat
+                ON io.id = pubstat.object_id
+                LEFT JOIN '.QubitDigitalObject::TABLE_NAME.' do
+                ON io.id = do.object_id
+                WHERE io.id = :id';
+
+            self::$statements['informationObject'] = self::$conn->prepare($sql);
+        }
+
+        // Do select
+        self::$statements['informationObject']->execute([':id' => $id]);
+
+        // Get first result
+        $this->data = self::$statements['informationObject']->fetch(PDO::FETCH_ASSOC);
+
+        if (false === $this->data) {
+            throw new sfException("Couldn't find information object (id: {$id})");
+        }
+
+        // Load event data
+        $this->loadEvents();
+
+        return $this;
+    }
+
+    protected function loadEvents()
+    {
+        if (!isset($this->events)) {
+            $events = [];
+
+            if (!isset(self::$statements['event'])) {
+                $sql = 'SELECT
+                    event.id,
+                    event.start_date,
+                    event.end_date,
+                    event.actor_id,
+                    event.type_id,
+                    event.source_culture,
+                    i18n.date,
+                    i18n.culture';
+                $sql .= ' FROM '.QubitEvent::TABLE_NAME.' event';
+                $sql .= ' JOIN '.QubitEventI18n::TABLE_NAME.' i18n
+                    ON event.id = i18n.id';
+                $sql .= ' WHERE event.object_id = ?';
+
+                self::$statements['event'] = self::$conn->prepare($sql);
+            }
+
+            self::$statements['event']->execute([$this->__get('id')]);
+
+            foreach (self::$statements['event']->fetchAll() as $item) {
+                if (!isset($events[$item['id']])) {
+                    $event = new stdClass();
+                    $event->id = $item['id'];
+                    $event->start_date = $item['start_date'];
+                    $event->end_date = $item['end_date'];
+                    $event->actor_id = $item['actor_id'];
+                    $event->type_id = $item['type_id'];
+                    $event->source_culture = $item['source_culture'];
+
+                    $events[$item['id']] = $event;
+                }
+
+                $events[$item['id']]->dates[$item['culture']] = $item['date'];
+            }
+
+            $this->events = $events;
+        }
+
+        return $this->events;
+    }
+
+    protected function getAlternativeIdentifiers()
+    {
+        // Find langs and scripts
+        if (!isset(self::$statements['alternativeIdentifiers'])) {
+            $sql = 'SELECT node.name, i18n.value';
+            $sql .= ' FROM '.QubitProperty::TABLE_NAME.' node';
+            $sql .= ' JOIN '.QubitPropertyI18n::TABLE_NAME.' i18n
+                ON node.id = i18n.id';
+            $sql .= ' WHERE node.source_culture = i18n.culture
+                AND node.object_id = ?
+                AND node.scope = ?';
+
+            self::$statements['alternativeIdentifiers'] = self::$conn->prepare($sql);
+        }
+
+        self::$statements['alternativeIdentifiers']->execute([
+            $this->__get('id'),
+            'alternativeIdentifiers',
+        ]);
+
+        $alternativeIdentifiers = [];
+        foreach (self::$statements['alternativeIdentifiers']->fetchAll() as $item) {
+            $tmp = [];
+
+            $tmp['label'] = $item['name'];
+            $tmp['identifier'] = $item['value'];
+
+            $alternativeIdentifiers[] = $tmp;
+        }
+
+        return $alternativeIdentifiers;
+    }
+
+    protected function getProperty($name)
+    {
+        $sql = 'SELECT prop.id, prop.source_culture';
+        $sql .= ' FROM '.QubitProperty::TABLE_NAME.' prop';
+        $sql .= ' WHERE prop.object_id = ? AND prop.name = ?';
+
+        self::$statements['property'] = self::$conn->prepare($sql);
+        self::$statements['property']->execute([$this->__get('id'), $name]);
+
+        return self::$statements['property']->fetch(PDO::FETCH_OBJ);
+    }
+
+    protected function getAips()
+    {
+        $sql = 'SELECT aip.id';
+        $sql .= ' FROM '.QubitAip::TABLE_NAME.' aip';
+        $sql .= ' JOIN '.QubitRelation::TABLE_NAME.' relation
+            ON aip.id = relation.subject_id';
+        $sql .= ' WHERE relation.object_id = ?
+            AND relation.type_id = ?';
+
+        self::$statements['aips'] = self::$conn->prepare($sql);
+        self::$statements['aips']->execute([$this->__get('id'), QubitTerm::AIP_RELATION_ID]);
+
+        return self::$statements['aips']->fetchAll(PDO::FETCH_OBJ);
+    }
+
+    private function getBasisRights()
+    {
+        $basisRights = [];
+
+        foreach ($this->getRights() as $right) {
+            $basisRight = [];
+
+            $basisRight['startDate'] = arSolrPluginUtil::normalizeDateWithoutMonthOrDay($right->start_date);
+            $basisRight['endDate'] = arSolrPluginUtil::normalizeDateWithoutMonthOrDay($right->end_date, true);
+            $basisRight['rightsNote'] = $right->rights_note;
+            $basisRight['licenseTerms'] = $right->license_terms;
+
+            if ($right->rights_holder_id) {
+                $basisRight['rightsHolder'] = QubitActor::getById($right->rights_holder_id)->getAuthorizedFormOfName();
+            }
+
+            if ($right->basis_id) {
+                $basisRight['basis'] = QubitTerm::getById($right->basis_id)->getName();
+            }
+
+            if ($right->copyright_status_id) {
+                $basisRight['copyrightStatus'] = QubitTerm::getById($right->copyright_status_id)->getName();
+            }
+
+            $basisRights[] = $basisRight;
+        }
+
+        return $basisRights;
+    }
+
+    private function getActRights()
+    {
+        $actRights = [];
+        foreach ($this->getGrantedRights() as $grantedRight) {
+            $actRight = [];
+
+            if ($grantedRight->act_id) {
+                $actRight['act'] = QubitTerm::getById($grantedRight->act_id)->getName();
+            }
+
+            $actRight['restriction'] = QubitGrantedRight::getRestrictionString($grantedRight->restriction);
+            $actRight['startDate'] = arSolrPluginUtil::normalizeDateWithoutMonthOrDay($grantedRight->start_date);
+            $actRight['endDate'] = arSolrPluginUtil::normalizeDateWithoutMonthOrDay($grantedRight->end_date, true);
+
+            $actRights[] = $actRight;
+        }
+
+        return $actRights;
+    }
+}
diff --git a/plugins/arSolrPlugin/lib/model/arSolrModelBase.class.php b/plugins/arSolrPlugin/lib/model/arSolrModelBase.class.php
new file mode 100644
index 0000000000..15c9416483
--- /dev/null
+++ b/plugins/arSolrPlugin/lib/model/arSolrModelBase.class.php
@@ -0,0 +1,216 @@
+<?php
+
+/*
+ * This file is part of the Access to Memory (AtoM) software.
+ *
+ * Access to Memory (AtoM) is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Access to Memory (AtoM) is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Access to Memory (AtoM).  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+abstract class arSolrModelBase
+{
+    protected $timer;
+    protected $count = 0;
+
+    protected static $conn;
+    protected static $termParentList;
+    protected static $allowedLanguages;
+
+    public function __construct()
+    {
+        if (!isset(self::$conn)) {
+            self::$conn = Propel::getConnection();
+        }
+
+        $this->search = QubitSearch::getSolrInstance();
+
+        $this->log(' - Loading '.get_class($this).'...');
+    }
+
+    public function getCount()
+    {
+        return $this->count;
+    }
+
+    public function setTimer($timer)
+    {
+        $this->timer = $timer;
+    }
+
+    public static function serializeI18ns($id, array $classes, $options = [])
+    {
+        if (empty($classes)) {
+            throw new sfException('At least one class name must be passed.');
+        }
+
+        // Get an array of i18n languages
+        if (!isset(self::$allowedLanguages)) {
+            self::$allowedLanguages = sfConfig::get('app_i18n_languages');
+        }
+
+        // Properties
+        $i18ns = ['languages' => []];
+
+        // Allow merging i18n fields, used for partial foreign types
+        // when different object fields are included in the same object
+        if (isset($options['merge'])) {
+            $i18ns = $options['merge'];
+        }
+
+        foreach ($classes as $class) {
+            // Build SQL query per table. Tried with joins but for some reason the
+            // culture value appears empty. The statement can't be reused as it's
+            // not possible to bind and use a variable for the table name.
+            $rows = QubitPdo::fetchAll(
+                sprintf('SELECT * FROM %s WHERE id = ?', ($class.'I18n')::TABLE_NAME),
+                [$id],
+                ['fetchMode' => PDO::FETCH_ASSOC]
+            );
+
+            foreach ($rows as $row) {
+                // Any i18n record within a culture previously not configured will
+                // be ignored since the search engine will only accept known languages
+                if (!in_array($row['culture'], self::$allowedLanguages)) {
+                    continue;
+                }
+
+                // Collect cultures added
+                $i18ns['languages'][] = $row['culture'];
+
+                foreach ($row as $key => $value) {
+                    // Pass if the column is unneeded or null, or if it's not set in options fields
+                    if (
+                        in_array($key, ['id', 'culture']) || is_null($value)
+                        || (isset($options['fields']) && !in_array($key, $options['fields']))
+                    ) {
+                        continue;
+                    }
+
+                    $camelized = lcfirst(sfInflector::camelize($key));
+                    $i18ns[$row['culture']][$camelized] = $value;
+                }
+            }
+        }
+
+        // Remove duplicated cultures from language values
+        $i18ns['languages'] = array_unique(array_values($i18ns['languages']));
+
+        return $i18ns;
+    }
+
+    // abstract public function update($object);
+    public static function update($object)
+    {
+        return true;
+    }
+
+    public static function getRelatedTerms($objectId, $taxonomyIds)
+    {
+        // We can't reuse this statement as there is no way to bind
+        // arrays with unknown length to use them in an IN condition.
+        $sql = 'SELECT term.taxonomy_id, term.id
+            FROM object_term_relation otr
+            JOIN term ON otr.term_id = term.id
+            WHERE otr.object_id = ?
+            AND term.taxonomy_id IN ('.implode(',', $taxonomyIds).')';
+
+        // Use FETCH_GROUP and FETCH_COLUMN combined to get
+        // an array of term ids grouped by taxonomy.
+        return QubitPdo::fetchAll(
+            $sql,
+            [$objectId],
+            ['fetchMode' => PDO::FETCH_GROUP | PDO::FETCH_COLUMN]
+        );
+    }
+
+    public static function extendRelatedTerms($termIds)
+    {
+        if (empty($termIds)) {
+            return [];
+        }
+
+        // Try to get term parent list from sfConfig, added in
+        // the populate process when it includes terms and/or IOs.
+        if (!isset(self::$termParentList)) {
+            self::$termParentList = sfConfig::get('term_parent_list', null);
+        }
+
+        // If the term parent list is populated, recursively extend the terms
+        if (isset(self::$termParentList)) {
+            $relatedTerms = [];
+
+            // Iterate over each directly related term, adding all ancestors of each
+            foreach ($termIds as $id) {
+                $relatedTerms = array_merge(
+                    $relatedTerms,
+                    self::recursivelyGetParentTerms($id)
+                );
+            }
+
+            return array_unique($relatedTerms);
+        }
+
+        // Otherwise, get the extended terms from the database.
+        // We can't reuse this statement as there is no way to bind
+        // arrays with unknown length to use them in an IN condition.
+        $sql = 'WITH RECURSIVE cte AS
+            (
+                SELECT term1.id, term1.parent_id
+                FROM term term1 WHERE term1.id IN ('.implode(',', $termIds).')
+                UNION ALL
+                SELECT term2.id, term2.parent_id
+                FROM term term2 JOIN cte ON cte.parent_id=term2.id
+                WHERE term2.id != ?
+            )
+            SELECT DISTINCT id FROM cte';
+
+        return QubitPdo::fetchAll(
+            $sql,
+            [QubitTerm::ROOT_ID],
+            ['fetchMode' => PDO::FETCH_COLUMN]
+        );
+    }
+
+    protected function log($message)
+    {
+        $this->search->log($message);
+    }
+
+    protected function logEntry($title, $count)
+    {
+        $this->log(sprintf(
+            '    [%s] %s inserted (%ss) (%s/%s)',
+            str_replace('arSolr', '', get_class($this)),
+            $title,
+            $this->timer->elapsed(),
+            $count,
+            $this->getCount()
+        ));
+    }
+
+    /**
+     * Recursively find all ancestors (except the root) for a term.
+     *
+     * @param array $id the term id to find the ancestors for
+     *
+     * @return array ids of the ancestors and self
+     */
+    private static function recursivelyGetParentTerms($id)
+    {
+        if (!isset(self::$termParentList) || null === $parent = self::$termParentList[$id]) {
+            return [$id];
+        }
+
+        return array_merge([$id], self::recursivelyGetParentTerms($parent));
+    }
+}
diff --git a/plugins/arSolrPlugin/lib/model/arSolrNote.class.php b/plugins/arSolrPlugin/lib/model/arSolrNote.class.php
new file mode 100644
index 0000000000..854615b409
--- /dev/null
+++ b/plugins/arSolrPlugin/lib/model/arSolrNote.class.php
@@ -0,0 +1,31 @@
+<?php
+
+/*
+ * This file is part of the Access to Memory (AtoM) software.
+ *
+ * Access to Memory (AtoM) is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Access to Memory (AtoM) is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Access to Memory (AtoM).  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+class arSolrNote extends arSolrModelBase
+{
+    public static function serialize($object)
+    {
+        $serialized = [];
+
+        $serialized['sourceCulture'] = $object->source_culture;
+        $serialized['i18n'] = self::serializeI18ns($object->id, ['QubitNote']);
+
+        return $serialized;
+    }
+}
diff --git a/plugins/arSolrPlugin/lib/model/arSolrOtherName.class.php b/plugins/arSolrPlugin/lib/model/arSolrOtherName.class.php
new file mode 100644
index 0000000000..2ca6ce94c6
--- /dev/null
+++ b/plugins/arSolrPlugin/lib/model/arSolrOtherName.class.php
@@ -0,0 +1,40 @@
+<?php
+
+/*
+ * This file is part of the Access to Memory (AtoM) software.
+ *
+ * Access to Memory (AtoM) is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Access to Memory (AtoM) is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Access to Memory (AtoM).  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+class arSolrOtherName extends arSolrModelBase
+{
+    public static function serialize($object)
+    {
+        $serialized = [];
+
+        $serialized['sourceCulture'] = $object->source_culture;
+        $serialized['i18n'] = self::serializeI18ns($object->id, ['QubitOtherName']);
+
+        // Serialize type term
+        if (!empty($object->type_id)) {
+            $serialized['type'] = ['i18n' => arSolrModelBase::serializeI18ns(
+                $object->type_id,
+                ['QubitTerm'],
+                ['fields' => ['name']]
+            )];
+        }
+
+        return $serialized;
+    }
+}
diff --git a/plugins/arSolrPlugin/lib/model/arSolrPhysicalObject.class.php b/plugins/arSolrPlugin/lib/model/arSolrPhysicalObject.class.php
new file mode 100644
index 0000000000..1be286e150
--- /dev/null
+++ b/plugins/arSolrPlugin/lib/model/arSolrPhysicalObject.class.php
@@ -0,0 +1,31 @@
+<?php
+
+/*
+ * This file is part of the Access to Memory (AtoM) software.
+ *
+ * Access to Memory (AtoM) is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Access to Memory (AtoM) is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Access to Memory (AtoM).  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+class arSolrPhysicalObject extends arSolrModelBase
+{
+    public static function serialize($object)
+    {
+        $serialized = [];
+
+        $serialized['sourceCulture'] = $object->source_culture;
+        $serialized['i18n'] = self::serializeI18ns($object->id, ['QubitPhysicalObject']);
+
+        return $serialized;
+    }
+}
diff --git a/plugins/arSolrPlugin/lib/model/arSolrProperty.class.php b/plugins/arSolrPlugin/lib/model/arSolrProperty.class.php
new file mode 100644
index 0000000000..8840e20fa0
--- /dev/null
+++ b/plugins/arSolrPlugin/lib/model/arSolrProperty.class.php
@@ -0,0 +1,31 @@
+<?php
+
+/*
+ * This file is part of the Access to Memory (AtoM) software.
+ *
+ * Access to Memory (AtoM) is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Access to Memory (AtoM) is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Access to Memory (AtoM).  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+class arSolrProperty extends arSolrModelBase
+{
+    public static function serialize($object)
+    {
+        $serialized = [];
+
+        $serialized['sourceCulture'] = $object->source_culture;
+        $serialized['i18n'] = self::serializeI18ns($object->id, ['QubitProperty']);
+
+        return $serialized;
+    }
+}
diff --git a/plugins/arSolrPlugin/lib/model/arSolrRepository.class.php b/plugins/arSolrPlugin/lib/model/arSolrRepository.class.php
new file mode 100644
index 0000000000..7c43b3fe4a
--- /dev/null
+++ b/plugins/arSolrPlugin/lib/model/arSolrRepository.class.php
@@ -0,0 +1,142 @@
+<?php
+
+/*
+ * This file is part of the Access to Memory (AtoM) software.
+ *
+ * Access to Memory (AtoM) is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Access to Memory (AtoM) is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Access to Memory (AtoM).  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+class arSolrRepository extends arSolrModelBase
+{
+    public function load()
+    {
+        $criteria = new Criteria();
+        $criteria->add(QubitRepository::ID, QubitRepository::ROOT_ID, Criteria::NOT_EQUAL);
+        $repositories = QubitRepository::get($criteria);
+
+        $this->count = count($repositories);
+
+        return $repositories;
+    }
+
+    public function populate()
+    {
+        $errors = [];
+
+        $repositories = $this->load();
+
+        foreach ($repositories as $key => $repository) {
+            try {
+                $data = self::serialize($repository);
+
+                $this->search->addDocument($data, 'QubitRepository');
+
+                $this->logEntry($repository->__toString(), $key + 1);
+            } catch (sfException $e) {
+                $errors[] = $e->getMessage();
+            }
+        }
+
+        return $errors;
+    }
+
+    public static function serialize($object)
+    {
+        $serialized = [];
+
+        $serialized['id'] = $object->id;
+        $serialized['slug'] = $object->slug;
+        $serialized['identifier'] = $object->identifier;
+
+        // Related terms
+        $relatedTerms = arSolrModelBase::getRelatedTerms(
+            $object->id,
+            [
+                QubitTaxonomy::REPOSITORY_TYPE_ID,
+                QubitTaxonomy::THEMATIC_AREA_ID,
+                QubitTaxonomy::GEOGRAPHIC_SUBREGION_ID,
+            ]
+        );
+
+        if (isset($relatedTerms[QubitTaxonomy::REPOSITORY_TYPE_ID])) {
+            $serialized['types'] = $relatedTerms[QubitTaxonomy::REPOSITORY_TYPE_ID];
+        }
+
+        if (isset($relatedTerms[QubitTaxonomy::THEMATIC_AREA_ID])) {
+            $serialized['thematicAreas'] = $relatedTerms[QubitTaxonomy::THEMATIC_AREA_ID];
+        }
+
+        if (isset($relatedTerms[QubitTaxonomy::GEOGRAPHIC_SUBREGION_ID])) {
+            $serialized['geographicSubregions'] = $relatedTerms[QubitTaxonomy::GEOGRAPHIC_SUBREGION_ID];
+        }
+
+        foreach ($object->contactInformations as $contactInformation) {
+            $serialized['contactInformations'][] = arSolrContactInformation::serialize($contactInformation);
+        }
+
+        $sql = 'SELECT id, source_culture FROM '.QubitOtherName::TABLE_NAME.' WHERE object_id = ? AND type_id = ?';
+        foreach (QubitPdo::fetchAll($sql, [$object->id, QubitTerm::OTHER_FORM_OF_NAME_ID]) as $item) {
+            $serialized['otherNames'][] = arSolrOtherName::serialize($item);
+        }
+
+        $sql = 'SELECT id, source_culture FROM '.QubitOtherName::TABLE_NAME.' WHERE object_id = ? AND type_id = ?';
+        foreach (QubitPdo::fetchAll($sql, [$object->id, QubitTerm::PARALLEL_FORM_OF_NAME_ID]) as $item) {
+            $serialized['parallelNames'][] = arSolrOtherName::serialize($item);
+        }
+
+        if ($object->existsLogo()) {
+            $serialized['logoPath'] = $object->getLogoPath();
+        }
+
+        $serialized['createdAt'] = arSolrPluginUtil::convertDate($object->createdAt);
+        $serialized['updatedAt'] = arSolrPluginUtil::convertDate($object->updatedAt);
+
+        $serialized['sourceCulture'] = $object->sourceCulture;
+        $serialized['i18n'] = self::serializeI18ns($object->id, ['QubitActor', 'QubitRepository']);
+        self::addExtraSortInfo($serialized['i18n'], $object);
+
+        return $serialized;
+    }
+
+    public static function update($object)
+    {
+        $data = self::serialize($object);
+
+        QubitSearch::getSolrInstance()->addDocument($data, 'QubitRepository');
+
+        return true;
+    }
+
+    /**
+     * We store extra I18n fields (city, region) for table sorting purposes in the repository browse page.
+     *
+     * These values will be the city & region of the primary contact if valid, otherwise the first contact
+     * that has a valid city / region will be used.
+     *
+     * @param mixed $i18n
+     * @param mixed $object
+     */
+    private static function addExtraSortInfo(&$i18n, $object)
+    {
+        foreach (sfConfig::get('app_i18n_languages') as $lang) {
+            if ($object->getCity(['culture' => $lang])) {
+                $i18n[$lang]['city'] = $object->getCity(['culture' => $lang]);
+            }
+
+            if ($object->getRegion(['culture' => $lang])) {
+                $i18n[$lang]['region'] = $object->getRegion(['culture' => $lang]);
+            }
+        }
+    }
+}
diff --git a/plugins/arSolrPlugin/lib/model/arSolrTerm.class.php b/plugins/arSolrPlugin/lib/model/arSolrTerm.class.php
new file mode 100644
index 0000000000..ebf4d6bb71
--- /dev/null
+++ b/plugins/arSolrPlugin/lib/model/arSolrTerm.class.php
@@ -0,0 +1,66 @@
+<?php
+
+/*
+ * This file is part of the Access to Memory (AtoM) software.
+ *
+ * Access to Memory (AtoM) is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Access to Memory (AtoM) is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Access to Memory (AtoM).  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+class arSolrTerm extends arSolrModelBase
+{
+    public function load()
+    {
+        $sql = 'SELECT term.id';
+        $sql .= ' FROM '.QubitTerm::TABLE_NAME.' term';
+        $sql .= ' JOIN '.QubitObject::TABLE_NAME.' object ON term.id = object.id';
+        $sql .= ' WHERE term.id != ? AND object.class_name = ?';
+        $sql .= ' ORDER BY term.lft';
+
+        $terms = QubitPdo::fetchAll($sql, [QubitTerm::ROOT_ID, 'QubitTerm']);
+
+        $this->count = count($terms);
+
+        return $terms;
+    }
+
+    public function populate()
+    {
+        $errors = [];
+
+        // Loop through results, and add to search index
+        foreach ($this->load() as $key => $item) {
+            try {
+                $node = new arSolrTermPdo($item->id);
+                $data = $node->serialize();
+
+                QubitSearch::getSolrInstance()->addDocument($data, 'QubitTerm');
+
+                $this->logEntry($data['i18n'][$data['sourceCulture']]['name'], $key + 1);
+            } catch (sfException $e) {
+                $errors[] = $e->getMessage();
+            }
+        }
+
+        return $errors;
+    }
+
+    public static function update($object)
+    {
+        $node = new arSolrTermPdo($object->id);
+
+        QubitSearch::getSolrInstance()->addDocument($node->serialize(), 'QubitTerm');
+
+        return true;
+    }
+}
diff --git a/plugins/arSolrPlugin/lib/model/arSolrTermPdo.class.php b/plugins/arSolrPlugin/lib/model/arSolrTermPdo.class.php
new file mode 100644
index 0000000000..27ddfcf78c
--- /dev/null
+++ b/plugins/arSolrPlugin/lib/model/arSolrTermPdo.class.php
@@ -0,0 +1,132 @@
+<?php
+
+/*
+ * This file is part of the Access to Memory (AtoM) software.
+ *
+ * Access to Memory (AtoM) is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Access to Memory (AtoM) is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Access to Memory (AtoM).  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * Manage terms in search index.
+ */
+class arSolrTermPdo
+{
+    public $i18ns;
+
+    protected $data = [];
+
+    protected static $conn;
+    protected static $lookups;
+    protected static $statements;
+
+    /**
+     * METHODS.
+     *
+     * @param mixed $id
+     * @param mixed $options
+     */
+    public function __construct($id, $options = [])
+    {
+        if (isset($options['conn'])) {
+            self::$conn = $options['conn'];
+        }
+
+        if (!isset(self::$conn)) {
+            self::$conn = Propel::getConnection();
+        }
+
+        $this->loadData($id, $options);
+    }
+
+    public function __isset($name)
+    {
+        return isset($this->data[$name]);
+    }
+
+    public function __get($name)
+    {
+        if (isset($this->data[$name])) {
+            return $this->data[$name];
+        }
+    }
+
+    public function __set($name, $value)
+    {
+        $this->data[$name] = $value;
+    }
+
+    public function serialize()
+    {
+        $serialized = [];
+
+        $serialized['id'] = $this->id;
+        $serialized['slug'] = $this->slug;
+
+        $serialized['taxonomyId'] = $this->taxonomy_id;
+
+        $sql = 'SELECT id, source_culture FROM '.QubitOtherName::TABLE_NAME.' WHERE object_id = ? AND type_id = ?';
+        foreach (QubitPdo::fetchAll($sql, [$this->id, QubitTerm::ALTERNATIVE_LABEL_ID]) as $item) {
+            $serialized['useFor'][] = arSolrOtherName::serialize($item);
+        }
+
+        $sql = 'SELECT id, source_culture FROM '.QubitNote::TABLE_NAME.' WHERE object_id = ? AND type_id = ?';
+        foreach (QubitPdo::fetchAll($sql, [$this->id, QubitTerm::SCOPE_NOTE_ID]) as $item) {
+            $serialized['scopeNotes'][] = arSolrNote::serialize($item);
+        }
+
+        $serialized['isProtected'] = QubitTerm::isProtected($this->id);
+        $serialized['numberOfDescendants'] = ($this->rgt - $this->lft - 1) / 2;
+
+        $serialized['createdAt'] = arSolrPluginUtil::convertDate($this->created_at);
+        $serialized['updatedAt'] = arSolrPluginUtil::convertDate($this->updated_at);
+
+        $serialized['sourceCulture'] = $this->source_culture;
+        $serialized['i18n'] = arSolrModelBase::serializeI18ns($this->id, ['QubitTerm']);
+
+        return $serialized;
+    }
+
+    protected function loadData($id)
+    {
+        if (!isset(self::$statements['term'])) {
+            $sql = 'SELECT
+                term.*,
+                slug.slug,
+                object.created_at,
+                object.updated_at
+                FROM '.QubitTerm::TABLE_NAME.' term
+                JOIN '.QubitSlug::TABLE_NAME.' slug
+                ON term.id = slug.object_id
+                JOIN '.QubitObject::TABLE_NAME.' object
+                ON term.id = object.id
+                WHERE term.id = :id';
+
+            self::$statements['term'] = self::$conn->prepare($sql);
+        }
+
+        // Do select
+        self::$statements['term']->execute([':id' => $id]);
+
+        // Get first result
+        $this->data = self::$statements['term']->fetch(PDO::FETCH_ASSOC);
+
+        if (false === $this->data) {
+            throw new sfException("Couldn't find term (id: {$id})");
+        }
+
+        self::$statements['term']->closeCursor();
+
+        return $this;
+    }
+}
diff --git a/plugins/arSolrPlugin/modules/solrPanel/templates/solrMenu.php b/plugins/arSolrPlugin/modules/solrPanel/templates/solrMenu.php
new file mode 100644
index 0000000000..dbc4b0b6b2
--- /dev/null
+++ b/plugins/arSolrPlugin/modules/solrPanel/templates/solrMenu.php
@@ -0,0 +1 @@
+<h1>SOLR TEST</h1>
diff --git a/plugins/qbAclPlugin/lib/QubitSolrAclSearch.class.php b/plugins/qbAclPlugin/lib/QubitSolrAclSearch.class.php
new file mode 100644
index 0000000000..3aa76661c2
--- /dev/null
+++ b/plugins/qbAclPlugin/lib/QubitSolrAclSearch.class.php
@@ -0,0 +1,182 @@
+<?php
+
+/*
+ * This file is part of the Access to Memory (AtoM) software.
+ *
+ * Access to Memory (AtoM) is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Access to Memory (AtoM) is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Access to Memory (AtoM).  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * Filter search query objects based in the access lists. The queries are
+ * instances of the \Elastica\Query class.
+ */
+class QubitSolrAclSearch
+{
+    /**
+     * Filter search query by repository.
+     *
+     * @param \Elastica\Query $query  Search query object
+     * @param string          $action Action
+     *
+     * @return \Elastica\Query Filtered query
+     */
+    public static function filterByRepository(arSolrPluginQuery $query, $action)
+    {
+        $repositoryAccess = QubitAcl::getRepositoryAccess($action);
+        if (1 == count($repositoryAccess)) {
+            // If all repositories are denied access, re-route user to login
+            if (QubitAcl::DENY == $repositoryAccess[0]['access']) {
+                QubitAcl::forwardUnauthorized();
+            }
+        } else {
+            while ($repo = array_shift($repositoryAccess)) {
+                if ('*' == $repo['id']) {
+                    $queryBool = new arSolrBoolQuery();
+
+                    $query = new arSolrTermQuery();
+                    $query->setTerm('repositoryId', $repo['id']);
+
+                    if (QubitAcl::DENY == $repo['access']) {
+                        // Require repos to be specifically allowed (all others prohibited)
+                        // (ZSL) $query->addSubquery(QubitSearch::getInstance()->addTerm($repo['id'], 'repositoryId'), true);
+                        $queryBool->addMust($query);
+                    } else {
+                        // Prohibit specified repos (all others allowed)
+                        // (ZSL) $query->addSubquery(QubitSearch::getInstance()->addTerm($repo['id'], 'repositoryId'), false);
+                        $queryBool->addMustNot($query);
+                    }
+
+                    $query->setPostFilter($queryBool);
+                }
+            }
+        }
+
+        return $query;
+    }
+
+    /**
+     * Filter search query by resource specific ACL.
+     *
+     * @param \Elastica\Query $query Search query object
+     * @param mixed           $root  Root object for list
+     *
+     * @return \Elastica\Query Filtered query
+     */
+    public static function filterByResource(arSolrPluginQuery $query, $root)
+    {
+        $user = sfContext::getInstance()->user;
+
+        $permissions = QubitAcl::getUserPermissionsByAction($user, get_class($root), 'read');
+
+        // Build access control list
+        $grants = 0;
+        if (0 < count($permissions)) {
+            foreach ($permissions as $permission) {
+                if (!isset($resourceAccess[$permission->objectId])) {
+                    $resourceAccess[$permission->objectId] = QubitAcl::isAllowed($user, $permission->objectId, 'read');
+
+                    if ($resourceAccess[$permission->objectId]) {
+                        ++$grants;
+                    }
+                }
+            }
+        }
+
+        // If no grants then user can't see anything
+        if (0 == $grants) {
+            QubitAcl::forwardUnauthorized();
+        }
+
+        // If global deny is default, then list allowed resources
+        elseif (!QubitAcl::isAllowed($user, $root->id, 'read')) {
+            $allows = array_keys($resourceAccess, true, true);
+
+            $ids = [];
+            while ($resourceId = array_shift($allows)) {
+                // (ZSL) $query->addSubquery(QubitSearch::getInstance()->addTerm($resourceId, 'id'), true);
+                $ids[] = $resourceId;
+            }
+
+            if (0 < count($ids)) {
+                $queryIds = new arSolrQueryIds();
+                $queryIds->setIds($ids);
+
+                $query->setPostFilter($queryIds);
+            }
+        }
+
+        // Otherwise, build a list of banned resources
+        else {
+            $bans = array_keys($resourceAccess, false, true);
+
+            $ids = [];
+            while ($resourceId = array_shift($bans)) {
+                // (ZSL) $query->addSubquery(QubitSearch::getInstance()->addTerm($resourceId, 'id'), false);
+                $ids[] = $resourceId;
+            }
+
+            if (0 < count($ids)) {
+                $queryIds = new arSolrQueryIds();
+                $queryIds->setIds($ids);
+
+                $queryBool = new arSolrBoolQuery();
+                $queryBool->addMustNot($ids);
+
+                $query->setPostFilter($queryIds);
+            }
+        }
+
+        return $query;
+    }
+
+    /**
+     * Filter search query by resource specific ACL.
+     *
+     * @param arSolrBoolQuery $queryBool Search query object
+     */
+    public static function filterDrafts(arSolrBoolQuery $queryBool)
+    {
+        // Filter out 'draft' items by repository
+        $repositoryViewDrafts = QubitAcl::getRepositoryAccess('viewDraft');
+        if (1 == count($repositoryViewDrafts)) {
+            if (QubitAcl::DENY == $repositoryViewDrafts[0]['access']) {
+                // Don't show *any* draft info objects
+                $query = new arSolrTermQuery();
+                $query->setTerm('publicationStatusId', QubitTerm::PUBLICATION_STATUS_PUBLISHED_ID);
+
+                $queryBool->addMust($query);
+            }
+        } else {
+            // Get last rule in list, it will be the global rule with the opposite
+            // access of the preceeding rules (e.g. if last rule is "DENY ALL" then
+            // preceeding rules will be "ALLOW" rules)
+            $globalRule = array_pop($repositoryViewDrafts);
+
+            $query = new arSolrBoolQuery();
+
+            while ($repo = array_shift($repositoryViewDrafts)) {
+                $query->addShould(new arSolrTermQuery(['repository.id' => (int) $repo['id']]));
+            }
+
+            $query->addShould(new arSolrTermQuery(['publicationStatusId' => QubitTerm::PUBLICATION_STATUS_PUBLISHED_ID]));
+
+            // Does this ever happen in AtoM?
+            if (QubitAcl::GRANT == $globalRule['access']) {
+                $queryBool->addMustNot($query);
+            } else {
+                $queryBool->addMust($query);
+            }
+        }
+    }
+}
diff --git a/test/phpunit/arSolrPlugin/config/ArSolrPluginConfigurationTest.php b/test/phpunit/arSolrPlugin/config/ArSolrPluginConfigurationTest.php
new file mode 100644
index 0000000000..232635cd9b
--- /dev/null
+++ b/test/phpunit/arSolrPlugin/config/ArSolrPluginConfigurationTest.php
@@ -0,0 +1,50 @@
+<?php
+
+use PHPUnit\Framework\TestCase;
+
+require_once 'plugins/arSolrPlugin/config/arSolrPluginConfiguration.class.php';
+
+/**
+ * @internal
+ *
+ * @covers \arSolrConfigHandler
+ * @covers \arSolrPluginConfiguration
+ * @covers \BaseSetting
+ * @covers \BaseSettingI18n
+ * @covers \QubitApcUniversalClassLoader
+ * @covers \QubitQuery
+ */
+class ArSolrPluginConfigurationTest extends TestCase
+{
+    protected $pluginConfiguration;
+
+    public function solrPluginConfigurationProvider(): array
+    {
+        $this->sfProjectConfigurationObj = new sfProjectConfiguration();
+        $this->qubitConfigrationObj = new qubitConfiguration('test', false);
+
+        return [
+            'Supply sfProjectConfiguration only' => [$this->sfProjectConfigurationObj, null, null],
+            'Supply qubitConfiguration only' => [$this->qubitConfigrationObj, null, null],
+            'Supply sfProjectConfiguration with params' => [$this->sfProjectConfigurationObj, 'plugins/arSolrPlugin', 'arSolrPlugin'],
+            'Supply qubitConfiguration with params' => [$this->qubitConfigrationObj, 'plugins/arSolrPlugin', 'arSolrPlugin'],
+        ];
+    }
+
+    /**
+     * @dataProvider solrPluginConfigurationProvider
+     *
+     * @param mixed $obj
+     * @param mixed $rootDir
+     * @param mixed $name
+     */
+    public function testInitializeWithProjectConfiguration($obj, $rootDir, $name)
+    {
+        $this->pluginConfiguration = new arSolrPluginConfiguration($obj, $rootDir, $name);
+        $this->pluginConfiguration->initialize();
+
+        $this->assertTrue($this->pluginConfiguration instanceof arSolrPluginConfiguration, 'Assert plugin object is arSolrPluginConfiguration');
+
+        $this->assertTrue(is_array(arSolrPluginConfiguration::$config), 'Assert plugin config result is array');
+    }
+}
diff --git a/test/phpunit/arSolrPlugin/lib/query/ArSolrExistsQueryTest.php b/test/phpunit/arSolrPlugin/lib/query/ArSolrExistsQueryTest.php
new file mode 100644
index 0000000000..3e36d560fe
--- /dev/null
+++ b/test/phpunit/arSolrPlugin/lib/query/ArSolrExistsQueryTest.php
@@ -0,0 +1,125 @@
+<?php
+
+use PHPUnit\Framework\TestCase;
+
+require_once 'plugins/arSolrPlugin/lib/client/arSolrAbstractQuery.class.php';
+
+require_once 'plugins/arSolrPlugin/lib/client/arSolrExistsQuery.class.php';
+
+/**
+ * @internal
+ *
+ * @covers \arSolrExistsQuery
+ */
+class ArSolrExistsQueryTest extends TestCase
+{
+    public function createSolrExistsQueryProvider(): array
+    {
+        return [
+            'New arSolrExistsQuery with blank field' => [
+                'field' => '',
+                'result' => null,
+            ],
+            'New arSolrExistsQuery with null field' => [
+                'field' => null,
+                'result' => null,
+            ],
+            'New arSolrExistsQuery with string field' => [
+                'field' => 'testField',
+                'result' => 'testField',
+            ],
+        ];
+    }
+
+    /**
+     * @dataProvider createSolrExistsQueryProvider
+     *
+     * @param mixed $field
+     * @param mixed $expected
+     */
+    public function testCreateSolrExistsQuery($field, $expected)
+    {
+        $this->existsQuery = new arSolrExistsQuery($field);
+        $this->assertTrue($this->existsQuery instanceof arSolrExistsQuery, 'Assert plugin object is arSolrExistsQuery.');
+        $this->assertSame($expected, $this->existsQuery->getField(), 'Assert arSolrExistsQuery field is correct.');
+    }
+
+    public function getQueryParamsProvider(): array
+    {
+        return [
+            'Generate exists query with specified type' => [
+                'field' => 'testField',
+                'type' => 'testType',
+                'result' => [
+                    'query' => [
+                        'lucene' => [
+                            'query' => 'testType.testField:*',
+                        ],
+                    ],
+                    'offset' => 0,
+                    'limit' => 10,
+                ],
+            ],
+        ];
+    }
+
+    /**
+     * @dataProvider getQueryParamsProvider
+     *
+     * @param mixed $expected
+     * @param mixed $field
+     * @param mixed $type
+     */
+    public function testGetQueryParams($field, $type, $expected)
+    {
+        $this->existsQuery = new arSolrExistsQuery($field);
+        $this->existsQuery->setType($type);
+
+        $actual = $this->existsQuery->getQueryParams();
+
+        $this->assertSame($expected, $actual, 'Params passed does not match expected.');
+    }
+
+    public function getQueryParamsExceptionProvider(): array
+    {
+        return [
+            'Generate exists query with missing type' => [
+                'field' => 'testField',
+                'type' => '',
+                'expectedException' => '\Exception',
+                'expectedExceptionMessage' => 'Field \'type\' is not set.',
+            ],
+            'Generate exists query with missing field' => [
+                'field' => '',
+                'type' => 'testType',
+                'expectedException' => '\Exception',
+                'expectedExceptionMessage' => 'Field is not set.',
+            ],
+            'Generate exists query with missing field and type' => [
+                'field' => '',
+                'type' => '',
+                'expectedException' => '\Exception',
+                'expectedExceptionMessage' => 'Field is not set.',
+            ],
+        ];
+    }
+
+    /**
+     * @dataProvider getQueryParamsExceptionProvider
+     *
+     * @param mixed $field
+     * @param mixed $type
+     * @param mixed $expectedException
+     * @param mixed $expectedExceptionMessage
+     */
+    public function testGetQueryParamsException($field, $type, $expectedException, $expectedExceptionMessage)
+    {
+        $this->existsQuery = new arSolrExistsQuery($field);
+        $this->existsQuery->setType($type);
+
+        $this->expectException($expectedException);
+        $this->expectExceptionMessage($expectedExceptionMessage);
+
+        $this->existsQuery->getQueryParams();
+    }
+}
diff --git a/test/phpunit/arSolrPlugin/lib/query/ArSolrIdsQueryTest.php b/test/phpunit/arSolrPlugin/lib/query/ArSolrIdsQueryTest.php
new file mode 100644
index 0000000000..c13f9912f2
--- /dev/null
+++ b/test/phpunit/arSolrPlugin/lib/query/ArSolrIdsQueryTest.php
@@ -0,0 +1,160 @@
+<?php
+
+use PHPUnit\Framework\TestCase;
+
+require_once 'plugins/arSolrPlugin/lib/client/arSolrAbstractQuery.class.php';
+
+require_once 'plugins/arSolrPlugin/lib/client/arSolrTermsQuery.class.php';
+
+require_once 'plugins/arSolrPlugin/lib/client/arSolrIdsQuery.class.php';
+
+/**
+ * @internal
+ *
+ * @covers \arSolrIdsQuery
+ * @covers \arSolrTermsQuery
+ */
+class ArSolrIdsQueryTest extends TestCase
+{
+    public function testCreateEmptySolrIdsQuery()
+    {
+        $this->idsQuery = new arSolrIdsQuery();
+        $this->assertTrue($this->idsQuery instanceof arSolrIdsQuery, 'Assert plugin object is arSolrIdsQuery.');
+    }
+
+    public function createSolrIdsQueryProvider(): array
+    {
+        return [
+            'New arSolrIdsQuery with no ids' => [
+                'ids' => null,
+                'expectedField' => 'id',
+                'expectedValue' => null,
+            ],
+            'New arSolrIdsQuery with empty ids' => [
+                'ids' => [],
+                'expectedField' => 'id',
+                'expectedValue' => [],
+            ],
+            'New arSolrIdsQuery with one id' => [
+                'ids' => [123],
+                'expectedField' => 'id',
+                'expectedValue' => [123],
+            ],
+            'New arSolrIdsQuery with multiple ids' => [
+                'ids' => [123, 456],
+                'expectedField' => 'id',
+                'expectedValue' => [123, 456],
+            ],
+        ];
+    }
+
+    /**
+     * @dataProvider createSolrIdsQueryProvider
+     *
+     * @param mixed $ids
+     * @param mixed $expectedField
+     * @param mixed $expectedValue
+     */
+    public function testCreateSolrIdsQuery($ids, $expectedField, $expectedValue)
+    {
+        $this->idsQuery = new arSolrIdsQuery($ids);
+        $actualField = $this->idsQuery->getTermField();
+        $actualValues = $this->idsQuery->getIds();
+
+        $this->assertTrue($this->idsQuery instanceof arSolridsQuery, 'Assert plugin object is arSolrIdsQuery.');
+        $this->assertSame($expectedField, $actualField, 'Passed field does not match expected field.');
+        $this->assertSame($expectedValue, $actualValues, 'Passed value does not match expected value.');
+    }
+
+    public function getQueryParamsProvider(): array
+    {
+        return [
+            'Generate ids query with single id' => [
+                'ids' => [123],
+                'type' => 'test_type',
+                'expected' => [
+                    'query' => [
+                        'edismax' => [
+                            'query' => 'test_type.id:(123)',
+                        ],
+                    ],
+                    'offset' => 0,
+                    'limit' => 10,
+                ],
+            ],
+            'Generate ids query with multiple ids' => [
+                'ids' => [123, 345, 456],
+                'type' => 'test_type',
+                'expected' => [
+                    'query' => [
+                        'edismax' => [
+                            'query' => 'test_type.id:(123 OR 345 OR 456)',
+                        ],
+                    ],
+                    'offset' => 0,
+                    'limit' => 10,
+                ],
+            ],
+        ];
+    }
+
+    /**
+     * @dataProvider getQueryParamsProvider
+     *
+     * @param mixed $ids
+     * @param mixed $type
+     * @param mixed $expected
+     */
+    public function testGetQueryParams($ids, $type, $expected)
+    {
+        $this->idsQuery = new arSolrIdsQuery($ids);
+        $this->idsQuery->setType($type);
+
+        $actual = $this->idsQuery->getQueryParams();
+
+        $this->assertSame($expected, $actual, 'Params passed do not match expected.');
+    }
+
+    public function getQueryParamsExceptionProvider(): array
+    {
+        return [
+            'Generate ids query with missing type' => [
+                'ids' => [123],
+                'type' => '',
+                'expectedException' => '\Exception',
+                'expectedExceptionMessage' => 'Field \'type\' is not set.',
+            ],
+            'Generate ids query with no ids' => [
+                'ids' => null,
+                'type' => 'test_type',
+                'expectedException' => '\Exception',
+                'expectedExceptionMessage' => 'Ids are not set.',
+            ],
+            'Generate ids query with zero ids' => [
+                'ids' => [],
+                'type' => 'test_type',
+                'expectedException' => '\Exception',
+                'expectedExceptionMessage' => 'Ids are not set.',
+            ],
+        ];
+    }
+
+    /**
+     * @dataProvider getQueryParamsExceptionProvider
+     *
+     * @param mixed $ids
+     * @param mixed $type
+     * @param mixed $expectedException
+     * @param mixed $expectedExceptionMessage
+     */
+    public function testGetQueryParamsException($ids, $type, $expectedException, $expectedExceptionMessage)
+    {
+        $this->idsQuery = new arSolrIdsQuery($ids);
+        $this->idsQuery->setType($type);
+
+        $this->expectException($expectedException);
+        $this->expectExceptionMessage($expectedExceptionMessage);
+
+        $this->idsQuery->getQueryParams();
+    }
+}
diff --git a/test/phpunit/arSolrPlugin/lib/query/ArSolrMatchAllQueryTest.php b/test/phpunit/arSolrPlugin/lib/query/ArSolrMatchAllQueryTest.php
new file mode 100644
index 0000000000..fbc5d1c6d5
--- /dev/null
+++ b/test/phpunit/arSolrPlugin/lib/query/ArSolrMatchAllQueryTest.php
@@ -0,0 +1,99 @@
+<?php
+
+use PHPUnit\Framework\TestCase;
+
+require_once 'plugins/arSolrPlugin/lib/client/arSolrMatchAllQuery.class.php';
+
+/**
+ * @internal
+ *
+ * @covers \arSolrMatchAllQuery
+ */
+class ArSolrMatchAllQueryTest extends TestCase
+{
+    public function createSolrMatchAllQueryProvider()
+    {
+        return [
+            'New arSolrMatchAllQuery with default options' => [
+                'expected' => [
+                    'query' => [
+                        'lucene' => [
+                            'q.op' => 'AND',
+                            'stopwords' => 'true',
+                            'query' => '*:*',
+                        ],
+                    ],
+                    'offset' => 0,
+                    'limit' => 10,
+                ],
+            ],
+        ];
+    }
+
+    /**
+     * @dataProvider createSolrMatchAllQueryProvider
+     *
+     * @param array $expected
+     */
+    public function testCreateSolrMatchAllQuery($expected)
+    {
+        $this->matchAllQuery = new arSolrMatchAllQuery();
+        $actual = $this->matchAllQuery->getQueryParams();
+
+        $this->assertTrue($this->matchAllQuery instanceof arSolrMatchAllQuery, 'Assert plugin object is arSolrMatchAllQuery.');
+        $this->assertSame($expected, $actual, 'Params passed do not match expected.');
+    }
+
+    public function testSetDefaultOperatorException()
+    {
+        $this->matchAllQuery = new arSolrMatchAllQuery();
+
+        $this->expectException('\Exception');
+        $this->expectExceptionMessage('Invalid operator. AND and OR are the only acceptable operator types.');
+
+        $this->matchAllQuery->setDefaultOperator('testOperator');
+    }
+
+    public function setDefaultOperatorProvider()
+    {
+        return [
+            'Test setting the default operator to \'OR\'' => [
+                'operator' => 'OR',
+                'expected' => 'OR',
+            ],
+            'Test setting the default operator to \'AND\'' => [
+                'operator' => 'AND',
+                'expected' => 'AND',
+            ],
+        ];
+    }
+
+    /**
+     * @dataProvider setDefaultOperatorProvider
+     *
+     * @param mixed  $expected
+     * @param string $operator
+     */
+    public function testSetDefaultOperator($expected, $operator)
+    {
+        $this->matchAllQuery = new arSolrMatchAllQuery();
+        $this->matchAllQuery->setDefaultOperator($operator);
+
+        $actual = $this->matchAllQuery->getDefaultOperator();
+
+        $this->assertSame($expected, $actual, 'Params passed do not match expected.');
+    }
+
+    public function testSetSearchQuery()
+    {
+        $this->matchAllQuery = new arSolrMatchAllQuery();
+
+        // Test setting the search query to blank query
+        $this->matchAllQuery->setSearchQuery('');
+        $this->assertEquals('', $this->matchAllQuery->getSearchQuery());
+
+        // Test setting the search query to default
+        $this->matchAllQuery->setSearchQuery('*:*');
+        $this->assertEquals('*:*', $this->matchAllQuery->getSearchQuery());
+    }
+}
diff --git a/test/phpunit/arSolrPlugin/lib/query/ArSolrMatchQueryTest.php b/test/phpunit/arSolrPlugin/lib/query/ArSolrMatchQueryTest.php
new file mode 100644
index 0000000000..d60c21f71b
--- /dev/null
+++ b/test/phpunit/arSolrPlugin/lib/query/ArSolrMatchQueryTest.php
@@ -0,0 +1,111 @@
+<?php
+
+use PHPUnit\Framework\TestCase;
+
+require_once 'plugins/arSolrPlugin/lib/client/arSolrAbstractQuery.class.php';
+
+require_once 'plugins/arSolrPlugin/lib/client/arSolrTermQuery.class.php';
+
+require_once 'plugins/arSolrPlugin/lib/client/arSolrMatchQuery.class.php';
+
+/**
+ * @internal
+ *
+ * @covers \arSolrMatchQuery
+ * @covers \arSolrTermQuery
+ */
+class ArSolrMatchQueryTest extends TestCase
+{
+    public function testCreateEmptySolrMatchQuery()
+    {
+        $this->matchQuery = new arSolrMatchQuery();
+        $this->assertTrue($this->matchQuery instanceof arSolrMatchQuery, 'Assert plugin object is arSolrMatchQuery.');
+    }
+
+    public function getQueryParamsProvider(): array
+    {
+        return [
+            'Generate match query with specified type' => [
+                'field' => 'test_field',
+                'value' => 'testVal',
+                'type' => 'test_type',
+                'expected' => [
+                    'query' => [
+                        'edismax' => [
+                            'query' => 'test_type.test_field:testVal~',
+                        ],
+                    ],
+                    'offset' => 0,
+                    'limit' => 10,
+                ],
+            ],
+        ];
+    }
+
+    /**
+     * @dataProvider getQueryParamsProvider
+     *
+     * @param mixed $field
+     * @param mixed $value
+     * @param mixed $type
+     * @param mixed $expected
+     */
+    public function testGetQueryParams($field, $value, $type, $expected)
+    {
+        $this->matchQuery = new arSolrMatchQuery();
+        $this->matchQuery->setFieldQuery($field, $value);
+        $this->matchQuery->setType($type);
+
+        $actual = $this->matchQuery->getQueryParams();
+
+        $this->assertSame($expected, $actual, 'Params passed do not match expected.');
+    }
+
+    public function getQueryParamsUsingSetExceptionProvider(): array
+    {
+        return [
+            'Generate match query with missing field \'field\'' => [
+                'field' => null,
+                'value' => null,
+                'type' => '',
+                'expectedException' => '\Exception',
+                'expectedExceptionMessage' => 'Match field is not set.',
+            ],
+            'Generate match query with missing field value' => [
+                'field' => 'tField',
+                'value' => null,
+                'type' => '',
+                'expectedException' => '\Exception',
+                'expectedExceptionMessage' => 'Match value is not set.',
+            ],
+            'Generate match query with missing type' => [
+                'field' => 'tField',
+                'value' => 'tValue',
+                'type' => '',
+                'expectedException' => '\Exception',
+                'expectedExceptionMessage' => 'Match \'type\' is not set.',
+            ],
+        ];
+    }
+
+    /**
+     * @dataProvider getQueryParamsUsingSetExceptionProvider
+     *
+     * @param mixed $field
+     * @param mixed $value
+     * @param mixed $type
+     * @param mixed $expectedException
+     * @param mixed $expectedExceptionMessage
+     */
+    public function testGetQueryParamsUsingSetException($field, $value, $type, $expectedException, $expectedExceptionMessage)
+    {
+        $this->matchQuery = new arSolrMatchQuery();
+        $this->matchQuery->setFieldQuery($field, $value);
+        $this->matchQuery->setType($type);
+
+        $this->expectException($expectedException);
+        $this->expectExceptionMessage($expectedExceptionMessage);
+
+        $this->matchQuery->getQueryParams();
+    }
+}
diff --git a/test/phpunit/arSolrPlugin/lib/query/ArSolrRangeQueryTest.php b/test/phpunit/arSolrPlugin/lib/query/ArSolrRangeQueryTest.php
new file mode 100644
index 0000000000..1465c681f0
--- /dev/null
+++ b/test/phpunit/arSolrPlugin/lib/query/ArSolrRangeQueryTest.php
@@ -0,0 +1,200 @@
+<?php
+
+use PHPUnit\Framework\TestCase;
+
+require_once 'plugins/arSolrPlugin/lib/client/arSolrRangeQuery.class.php';
+
+/**
+ * @internal
+ *
+ * @covers \arSolrRangeQuery
+ */
+class ArSolrRangeQueryTest extends TestCase
+{
+    public function createSolrRangeQueryProvider()
+    {
+        return [
+            'New arSolrRangeQuery with default field and lte range' => [
+                'field' => ['dates.startDate'],
+                'range' => ['lte' => '1900-01-01'],
+                'expected' => [
+                    ['dates.startDate'],
+                    ['lte' => '1900-01-01'],
+                ],
+            ],
+            'New arSolrRangeQuery with default field and lt range' => [
+                'field' => ['dates.startDate'],
+                'range' => ['lt' => '1900'],
+                'expected' => [
+                    ['dates.startDate'],
+                    ['lt' => '1900'],
+                ],
+            ],
+            'New arSolrRangeQuery with empty field and default gt range' => [
+                'field' => [],
+                'range' => ['gt' => '1900-01-01'],
+                'expected' => [
+                    [],
+                    ['gt' => '1900-01-01'],
+                ],
+            ],
+            'New arSolrRangeQuery with NULL field and default range' => [
+                'field' => null,
+                'range' => ['gte' => '1900'],
+                'expected' => [
+                    null,
+                    ['gte' => '1900'],
+                ],
+            ],
+        ];
+    }
+
+    /**
+     * @dataProvider createSolrRangeQueryProvider
+     *
+     * @param string $field
+     * @param array  $range
+     * @param array  $expected
+     */
+    public function testCreateSolrRangeQuery($field, $range, $expected)
+    {
+        $this->rangeQuery = new arSolrRangeQuery($field, $range);
+
+        $this->assertTrue($this->rangeQuery instanceof arSolrRangeQuery, 'Assert plugin object is arSolrRangeQuery.');
+        $this->assertSame($this->rangeQuery->getField(), $expected[0], 'Assert arSolrRangeQuery field is correct.');
+        $this->assertSame($this->rangeQuery->getRange(), $expected[1], 'Assert arSolrRangeQuery range is correct.');
+    }
+
+    public function createSolrRangeQueryExceptionProvider()
+    {
+        return [
+            'New arSolrRangeQuery with empty range' => [
+                'range' => [],
+                'expectedException' => '\Exception',
+                'expectedExceptionMessage' => 'Invalid range date format. Range date must be formatted as YYYY-MM-DD or YYYY.',
+            ],
+            'New arSolrRangeQuery with string range' => [
+                'range' => 'test_range',
+                'expectedException' => '\Exception',
+                'expectedExceptionMessage' => 'Invalid range date format. Range date must be formatted as YYYY-MM-DD or YYYY.',
+            ],
+            'New arSolrRangeQuery with NULL range' => [
+                'range' => null,
+                'expectedException' => '\Exception',
+                'expectedExceptionMessage' => 'Invalid range date format. Range date must be formatted as YYYY-MM-DD or YYYY.',
+            ],
+        ];
+    }
+
+    /**
+     * @dataProvider createSolrRangeQueryExceptionProvider
+     *
+     * @param array $range
+     * @param mixed $expectedException
+     * @param mixed $expectedExceptionMessage
+     */
+    public function testCreateSolrRangeQueryException($range, $expectedException, $expectedExceptionMessage)
+    {
+        $this->expectException($expectedException);
+        $this->expectExceptionMessage($expectedExceptionMessage);
+
+        $this->rangeQuery = new arSolrRangeQuery('testField', $range);
+    }
+
+    public function testSetComputedRange()
+    {
+        $this->rangeQuery = new arSolrRangeQuery('test_field', ['lte' => '2000', 'gte' => '2000']);
+        $this->rangeQuery->setRange(['lte' => '2000', 'gte' => '2000']);
+        $this->rangeQuery->setType('test_type');
+
+        $this->rangeQuery->getQueryParams();
+
+        $this->assertSame('[2000 TO 2000]', $this->rangeQuery->getComputedRange(), 'Params passed does not match expected.');
+    }
+
+    public function testSetTypeException()
+    {
+        $this->rangeQuery = new arSolrRangeQuery('test_field', ['lte' => '2000', 'gte' => '2000']);
+
+        $this->assertNull($this->rangeQuery->setType(''));
+    }
+
+    public function getQueryParamsProvider(): array
+    {
+        return [
+            'Test range query with default options' => [
+                'field' => 'testField',
+                'range' => ['lte' => '1990', 'gte' => '2000'],
+                'type' => 'testType',
+                'expected' => [
+                    'query' => [
+                        'lucene' => [
+                            'query' => 'testType.testField:[1990 TO 2000]',
+                        ],
+                    ],
+                    'offset' => 0,
+                    'limit' => 10,
+                ],
+            ],
+        ];
+    }
+
+    /**
+     * @dataProvider getQueryParamsProvider
+     *
+     * @param string $field
+     * @param array  $range
+     * @param string $type
+     * @param array  $expected
+     */
+    public function testGetQueryParams($field, $range, $type, $expected)
+    {
+        $this->rangeQuery = new arSolrRangeQuery($field, $range);
+        $this->rangeQuery->setRange($range);
+        $this->rangeQuery->setField($field);
+        $this->rangeQuery->setType($type);
+
+        $actual = $this->rangeQuery->getQueryParams();
+
+        $this->assertSame($expected, $actual, 'Params passed do not match expected.');
+    }
+
+    public function getQueryParamsExceptionProvider(): array
+    {
+        return [
+            'Test range query with NULL field' => [
+                'type' => 'test_type',
+                'field' => null,
+                'range' => ['lte' => '2000', 'gte' => '2000'],
+                'expectedException' => '\Exception',
+                'expectedExceptionMessage' => 'Field is not set.',
+            ],
+            'Test range query with empty type field' => [
+                'type' => '',
+                'field' => 'test_field',
+                'range' => ['lte' => '2000', 'gte' => '2000'],
+                'expectedException' => '\Exception',
+                'expectedExceptionMessage' => 'Field \'type\' is not set.',
+            ],
+        ];
+    }
+
+    /**
+     * @dataProvider getQueryParamsExceptionProvider
+     *
+     * @param string $type
+     * @param array  $field
+     * @param mixed  $range
+     * @param mixed  $expectedException
+     * @param mixed  $expectedExceptionMessage
+     */
+    public function testGetQueryParamsException($type, $field, $range, $expectedException, $expectedExceptionMessage)
+    {
+        $this->rangeQuery = new arSolrRangeQuery($field, $range);
+        $this->rangeQuery->setType($type);
+
+        $this->expectException($expectedException);
+        $this->expectExceptionMessage($expectedExceptionMessage);
+        $this->rangeQuery->getQueryParams();
+    }
+}
diff --git a/test/phpunit/arSolrPlugin/lib/query/ArSolrStringQueryTest.php b/test/phpunit/arSolrPlugin/lib/query/ArSolrStringQueryTest.php
new file mode 100644
index 0000000000..a02c3455cf
--- /dev/null
+++ b/test/phpunit/arSolrPlugin/lib/query/ArSolrStringQueryTest.php
@@ -0,0 +1,252 @@
+<?php
+
+use PHPUnit\Framework\TestCase;
+
+require_once 'plugins/arSolrPlugin/lib/client/arSolrStringQuery.class.php';
+
+/**
+ * @internal
+ *
+ * @covers \arSolrStringQuery
+ */
+class ArSolrQueryTest extends TestCase
+{
+    public function createSolrQueryProvider()
+    {
+        return [
+            'New arSolrStringQuery with default options' => [
+                'searchQuery' => '*:*',
+                'expected' => '*:*',
+            ],
+        ];
+    }
+
+    /**
+     * @dataProvider createSolrQueryProvider
+     *
+     * @param mixed $searchQuery
+     * @param mixed $expected
+     */
+    public function testCreateSolrQuery($searchQuery, $expected)
+    {
+        $this->query = new arSolrStringQuery($searchQuery);
+        $actual = $this->query->getSearchQuery();
+
+        $this->assertTrue($this->query instanceof arSolrStringQuery, 'Assert plugin object is arSolrStringQuery.');
+        $this->assertSame($expected, $actual, 'Assert arSolrStringQuery search query is correct.');
+    }
+
+    public function testSetFields()
+    {
+        $this->query = new arSolrStringQuery('*:*');
+
+        // Test setting the fields to empty array
+        $this->query->setFields('');
+        $this->assertEquals('', $this->query->getFields());
+
+        // Test setting the fields to null
+        $this->query->setFields(null);
+        $this->assertEquals(null, $this->query->getFields());
+
+        $fields = ['QubitInformationObject.i18n.en.title', 'QubitInformationObject.i18n.fr.title'];
+        // Test setting the fields to array
+        $this->query->setFields($fields);
+        $this->assertEquals($fields, $this->query->getFields());
+    }
+
+    public function setDefaultOperatorProvider()
+    {
+        return [
+            'Test set default operator with \'OR\'' => [
+                'operator' => 'OR',
+                'expected' => 'OR',
+            ],
+            'Test set default operator with \'AND\'' => [
+                'operator' => 'AND',
+                'expected' => 'AND',
+            ],
+        ];
+    }
+
+    /**
+     * @dataProvider setDefaultOperatorProvider
+     *
+     * @param string $operator
+     * @param string $expected
+     */
+    public function testSetDefaultOperator($operator, $expected)
+    {
+        $this->query = new arSolrStringQuery('*:*');
+        $this->query->setDefaultOperator($operator);
+        $actual = $this->query->getDefaultOperator();
+
+        $this->assertSame($expected, $actual, 'Params passed does not match expected.');
+    }
+
+    public function testSetDefaultOperatorException()
+    {
+        $this->query = new arSolrStringQuery('*:*');
+
+        $this->expectException('\Exception');
+        $this->expectExceptionMessage('Invalid operator. AND and OR are the only acceptable operator types.');
+
+        $this->query->setDefaultOperator('testOperator');
+    }
+
+    public function testSetAggregations()
+    {
+        $this->query = new arSolrStringQuery('*:*');
+
+        // Test setting the aggrergations to empty array
+        $this->query->setAggregations([]);
+        $this->assertEquals([], $this->query->getAggregations());
+
+        $aggregations = ['field' => 'QubitInformationObject.i18n.en.title', 'size' => '10'];
+        // Test setting the aggregations to array
+        $this->query->setAggregations($aggregations);
+        $this->assertEquals($aggregations, $this->query->getAggregations());
+    }
+
+    public function getQueryParamsProvider(): array
+    {
+        $fields = ['testField', 'testField2'];
+
+        return [
+            'Test Solr MatchAll query with default options' => [
+                'fields' => $fields,
+                'type' => 'testType',
+                'operator' => 'AND',
+                'searchQuery' => 'searchString',
+                'expected' => [
+                    'query' => [
+                        'edismax' => [
+                            'q.op' => 'AND',
+                            'stopwords' => 'true',
+                            'query' => 'searchString~',
+                            'qf' => 'testType.testField testType.testField2',
+                        ],
+                    ],
+                    'offset' => 0,
+                    'limit' => 10,
+                ],
+            ],
+        ];
+    }
+
+    /**
+     * @dataProvider getQueryParamsProvider
+     *
+     * @param array  $fields
+     * @param string $type
+     * @param string $operator
+     * @param string $searchQuery
+     * @param mixed  $expected
+     */
+    public function testGetQueryParams($fields, $type, $operator, $searchQuery, $expected)
+    {
+        $this->query = new arSolrStringQuery($searchQuery);
+        $this->query->setFields($fields);
+        $this->query->setDefaultOperator($operator);
+        $this->query->setType($type);
+
+        $actual = $this->query->getQueryParams();
+
+        $this->assertSame($expected, $actual, 'Params passed does not match expected.');
+    }
+
+    public function getQueryParamsAggsProvider(): array
+    {
+        $fields = ['testField', 'testField2'];
+        $aggregations = ['field' => 'testField2', 'size' => '10'];
+
+        return [
+            'Test Solr MatchAll query with default options' => [
+                'fields' => $fields,
+                'operator' => 'AND',
+                'type' => 'testType',
+                'searchQuery' => '*:*',
+                'aggregations' => $aggregations,
+                'expected' => [
+                    'query' => [
+                        'edismax' => [
+                            'q.op' => 'AND',
+                            'stopwords' => 'true',
+                            'query' => '*:*~',
+                            'qf' => 'testType.testField testType.testField2',
+                        ],
+                    ],
+                    'facet' => [
+                        'categories' => [
+                            'type' => 'terms',
+                            'field' => 'testType.testField2',
+                            'limit' => '10',
+                        ],
+                    ],
+                    'offset' => 0,
+                    'limit' => 10,
+                ],
+            ],
+        ];
+    }
+
+    /**
+     * @dataProvider getQueryParamsAggsProvider
+     *
+     * @param array  $fields
+     * @param string $operator
+     * @param string $searchQuery
+     * @param array  $aggregations
+     * @param mixed  $expected
+     * @param mixed  $type
+     */
+    public function testGetQueryParamsAggs($fields, $operator, $type, $searchQuery, $aggregations, $expected)
+    {
+        $this->query = new arSolrStringQuery($searchQuery);
+        $this->query->setFields($fields);
+        $this->query->setType($type);
+        $this->query->setDefaultOperator($operator);
+        $this->query->setAggregations($aggregations);
+
+        $actual = $this->query->getQueryParams();
+
+        $this->assertSame($expected, $actual, 'Params passed do not match expected.');
+    }
+
+    public function getQueryParamsAggsExceptionProvider(): array
+    {
+        return [
+            'Test Solr MatchAll query with null fields' => [
+                'fields' => null,
+                'type' => 'testType',
+                'expectedException' => '\Exception',
+                'expectedExceptionMessage' => 'Fields not set.',
+            ],
+            'Test Solr MatchAll query with null type' => [
+                'fields' => 'testField',
+                'type' => null,
+                'expectedException' => '\Exception',
+                'expectedExceptionMessage' => 'Field \'type\' is not set.',
+            ],
+        ];
+    }
+
+    /**
+     * @dataProvider getQueryParamsAggsExceptionProvider
+     *
+     * @param array $fields
+     * @param mixed $type
+     * @param mixed $expectedException
+     * @param mixed $expectedExceptionMessage
+     */
+    public function testGetQueryParamsAggsException($fields, $type, $expectedException, $expectedExceptionMessage)
+    {
+        $this->query = new arSolrStringQuery('*:*');
+        $this->query->setFields($fields);
+        $this->query->setType($type);
+
+        $this->expectException($expectedException);
+        $this->expectExceptionMessage($expectedExceptionMessage);
+
+        $this->query->getQueryParams();
+    }
+}
diff --git a/test/phpunit/arSolrPlugin/lib/query/ArSolrTermQueryTest.php b/test/phpunit/arSolrPlugin/lib/query/ArSolrTermQueryTest.php
new file mode 100644
index 0000000000..a5028e506f
--- /dev/null
+++ b/test/phpunit/arSolrPlugin/lib/query/ArSolrTermQueryTest.php
@@ -0,0 +1,181 @@
+<?php
+
+use PHPUnit\Framework\TestCase;
+
+require_once 'plugins/arSolrPlugin/lib/client/arSolrAbstractQuery.class.php';
+
+require_once 'plugins/arSolrPlugin/lib/client/arSolrTermQuery.class.php';
+
+/**
+ * @internal
+ *
+ * @covers \arSolrTermQuery
+ */
+class ArSolrTermQueryTest extends TestCase
+{
+    public function createSolrTermQueryProvider(): array
+    {
+        return [
+            'New arSolrTermQuery with no term' => [
+                'term' => null,
+                'expectedField' => null,
+                'expectedValue' => null,
+            ],
+            'New arSolrTermQuery with empty term' => [
+                'term' => ['' => ''],
+                'expectedField' => '',
+                'expectedValue' => '',
+            ],
+            'New arSolrTermQuery with string array term' => [
+                'term' => ['tField' => 'tValue'],
+                'expectedField' => 'tField',
+                'expectedValue' => 'tValue',
+            ],
+        ];
+    }
+
+    public function testCreateEmptySolrTermQuery()
+    {
+        $this->termQuery = new arSolrTermQuery();
+        $this->assertTrue($this->termQuery instanceof arSolrTermQuery, 'Assert plugin object is arSolrTermQuery.');
+    }
+
+    /**
+     * @dataProvider createSolrTermQueryProvider
+     *
+     * @param mixed $term
+     * @param mixed $expectedField
+     * @param mixed $expectedValue
+     */
+    public function testCreateSolrTermQuery($term, $expectedField, $expectedValue)
+    {
+        $this->termQuery = new arSolrTermQuery($term);
+        $actualField = $this->termQuery->getTermField();
+        $actualValue = $this->termQuery->getTermValue();
+
+        $this->assertTrue($this->termQuery instanceof arSolrTermQuery, 'Assert plugin object is arSolrTermQuery.');
+        $this->assertSame($expectedField, $actualField, 'Passed field does not match expected field.');
+        $this->assertSame($expectedValue, $actualValue, 'Passed value does not match expected value.');
+    }
+
+    public function getQueryParamsProvider(): array
+    {
+        return [
+            'Generate term query with specified type' => [
+                'term' => ['test_field' => 'testVal'],
+                'type' => 'test_type',
+                'expected' => [
+                    'query' => [
+                        'edismax' => [
+                            'query' => 'test_type.test_field:testVal',
+                        ],
+                    ],
+                    'offset' => 0,
+                    'limit' => 10,
+                ],
+            ],
+        ];
+    }
+
+    /**
+     * @dataProvider getQueryParamsProvider
+     *
+     * @param mixed $term
+     * @param mixed $type
+     * @param mixed $expected
+     */
+    public function testGetQueryParams($term, $type, $expected)
+    {
+        $this->termQuery = new arSolrTermQuery($term);
+        $this->termQuery->setType($type);
+
+        $actual = $this->termQuery->getQueryParams();
+
+        $this->assertSame($expected, $actual, 'Params passed do not match expected.');
+    }
+
+    public function getQueryParamsExceptionProvider(): array
+    {
+        return [
+            'Generate term query with missing type' => [
+                'term' => ['test_field' => 'testVal'],
+                'type' => '',
+                'expectedException' => '\Exception',
+                'expectedExceptionMessage' => 'Field \'type\' is not set.',
+            ],
+            'Generate term query with missing term' => [
+                'term' => [],
+                'type' => 'test_type',
+                'expectedException' => '\Exception',
+                'expectedExceptionMessage' => 'Term field is not set.',
+            ],
+        ];
+    }
+
+    /**
+     * @dataProvider getQueryParamsExceptionProvider
+     *
+     * @param mixed $term
+     * @param mixed $type
+     * @param mixed $expectedException
+     * @param mixed $expectedExceptionMessage
+     */
+    public function testGetQueryParamsException($term, $type, $expectedException, $expectedExceptionMessage)
+    {
+        $this->termQuery = new arSolrTermQuery($term);
+        $this->termQuery->setType($type);
+
+        $this->expectException($expectedException);
+        $this->expectExceptionMessage($expectedExceptionMessage);
+
+        $this->termQuery->getQueryParams();
+    }
+
+    public function getQueryParamsUsingSetExceptionProvider(): array
+    {
+        return [
+            'Generate term query with missing term field' => [
+                'termField' => null,
+                'termValue' => null,
+                'type' => '',
+                'expectedException' => '\Exception',
+                'expectedExceptionMessage' => 'Term field is not set.',
+            ],
+            'Generate term query with missing term value' => [
+                'termField' => 'tField',
+                'termValue' => null,
+                'type' => '',
+                'expectedException' => '\Exception',
+                'expectedExceptionMessage' => 'Term value is not set.',
+            ],
+            'Generate term query with missing missing type' => [
+                'termField' => 'tField',
+                'termValue' => 'tValue',
+                'type' => '',
+                'expectedException' => '\Exception',
+                'expectedExceptionMessage' => 'Field \'type\' is not set.',
+            ],
+        ];
+    }
+
+    /**
+     * @dataProvider getQueryParamsUsingSetExceptionProvider
+     *
+     * @param mixed $termField
+     * @param mixed $termValue
+     * @param mixed $type
+     * @param mixed $expectedException
+     * @param mixed $expectedExceptionMessage
+     */
+    public function testGetQueryParamsUsingSetException($termField, $termValue, $type, $expectedException, $expectedExceptionMessage)
+    {
+        $this->termQuery = new arSolrTermQuery();
+        $this->termQuery->setTerm($termField, $termValue);
+        $this->termQuery->setType($type);
+
+        $this->expectException($expectedException);
+        $this->expectExceptionMessage($expectedExceptionMessage);
+
+        $this->termQuery->getQueryParams();
+    }
+}
diff --git a/test/phpunit/arSolrPlugin/lib/query/ArSolrTermsQueryTest.php b/test/phpunit/arSolrPlugin/lib/query/ArSolrTermsQueryTest.php
new file mode 100644
index 0000000000..28031c7ed7
--- /dev/null
+++ b/test/phpunit/arSolrPlugin/lib/query/ArSolrTermsQueryTest.php
@@ -0,0 +1,199 @@
+<?php
+
+use PHPUnit\Framework\TestCase;
+
+require_once 'plugins/arSolrPlugin/lib/client/arSolrAbstractQuery.class.php';
+
+require_once 'plugins/arSolrPlugin/lib/client/arSolrTermsQuery.class.php';
+
+/**
+ * @internal
+ *
+ * @covers \arSolrTermsQuery
+ */
+class ArSolrTermsQueryTest extends TestCase
+{
+    public function createSolrTermsQueryProvider(): array
+    {
+        return [
+            'New arSolrTermsQuery with no term' => [
+                'term' => null,
+                'expectedField' => null,
+                'expectedValue' => null,
+            ],
+            'New arSolrTermsQuery with empty term' => [
+                'term' => ['' => []],
+                'expectedField' => '',
+                'expectedValue' => [],
+            ],
+            'New arSolrTermsQuery with one string term' => [
+                'term' => ['tField' => ['tValue']],
+                'expectedField' => 'tField',
+                'expectedValue' => ['tValue'],
+            ],
+            'New arSolrTermsQuery with multiple string terms' => [
+                'term' => ['tField' => ['tValue', 'tValue2']],
+                'expectedField' => 'tField',
+                'expectedValue' => ['tValue', 'tValue2'],
+            ],
+        ];
+    }
+
+    public function testCreateEmptySolrTermsQuery()
+    {
+        $this->termsQuery = new arSolrTermsQuery();
+        $this->assertTrue($this->termsQuery instanceof arSolrTermsQuery, 'Assert plugin object is arSolrTermsQuery.');
+    }
+
+    /**
+     * @dataProvider createSolrTermsQueryProvider
+     *
+     * @param mixed $term
+     * @param mixed $expectedField
+     * @param mixed $expectedValue
+     */
+    public function testCreateSolrTermsQuery($term, $expectedField, $expectedValue)
+    {
+        $this->termsQuery = new arSolrTermsQuery($term);
+        $actualField = $this->termsQuery->getTermField();
+        $actualValues = $this->termsQuery->getTermValues();
+
+        $this->assertTrue($this->termsQuery instanceof arSolrTermsQuery, 'Assert plugin object is arSolrTermsQuery.');
+        $this->assertSame($expectedField, $actualField, 'Passed field does not match expected field.');
+        $this->assertSame($expectedValue, $actualValues, 'Passed value does not match expected value.');
+    }
+
+    public function getQueryParamsProvider(): array
+    {
+        return [
+            'Generate terms query with specified type' => [
+                'term' => ['test_field' => ['testVal']],
+                'type' => 'test_type',
+                'expected' => [
+                    'query' => [
+                        'edismax' => [
+                            'query' => 'test_type.test_field:(testVal)',
+                        ],
+                    ],
+                    'offset' => 0,
+                    'limit' => 10,
+                ],
+            ],
+            'Generate terms query with multiple values' => [
+                'term' => ['test_field' => ['testVal', 'testVal2']],
+                'type' => 'test_type',
+                'expected' => [
+                    'query' => [
+                        'edismax' => [
+                            'query' => 'test_type.test_field:(testVal OR testVal2)',
+                        ],
+                    ],
+                    'offset' => 0,
+                    'limit' => 10,
+                ],
+            ],
+        ];
+    }
+
+    /**
+     * @dataProvider getQueryParamsProvider
+     *
+     * @param mixed $term
+     * @param mixed $type
+     * @param mixed $expected
+     */
+    public function testGetQueryParams($term, $type, $expected)
+    {
+        $this->termsQuery = new arSolrTermsQuery($term);
+        $this->termsQuery->setType($type);
+
+        $actual = $this->termsQuery->getQueryParams();
+
+        $this->assertSame($expected, $actual, 'Params passed do not match expected.');
+    }
+
+    public function getQueryParamsExceptionProvider(): array
+    {
+        return [
+            'Generate terms query with missing type' => [
+                'term' => ['test_field' => ['testVal']],
+                'type' => '',
+                'expectedException' => '\Exception',
+                'expectedExceptionMessage' => 'Field \'type\' is not set.',
+            ],
+            'Generate terms query with missing term' => [
+                'term' => [],
+                'type' => 'test_type',
+                'expectedException' => '\Exception',
+                'expectedExceptionMessage' => 'Term field is not set.',
+            ],
+        ];
+    }
+
+    /**
+     * @dataProvider getQueryParamsExceptionProvider
+     *
+     * @param mixed $term
+     * @param mixed $type
+     * @param mixed $expectedException
+     * @param mixed $expectedExceptionMessage
+     */
+    public function testGetQueryParamsException($term, $type, $expectedException, $expectedExceptionMessage)
+    {
+        $this->termsQuery = new arSolrTermsQuery($term);
+        $this->termsQuery->setType($type);
+
+        $this->expectException($expectedException);
+        $this->expectExceptionMessage($expectedExceptionMessage);
+
+        $this->termsQuery->getQueryParams();
+    }
+
+    public function getQueryParamsUsingSetExceptionProvider(): array
+    {
+        return [
+            'Generate term query with missing term field' => [
+                'termField' => null,
+                'termValue' => null,
+                'type' => '',
+                'expectedException' => '\Exception',
+                'expectedExceptionMessage' => 'Term field is not set.',
+            ],
+            'Generate term query with missing term value' => [
+                'termField' => 'tField',
+                'termValue' => null,
+                'type' => '',
+                'expectedException' => '\Exception',
+                'expectedExceptionMessage' => 'Term values are not set.',
+            ],
+            'Generate term query with missing missing type' => [
+                'termField' => 'tField',
+                'termValue' => ['tValue'],
+                'type' => '',
+                'expectedException' => '\Exception',
+                'expectedExceptionMessage' => 'Field \'type\' is not set.',
+            ],
+        ];
+    }
+
+    /**
+     * @dataProvider getQueryParamsUsingSetExceptionProvider
+     *
+     * @param mixed $termField
+     * @param mixed $termValue
+     * @param mixed $type
+     * @param mixed $expectedException
+     * @param mixed $expectedExceptionMessage
+     */
+    public function testGetQueryParamsUsingSetException($termField, $termValue, $type, $expectedException, $expectedExceptionMessage)
+    {
+        $this->termsQuery = new arSolrTermsQuery();
+        $this->termsQuery->setTerms($termField, $termValue);
+        $this->termsQuery->setType($type);
+
+        $this->expectException($expectedException);
+        $this->expectExceptionMessage($expectedExceptionMessage);
+
+        $this->termsQuery->getQueryParams();
+    }
+}