path: root/lib/d2/app/adapters/detail.py

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
from d2.app.model.static import StaticData
from collections import namedtuple
from whoosh.fields import Schema, TEXT, ID
from whoosh.index import create_in

class DetailAdapter(BaseAdapter):

    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
        self._multiple_value_labels_ = None
        self._make = namedtuple('detail', 'name data')

    @classmethod
    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, Forge,
                   Plot, Occupant)

    @property
    def _label_detail_type_ids(self):
        if not self._label_detail_type_ids_:
            self._label_detail_type_ids_ = [
                    self._static.detail_type.first_name,
                    self._static.detail_type.last_name,
                    self._static.detail_type.name,
                    self._static.detail_type.network_id
            ]
        return self._label_detail_type_ids_

    @property
    def _multiple_value_labels(self):
        if not self._multiple_value_labels_:
            self._multiple_value_labels_ = [
                self._static.detail_type.network_jack,
            ]
        return self._multiple_value_labels_

    def fetch_all_occupant_details(self, occupant_id, date_start=None):
        """Fetch all details for the given occupant_id
        """
        return self._fetch_details(None, occupant_id, date_start)

    def fetch_all_plot_details(self, plot_id, date_start=None):
        """Fetch all details for the given plot_id
        """
        return self._fetch_details(plot_id, None, date_start)

    def fetch_occupant_detail(self, occupant_id, detail_type_id,
                              date_start=None):
        """Fetch a single detail for the given occupant_id and
        detail_type_id
        """
        return self._fetch_detail(None, occupant_id, detail_type_id,
                                  date_start)

    def fetch_plot_detail(self, plot_id, detail_type_id, date_start=None):
        """Fetch a single detail for the given plot_id and
        detail_type_id
        """
        return self._fetch_detail(plot_id, None, detail_type_id, date_start)

    def fetch_detail_by_type_data(self, detail_type_id, data, date_start=None):
        """Fetch all detail records given detail_type_id and data
        """
        date_start = self.build_date(date_start)
        obj = self._db.session.query(self._detail
            ).filter(self._detail.detail_type_id==detail_type_id
            ).filter(func.lower(self._detail.data)==data.lower()
            ).filter(self._detail.date_override==None
            ).filter(self._detail.date_start<=date_start
            ).filter(or_(self._detail.date_end>date_start,
                self._detail.date_end==None)
        ).all()
        if not obj:
            return []
        else:
            return obj

    def _fetch_detail(self, plot_id, occupant_id, detail_type_id, date_start):
        date_start = self.build_date(date_start)
        return self._db.session.query(self._detail
            ).filter(self._detail.plot_id==plot_id
            ).filter(self._detail.occupant_id==occupant_id
            ).filter(self._detail.detail_type_id==detail_type_id
            ).filter(self._detail.date_override==None
            ).filter(self._detail.date_start<=date_start
            ).filter(or_(self._detail.date_end>date_start,
                self._detail.date_end==None)
        ).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
            ).filter(self._detail.occupant_id==occupant_id
            ).filter(self._detail.date_override==None
            ).filter(self._detail.date_start<=date_start
            ).filter(or_(self._detail.date_end>date_start,
                self._detail.date_end==None)
        ).all()
        if not obj:
            return []
        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
        """
        return self._insert_detail(None, occupant_id, detail_type_id, data,
                                   date_start, date_end)

    def insert_plot_detail(self, plot_id, detail_type_id, data,
                                date_start=None, date_end=None):
        """Inserts detail data for an occupant
        """
        return self._insert_detail(plot_id, None, detail_type_id, data,
                                   date_start, date_end)

    def _insert_detail(self, plot_id, occupant_id, detail_type_id, data,
                               date_start=None, date_end=None):

        date_start= self.build_date(date_start)
        data = dict(
                plot_id=plot_id,
                occupant_id=occupant_id,
                detail_type_id=detail_type_id,
                data=data,
                date_start=date_start,
                date_end=date_end,
                date_created=datetime.now(),
                date_override=None
                )
        obj = self._detail.from_dict(data)
        self._db.session.add(obj)
        self._db.session.commit()
        return obj

    def _change_detail(self, plot_id, occupant_id, detail_type_id, data,
                       date_start=None, date_end=None):
        """
        TODO: FIXME
        """
        if plot_id:
            previous_record = self.fetch_plot_detail(plot_id, detail_type_id,
                                                     date_start)
        else:
            previous_record = self.fetch_occupant_detail(occupant_id,
                                detail_type_id, date_start)

        if previous_record:
            self._set_override(previous_record)
            self._set_end(previous_record, date_end)
        else:
            raise Exception("Missing previous recored.  Unable to change.")

        date_start= self.build_date(date_start)
        data = dict(
                plot_id=plot_id,
                occupant_id=occupant_id,
                detail_type_id=detail_type_id,
                data=data,
                date_start=date_start,
                date_end=date_end,
                date_created=datetime.now(),
                date_override=None
                )
        obj = self._detail.from_dict(data)
        self._db.session.add(obj)
        self._db.session.commit()
        return obj

    def _set_override(self, detail_obj):
        detail_obj.date_override = datetime.now()
        self._db.session.commit()

    def _set_end(self, detail_obj, date_end=None):
        date_end = self.build_date(date_end)
        data = detail_obj.as_dict()
        if 'id' in data:
            del(data['id'])
        data['date_end'] = date_end
        data['date_created'] = datetime.now()
        data['date_override'] = None
        obj = self._detail.from_dict(data)
        self._db.session.add(obj)
        self._db.session.commit()

    def update_detail(self, detail_obj):
        """Updates the given changed detail_obj
        """
        if self._db.session.is_modified(detail_obj):
            new_data = detail_obj.as_dict()
            if 'id' in new_data:
                del(new_data['id'])
            self._db.session.refresh(detail_obj)
            detail_obj.date_override = datetime.now()
            obj = self._detail.from_dict(new_data)
            self._db.session.add(obj)
            self._db.session.commit()

    def occupant_details(self, occupant_id, date_start=None):
        results = self.fetch_all_occupant_details(occupant_id, date_start)
        return self._details_to_tuple(results)

    def plot_details(self, plot_id, date_start=None):
        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 = []
            hold = {}
            for detail in details:
                if (detail.detail_type_id in self._label_detail_type_ids
                            and detail.data):
                    hold[detail.detail_type_id] = detail.data
            if self._static.detail_type.first_name in hold:
                out.append(hold[self._static.detail_type.first_name])
                if self._static.detail_type.last_name in hold:
                    out.append(hold[self._static.detail_type.last_name])
            elif self._static.detail_type.last_name in hold:
                out.append(hold[self._static.detail_type.last_name])
            elif self._static.detail_type.name in hold:
                out.append(hold[self._static.detail_type.name])
            elif self._static.detail_type.network_id in hold:
                out.append(hold[self._static.detail_type.network_id])
            else:
                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 = {}
            keys = []
            vals = []
            hold[u'label'] = self._label_from_details(details)
            if details[0].plot_id:
                hold[u'plot_id'] = details[0].plot_id
                hold[u'occupant_id'] = None
            else:
                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):
                    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 hold:
                            data = hold[key].data
                            data.append(detail.data)
                            hold[key] = hold[key]._replace(data=data)
                        else:
                            keys.append(key)
                            data = [detail.data]
                            hold[key] = self._make(name, data)
                    else:
                        keys.append(key)
                        hold[key] = self._make(name, detail.data)
            keys.sort()
            keys = [u'label', u'id', u'id_type'] + keys
            for key in keys:
                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