created new search to handle multiple plots. Mainly for the Empty occupant

3 files changed, 338 insertions, 61 deletions

diff --git a/lib/d2/app/adapters/detail.py b/lib/d2/app/adapters/detail.py
index 7231faa..738230b 100644
--- a/lib/d2/app/adapters/detail.py
+++ b/lib/d2/app/adapters/detail.py
@@ -2,6 +2,9 @@ from d2.app.adapters import BaseAdapter
 from datetime import datetime
 from d2.db import DetailType
 from d2.db import Detail
+from d2.db import Forge
+from d2.db import Plot
+from d2.db import Occupant
 from sqlalchemy import or_
 from sqlalchemy import func
 from d2.config import Config
@@ -12,12 +15,16 @@ from whoosh.index import create_in
 
 class DetailAdapter(BaseAdapter):
 
-    def __init__(self, db, log, static, detail, detail_type):
+    def __init__(self, db, log, static, detail, detail_type, forge, plot,
+                 occupant):
         self._db = db
         self._log = log
         self._static = static
         self._detail = detail
         self._detail_type = detail_type
+        self._forge = forge
+        self._plot = plot
+        self._occupant = occupant
         self._search_schema_ = None
         self._search_index_ = None
         self._label_detail_type_ids_ = None
@@ -28,7 +35,8 @@ class DetailAdapter(BaseAdapter):
     def load(cls, config=None, static=None):
         config = config or Config.load()
         static = static or StaticData.load(config.db)()
-        return cls(config.db, config.log, static, Detail, DetailType)
+        return cls(config.db, config.log, static, Detail, DetailType, Forge,
+                   Plot, Occupant)
 
     @property
     def _label_detail_type_ids(self):
@@ -45,7 +53,7 @@ class DetailAdapter(BaseAdapter):
     def _multiple_value_labels(self):
         if not self._multiple_value_labels_:
             self._multiple_value_labels_ = [
-                self._static.detail_type.network_jack,    
+                self._static.detail_type.network_jack,
             ]
         return self._multiple_value_labels_
 
@@ -103,6 +111,8 @@ class DetailAdapter(BaseAdapter):
         ).first()
 
     def _fetch_details(self, plot_id, occupant_id, date_start):
+        if not plot_id and not occupant_id:
+            return []
         date_start = self.build_date(date_start)
         obj = self._db.session.query(self._detail
             ).filter(self._detail.plot_id==plot_id
@@ -117,6 +127,7 @@ class DetailAdapter(BaseAdapter):
         else:
             return obj
 
+
     def insert_occupant_detail(self, occupant_id, detail_type_id, data,
                                 date_start=None, date_end=None):
         """Inserts detail data for an occupant
@@ -221,6 +232,14 @@ class DetailAdapter(BaseAdapter):
         results = self.fetch_all_plot_details(plot_id, date_start)
         return self._details_to_tuple(results)
 
+    def occupant_dict(self, occupant_id, date_start=None):
+        details = self.fetch_all_occupant_details(occupant_id, date_start)
+        return self.details_to_dict(details)
+
+    def plot_dict(self, plot_id, date_start=None):
+        details = self.fetch_all_plot_details(plot_id, date_start)
+        return self.details_to_dict(details)
+
     def _label_from_details(self, details):
         if details:
             out = []
@@ -243,6 +262,56 @@ class DetailAdapter(BaseAdapter):
                 out.append(u'Unknown')
             return u' '.join(out)
 
+    def details_to_dict(self, details):
+        out = {}
+        if details:
+            out[u'label'] = self._label_from_details(details)
+            out[u'plot_id'] = details[0].plot_id
+            out[u'occupant_id'] = details[0].occupant_id
+            for detail in details:
+                if (detail.detail_type_id not in self._label_detail_type_ids
+                            and detail.data):
+                    name = detail.detail_type.name
+                    key = name.lower().strip().replace(u' ', u'_')
+                    if detail.detail_type_id in self._multiple_value_labels:
+                        if key in out:
+                            name = out[key][u'name'].strip()
+                            if not name.endswith(u's'):
+                                name = u"{0}s".format(name)
+                                out[key][u'name'] = name
+                            data = out[key][u'data']
+                            data.append(detail.data)
+                            out[key][u'data'] = data
+                        else:
+                            out[key] = {}
+                            out[key][u'name'] = name
+                            out[key][u'data'] = [detail.data]
+                    else:
+                        out[key] = {}
+                        out[key][u'name'] = name
+                        out[key][u'data'] = detail.data
+        return out
+
+    def _details_dict_to_tuple(self, details):
+        """Takes a details dictionary and turnes it into a named tuple
+        """
+        if details:
+            keys = [u'label', u'plot_id', u'occupant_id']
+            key_hold = []
+            vals = []
+            for key in details.keys():
+                if key not in keys and key not in key_hold:
+                    key_hold.append(key)
+            key_hold.sort()
+            keys = keys + key_hold
+            for key in keys:
+                val = details[key]
+                if isinstance(val, dict):
+                    val = self._make(val[u'name'], val[u'data'])
+                vals.append(val)
+            make = namedtuple('details', keys)
+            return make(*vals)
+
     def _details_to_tuple(self, details):
         if details:
             hold = {}
@@ -250,11 +319,11 @@ class DetailAdapter(BaseAdapter):
             vals = []
             hold[u'label'] = self._label_from_details(details)
             if details[0].plot_id:
-                hold[u'id'] = details[0].plot_id
-                hold[u'id_type'] = u'plot'
+                hold[u'plot_id'] = details[0].plot_id
+                hold[u'occupant_id'] = None
             else:
-                hold[u'id'] = details[0].occupant_id
-                hold[u'id_type'] = u'occupant'
+                hold[u'plot_id'] = None
+                hold[u'occupant_id'] = details[0].occupant_id
             for detail in details:
                 if (detail.detail_type_id not in self._label_detail_type_ids
                             and detail.data):
@@ -278,3 +347,84 @@ class DetailAdapter(BaseAdapter):
                 vals.append(hold[key])
             make = namedtuple('details', keys)
             return make(*vals)
+
+    def details(self, plot_id=None, occupant_id=None):
+        """ Returns a named tuple with complete details.
+        """
+        plot_id, occupant_id = self._validate(plot_id, occupant_id)
+        plot = self.details_to_dict(self.fetch_all_plot_details(plot_id))
+        occupant = self.details_to_dict(self.fetch_all_occupant_details(
+                                occupant_id))
+
+        if plot and occupant:
+            occupant[u'plot_id'] = plot[u'plot_id']
+            occupant[u'plot'] = {
+                u'name': u'Plot',
+                u'data': plot['label']
+            }
+            del plot[u'plot_id']
+            del plot[u'occupant_id']
+            del plot[u'label']
+
+            for key, val in plot.items():
+                occupant[key] = val
+            return self._details_dict_to_tuple(occupant)
+
+        if plot:
+            return self._details_dict_to_tuple(plot)
+
+        if occupant:
+            return self._details_dict_to_tuple(occupant)
+
+    def _validate(self, plot_id, occupant_id, start_date=None):
+        """Validates that the given plot_id and occupant_id
+        are valid.  Also checks forge
+        """
+        if not self._is_valid_plot(plot_id):
+            plot_id = None
+        if not self._is_valid_occupant(occupant_id):
+            occupant_id = None
+        if plot_id and occupant_id:
+            if not self._is_valid_forge(plot_id, occupant_id, start_date):
+                plot_id = None
+        return plot_id, occupant_id
+
+    def _is_valid_plot(self, plot_id):
+        """Validates that the given plot_id actually exists
+        """
+        if plot_id:
+            obj = self._db.session.query(self._plot
+                ).filter(self._plot.id==plot_id
+            ).first()
+            if obj:
+                return True
+        return False
+
+    def _is_valid_occupant(self, occupant_id):
+        """Validates that the given occupant_id actually exists
+        """
+        if occupant_id:
+            obj = self._db.session.query(self._occupant
+                ).filter(self._occupant.id==occupant_id
+            ).first()
+            if obj:
+                return True
+        return False
+
+    def _is_valid_forge(self, plot_id, occupant_id, date_start=None):
+        """Validates that the given plot_id and occupant_id are related
+        in the forge table.
+        """
+        date_start = self.build_date(date_start)
+        obj = self._db.session.query(self._forge
+            ).filter(self._forge.plot_id==plot_id
+            ).filter(self._forge.occupant_id==occupant_id
+            ).filter(self._forge.date_override==None
+            ).filter(self._forge.date_start<=date_start
+            ).filter(or_(self._forge.date_end>date_start,
+                self._forge.date_end==None)
+        ).first()
+        if obj:
+            return True
+        else:
+            return False
diff --git a/lib/d2/app/adapters/search.py b/lib/d2/app/adapters/search.py
index 92d0ee5..693cdda 100644
--- a/lib/d2/app/adapters/search.py
+++ b/lib/d2/app/adapters/search.py
@@ -13,16 +13,20 @@ from whoosh.index import create_in
 from whoosh.index import open_dir
 from whoosh.qparser import QueryParser
 from whoosh.spelling import SpellChecker
+from d2.app.adapters.forge import ForgeAdapter
 import os
 import stat
 import re
+from copy import deepcopy
+from collections import namedtuple
 
 class SearchAdapter(BaseAdapter):
 
     PERM_DIR = stat.S_IXUSR | stat.S_IRUSR | stat.S_IWUSR
+    SEARCH_ARGS = ['label', 'description', 'plot_id', 'occupant_id']
 
     def __init__(self, db, log, index_directory, static, detail, detail_type,
-                 detail_adapter):
+                 detail_adapter, forge_adapter):
         self._db = db
         self._log = log
         self._index_directory = index_directory
@@ -30,18 +34,22 @@ class SearchAdapter(BaseAdapter):
         self._detail = detail
         self._detail_type = detail_type
         self._detail_adapter = detail_adapter
+        self._forge_adapter = forge_adapter
         self._label_detail_type_ids_ = None
         self._search_schema_ = None
         self._index_ = None
         self._index_directory_ = None
+        self._make_search_result = namedtuple('Result', self.SEARCH_ARGS)
 
     @classmethod
-    def load(cls, config=None, static=None, detail_adapter=None):
+    def load(cls, config=None, static=None, detail_adapter=None,
+             forge_adapter=None):
         config = config or Config.load()
         static = static or StaticData.load(config.db)()
         detail_adapter = detail_adapter or DetailAdapter.load(config, static)
+        forge_adapter = forge_adapter or ForgeAdapter.load(config, static)
         return cls(config.db, config.log, config.index_directory, static,
-                   Detail, DetailType, detail_adapter)
+                   Detail, DetailType, detail_adapter, forge_adapter)
 
     @property
     def _label_detail_type_ids(self):
@@ -58,8 +66,9 @@ class SearchAdapter(BaseAdapter):
         if not self._search_schema_:
             self._search_schema_ = Schema(
                 label=TEXT(stored=True),
-                id=NUMERIC(stored=True),
-                id_type=ID(stored=True),
+                description=TEXT(stored=True),
+                plot_id=NUMERIC(stored=True),
+                occupant_id=NUMERIC(stored=True),
                 context=TEXT)
         return self._search_schema_
 
@@ -81,7 +90,9 @@ class SearchAdapter(BaseAdapter):
     def build_index(self):
         index = create_in(self.index_directory, self.search_schema)
         writer = index.writer()
-        results = self.search_index_data()
+        results = self._search_index_data()
+        results = self._add_descriptions(results)
+        results = self._build_search_dictionaries(results)
         for row in results:
             writer.add_document(**row)
         writer.commit()
@@ -92,8 +103,8 @@ class SearchAdapter(BaseAdapter):
         speller = SpellChecker(ix.storage)
         speller.add_field(ix, "context")
 
-    def search_index_data(self, date_start=None):
-        hold = {u'plot':{}, u'occupant':{}}
+    def _search_index_data(self, date_start=None):
+        hold = {}
         data = []
         date_start = self.build_date(date_start)
         results = self._db.session.query(self._detail
@@ -103,45 +114,137 @@ class SearchAdapter(BaseAdapter):
                 self._detail.date_end==None)
         ).all()
         for row in results:
-            if row.plot_id:
-                if row.plot_id not in hold[u'plot']:
-                    hold[u'plot'][row.plot_id] = []
-                hold[u'plot'][row.plot_id].append(row)
-            else:
-                if row.occupant_id not in hold[u'occupant']:
-                    hold[u'occupant'][row.occupant_id] = []
-                hold[u'occupant'][row.occupant_id].append(row)
-        for key, details in hold[u'plot'].items():
-            data.append(self._details_to_search_dictionary(details))
-        for key, details in hold[u'occupant'].items():
-            data.append(self._details_to_search_dictionary(details))
+            key = (row.plot_id, row.occupant_id)
+            if key not in hold:
+                hold[key] = []
+            hold[key].append(row)
+
+        for key, details in hold.items():
+            data.append(self._detail_adapter.details_to_dict(details))
+
         return data
 
+    def _add_descriptions(self, results):
+        out = []
+        for details in results:
+            if details[u'occupant_id']:
+                plots = self._get_plots(details[u'occupant_id'])
+                if plots:
+                    for plot_id in plots:
+                        details_ = deepcopy(details)
+                        details_[u'plot_id'] = plot_id
+                        details_[u'description'] = \
+                            self._build_occupant_decription_with_plot(
+                                    details_)
+                        out.append(details_)
+                else:
+                    details[u'description'] = \
+                        self._build_occupant_decription(details)
+                    out.append(details)
+
+            else:
+                occupants = self._get_occupants(details[u'plot_id'])
+                details[u'description'] = \
+                        self._build_plot_description(details, occupants)
+                out.append(details)
+        return out
+
+    def _get_plots(self, occupant_id, date_start=None):
+        """Returns a set of plot_ids from forge with the given occupant_id
+        """
+        out = set()
+        forges = self._forge_adapter.get_forge_by_occupant_id(occupant_id,
+                                                              date_start)
+        for forge in forges:
+            if forge.plot_id:
+                out.add(forge.plot_id)
+        return out
+
+    def _get_occupants(self, plot_id, date_start=None):
+        """Returns a set of occupant_ids from forge with the given plot_id
+        """
+        out = set()
+        forges = self._forge_adapter.get_forge_by_plot_id(plot_id, date_start)
+        for forge in forges:
+            if forge.occupant_id:
+                out.add(forge.occupant_id)
+        return out
+
+    def _build_occupant_decription_with_plot(self, details):
+        out = []
+        plot_dict = self._detail_adapter.plot_dict(details[u'plot_id'])
+        out.append(u'Plot: {0}'.format(plot_dict[u'label']))
+        if u'title' in details:
+            out.append(details[u'title'][u'data'])
+        if u'department' in details:
+            out.append(details[u'department'][u'data'])
+        return u' '.join(out)
+
+    def _build_occupant_decription(self, details):
+        out = []
+        if u'title' in details:
+            out.append(details[u'title'][u'data'])
+        if u'department' in details:
+            out.append(details[u'department'][u'data'])
+        return u' '.join(out)
+
+    def _build_plot_description(self, details, occupants):
+        out = []
+        for occupant_id in occupants:
+            occupant = self._detail_adapter.occupant_dict(occupant_id)
+            out.append(occupant[u'label'])
+        return u', '.join(out)
+
+
     def _split_label(self, data):
         name_pattern = re.compile("([A-Z]\w*)([A-Z].*)")
         return re.sub(name_pattern, r"\1" + " " + r"\2", data)
 
+    def _label_to_initials(self, data):
+        out = []
+        data = data.split(u' ')
+        for word in data:
+            out.append(word[0])
+            if len(out) >= 2:
+                break
+        if len(out) == 2:
+            out = u''.join(out)
+            return out.upper()
+
+
+    def _build_search_dictionaries(self, results):
+        out = []
+        for details in results:
+            out.append(self._details_to_search_dictionary(details))
+        return out
+
     def _details_to_search_dictionary(self, details):
+        out = {}
         if details:
-            out = {}
-            label = self._detail_adapter._label_from_details(details)
-            out['label'] = label
-            alt_label = self._split_label(label)
-            hold = [label]
-            if alt_label != label:
-                hold.append(alt_label)
-                
-            if details[0].plot_id:
-                out['id'] = details[0].plot_id
-                out['id_type'] = u'plot'
+            context = [details[u'label']]
+            out[u'label'] = details[u'label']
+            out[u'plot_id'] = details[u'plot_id']
+            out[u'occupant_id'] = details[u'occupant_id']
+            out[u'description'] = details[u'description']
+            if details[u'plot_id']:
+                if u'empty' in out['description'].lower():
+                    context.append(u'Empty')
             else:
-                out['id'] = details[0].occupant_id
-                out['id_type'] = u'occupant'
-            for detail in details:
-                if (detail.detail_type_id not in self._label_detail_type_ids
-                            and detail.data):
-                    hold.append(detail.data)
-            out['context'] = u' '.join(hold)
+                alt_label = self._split_label(out[u'label'])
+                if alt_label != out[u'label']:
+                    context.append(alt_label)
+                initials = self._label_to_initials(out[u'label'])
+                if initials:
+                    context.append(initials)
+
+            for key, detail in details.items():
+                if isinstance(detail, dict):
+                    if isinstance(detail[u'data'], list):
+                        for data in detail[u'data']:
+                            context.append(data)
+                    else:
+                        context.append(detail[u'data'])
+            out['context'] = u' '.join(context)
             return out
 
     def _all_terms(self, user_query):
@@ -191,9 +294,10 @@ class SearchAdapter(BaseAdapter):
             myquery = query.parse(user_query_string)
             results = searcher.search(myquery)
             for row in results[0:len(results)]:
-                if row[u'id_type'] == 'plot':
-                    out.append(self._detail_adapter.plot_details(row[u'id']))
-                else:
-                    out.append(self._detail_adapter.occupant_details(
-                        row[u'id']))
+                out.append(self._make_search_result(
+                        row[u'label'],
+                        row[u'description'],
+                        row[u'plot_id'],
+                        row[u'occupant_id']
+                    ))
         return out
diff --git a/lib/d2/bin/d2_agi_db_setup.py b/lib/d2/bin/d2_agi_db_setup.py
index f9bdf96..4cf3602 100644
--- a/lib/d2/bin/d2_agi_db_setup.py
+++ b/lib/d2/bin/d2_agi_db_setup.py
@@ -1,22 +1,45 @@
 import argparse
-from d2.config import Config as D2Config
+from d2.config import Config
+from d2.app.model.static import StaticData
 from d2.db import Base
 from d2.db import Location
 from d2.db import Map
-
-class Config(object):
-
-    DESCRIPTION = """
-    Populate static tables that are AGI specific.
-    The database connection information is read from the d2 configuration
-    file: ~/.d2/config
-    """
-    def __init__(self):
+from d2.db import Room
+from d2.db import Floor
+
+class Args(object):
+
+    DATA = {
+        u'Cleveland': {
+            u'floors': [u'1', u'2', u'3'],
+            u'rooms': [u'a', u'b', u'c']
+        },
+        u'Bucharest': {
+            u'floors': [u'1', u'2', u'3', u'4', u'5', u'6', u'7']
+        }
+    }
+
+    DESCRIPTION = "Populate static tables that are AGI specific.  The "\
+                  "database connection information is read from the d2 "\
+                  "configuration file: ~/.d2/config"
+
+    def __init__(self, config, static):
+        self._config = config
+        self._static = static
         self._parser = argparse.ArgumentParser(description=self.DESCRIPTION)
 
+    @classmethod
+    def load(cls, config=None):
+        config = config or Config.load()
+        static = StaticData.load(config.db)()
+        obj = cls(config, static)
+        return obj()
+
     def __call__(self):
         args = self._parser.parse_args()
-        return D2Config.load()
+        args.config = self._config
+        args.static = self._static
+        return args
 
 
 class PopulateLocation(object):