IfcOpenShell/src/ifcblenderexport/cobie.py

import time
import datetime
import ifcopenshell
import logging
import pprint
import csv
from openpyxl import Workbook
from openpyxl.styles import PatternFill

class IfcCobieParser():
    def __init__(self, logger):
        self.logger = logger
        self.file = None
        self.contacts = {}
        self.facilities = {}
        self.floors = {}
        self.spaces = {}
        self.zones = {}
        self.types = {}
        self.components = {}
        self.systems = {}
        self.assemblies = {}
        self.connections = {}
        self.spares = {}
        self.resources = {}
        self.jobs = {}
        self.impacts = {}
        self.documents = {}
        self.attributes = {}
        self.coordinates = {}
        self.issues = {}
        self.type_assets = [
            'IfcDoorStyle',
            'IfcBuildingElementProxyType',
            'IfcChimneyType',
            'IfcCoveringType',
            'IfcDoorType',
            'IfcFootingType',
            'IfcPileType',
            'IfcRoofType',
            'IfcShadingDeviceType',
            'IfcWindowType',
            'IfcDistributionControlElementType',
            'IfcDistributionChamberElementType',
            'IfcEnergyConversionDeviceType',
            'IfcFlowControllerType',
            'IfcFlowMovingDeviceType',
            'IfcFlowStorageDeviceType',
            'IfcFlowTerminalType',
            'IfcFlowTreatmentDeviceType',
            'IfcElementAssemblyType',
            'IfcBuildingElementPartType',
            'IfcDiscreteAccessoryType',
            'IfcMechanicalFastenerType',
            'IfcReinforcingElementType',
            'IfcVibrationIsolatorType',
            'IfcFurnishingElementType',
            'IfcGeographicElementType',
            'IfcTransportElementType',
            'IfcSpatialZoneType',
            'IfcWindowStyle',
            ]
        self.component_assets = [
            'IfcBuildingElementProxy',
            'IfcChimney',
            'IfcCovering',
            'IfcDoor',
            'IfcShadingDevice',
            'IfcWindow',
            'IfcDistributionControlElement',
            'IfcDistributionChamberElement',
            'IfcEnergyConversionDevice',
            'IfcFlowController',
            'IfcFlowMovingDevice',
            'IfcFlowStorageDevice',
            'IfcFlowTerminal',
            'IfcFlowTreatmentDevice',
            'IfcDiscreteAccessory',
            'IfcTendon',
            'IfcTendonAnchor',
            'IfcVibrationIsolator',
            'IfcFurnishingElement',
            'IfcGeographicElement',
            'IfcTransportElement',
            ]
        self.picklists = {
            'Category-Role': [],
            'Category-Facility': [],
            'FloorType': [],
            'Category-Space': [],
            'ZoneType': [],
            'Category-Product': [],
            'AssetType': [],
            'DurationUnit': ['day'], # See note about hardcoded day below
            'Category-Element': [],
            'SpareType': [],
            'ApprovalBy': [],
            'StageType': [],
            'objType': []
            }
        self.default_date = (datetime.datetime(1970, 1, 1) + datetime.timedelta(seconds = -2177452801)).isoformat()

    def parse(self):
        self.file = ifcopenshell.open('C:/cygwin64/home/moud308/Projects/ifc2cobie/arch.ifc')
        self.get_contacts()
        self.get_facilities()
        self.get_floors()
        self.get_spaces()
        self.get_zones()
        self.get_types()
        self.get_components()
        self.get_systems()
        self.get_assemblies()
        self.get_connections()
        self.get_spares()
        self.get_resources()
        self.get_jobs()
        self.get_impacts()
        self.get_documents()
        self.get_attributes()
        self.get_coordinates()
        self.get_issues()

    def get_contacts(self):
        histories = self.file.by_type('IfcOwnerHistory')
        for history in histories:
            email = self.get_email_from_history(history)
            if not email:
                continue
            postal_address = self.get_postal_address_from_history(history)
            self.contacts[email] = {
                'CreatedBy': email,
                'CreatedOn': datetime.datetime.fromtimestamp(history.CreationDate).isoformat() if history.CreationDate else datetime.datetime.now().isoformat(),
                'Category': self.get_category_from_history(history),
                'Company': history.OwningUser.TheOrganization.Name or 'n/a',
                'Phone': self.get_phone_from_history(history),
                'ExtSystem': self.get_ext_system_from_history(history),
                'ExtObject': self.get_ext_object_from_history(history),
                'ExtIdentifier': history.OwningUser.ThePerson.Id if self.file.schema == 'IFC2X3' else history.OwningUser.ThePerson.Identification,
                'Department': self.get_department_from_history(history),
                'OrganizationCode': (history.OwningUser.TheOrganization.Id or 'n/a') if self.file.schema == 'IFC2X3' else (history.OwningUser.TheOrganization.Identification or 'n/a'),
                'GivenName': self.get_name_from_person(history.OwningUser.ThePerson, 'GivenName'),
                'FamilyName': self.get_name_from_person(history.OwningUser.ThePerson, 'FamilyName'),
                'Street': self.get_attribute_from_address(postal_address, 'AddressLines'),
                'PostalBox': self.get_attribute_from_address(postal_address, 'PostalBox'),
                'Town': self.get_attribute_from_address(postal_address, 'Town'),
                'StateRegion': self.get_attribute_from_address(postal_address, 'Region'),
                'PostalCode': self.get_attribute_from_address(postal_address, 'PostalCode'),
                'Country': self.get_attribute_from_address(postal_address, 'Country')
                }

    def get_facilities(self):
        buildings = self.file.by_type('IfcBuilding')
        for building in buildings:
            building_name = self.get_object_name(building)
            units = self.get_units_from_building(building)
            self.facilities[building_name] = {
                'CreatedBy': self.get_email_from_history(building.OwnerHistory),
                'CreatedOn': self.get_created_on_from_history(building.OwnerHistory),
                'Category': self.get_category_from_object(building, 'Category-Facility'),
                'ProjectName': self.get_project_name_from_building(building),
                'SiteName': self.get_site_name_from_building(building),
                'LinearUnits': self.get_unit_type_from_units(units, 'LENGTHUNIT'),
                'AreaUnits': self.get_unit_type_from_units(units, 'AREAUNIT'),
                'VolumeUnits': self.get_unit_type_from_units(units, 'VOLUMEUNIT'),
                'CostUnit': self.get_monetary_unit_from_units(units),
                'AreaMeasurement': self.get_area_measurement_from_building(building),
                'ExternalSystem': self.get_ext_system_from_history(building.OwnerHistory),
                'ExternalProjectObject': self.get_ext_project_object(),
                'ExternalProjectIdentifier': self.get_project_globalid_from_building(building),
                'ExternalSiteObject': self.get_ext_site_object(),
                'ExternalSiteIdentifier': self.get_site_globalid_from_building(building),
                'ExternalFacilityObject': self.get_ext_object(building),
                'ExternalFacilityIdentifier': building.GlobalId,
                'Description': self.get_object_attribute(building, 'Description', default='n/a'),
                'ProjectDescription': self.get_object_attribute(self.get_parent_spatial_element(building, 'IfcProject'), 'Description', default='n/a'),
                'SiteDescription': self.get_object_attribute(self.get_parent_spatial_element(building, 'IfcSite'), 'Description', default='n/a'),
                'Phase': self.get_object_attribute(self.get_parent_spatial_element(building, 'IfcProject'), 'Phase', default='n/a')
                }

    def get_floors(self):
        storeys = self.file.by_type('IfcBuildingStorey')
        for storey in storeys:
            storey_name = self.get_object_name(storey)
            self.floors[storey_name] = {
                'CreatedBy': self.get_email_from_history(storey.OwnerHistory),
                'CreatedOn': self.get_created_on_from_history(storey.OwnerHistory),
                'Category': self.get_category_from_object(storey, 'FloorType'),
                'ExtSystem': self.get_ext_system_from_history(storey.OwnerHistory),
                'ExtObject': self.get_ext_object(storey),
                'ExtIdentifier': storey.GlobalId,
                'Description': self.get_object_attribute(storey, 'Description', default='n/a'),
                'Elevation': self.get_object_attribute(storey, 'Elevation', default='n/a'),
                'Height': self.get_height_from_storey(storey)
                }

    def get_spaces(self):
        spaces = self.file.by_type('IfcSpace')
        for space in spaces:
            space_name = self.get_object_name(space)
            self.spaces[space_name] = {
                'CreatedBy': self.get_email_from_history(space.OwnerHistory),
                'CreatedOn': self.get_created_on_from_history(space.OwnerHistory),
                'Category': self.get_category_from_object(space, 'Category-Space'),
                'FloorName': self.get_object_attribute(self.get_parent_spatial_element(space, 'IfcBuildingStorey'), 'Name', is_primary_key=True, default='n/a'),
                'Description': self.get_object_attribute(space, 'Description', default='n/a'),
                'ExtSystem': self.get_ext_system_from_history(space.OwnerHistory),
                'ExtObject': self.get_ext_object(space),
                'ExtIdentifier': space.GlobalId,
                'RoomTag': self.get_pset_value_from_object(space, 'COBie_Space', 'RoomTag', 'n/a'),
                'UsableHeight': self.get_usable_height_from_space(space),
                'GrossArea': self.get_gross_area_from_space(space),
                'NetArea': self.get_net_area_from_space(space),
                }

    def get_zones(self):
        zones = self.file.by_type('IfcZone')
        for zone in zones:
            zone_name = self.get_object_name(zone)
            self.zones[zone_name] = {
                'CreatedBy': self.get_email_from_history(zone.OwnerHistory),
                'CreatedOn': self.get_created_on_from_history(zone.OwnerHistory),
                'Category': self.get_category_from_object(zone, 'ZoneType'),
                'SpaceNames': self.get_grouped_product_names_from_object(zone, 'IfcSpace'),
                'ExtSystem': self.get_ext_system_from_history(zone.OwnerHistory),
                'ExtObject': self.get_ext_object(zone),
                'ExtIdentifier': zone.GlobalId,
                'Description': self.get_object_attribute(zone, 'Description', default='n/a'),
                }

    def get_types(self):
        types = self.file.by_type('IfcTypeObject')
        for type in types:
            is_a_type_asset = False
            for type_asset in self.type_assets:
                if type.is_a(type_asset):
                    is_a_type_asset = True
            if not is_a_type_asset:
                self.logger.warning('A type which is not an asset was found for {}'.format(type))
                continue
            # The responsibility matrix states to parse IfcMaterial and
            # IfcMaterialLayerSet too, but it doesn't make much sense, so I
            # don't parse it.
            type_name = self.get_object_name(type)
            self.types[type_name] = {
                'CreatedBy': self.get_email_from_history(type.OwnerHistory),
                'CreatedOn': self.get_created_on_from_history(type.OwnerHistory),
                'Category': self.get_category_from_object(type, 'Category-Product'),
                # The responsibility matrix states two possible fallbacks. I
                # choose the 'n/a' option as opposed to repeating the name.
                'Description': self.get_object_attribute(type, 'Description', default='n/a'),
                'AssetType': self.get_pset_value_from_object(type, 'COBie_Asset', 'AssetType', 'n/a', 'AssetType'),
                'Manufacturer': self.get_contact_pset_value_from_object(type, 'Pset_ManufacturerTypeInformation', 'Manufacturer'),
                'ModelNumber': self.get_pset_value_from_object(type, 'Pset_ManufacturerTypeInformation', 'ModelLabel', 'n/a'),
                # The responsibility matrix talks about using the Pset_Warranty
                # values, but Pset_Warranty only applies to objects, not types,
                # and so they are ignored.
                'WarrantyGuarantorParts': self.get_contact_pset_value_from_object(type, 'COBie_Warranty', 'WarrantyGuarantorParts'),
                'WarrantyDurationParts': self.get_pset_value_from_object(type, 'COBie_Warranty', 'WarrantyDurationParts', 0),
                'WarrantyGuarantorLabor': self.get_contact_pset_value_from_object(type, 'COBie_Warranty', 'WarrantyGuarantorLabor'),
                'WarrantyDurationLabor': self.get_pset_value_from_object(type, 'COBie_Warranty', 'WarrantyDurationLabor', 0),
                # TODO: this may be derived from the duration values above, but
                # until it is clarified, it will be hardcoded as 'day'
                'WarrantyDurationUnit': 'day',
                'ExtSystem': self.get_ext_system_from_history(type.OwnerHistory),
                'ExtObject': self.get_ext_object(type),
                'ExtIdentifier': type.GlobalId,
                'ReplacementCost': self.get_pset_value_from_object(type, 'COBie_EconomicImpactValues', 'ReplacementCost', 'n/a'),
                'ExpectedLife': self.get_expected_life_from_type(type),
                # See note about WarrantyDurationUnit above
                'DurationUnit': 'day',
                'NominalLength': self.get_pset_value_from_object(type, 'COBie_Specification', 'NominalLength', 0),
                'NominalWidth': self.get_pset_value_from_object(type, 'COBie_Specification', 'NominalWidth', 0),
                'NominalHeight': self.get_pset_value_from_object(type, 'COBie_Specification', 'NominalHeight', 0),
                'ModelReference': self.get_pset_value_from_object(type, 'Pset_ManufacturerTypeInformation', 'ModelReference', 'n/a'),
                'Shape': self.get_pset_value_from_object(type, 'COBie_Specification', 'Shape', 'n/a'),
                'Size': self.get_pset_value_from_object(type, 'COBie_Specification', 'Size', 'n/a'),
                # The responsbility matrix allows the British spelling of
                # "colour". I, however, do not.
                'Color': self.get_pset_value_from_object(type, 'COBie_Specification', 'Color', 'n/a'),
                'Finish': self.get_pset_value_from_object(type, 'COBie_Specification', 'Finish', 'n/a'),
                'Grade': self.get_pset_value_from_object(type, 'COBie_Specification', 'Grade', 'n/a'),
                'Material': self.get_pset_value_from_object(type, 'COBie_Specification', 'Material', 'n/a'),
                'Constituents': self.get_pset_value_from_object(type, 'COBie_Specification', 'Constituents', 'n/a'),
                'Features': self.get_pset_value_from_object(type, 'COBie_Specification', 'Features', 'n/a'),
                'AccessibilityPerformance': self.get_pset_value_from_object(type, 'COBie_Specification', 'AccessibilityPerformance', 'n/a'),
                'CodePerformance': self.get_pset_value_from_object(type, 'COBie_Specification', 'CodePerformance', 'n/a'),
                'SustainabilityPerformance': self.get_pset_value_from_object(type, 'COBie_Specification', 'SustainabilityPerformance', 'n/a'),
                }

    def get_components(self):
        components = self.file.by_type('IfcElement')
        for component in components:
            if not self.is_object_a_component_asset(component):
                self.logger.warning('A component which is not an asset was found for {}'.format(component))
                continue
            component_name = self.get_object_name(component)
            self.components[component_name] = {
                'CreatedBy': self.get_email_from_history(component.OwnerHistory),
                'CreatedOn': self.get_created_on_from_history(component.OwnerHistory),
                'TypeName': self.get_type_name_from_object(component),
                'Space': self.get_space_name_from_component(component),
                'Description': self.get_object_attribute(component, 'Description', default='n/a'),
                'ExtSystem': self.get_ext_system_from_history(component.OwnerHistory),
                'ExtObject': self.get_ext_object(component),
                'ExtIdentifier': component.GlobalId,
                'SerialNumber': self.get_pset_value_from_object(component, 'Pset_ManufacturerOccurence', 'SerialNumber', 'n/a'),
                'InstallationDate': self.get_pset_value_from_object(component, 'COBie_Component', 'InstallationDate', self.default_date),
                'WarrantyStartDate': self.get_pset_value_from_object(component, 'COBie_Component', 'WarrantyStartDate', self.default_date),
                'TagNumber': self.get_pset_value_from_object(component, 'COBie_Component', 'TagNumber', 'n/a'),
                'BarCode': self.get_pset_value_from_object(component, 'Pset_ManufacturerOccurence', 'BarCode', 'n/a'),
                'AssetIdentifier': self.get_pset_value_from_object(component, 'COBie_Component', 'AssetIdentifier', 'n/a'),
                }

    def get_systems(self):
        systems = self.file.by_type('IfcSystem')
        for system in systems:
            system_name = self.get_object_name(system)
            self.systems[system_name] = {
                'CreatedBy': self.get_email_from_history(system.OwnerHistory),
                'CreatedOn': self.get_created_on_from_history(system.OwnerHistory),
                'Category': self.get_category_from_object(system, 'Category-Element'),
                'ComponentNames': self.get_grouped_product_names_from_object(system, 'IfcProduct'),
                'ExtSystem': self.get_ext_system_from_history(system.OwnerHistory),
                'ExtObject': self.get_ext_object(system),
                'ExtIdentifier': system.GlobalId,
                'Description': self.get_object_attribute(system, 'Description', default='n/a'),
                }

    def get_assemblies(self):
        assemblies = self.file.by_type('IfcRelAggregates')
        for assembly in assemblies:
            assembly_name = self.get_object_name(assembly)
            if not self.is_object_a_component_asset(assembly.RelatingObject):
                continue
            self.assemblies[assembly_name] = {
                'CreatedBy': self.get_email_from_history(assembly.OwnerHistory),
                'CreatedOn': self.get_created_on_from_history(assembly.OwnerHistory),
                'SheetName': 'Assembly',
                'ParentName': self.get_object_name(assembly.RelatingObject),
                'ChildNames': ','.join([o.Name for o in assembly.RelatedObjects]),
                'AssemblyType': 'n/a', # I don't understand this field
                'ExtSystem': self.get_ext_system_from_history(assembly.OwnerHistory),
                'ExtObject': self.get_ext_object(assembly),
                'ExtIdentifier': assembly.GlobalId,
                'Description': self.get_object_attribute(assembly, 'Description', default='n/a'),
                }

    def get_connections(self):
        connections = self.file.by_type('IfcRelConnects')
        for connection in connections:
            connection_name = self.get_object_name(connection)
            self.connections[connection_name] = {
                'CreatedBy': self.get_email_from_history(connection.OwnerHistory),
                'CreatedOn': self.get_created_on_from_history(connection.OwnerHistory),
                # There is ambiguity for what the ConnectionType mapping should be
                'ConnectionType': self.get_object_attribute(connection, 'Description', default='n/a'),
                'SheetName': 'Connections',
                'RowName1': self.get_row_name_from_connection(connection, 'RelatingElement'),
                'RowName2': self.get_row_name_from_connection(connection, 'RelatedElement'),
                'RealizingElement': self.get_port_name_from_connection(connection, 'RealizingElement'),
                'PortName1': self.get_port_name_from_connection(connection, 'RelatingPort'),
                'PortName2': self.get_port_name_from_connection(connection, 'RelatedPort'),
                'ExtSystem': self.get_ext_system_from_history(connection.OwnerHistory),
                'ExtObject': self.get_ext_object(connection),
                'ExtIdentifier': connection.GlobalId,
                'Description': self.get_object_attribute(connection, 'Description', default='n/a'),
                }

    def get_spares(self):
        spares = self.file.by_type('IfcConstructionProductResource')
        for spare in spares:
            spare_name = self.get_object_name(spare)
            self.spares[spare_name] = {
                'CreatedBy': self.get_email_from_history(spare.OwnerHistory),
                'CreatedOn': self.get_created_on_from_history(spare.OwnerHistory),
                'Category': self.get_category_from_object(spare, 'SpareType'),
                'TypeName': self.get_type_name_from_object(spare),
                'Suppliers': self.get_contact_pset_value_from_object(spare, 'COBie_Spare', 'Suppliers'),
                'ExtSystem': self.get_ext_system_from_history(spare.OwnerHistory),
                'ExtObject': self.get_ext_object(spare),
                'ExtIdentifier': spare.GlobalId,
                'Description': self.get_object_attribute(spare, 'Description', default='n/a'),
                'SetNumber': self.get_contact_pset_value_from_object(spare, 'COBie_Spare', 'SetNumber'),
                'PartNumber': self.get_contact_pset_value_from_object(spare, 'COBie_Spare', 'PartNumber'),
                }

    def get_resources(self):
        resources = self.file.by_type('IfcConstructionProductResource')
        for resource in resources:
            resource_name = self.get_object_name(resource)
            self.resources[resource_name] = {
                'CreatedBy': self.get_email_from_history(resource.OwnerHistory),
                'CreatedOn': self.get_created_on_from_history(resource.OwnerHistory),
                'Category': self.get_object_attribute(resource, 'ObjectType', picklist='ResourceType', default='n/a'),
                'ExtSystem': self.get_ext_system_from_history(resource.OwnerHistory),
                'ExtObject': self.get_ext_object(resource),
                'ExtIdentifier': resource.GlobalId,
                'Description': self.get_object_attribute(resource, 'Description', default='n/a'),
                }

    def get_jobs(self):
        jobs = self.file.by_type('IfcTask')
        for job in jobs:
            job_name = self.get_object_name(job)
            task_time = job.TaskTime
            self.jobs[job_name] = {
                'CreatedBy': self.get_email_from_history(job.OwnerHistory),
                'CreatedOn': self.get_created_on_from_history(job.OwnerHistory),
                'Category': self.get_object_attribute(job, 'ObjectType', picklist='JobType', default='n/a'),
                'Status': self.get_object_attribute(job, 'Status', picklist='JobStatusType', default='n/a'),
                'TypeName': self.get_type_name_from_object(job),
                'Description': self.get_object_attribute(job, 'Description', default='n/a'),
                'Duration': self.get_object_attribute(task_time, 'ScheduleDuration', default=0),
                'DurationUnit': 'day',
                'Start': self.get_object_attribute(task_time, 'ScheduleStart', default=0),
                'TaskStartUnit': 'day',
                'Frequency': self.get_object_attribute(task_time.Recurrence, 'Occurrences', default=0) if hasattr(task_time, 'Recurrence') else 0,
                'FrequencyUnit': 'day',
                'ExtSystem': self.get_ext_system_from_history(job.OwnerHistory),
                'ExtObject': self.get_ext_object(job),
                'ExtIdentifier': job.GlobalId,
                'TaskNumber': self.get_object_attribute(job, 'Identification'),
                'Priors': self.get_priors_from_job(job),
                'ResourceNames': self.get_resource_names_from_job(job),
                }

    # Impacts is not explicitly defined as a mapping in the responsibliity
    # matrix. This is my best guess. This data should not be relied upon until
    # this is clarified.
    def get_impacts(self):
        impacts = self.file.by_type('IfcPropertySet')
        for impact in impacts:
            if impact.Name != 'Pset_EnvironmentalImpactValues' \
                or not impact.HasProperties:
                continue
            for property in impact.HasProperties:
                property_name = '{}-{}'.format(property.id(), self.get_object_name(property))
                self.impacts[property_name] = {
                    'CreatedBy': self.get_email_from_history(impact.OwnerHistory),
                    'CreatedOn': self.get_created_on_from_history(impact.OwnerHistory),
                    'ImpactType': None,
                    'ImpactStage': None,
                    'SheetName': 'Impacts',
                    'RowName': 'n/a',
                    'Value': self.get_object_attribute(property, 'NominalValue', default='n/a') if property.is_a('IfcPropertySingleValue') else 'n/a',
                    'Unit': '{}{}'.format(property.Unit.Prefix, property.Unit.Name) if hasattr(property, 'Unit') and property.Unit else 'n/a',
                    'LeadInTime': self.get_object_attribute(property, 'NominalValue', default='n/a') if property.is_a('IfcPropertySingleValue') and property.Name == 'LeadInTime' else 'n/a',
                    'Duration': self.get_object_attribute(property, 'NominalValue', default='n/a') if property.is_a('IfcPropertySingleValue') and property.Name == 'Duration' else 'n/a',
                    'LeadOutTime': self.get_object_attribute(property, 'NominalValue', default='n/a') if property.is_a('IfcPropertySingleValue') and property.Name == 'LeadOutTime' else 'n/a',
                    'ExtSystem': self.get_ext_system_from_history(impact.OwnerHistory),
                    'ExtObject': self.get_ext_object(impact),
                    'ExtIdentifier': impact.GlobalId,
                    'Description': self.get_object_attribute(impact, 'Description', default='n/a'),
                }

    def get_documents(self):
        documents = self.file.by_type('IfcDocumentInformation')
        for document in documents:
            document_name = self.get_object_name(document)
            self.documents[document_name] = {
                'CreatedBy': self.get_email_from_history(document.OwnerHistory),
                'CreatedOn': self.get_created_on_from_history(document.OwnerHistory),
                'Category': 'n/a', # I am not sure what this mapping is meant to be
                'ApprovalBy': self.get_object_attribute(document, 'IntendedUse', picklist='ApprovalBy', default='Information Only'),
                'Stage': self.get_object_attribute(document, 'Scope', picklist='StageType', default='Required'),
                'SheetName': 'Documents',
                'RowName': 'n/a',
                'Directory': self.get_directory_from_document(document),
                'File': self.get_file_from_document(document),
                'ExtSystem': self.get_ext_system_from_history(document.OwnerHistory),
                'ExtObject': self.get_ext_object(document),
                'ExtIdentifier': document.GlobalId,
                'Description': self.get_object_attribute(document, 'Description', default=document_name),
                'Reference': document_name,
                }

    # Attributes is not explicitly defined as a mapping in the responsibliity
    # matrix. This is my best guess. This data should not be relied upon until
    # this is clarified.
    def get_attributes(self):
        attributes = self.file.by_type('IfcPropertySet')
        for attribute in attributes:
            if not attribute.HasProperties:
                continue
            for property in attribute.HasProperties:
                property_name = '{}-{}'.format(property.id(), self.get_object_name(property))
                self.attributes[property_name] = {
                    'CreatedBy': self.get_email_from_history(attribute.OwnerHistory),
                    'CreatedOn': self.get_created_on_from_history(attribute.OwnerHistory),
                    'Category': 'n/a', # I am not sure what this mapping is meant to be
                    'SheetName': 'Attributes',
                    'RowName': 'n/a', # I am not sure what this mapping is meant to be
                    'Value': self.get_object_attribute(property, 'NominalValue', default='n/a') if property.is_a('IfcPropertySingleValue') else 'n/a',
                    'Unit': '{}{}'.format(property.Unit.Prefix, property.Unit.Name) if hasattr(property, 'Unit') and property.Unit else 'n/a',
                    'ExtSystem': self.get_ext_system_from_history(attribute.OwnerHistory),
                    'ExtObject': self.get_ext_object(attribute),
                    'ExtIdentifier': attribute.GlobalId,
                    'Description': self.get_object_attribute(attribute, 'Description', default='n/a'),
                    # I'm holding off implementing this until I understand a bit
                    # more about attributes
                    'AllowedValues': 'n/a',
                    }

    def get_coordinates(self):
        coordinates = self.file.by_type('IfcBuildingStorey') \
            + self.file.by_type('IfcSpace') \
            + self.file.by_type('IfcProduct')
        for coordinate in coordinates:
            coordinate_name = '{}/{}'.format(coordinate.is_a(), self.get_object_name(coordinate))
            self.coordinates[coordinate_name] = {
                'CreatedBy': self.get_email_from_history(coordinate.OwnerHistory),
                'CreatedOn': self.get_created_on_from_history(coordinate.OwnerHistory),
                'Category': 'Location', # I am not sure what this mapping is meant to be
                'SheetName': 'Coordinates',
                'RowName': 'n/a',
                'CoordinateXAxis': coordinate.ObjectPlacement.RelativePlacement.Location.Coordinates[0],
                'CoordinateYAxis': coordinate.ObjectPlacement.RelativePlacement.Location.Coordinates[1],
                'CoordinateZAxis': coordinate.ObjectPlacement.RelativePlacement.Location.Coordinates[2],
                'ExtSystem': self.get_ext_system_from_history(coordinate.OwnerHistory),
                'ExtObject': self.get_ext_object(coordinate),
                'ExtIdentifier': coordinate.GlobalId,
                # Holding off implementing this, see Bug #688:
                # https://github.com/IfcOpenShell/IfcOpenShell/issues/688
                'ClockwiseRotation': 'n/a', # X axis
                'ElevationalRotation': 'n/a', # Y axis
                'YawRotation': 'n/a', # Z axis
                }

    # I don't fully understand this worksheet. Don't trust this data.
    def get_issues(self):
        issues = self.file.by_type('IfcApproval')
        for issue in issues:
            issue_name = self.get_object_name(issue)
            self.issues[issue_name] = {
                'CreatedBy': self.get_email_from_history(issue.OwnerHistory),
                'CreatedOn': self.get_created_on_from_history(issue.OwnerHistory),
                'Type': 'n/a', # How do we get to the Pset_Risk from the IfcApproval?
                'Risk': 'n/a', # How do we get to the Pset_Risk from the IfcApproval?
                'Chance': 'n/a', # How do we get to the Pset_Risk from the IfcApproval?
                'Impact': 'n/a', # How do we get to the Pset_Risk from the IfcApproval?
                'SheetName1': 'n/a',
                'RowName1': 'n/a',
                'SheetName2': 'n/a',
                'RowName2': 'n/a',
                'Description': self.get_object_attribute(issue, 'Description', default='n/a'),
                'Owner': self.get_email_from_history(issue.RequestingApproval), # Is this correct?
                'Mitigation': 'n/a',
                'ExtSystem': self.get_ext_system_from_history(issue.OwnerHistory),
                'ExtObject': self.get_ext_object(issue),
                'ExtIdentifier': issue.GlobalId,
                }

    def get_directory_from_document(self, document):
        if self.file.schema == 'IFC2X3':
            if document.HasDocumentReferences:
                for reference in document.HasDocumentReferences:
                    return self.get_object_attribute(reference, 'Location', default='n/a')
        else:
            return self.get_object_attribute(document, 'Location', default='n/a')

    def get_file_from_document(self, document):
        if self.file.schema == 'IFC2X3':
            if document.HasDocumentReferences:
                for reference in document.HasDocumentReferences:
                    return self.get_object_attribute(reference, 'Name', default='n/a')
        else:
            self.get_object_attribute(document, 'Identification', default='n/a')

    def get_resource_names_from_job(self, job):
        names = []
        if job.OperatesOn \
            and job.OperatesOn.RelatedObjects:
            for object in job.OperatesOn.RelatedObjects:
                names.append(object.Name)
        return ','.join(names)

    def get_priors_from_job(self, job):
        # The responsibility matrix is vague as to whether it expects a task
        # name or a task identification. I chose task name.
        if job.IsSuccessorFrom \
            and job.IsSuccessorFrom.RelatingProcess \
            and job.IsSuccessorFrom.RelatingProcess.is_a('IfcTask'):
                return self.get_object_name(job.IsSuccessorFrom.RelatingProcess)

    def get_row_name_from_connection(self, connection, key):
        if not connection.is_a('IfcRelConnectsElements'):
            return None
        object = getattr(connection, key)
        if self.is_object_a_component_asset(object):
            return object.Name
        self.logger.error('The connected object relationship {} is not a component asset for {}'.format(key, connection))

    def get_port_name_from_connection(self, connection, key):
        if not connection.is_a('IfcRelConnectsPorts'):
            return None
        object = getattr(connection, key)
        if self.is_object_a_component_asset(object):
            return object.Name
        self.logger.error('The connected object relationship {} is not a component asset for {}'.format(key, connection))

    def is_object_a_component_asset(self, object):
        is_an_asset = False
        for asset in self.component_assets:
            if object.is_a(asset):
                is_an_asset = True
        return is_an_asset

    def get_space_name_from_component(self, component):
        for relationship in component.ContainedInStructure:
            if relationship.RelatingStructure.is_a('IfcSpace') \
                and relationship.RelatingStructure.Name:
                return relationship.RelatingStructure.Name
        self.logger.error('A related space name could not be determined for {}'.format(component))

    def get_type_name_from_object(self, object):
        if self.file.schema == 'IFC2X3':
            for relationship in object.IsDefinedBy:
                if relationship.is_a('IfcRelDefinesByType') \
                    and relationship.RelatingType.Name:
                    return relationship.RelatingType.Name
        else:
            for relationship in object.IsTypedBy:
                if relationship.RelatingType.Name:
                    return relationship.RelatingType.Name
        self.logger.error('A related type name could not be determined for {}'.format(object))

    def get_expected_life_from_type(self, type):
        if self.file.schema == 'IFC2X3':
            return self.get_pset_value_from_object(type, 'COBie_ServiceLife', 'ServiceLifeDuration', 'n/a')
        return self.get_pset_value_from_object(type, 'Pset_ServiceLife', 'ServiceLifeDuration', 'n/a')

    def get_contact_pset_value_from_object(self, object, pset_name, property_name):
        result = self.get_pset_value_from_object(object, pset_name, property_name)
        if not result:
            self.logger.error('No property {} in {} was found for {}'.format(property_name, pset_name, object))
        if result not in self.contacts:
            self.logger.error('A coresponding {} contact in {} was not found for {}'.format(property_name, pset_name, object))
        return result

    def get_pset_value_from_object(self, object, pset_name, property_name, default=None, picklist=None):
        pset = self.get_pset_from_object(object, pset_name)
        if not pset:
            if picklist:
                self.picklists[picklist].append(default)
            return default
        property = self.get_property_from_pset(pset, property_name, default)
        if picklist:
            self.picklists[picklist].append(property)
        return property

    def get_grouped_product_names_from_object(self, object, type):
        names = []
        for relationship in object.IsGroupedBy:
            for related_object in relationship.RelatedObjects:
                if related_object.is_a(type):
                    names.append(related_object.Name)
        if names:
            return ','.join(names)
        self.logger.error('No related {} were found for {}'.format(type, object))

    def get_net_area_from_space(self, space):
        qto = self.get_qto_from_object(space, 'Qto_SpaceBaseQuantities')
        if not qto:
            return 'n/a'
        return self.get_property_from_qto(qto, 'NetFloorArea', 'AreaValue')

    def get_gross_area_from_space(self, space):
        qto = self.get_qto_from_object(space, 'Qto_SpaceBaseQuantities')
        if not qto:
            return 'n/a'
        return self.get_property_from_qto(qto, 'GrossFloorArea', 'AreaValue')

    def get_usable_height_from_space(self, space):
        qto = self.get_qto_from_object(space, 'Qto_SpaceBaseQuantities')
        if not qto:
            return 'n/a'
        return self.get_property_from_qto(qto, 'FinishCeilingHeight', 'LengthValue')

    def get_qto_from_object(self, object, name):
        for relationship in object.IsDefinedBy:
            if relationship.RelatingPropertyDefinition.is_a('IfcQuantitySet') \
                and relationship.RelatingPropertyDefinition.Name == name:
                return relationship.RelatingPropertyDefinition
        self.logger.warning('The qto {} was not found for {}'.format(name, object))

    def get_property_from_qto(self, qto, name, attribute):
        for property in qto.Quantities:
            if property.Name == name:
                return getattr(property, attribute)
        self.logger.warning('The quantity value {} was not found for {}'.format(name, qto))
        return 'n/a'

    def get_property_from_pset(self, pset, name, default=None):
        for property in pset.HasProperties:
            if property.Name == name:
                return property.NominalValue
        self.logger.warning('The property {} was not found for {}'.format(name, pset))
        return default

    def get_pset_from_object(self, object, name):
        if object.is_a('IfcTypeObject'):
            if object.HasPropertySets:
                for pset in object.HasPropertySets:
                    if pset.is_a('IfcPropertySet') \
                        and pset.Name == name:
                        return pset
        else:
            for relationship in object.IsDefinedBy:
                if relationship.is_a('IfcRelDefinesByProperties') \
                    and relationship.RelatingPropertyDefinition.is_a('IfcPropertySet') \
                    and relationship.RelatingPropertyDefinition.Name == name:
                    return relationship.RelatingPropertyDefinition
        self.logger.warning('The pset {} was not found for {}'.format(name, object))

    def get_height_from_storey(self, storey):
        for relationship in storey.IsDefinedBy:
            if not relationship.RelatingPropertyDefinition.is_a('IfcElementQuantity'):
                continue
            for quantity in relationship.RelatingPropertyDefinition.Quantities:
                if quantity.is_a('IfcQuantityLength') \
                    and quantity.LengthValue:
                    return quantity.LengthValue
        self.logger.warning('A height length value was not found for {}'.format(storey))
        return 'n/a'

    def get_created_on_from_history(self, history):
        if history.CreationDate:
            return datetime.datetime.fromtimestamp(history.CreationDate).isoformat()
        self.logger.warning('A created on date was not found for {}'.format(history))
        return self.default_date

    def get_object_attribute(self, object, attribute, is_primary_key = False, picklist = None, default=None):
        result = getattr(object, attribute)
        if result:
            if picklist:
                self.picklists[picklist].append(result)
            return result
        if is_primary_key:
            self.logger.error('The primary key attribute {} was not found for {}'.format(attribute, object))
        else:
            self.logger.warning('The attribute {} was not found for {}'.format(attribute, object))
        return default

    def get_ext_project_object(self):
        self.picklists['objType'].append('IfcProject')
        return 'IfcProject'

    def get_ext_site_object(self):
        self.picklists['objType'].append('IfcSite')
        return 'IfcSite'

    def get_ext_object(self, object):
        self.picklists['objType'].append(object.is_a())
        return object.is_a()

    def get_ext_system_from_history(self, history):
        return history.OwningApplication.ApplicationFullName

    def get_object_name(self, object):
        if not object.Name:
            self.logger.error('A primary key name was not found for {}'.format(object))
            return 'Object{}'.format(object.id())
        return object.Name

    def get_area_measurement_from_building(self, building):
        for relationship in building.IsDefinedBy:
            if relationship.RelatingPropertyDefinition.is_a('IfcElementQuantity') \
                and relationship.RelatingPropertyDefinition.MethodOfMeasurement:
                return relationship.RelatingPropertyDefinition.MethodOfMeasurement
        self.logger.warning('A method of measurement was not defined for {}'.format(building))

    def get_unit_type_from_units(self, units, type):
        for unit in units:
            if unit.UnitType == type:
                if unit.is_a('IfcSIUnit') and unit.Prefix:
                    return '{}{}'.format(unit.Prefix, unit.Name)
                return unit.Name
        self.logger.error('A unit {} was not defined in this project for {}'.format(type, units))

    def get_monetary_unit_from_units(self, units):
        for unit in units:
            if unit.is_a('IfcMonetaryUnit'):
                return unit.Currency
        self.logger.error('A monetary unit could not be found for {}'.format(units))

    def get_project_globalid_from_building(self, building):
        return self.get_parent_spatial_element(building, 'IfcProject').GlobalId

    def get_site_globalid_from_building(self, building):
        return self.get_parent_spatial_element(building, 'IfcSite').GlobalId

    def get_project_name_from_building(self, building):
        project = self.get_parent_spatial_element(building, 'IfcProject')
        if project.Name:
            return project.Name
        self.logger.error('The project name is empty for {}'.format(project))
        return 'n/a'

    def get_site_name_from_building(self, building):
        site = self.get_parent_spatial_element(building, 'IfcSite')
        if site.Name:
            return site.Name
        self.logger.error('The site name is empty for {}'.format(site))
        return 'n/a'

    def get_units_from_building(self, building):
        return self.get_parent_spatial_element(building, 'IfcProject').UnitsInContext.Units

    def get_parent_spatial_element(self, child, name):
        for relationship in child.Decomposes:
            if relationship.RelatingObject.is_a(name):
                return relationship.RelatingObject
            return self.get_parent_spatial_element(relationship.RelatingObject, name)
        return None

    def get_category_from_object(self, object, picklist):
        class_identification = None
        class_name = None
        for association in object.HasAssociations:
            if not association.is_a('IfcRelAssociatesClassification'):
                continue
            if not association.RelatingClassification.is_a('IfcClassificationReference'):
                continue
            if self.file.schema == 'IFC2X3':
                class_identification = association.RelatingClassification.ItemReference
            else:
                class_identification = association.RelatingClassification.Identification
            class_name = association.RelatingClassification.Name
            break
        if not class_identification or class_name:
            self.logger.error('The classification has invalid identification and name for {}'.format(object))
        result = '{}:{}'.format(class_identification, class_name)
        self.picklists[picklist].append(result)
        return result
        # The responsibility matrix lists a fallback, but it is a very
        # cumbersome check, and so it is not implemented here.

    def get_name_from_person(self, person, attribute):
        name = getattr(person, attribute)
        if not name.isalpha():
            self.logger.warning('The person\'s {} seems to be badly formatted ("{}") for {}'.format(attribute, name, person))
        return name if name else 'n/a'

    def get_attribute_from_address(self, address, attribute):
        result = getattr(address, attribute)
        if not result:
            self.logger.warning('The address {} seems to not exist for {}'.format(attribute, address))
            return 'n/a'
        return result

    def get_email_from_history(self, history):
        person = history.OwningUser.ThePerson
        organisation = history.OwningUser.TheOrganization
        email = self.get_email_from_person_or_organisation(person)
        if email:
            return email

        email = self.get_email_from_person_or_organisation(organisation)
        if email:
            return email

        given_name = person.GivenName if person.GivenName else "unknown"
        family_name = person.FamilyName if person.FamilyName else "unknown"
        organisation_name = organisation.Name if organisation.Name else "unknown"

        if given_name == 'unknown' \
            and family_name == 'unknown' \
            and organisation_name == 'unknown':
            self.logger.error('No primary key could be determined from {}'.format(history))

        return '{}{}@{}'.format(given_name, family_name, organisation_name)

    def get_postal_address_from_history(self, history):
        for address in (history.OwningUser.ThePerson.Addresses or []):
            if address.is_a('IfcPostalAddress'):
                return address
        for address in (history.OwningUser.TheOrganization.Addresses or []):
            if address.is_a('IfcPostalAddress'):
                return address
        return self.file.createIfcPostalAddress()

    def get_category_from_history(self, history):
        roles = []
        both = history.OwningUser
        person = both.ThePerson
        organisation = both.TheOrganization
        for role in ((both.Roles or []) + (person.Roles or []) + (organisation.Roles or [])):
            roles.append(self.get_role(role))
        result = ','.join(set(roles))
        if not result:
            self.logger.error('No roles could be found for {}'.format(history))
            return
        self.picklists['Category-Role'].append(result)
        return result

    def get_phone_from_history(self, history):
        person = history.OwningUser.ThePerson
        organisation = history.OwningUser.TheOrganization
        phone = self.get_phone_from_person_or_organisation(person)
        if phone:
            return phone
        phone = self.get_phone_from_person_or_organisation(organisation)
        if phone:
            return phone
        return 'n/a'

    def get_ext_object_from_history(self, history):
        result = history.OwningUser.is_a()
        self.picklists['objType'].append(result)
        return result

    def get_department_from_history(self, history):
        organisation = history.OwningUser.TheOrganization
        department = self.get_internal_location_from_organisation(organisation)
        if department:
            return department
        last_department = None
        for relationship in organisation.Relates:
            for related_organisation in relationship.RelatedOrganizations:
                department = self.get_internal_location_from_organisation(related_organisation)
                if department:
                    last_department = department
        if last_department:
            return last_department
        return history.OwningUser.TheOrganization.Name or 'n/a'

    def get_internal_location_from_organisation(self, organisation):
        for address in (organisation.Addresses or []):
            if address.is_a('IfcPostalAddress'):
                return address.InternalLocation
        self.logger.warning('An internal location was not found for {}'.format(organisation))

    def get_role(self, role):
        if role.Role == 'USERDEFINED':
            return role.UserDefinedRole
        return role.Role

    def get_phone_from_person_or_organisation(self, person_or_org):
        for address in (person_or_org.Addresses or []):
            if address.is_a('IfcTelecomAddress'):
                return address.TelephoneNumbers[0]
        self.logger.warning('A phone was not found for {}'.format(person_or_org))

    def get_email_from_person_or_organisation(self, person_or_org):
        for address in (person_or_org.Addresses or []):
            if address.is_a('IfcTelecomAddress'):
                return address.ElectronicMailAddresses[0]
        self.logger.warning('An email address was not found for {}'.format(person_or_org))

class CobieCsvWriter():
    def __init__(self, parser):
        self.parser = parser

    def write(self):
        self.write_file('Contact', self.parser.contacts, 'Email',
            ['Email', 'CreatedBy', 'CreatedOn', 'Category', 'Company',
            'Phone', 'ExtSystem', 'ExtObject', 'ExtIdentifier',
            'Department', 'OrganizationCode', 'GivenName', 'FamilyName',
            'Street', 'PostalBox', 'Town', 'StateRegion', 'PostalCode',
            'Country'])
        self.write_file('Facility', self.parser.facilities, 'Name',
            ['Name', 'CreatedBy', 'CreatedOn', 'Category', 'ProjectName',
            'SiteName', 'LinearUnits', 'AreaUnits', 'VolumeUnits', 'CostUnit',
            'AreaMeasurement', 'ExternalSystem', 'ExternalProjectObject',
            'ExternalProjectIdentifier', 'ExternalSiteObject',
            'ExternalSiteIdentifier', 'ExternalFacilityObject',
            'ExternalFacilityIdentifier', 'Description', 'ProjectDescription',
            'SiteDescription', 'Phase'])
        self.write_file('Floor', self.parser.floors, 'Name',
            ['Name', 'CreatedBy', 'CreatedOn', 'Category', 'ExtSystem',
            'ExtObject', 'ExtIdentifier', 'Description', 'Elevation', 'Height'])
        self.write_file('Space', self.parser.spaces, 'Name',
            ['Name', 'CreatedBy', 'CreatedOn', 'Category', 'FloorName',
            'Description', 'ExtSystem', 'ExtObject', 'ExtIdentifier', 'RoomTag',
            'UsableHeight', 'GrossArea', 'NetArea'])
        self.write_file('Zone', self.parser.zones, 'Name',
            ['Name', 'CreatedBy', 'CreatedOn', 'Category', 'SpaceNames',
            'ExtSystem', 'ExtObject', 'ExtIdentifier', 'Description',])
        self.write_file('Type', self.parser.types, 'Name',
            ['Name', 'CreatedBy', 'CreatedOn', 'Category', 'Description',
            'AssetType', 'Manufacturer', 'ModelNumber',
            'WarrantyGuarantorParts', 'WarrantyDurationParts',
            'WarrantyGuarantorLabor', 'WarrantyDurationLabor',
            'WarrantyDurationUnit', 'ExtSystem', 'ExtObject', 'ExtIdentifier',
            'ReplacementCost', 'ExpectedLife', 'DurationUnit', 'NominalLength',
            'NominalWidth', 'NominalHeight', 'ModelReference', 'Shape', 'Size',
            'Color', 'Finish', 'Grade', 'Material', 'Constituents', 'Features',
            'AccessibilityPerformance', 'CodePerformance',
            'SustainabilityPerformance',])
        self.write_file('Component', self.parser.components, 'Name',
            ['Name', 'CreatedBy', 'CreatedOn', 'TypeName', 'Space',
            'Description', 'ExtSystem', 'ExtObject', 'ExtIdentifier',
            'SerialNumber', 'InstallationDate', 'WarrantyStartDate',
            'TagNumber', 'BarCode', 'AssetIdentifier',])
        self.write_file('System', self.parser.systems, 'Name', 
            ['Name', 'CreatedBy', 'CreatedOn', 'Category', 'ComponentNames',
            'ExtSystem', 'ExtObject', 'ExtIdentifier', 'Description',])
        self.write_file('Assembly', self.parser.assemblies, 'Name',
            ['Name', 'CreatedBy', 'CreatedOn', 'SheetName', 'ParentName',
            'ChildNames', 'AssemblyType', 'ExtSystem', 'ExtObject',
            'ExtIdentifier', 'Description',])
        self.write_file('Connection', self.parser.connections, 'Name',
            ['Name', 'CreatedBy', 'CreatedOn', 'ConnectionType', 'SheetName',
            'RowName1', 'RowName2', 'RealizingElement', 'PortName1',
            'PortName2', 'ExtSystem', 'ExtObject', 'ExtIdentifier',
            'Description',])
        self.write_file('Spare', self.parser.spares, 'Name',
            ['Name', 'CreatedBy', 'CreatedOn', 'Category', 'TypeName',
            'Suppliers', 'ExtSystem', 'ExtObject', 'ExtIdentifier',
            'Description', 'SetNumber', 'PartNumber',])
        self.write_file('Resource', self.parser.resources, 'Name',
            ['Name', 'CreatedBy', 'CreatedOn', 'Category', 'ExtSystem',
            'ExtObject', 'ExtIdentifier', 'Description',])
        self.write_file('Job', self.parser.jobs, 'Name',
            ['Name', 'CreatedBy', 'CreatedOn', 'Category', 'Status', 'TypeName',
            'Description', 'Duration', 'DurationUnit', 'Start', 'TaskStartUnit',
            'Frequency', 'FrequencyUnit', 'ExtSystem', 'ExtObject',
            'ExtIdentifier', 'TaskNumber', 'Priors', 'ResourceNames',])
        self.write_file('Impact', self.parser.impacts, 'Name',
            ['Name', 'CreatedBy', 'CreatedOn', 'ImpactType', 'ImpactStage',
            'SheetName', 'RowName', 'Value', 'Unit', 'LeadInTime', 'Duration',
            'LeadOutTime', 'ExtSystem', 'ExtObject', 'ExtIdentifier',
            'Description',])
        self.write_file('Document', self.parser.documents, 'Name',
            ['Name', 'CreatedBy', 'CreatedOn', 'Category', 'ApprovalBy',
            'Stage', 'SheetName', 'RowName', 'Directory', 'File', 'ExtSystem',
            'ExtObject', 'ExtIdentifier', 'Description', 'Reference',])
        self.write_file('Attribute', self.parser.attributes, 'Name',
            ['Name', 'CreatedBy', 'CreatedOn', 'Category', 'SheetName',
            'RowName', 'Value', 'Unit', 'ExtSystem', 'ExtObject',
            'ExtIdentifier', 'Description', 'AllowedValues',])
        self.write_file('Coordinate', self.parser.coordinates, 'Name',
            ['Name', 'CreatedBy', 'CreatedOn', 'Category', 'SheetName',
            'RowName', 'CoordinateXAxis', 'CoordinateYAxis', 'CoordinateZAxis',
            'ExtSystem', 'ExtObject', 'ExtIdentifier', 'ClockwiseRotation',
            'ElevationalRotation', 'YawRotation',])
        self.write_file('Issue', self.parser.issues, 'Name',
            ['Name', 'CreatedBy', 'CreatedOn', 'Type', 'Risk', 'Chance',
            'Impact', 'SheetName1', 'RowName1', 'SheetName2', 'RowName2',
            'Description', 'Owner', 'Mitigation', 'ExtSystem', 'ExtObject',
            'ExtIdentifier',])

    def write_file(self, csv_name, data, primary_key, fieldnames):
        with open('C:/cygwin64/home/moud308/Projects/ifc2cobie/{}.csv'.format(csv_name), 'w', newline='') as file:
            writer = csv.DictWriter(file, fieldnames=fieldnames)
            writer.writeheader()
            for name, row in data.items():
                row[primary_key] = name
                writer.writerow(row)

class CobieXlsWriter(CobieCsvWriter):
    def write(self):
        self.colours = {
            'r': 'fdff8e', # Required
            'i': 'fdcd94', # Internal reference
            'e': 'cd95ff', # External reference
            'o': 'cdffc8', # Optional
            's': 'c0c0c0', # Secondary information
            'p': '9ccaff', # Project specific
            'n': '000000' # Not used
            }
        super().write()
        self.workbook = Workbook()
        self.workbook.remove(self.workbook.active)
        self.write_worksheet('Contact', self.colours['r'], 'ririrreeeoooooooooo')
        self.write_worksheet('Facility', self.colours['r'], 'ririrriiiireeeeeeeoooo')
        self.write_worksheet('Floor', self.colours['r'], 'ririeeeooo')
        self.write_worksheet('Space', self.colours['r'], 'ririireeeoooo')
        self.write_worksheet('Zone', self.colours['r'], 'ririieeeo')
        self.write_worksheet('Type', self.colours['r'], 'riririoooooooeeeooooooooooooooooooo')
        self.write_worksheet('Component', self.colours['r'], 'ririireeeoooooo')
        self.write_worksheet('System', self.colours['r'], 'ririieeeo')
        self.write_worksheet('Assembly', self.colours['r'], 'rirrrrreeeo')
        self.write_worksheet('Connection', self.colours['r'], 'ririiiiiiieeeo')
        self.write_worksheet('Spare', self.colours['r'], 'ririiieeeooo')
        self.write_worksheet('Resource', self.colours['r'], 'ririeeeo')
        self.write_worksheet('Job', self.colours['r'], 'ririiirriririeeeoii')
        self.write_worksheet('Impact', self.colours['r'], 'ririiiirioooeeeo')
        self.write_worksheet('Document', self.colours['r'], 'ririiiiirreeeoo')
        self.write_worksheet('Attribute', self.colours['r'], 'ririiirreeeoo')
        self.write_worksheet('Coordinate', self.colours['r'], 'ririiooooeeeooo')
        self.write_worksheet('Issue', self.colours['r'], 'ririooooooooooeee')
        self.workbook.save(filename='C:/cygwin64/home/moud308/Projects/ifc2cobie/out.xlsx')
        self.workbook.close()

    def write_worksheet(self, name, tab_colour, fill_map):
        worksheet = self.workbook.create_sheet(name)
        worksheet.sheet_properties.tabColor = tab_colour

        with open('C:/cygwin64/home/moud308/Projects/ifc2cobie/{}.csv'.format(name),
            'r') as f:
            reader = csv.reader(f)
            for r, row in enumerate(reader):
                for c, col in enumerate(row):
                    cell = worksheet.cell(column=c+1, row=r+1, value=col)
                    if r == 0:
                        cell.fill = PatternFill(fill_type='solid', fgColor=self.colours['s'])
                    else:
                        cell.fill = PatternFill(fill_type='solid', fgColor=self.colours[fill_map[c]])

start = time.time()
logging.basicConfig(
    filename='C:/cygwin64/home/moud308/Projects/ifc2cobie/process.log',
    filemode='a', level=logging.DEBUG)
logger = logging.getLogger('IFCtoCOBie')
logger.info('Starting conversion')
parser = IfcCobieParser(logger)
parser.parse()
#writer = CobieCsvWriter(parser)
#writer.write()
writer = CobieXlsWriter(parser)
writer.write()
logger.info('Finished conversion in {}s'.format(time.time() - start))