4 files changed, 128 insertions, 78 deletions

diff --git a/lib/d2/app/controllers/svg_text.py b/lib/d2/app/controllers/svg_text.py
index 4ffc5cf..1c4d37e 100644
--- a/lib/d2/app/controllers/svg_text.py
+++ b/lib/d2/app/controllers/svg_text.py
@@ -43,7 +43,9 @@ class SvgTextController(BaseController):
                                     plot_id=forge_record.plot_id,
                    detail_type_id=self._static.detail_type.name).first()
                 if coordinate:
-                    out.append(self.MAKE_ROW(forge_record.occupant_id,
+                    out.append(self.MAKE_ROW(
+                              "{0}_{1}".format(forge_record.occupant_id, 
+                                                   forge_record.plot_id),
                                      occupant_record.occupant_type.name, 
                                      label,
                                      coordinate.x, 
diff --git a/lib/d2/bin/d2_agi_db_setup.py b/lib/d2/bin/d2_agi_db_setup.py
index 2df60ef..a53e5b8 100644
--- a/lib/d2/bin/d2_agi_db_setup.py
+++ b/lib/d2/bin/d2_agi_db_setup.py
@@ -9,6 +9,7 @@ from d2.db import Room
 from d2.db import Floor
 from d2.db import OccupantType
 from d2.db import Occupant
+from d2.app.adapters.detail import DetailAdapter
 
 class Args(object):
 
@@ -95,6 +96,10 @@ class PopulateMap(object):
                 location_id=map.get('location_id')).first()
 
 class PopulateSpecialOccupants(object):
+    """
+    Data from LDAP does not contain these data.
+    Manually insert them in occupant and detail tables
+    """
 
     NAMES = {'person': [u'CSR', u'Temp'],
              'work area': [u'Cirith Ungol', u'Orodruin'],
@@ -105,37 +110,57 @@ class PopulateSpecialOccupants(object):
     def __init__(self, config):
         self._log = config.log
         self._db = config.db
+        self._detail_adapter = DetailAdapter.load(Config.load())
 
     def __call__(self):
         s = StaticData.load(self._db)
-        occupant_type_id_for_person = s().occupant_type.person
+
         for type, names in self.NAMES.iteritems():
             if type == 'person':
-                type_id = s().occupant_type.person
+                occupant_type_id = s().occupant_type.person
+                detail_type_id = s().detail_type.last_name
             elif type == 'work area':
-                type_id = s().occupant_type.work_area
+                occupant_type_id = s().occupant_type.work_area
+                detail_type_id = s().detail_type.name
             elif type == 'restroom':
-                type_id = s().occupant_type.restroom
+                occupant_type_id = s().occupant_type.restroom
+                detail_type_id = s().detail_type.name
 
             for name in names:
-                if not self._get(name):
-                    data = dict(occupant_type_id = type_id, 
+                if not self._get_occupant(name):
+                    data = dict(occupant_type_id = occupant_type_id, 
                                 key = self._get_key(name),
                                 active = True)
                     obj = Occupant.from_dict(data)
                     self._db.session.add(obj)
                     self._db.session.commit()
+                    occupant_id = obj.id
                     message = "{0} occupant was added".format(name)
                     self._log.info(message)
+                else:
+                    occupant_id = self._get_occupant(name).id
+                     
+                if not self._get_detail(detail_type_id, name):
+                    self._detail_adapter.insert_occupant_detail(
+                                                    occupant_id, 
+                                                 detail_type_id, 
+                                                           name)
+                    message = "{0} was added to detail".format(name)
+                    self._log.info(message)
 
     def _get_key(self, name):
         return unicode(hashlib.md5(unicode(name)).hexdigest())
 
-    def _get(self, name):
+    def _get_occupant(self, name):
         return self._db.session.query(Occupant).filter(
                       'key=:key').params(
                       key=self._get_key(name)).first()
 
+    def _get_detail(self, detail_type_id, data):
+        return self._detail_adapter.fetch_detail_by_type_data(
+                                                  detail_type_id,
+                                                            data)
+
 class PopulateTables(object):
 
     def __init__(self, config):
diff --git a/lib/d2/bin/d2_svg_processor.py b/lib/d2/bin/d2_svg_processor.py
index 3981ae5..d3d7815 100644
--- a/lib/d2/bin/d2_svg_processor.py
+++ b/lib/d2/bin/d2_svg_processor.py
@@ -44,8 +44,8 @@ NAME_LABEL_ID = {'3D13A1': 'NAME',
                  '3C1': 'NAME-2',
                  '3B1': 'NAME-6'}
 
-CONFERENCE_LABEL_ID = {'3B1': 'AREA_ID-6',
-                       '3C1': 'AREA_ID-0',
+CONFERENCE_LABEL_ID = {'3C1': 'AREA_ID-6',
+                       '3B1': 'AREA_ID-0',
                        '3D13A1': 'AREA_ID'}
 
 MAIN_ROOM_NODES = ['draft', 'draft-3', 'draft-4']
@@ -79,20 +79,9 @@ NAME_CORRECTIONS = {u'Deb Smith': u'Deborah Smith',
                     u'Sally Babcock': u'Sally Schriner',
                     u'Brian Staneck': u'Brian Stanek'}
 
+floor_plan_by_ntwk_id = {}
 
-MANUAL_PLOT_COORDINATES = {'ID1': [2, 3],
-                           'ID2': [3, 4],
-                           'ID3': [3, 4],
-                           'ID4': [3, 4],
-                           'ID5': [3, 4],
-                           'ID6': [3, 4],
-                           'ID7': [3, 4],
-                           'ID8': [3, 4],
-                           'ID9': [3, 4],
-                           'ID10': [3, 4]
-                          }
-
-floor_plan_data = {}
+floor_plan_by_name = {}
 
 ntwk_number_data = {}
 
@@ -201,13 +190,21 @@ class Args(object):
         )
 
 class ParseFloorPlanConferenceRoomXLS(object):
+    """
+    after process the xls sheet, info is kept in two dictionaries:
+
+    floor_plan_by_ntwk_id[room_name][ntwk_id] = [name, net_jack1, net_jack2]
+    floor_plan_by_name[room_name][name] = [ntwk_id]
+    """
 
-    MULTIPLE_RECORD_ERROR = "Data Error: floor plan xls has multiple records for {0} "\
-                            "in room {1}"
+    MULTIPLE_NTWK_ID_IN_ONE_ROOM_ERROR = "Data Error: floor plan xls has "\
+                             "multiple records for ntwk_id {0} in room {1}"
+    MULTIPLE_NAME_IN_ONE_ROOM_ERROR = "Warning: floor plan xls has "\
+                             "multiple records for name {0} in room {1}"
 
     def __init__(self):
         self._log_obj = None 
-        self._make = namedtuple('cubeInfo', 'name net_jack1 net_jack2')
+        self._make_cube_info = namedtuple('cubeInfo', 'name net_jack1 net_jack2')
         self._make_plot = namedtuple('addedPlot', 'abs_x, abs_y')
 
     def _determine_room(self, s):
@@ -221,54 +218,53 @@ class ParseFloorPlanConferenceRoomXLS(object):
                 return room
         return ''
 
-    def _process_floor_plan_sheet(self, sh, room_name):
+    def _process_sheet(self, sh, room_name):
         for rownum in range(2, sh.nrows):
             name = unicode(sh.cell(rowx=rownum, colx=0).value)
             cube = sh.cell(rowx=rownum, colx=2).value
             if name and cube:
                 net_jack1 = unicode(sh.cell(rowx=rownum, colx=3).value)
                 net_jack2 = unicode(sh.cell(rowx=rownum, colx=4).value)
-                if room_name not in floor_plan_data:
-                    floor_plan_data[room_name] = {}
-                if cube in floor_plan_data[room_name]:
-                    self._log_obj.error(self.MULTIPLE_RECORD_ERROR.format(cube,
-                                                               room_name))
+                if room_name not in floor_plan_by_ntwk_id:
+                    floor_plan_by_ntwk_id[room_name] = {}
+                if room_name not in floor_plan_by_name:
+                    floor_plan_by_name[room_name] = {}
+
+                if cube in floor_plan_by_ntwk_id[room_name]:
+                    self._log_obj.error(
+                        self.MULTIPLE_NTWK_ID_IN_ONE_ROOM_ERROR.format(
+                                                                  cube,
+                                                            room_name))
                 else:
-                    floor_plan_data[room_name][cube] = self._make(name,
-                                                              net_jack1,
-                                                              net_jack2)
-
-    def _process_conference_room_sheet(self, sh, room_name):
-        for rownum in range(2, sh.nrows):
-            name = unicode(sh.cell(rowx=rownum, colx=0).value)
-            cube = sh.cell(rowx=rownum, colx=2).value
-            if name and cube:
-                if room_name not in floor_plan_data:
-                    floor_plan_data[room_name] = {}
-                floor_plan_data[room_name][cube] = self._make(name, "", "")
+                    floor_plan_by_ntwk_id[room_name][cube] = \
+                            self._make_cube_info(name, net_jack1, net_jack2)
+
+                if name.lower() in floor_plan_by_name[room_name]:
+                    self._log_obj.error(
+                        self.MULTIPLE_NAME_IN_ONE_ROOM_ERROR.format(
+                                                            name.lower(),
+                                                              room_name))
+                else:
+                    floor_plan_by_name[room_name][name.lower()] = cube 
+ 
                 if cube[:2] == 'ID':
                     if room_name not in manually_added_plot:
                         manually_added_plot[room_name] = {}
                     manually_added_plot[room_name][cube] = self._make_plot( 
-                                             MANUAL_PLOT_COORDINATES[cube][0],
-                                             MANUAL_PLOT_COORDINATES[cube][1])
- 
+                                         sh.cell(rowx=rownum, colx=8).value,
+                                         sh.cell(rowx=rownum, colx=9).value)
+
+
+
     def __call__(self, args):
         self._log_obj = args.log
-        wb = xlrd.open_workbook(args.floor_plan_xls)
-        for sheet_name in wb.sheet_names():
-            room_name = self._determine_room(sheet_name)
-            if room_name:
-                self._process_floor_plan_sheet(wb.sheet_by_name(sheet_name),
-                                                                  room_name)
-
-        wb = xlrd.open_workbook(args.conference_room_xls)
-        for sheet_name in wb.sheet_names():
-            room_name = self._determine_room(sheet_name)
-            if room_name:
-                self._process_conference_room_sheet(
-                                    wb.sheet_by_name(sheet_name), 
-                                                      room_name)
+        for file_obj in (args.floor_plan_xls, args.conference_room_xls):
+            wb = xlrd.open_workbook(file_obj)
+            for sheet_name in wb.sheet_names():
+                room_name = self._determine_room(sheet_name)
+                if room_name:
+                    self._process_sheet(wb.sheet_by_name(sheet_name), room_name)
+
 
 class CreateStructureSVG(object):
 
@@ -482,10 +478,11 @@ class PopulateTables(object):
                                                       ntwk_id,
                                                       plot_id)
 
-        # Process manually added plot identifiers
+    def _add_manually_added_plots(self):
         #TODO:  manually added plots need to be in svg as well
         for (room_name, info) in manually_added_plot.items():
             for (ntwk_id, xy_info) in info.items():
+                print ntwk_id, xy_info.abs_x, xy_info.abs_y
                 plot_id = self._add_to_tables(xy_info.abs_x, 
                                               xy_info.abs_y, 
                                               ntwk_id)
@@ -586,6 +583,7 @@ class PopulateTables(object):
                                                    view_box_ymin,
                                                    view_box_height,
                                                    main_el_matrix)
+        self._add_manually_added_plots()
         return etree.tostring(ntwk_id_svg)
 
 
@@ -651,6 +649,13 @@ class PopulateTables(object):
                     if sub_el.tag == '{{{0}}}text'.format(NSMAP['svg']):
                         tspan_elem = sub_el.xpath('./svg:tspan',
                                                   namespaces=NSMAP)[0]
+                        current_name_shown = ""
+                        tspan_elem = sub_el.xpath('./svg:tspan', 
+                                               namespaces=NSMAP)
+                        for ts in tspan_elem:
+                            current_name_shown += ts.text + " "
+                        current_name_shown = current_name_shown[:-1]
+
                         transform_matrix = sub_el.attrib['transform']
                         matrices = list(base_matrices)
                         matrices.insert(0, transform_matrix)
@@ -670,13 +675,29 @@ class PopulateTables(object):
                                                          room_name,
                                                          abs_x,
                                                          abs_y)
+                            if el.attrib['id'] == "AREA_ID-6":
+                                print "closest_ntwk_id: ", closest_ntwk_id, room_name
 
-                            current_name_shown = ""
-                            tspan_elem = sub_el.xpath('./svg:tspan',
-                                                      namespaces=NSMAP)
-                            for ts in tspan_elem:
-                                current_name_shown += " " + ts.text
-
+                            if not closest_ntwk_id:
+                                print "looking for XXX{0}XXX".format(current_name_shown.lower())
+                                # try to find ntwk_id using floor_plan_by_name
+                                if current_name_shown.lower() in \
+                                       floor_plan_by_name[room_name]:
+                                    closest_ntwk_id = floor_plan_by_name[
+                                                         room_name][
+                                         current_name_shown.lower()]
+                                    print "USE floor_plan_by_name ", closest_ntwk_id
+                                else:
+                                    # try to trim "conference room" for match
+                                    conf_room_name = current_name_shown.lower()\
+                                                .replace(" conference room", "")
+                                    print "looking for XXX{0}XXX".format(conf_room_name)
+                                    if conf_room_name in \
+                                       floor_plan_by_name[room_name]:
+                                        closest_ntwk_id = floor_plan_by_name[
+                                                         room_name][
+                                                     conf_room_name]
+                                        print "USE floor_plan_by_name ", closest_ntwk_id
                             if not closest_ntwk_id:
                                 self._log_obj.error(
                                      self.NO_CLOSEBY_NTWK_ID_ERROR.format(
@@ -784,22 +805,24 @@ class PopulateTables(object):
             net_jack2 information
         """
         info = None
-        if ntwk_id in floor_plan_data[room_name]:
-            info = floor_plan_data[room_name][ntwk_id]
+        if ntwk_id in floor_plan_by_ntwk_id[room_name]:
+            info = floor_plan_by_ntwk_id[room_name][ntwk_id]
         else:
             normalized_id = self._get_normalized_ntwk_id(ntwk_id)
-            if normalized_id in floor_plan_data[room_name]:
-                info = floor_plan_data[room_name][normalized_id]
+            if normalized_id in floor_plan_by_ntwk_id[room_name]:
+                info = floor_plan_by_ntwk_id[room_name][normalized_id]
             else:
                 # try to add these weird symbols at the end...
                 normalized_id_with_C = normalized_id + "-C"
-                if normalized_id_with_C in floor_plan_data[room_name]:
-                    info = floor_plan_data[room_name][normalized_id_with_C]
+                if normalized_id_with_C in floor_plan_by_ntwk_id[room_name]:
+                    info = floor_plan_by_ntwk_id[room_name][
+                                       normalized_id_with_C]
                 else:
                     # try to add these weird symbols...
                     normalized_id_IDF = normalized_id + "/IDF"
-                    if normalized_id_IDF in floor_plan_data[room_name]:
-                        info = floor_plan_data[room_name][normalized_id_IDF]
+                    if normalized_id_IDF in floor_plan_by_ntwk_id[room_name]:
+                        info = floor_plan_by_ntwk_id[room_name][
+                                              normalized_id_IDF]
                     else:
                         self._log_obj.error(self.NO_AREA_INFO_ERROR.format(
                                                               room_name,
@@ -844,7 +867,7 @@ class PopulateTables(object):
         if not occupant_id:
             detail = self._search_adapter.search(info.name)
             if len(detail) == 1:
-                occupant_id = detail[0].id
+                occupant_id = detail[0].occupant_id
 
         if not occupant_id:
             self._log_obj.error(self.NO_OCCUPANT_DETAIL.format(info.name))
diff --git a/templates/index.html b/templates/index.html
index 89a1e9d..9a504a5 100644
--- a/templates/index.html
+++ b/templates/index.html
@@ -78,7 +78,7 @@
   function emphasize()
   {
      {% if (len(forges) > 0) %}
-         var e = document.getElementById("{{forges[0].occupant_id}}");
+     var e = document.getElementById("{{forges[0].occupant_id}}_{{forges[0].plot_id}}");
          if (e)
          {
             e.setAttributeNS(null, "fill", "red");