SEED-platform / seed / #44

pending completion

Build # #44

Build Type

push

travis-ci

Committed by

web-flow

Commit Message

<a href="https://github.com/SEED-platform/seed/commit/<a class=hub.com/SEED-platform/seed/commit/247d7566051bce5a2642e4a4d6593b63691dbc90">247d75660<a href="https://github.com/SEED-platform/seed/commit/247d7566051bce5a2642e4a4d6593b63691dbc90">">Merge </a><a class="double-link" href="https://github.com/SEED-platform/seed/commit/<a class="double-link" href="https://github.com/SEED-platform/seed/commit/f34046d3537b11b6f4e1c0f2f45674b61277411f">f34046d35</a>">f34046d35</a><a href="https://github.com/SEED-platform/seed/commit/247d7566051bce5a2642e4a4d6593b63691dbc90"> into d20c456f5">d20c456f5</a>

Run Details

161 of 1192 branches covered (13.51%)

Branch coverage included in aggregate %.

148 of 148 new or added lines in 11 files covered. (100.0%)

8546 of 15399 relevant lines covered (55.5%)

1.85 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

92.95

/seed/models/tax_lot_properties.py

# !/usr/bin/env python
# encoding: utf-8
"""
:copyright (c) 2014 - 2018, The Regents of the University of California, through Lawrence Berkeley National Laboratory (subject to receipt of any required approvals from the U.S. Department of Energy) and contributors. All rights reserved.  # NOQA
:author
"""
from __future__ import unicode_literals

import logging
from collections import defaultdict
from itertools import chain

from django.apps import apps
from django.db import models
from django.utils.timezone import make_naive
from seed.models.columns import Column

logger = logging.getLogger(__name__)


class TaxLotProperty(models.Model):
    property_view = models.ForeignKey('PropertyView')
    taxlot_view = models.ForeignKey('TaxLotView')
    cycle = models.ForeignKey('Cycle')

    # If there is a complex TaxLot/Property association, this field
    # lists the "main" tax lot that Properties should be reported under.
    # User controlled flag.
    primary = models.BooleanField(default=True)

    def __unicode__(self):
        return u'M2M Property View %s / TaxLot View %s' % (
            self.property_view_id, self.taxlot_view_id)

    class Meta:
        unique_together = ('property_view', 'taxlot_view',)
        index_together = [
            ['cycle', 'property_view'],
            ['cycle', 'taxlot_view'],
            ['property_view', 'taxlot_view']
        ]

    @classmethod
    def extra_data_to_dict_with_mapping(cls, instance, mappings, fields=None):
        """
        Convert the extra data to a dictionary with a name mapping for the keys

        :param instance: dict, the extra data dictionary
        :param mappings: dict, mapping names { "from_name": "to_name", ...}
        :param fields: list, extra data fields to include. Use the original column names (the ones in the database)
        :return: dict
        """
        data = {}
        for extra_data_field, extra_data_value in instance.items():
            if fields and extra_data_field not in fields:
                continue

            if extra_data_field in mappings:
                data[mappings[extra_data_field]] = extra_data_value
            else:
                data[extra_data_field] = extra_data_value

        return data

    @classmethod
    def model_to_dict_with_mapping(cls, instance, mappings, fields=None, exclude=None):
        """
        Copied from Django method and added a mapping for field names and excluding
        specific API fields.
        """
        from django.db import models
        opts = instance._meta
        data = {}
        for f in chain(opts.concrete_fields, opts.private_fields, opts.many_to_many):
            if not getattr(f, 'editable', False):
                continue
            if fields is not None and f.name not in fields:
                continue
            if exclude and f.name in exclude:
                continue
            if f.name in Column.EXCLUDED_COLUMN_RETURN_FIELDS:
                continue

            # fix specific time stamps
            if f.name in ['recent_sale_date', 'release_date', 'generation_date', 'analysis_start_time',
                          'analysis_end_time']:
                value = f.value_from_object(instance)
                if value:
                    value = make_naive(value).isoformat()
            else:
                value = f.value_from_object(instance)

            if f.name in mappings:
                data[mappings[f.name]] = value
            else:
                data[f.name] = value

            # Evaluate ManyToManyField QuerySets to prevent subsequent model
            # alteration of that field from being reflected in the data.
            if isinstance(f, models.ManyToManyField):
                data[f.name] = list(data[f.name])
        return data

    @classmethod
    def get_related(cls, object_list, show_columns, columns_from_database):
        """
        This method takes a list of TaxLotViews or PropertyViews and returns the data along
        with the related TaxLotView or PropertyView.

        The columns are the items as seen by the front end. This means that the columns
        are prepended with tax_ or property_ if they are the related columns.

        This method is just a copy/abstraction from the _get_filtered_results in the
        Property/TaxLot viewset.  In the future this should become a serializer. For now it is
        here so that we can use this method to create the data for exporting to CSV on the backend.

        :param object_list: list
        :param show_columns: list, columns (as defined by backend), Pass None to default to all columns
        :param columns_from_database: list, columns from the database as list of dict
        :return: list
        """
        results = []

        if len(object_list) == 0:
            return results

        if object_list[0].__class__.__name__ == 'PropertyView':
            lookups = {
                'obj_class': 'PropertyView',
                'obj_query_in': 'property_view_id__in',
                'obj_state_id': 'property_state_id',
                'obj_view_id': 'property_view_id',
                'obj_id': 'property_id',
                'related_class': 'TaxLotView',
                'select_related': 'taxlot',
                'related_view': 'taxlot_view',
                'related_view_id': 'taxlot_view_id',
                'related_state_id': 'taxlot_state_id',
            }
        else:
            lookups = {
                'obj_class': 'TaxLotView',
                'obj_query_in': 'taxlot_view_id__in',
                'obj_state_id': 'taxlot_state_id',
                'obj_view_id': 'taxlot_view_id',
                'obj_id': 'taxlot_id',
                'related_class': 'PropertyView',
                'select_related': 'property',
                'related_view': 'property_view',
                'related_view_id': 'property_view_id',
                'related_state_id': 'property_state_id',
            }

        # Ids of propertyviews to look up in m2m
        ids = [obj.pk for obj in object_list]
        joins = TaxLotProperty.objects.filter(**{lookups['obj_query_in']: ids}).select_related(lookups['related_view'])

        # Get all ids of tax lots on these joins
        related_ids = [getattr(j, lookups['related_view_id']) for j in joins]

        # Get all related views from the related_class
        related_views = apps.get_model('seed', lookups['related_class']).objects.select_related(
            lookups['select_related'], 'state', 'cycle').filter(pk__in=related_ids)

        related_columns = []
        related_column_name_mapping = {}
        obj_columns = []
        obj_column_name_mapping = {}
        for column in columns_from_database:
            if column['related']:
                related_columns.append(column)
                related_column_name_mapping[column['column_name']] = column['name']
            else:
                obj_columns.append(column)
                obj_column_name_mapping[column['column_name']] = column['name']

        related_map = {}

        if show_columns is None:
            filtered_fields = set([col['column_name'] for col in related_columns])
        else:
            filtered_fields = set([col['column_name'] for col in related_columns if col['id'] in show_columns])

        for related_view in related_views:
            related_dict = TaxLotProperty.model_to_dict_with_mapping(related_view.state,
                                                                     related_column_name_mapping,
                                                                     fields=filtered_fields,
                                                                     exclude=['extra_data'])

            related_dict[lookups['related_state_id']] = related_view.state.id

            # custom handling for when it is TaxLotView
            if lookups['obj_class'] == 'TaxLotView':
                if 'campus' in filtered_fields:
                    related_dict[related_column_name_mapping['campus']] = related_view.property.campus
                # Do not make these timestamps naive. They persist correctly.
                if 'updated' in filtered_fields:
                    related_dict[related_column_name_mapping['updated']] = related_view.property.updated
                if 'created' in filtered_fields:
                    related_dict[related_column_name_mapping['created']] = related_view.property.created
                # Replace the enumerations
                if 'analysis_state' in filtered_fields:
                    related_dict[
                        related_column_name_mapping['analysis_state']] = related_view.state.get_analysis_state_display()
            elif lookups['obj_class'] == 'PropertyView':
                # Do not make these timestamps naive. They persist correctly.
                if 'updated' in filtered_fields:
                    related_dict[related_column_name_mapping['updated']] = related_view.taxlot.updated
                if 'created' in filtered_fields:
                    related_dict[related_column_name_mapping['created']] = related_view.taxlot.created

            related_dict = dict(
                related_dict.items() +
                TaxLotProperty.extra_data_to_dict_with_mapping(
                    related_view.state.extra_data,
                    related_column_name_mapping, fields=show_columns
                ).items()
            )
            related_map[related_view.pk] = related_dict

            # Replace taxlot_view id with taxlot id
            related_map[related_view.pk]['id'] = getattr(related_view, lookups['select_related']).id

        # Not sure what this code is really doing, but it only exists for TaxLotViews
        if lookups['obj_class'] == 'TaxLotView':
            # Get whole taxlotstate table:
            tuple_prop_to_jurisdiction_tl = tuple(
                TaxLotProperty.objects.values_list('property_view_id', 'taxlot_view__state__jurisdiction_tax_lot_id')
            )

            # create a mapping that defaults to an empty list
            prop_to_jurisdiction_tl = defaultdict(list)

            # populate the mapping
            for name, pth in tuple_prop_to_jurisdiction_tl:
                prop_to_jurisdiction_tl[name].append(pth)

        # A mapping of object's view pk to a list of related state info for a related view
        join_map = {}
        for join in joins:
            # Another taxlot specific view
            if lookups['obj_class'] == 'TaxLotView':
                jurisdiction_tax_lot_ids = prop_to_jurisdiction_tl[join.property_view_id]

                # Filter out associated tax lots that are present but which do not have preferred
                none_in_jurisdiction_tax_lot_ids = None in jurisdiction_tax_lot_ids
                jurisdiction_tax_lot_ids = filter(lambda x: x is not None, jurisdiction_tax_lot_ids)

                if none_in_jurisdiction_tax_lot_ids:
                    jurisdiction_tax_lot_ids.append('Missing')

                join_dict = related_map[getattr(join, lookups['related_view_id'])].copy()
                join_dict.update({
                    # 'primary': 'P' if join.primary else 'S',
                    # 'calculated_taxlot_ids': '; '.join(jurisdiction_tax_lot_ids),
                    lookups['related_view_id']: getattr(join, lookups['related_view_id'])
                })

            else:
                join_dict = related_map[getattr(join, lookups['related_view_id'])].copy()
                join_dict.update({
                    # 'primary': 'P' if join.primary else 'S',
                    lookups['related_view_id']: getattr(join, lookups['related_view_id'])
                })

            join_dict['notes_count'] = getattr(join, lookups['related_view']).notes.count()

            # remove the measures from this view for now
            if join_dict.get('measures'):
                del join_dict['measures']

            try:
                join_map[getattr(join, lookups['obj_view_id'])].append(join_dict)
            except KeyError:
                join_map[getattr(join, lookups['obj_view_id'])] = [join_dict]

        if show_columns is None:
            filtered_fields = set([col['column_name'] for col in obj_columns])
        else:
            filtered_fields = set([col['column_name'] for col in obj_columns if col['id'] in show_columns])

        for obj in object_list:
            # Each object in the response is built from the state data, with related data added on.
            obj_dict = TaxLotProperty.model_to_dict_with_mapping(obj.state,
                                                                 obj_column_name_mapping,
                                                                 fields=filtered_fields,
                                                                 exclude=['extra_data'])

            obj_dict = dict(
                obj_dict.items() +
                TaxLotProperty.extra_data_to_dict_with_mapping(
                    obj.state.extra_data,
                    obj_column_name_mapping,
                    fields=show_columns
                ).items()
            )

            # Use property_id instead of default (state_id)
            obj_dict['id'] = getattr(obj, lookups['obj_id'])
            obj_dict['notes_count'] = obj.notes.count()

            obj_dict[lookups['obj_state_id']] = obj.state.id
            obj_dict[lookups['obj_view_id']] = obj.id

            # store the property / taxlot data to the object dictionary as well. This is hacky.
            if lookups['obj_class'] == 'PropertyView':
                if 'campus' in filtered_fields:
                    obj_dict[obj_column_name_mapping['campus']] = obj.property.campus
                # Do not make these timestamps naive. They persist correctly.
                if 'created' in filtered_fields:
                    obj_dict[obj_column_name_mapping['created']] = obj.property.created
                if 'updated' in filtered_fields:
                    obj_dict[obj_column_name_mapping['updated']] = obj.property.updated
                if 'analysis_state' in filtered_fields:
                    obj_dict[obj_column_name_mapping['analysis_state']] = obj.state.get_analysis_state_display()
            elif lookups['obj_class'] == 'TaxLotView':
                # Do not make these timestamps naive. They persist correctly.
                if 'updated' in filtered_fields:
                    obj_dict[obj_column_name_mapping['updated']] = obj.taxlot.updated
                if 'created' in filtered_fields:
                    obj_dict[obj_column_name_mapping['created']] = obj.taxlot.created

            # All the related tax lot states.
            obj_dict['related'] = join_map.get(obj.pk, [])

            # remove the measures from this view for now
            if obj_dict.get('measures'):
                del obj_dict['measures']

            label_string = []
            if hasattr(obj, 'property'):
                for label in obj.property.labels.all().order_by('name'):
                    label_string.append(label.name)
                obj_dict['property_labels'] = ','.join(label_string)

            elif hasattr(obj, 'taxlot'):
                for label in obj.taxlot.labels.all().order_by('name'):
                    label_string.append(label.name)
                obj_dict['taxlot_labels'] = ','.join(label_string)

            results.append(obj_dict)

        return results

1	# !/usr/bin/env python
2	# encoding: utf-8
3	"""	1✔
4	:copyright (c) 2014 - 2018, The Regents of the University of California, through Lawrence Berkeley National Laboratory (subject to receipt of any required approvals from the U.S. Department of Energy) and contributors. All rights reserved. # NOQA
5	:author
6	"""
7	from __future__ import unicode_literals	1✔
8
9	import logging	1✔
10	from collections import defaultdict	1✔
11	from itertools import chain	1✔
12
13	from django.apps import apps
14	from django.db import models
15	from django.utils.timezone import make_naive
16	from seed.models.columns import Column	1✔
17
18	logger = logging.getLogger(__name__)	1✔
19
20
21	class TaxLotProperty(models.Model):	1✔
22	property_view = models.ForeignKey('PropertyView')	1✔
23	taxlot_view = models.ForeignKey('TaxLotView')	1✔
24	cycle = models.ForeignKey('Cycle')	1✔
25
26	# If there is a complex TaxLot/Property association, this field
27	# lists the "main" tax lot that Properties should be reported under.
28	# User controlled flag.
29	primary = models.BooleanField(default=True)	1✔
30
31	def __unicode__(self):
32	return u'M2M Property View %s / TaxLot View %s' % (
33	self.property_view_id, self.taxlot_view_id)
34
35	class Meta:	1✔
36	unique_together = ('property_view', 'taxlot_view',)	1✔
37	index_together = [	1✔
38	['cycle', 'property_view'],
39	['cycle', 'taxlot_view'],
40	['property_view', 'taxlot_view']
41	]
42
43	@classmethod	1✔
44	def extra_data_to_dict_with_mapping(cls, instance, mappings, fields=None):	1✔
45	"""
46	Convert the extra data to a dictionary with a name mapping for the keys
47
48	:param instance: dict, the extra data dictionary
49	:param mappings: dict, mapping names { "from_name": "to_name", ...}
50	:param fields: list, extra data fields to include. Use the original column names (the ones in the database)
51	:return: dict
52	"""
53	data = {}	1✔
54	for extra_data_field, extra_data_value in instance.items():	1✔
55	if fields and extra_data_field not in fields:	1✔
56	continue	×
57
58	if extra_data_field in mappings:	1✔
59	data[mappings[extra_data_field]] = extra_data_value	1✔
60	else:
61	data[extra_data_field] = extra_data_value	1✔
62
63	return data	1✔
64
65	@classmethod	1✔
66	def model_to_dict_with_mapping(cls, instance, mappings, fields=None, exclude=None):	1✔
67	"""
68	Copied from Django method and added a mapping for field names and excluding
69	specific API fields.
70	"""
71	from django.db import models
72	opts = instance._meta	1✔
73	data = {}	1✔
74	for f in chain(opts.concrete_fields, opts.private_fields, opts.many_to_many):	1✔
75	if not getattr(f, 'editable', False):	1✔
76	continue	1✔
77	if fields is not None and f.name not in fields:	1✔
78	continue	1✔
79	if exclude and f.name in exclude:	1✔
80	continue	×
81	if f.name in Column.EXCLUDED_COLUMN_RETURN_FIELDS:	1✔
82	continue	×
83
84	# fix specific time stamps
85	if f.name in ['recent_sale_date', 'release_date', 'generation_date', 'analysis_start_time',	1✔
86	'analysis_end_time']:
87	value = f.value_from_object(instance)	1✔
88	if value:	1✔
89	value = make_naive(value).isoformat()	×
90	else:
91	value = f.value_from_object(instance)	1✔
92
93	if f.name in mappings:	1✔
94	data[mappings[f.name]] = value	1✔
95	else:
96	data[f.name] = value	×
97
98	# Evaluate ManyToManyField QuerySets to prevent subsequent model
99	# alteration of that field from being reflected in the data.
100	if isinstance(f, models.ManyToManyField):	1✔
101	data[f.name] = list(data[f.name])	×
102	return data	1✔
103
104	@classmethod	1✔
105	def get_related(cls, object_list, show_columns, columns_from_database):
106	"""
107	This method takes a list of TaxLotViews or PropertyViews and returns the data along
108	with the related TaxLotView or PropertyView.
109
110	The columns are the items as seen by the front end. This means that the columns
111	are prepended with tax_ or property_ if they are the related columns.
112
113	This method is just a copy/abstraction from the _get_filtered_results in the
114	Property/TaxLot viewset. In the future this should become a serializer. For now it is
115	here so that we can use this method to create the data for exporting to CSV on the backend.
116
117	:param object_list: list
118	:param show_columns: list, columns (as defined by backend), Pass None to default to all columns
119	:param columns_from_database: list, columns from the database as list of dict
120	:return: list
121	"""
122	results = []	1✔
123
124	if len(object_list) == 0:	1✔
125	return results	1✔
126
127	if object_list[0].__class__.__name__ == 'PropertyView':	1✔
128	lookups = {	1✔
129	'obj_class': 'PropertyView',
130	'obj_query_in': 'property_view_id__in',
131	'obj_state_id': 'property_state_id',
132	'obj_view_id': 'property_view_id',
133	'obj_id': 'property_id',
134	'related_class': 'TaxLotView',
135	'select_related': 'taxlot',
136	'related_view': 'taxlot_view',
137	'related_view_id': 'taxlot_view_id',
138	'related_state_id': 'taxlot_state_id',
139	}
140	else:
141	lookups = {	1✔
142	'obj_class': 'TaxLotView',
143	'obj_query_in': 'taxlot_view_id__in',
144	'obj_state_id': 'taxlot_state_id',
145	'obj_view_id': 'taxlot_view_id',
146	'obj_id': 'taxlot_id',
147	'related_class': 'PropertyView',
148	'select_related': 'property',
149	'related_view': 'property_view',
150	'related_view_id': 'property_view_id',
151	'related_state_id': 'property_state_id',
152	}
153
154	# Ids of propertyviews to look up in m2m
155	ids = [obj.pk for obj in object_list]	1✔
156	joins = TaxLotProperty.objects.filter(**{lookups['obj_query_in']: ids}).select_related(lookups['related_view'])	1✔
157
158	# Get all ids of tax lots on these joins
159	related_ids = [getattr(j, lookups['related_view_id']) for j in joins]	1✔
160
161	# Get all related views from the related_class
162	related_views = apps.get_model('seed', lookups['related_class']).objects.select_related(	1✔
163	lookups['select_related'], 'state', 'cycle').filter(pk__in=related_ids)
164
165	related_columns = []	1✔
166	related_column_name_mapping = {}	1✔
167	obj_columns = []	1✔
168	obj_column_name_mapping = {}	1✔
169	for column in columns_from_database:	1✔
170	if column['related']:	1✔
171	related_columns.append(column)	1✔
172	related_column_name_mapping[column['column_name']] = column['name']	1✔
173	else:
174	obj_columns.append(column)	1✔
175	obj_column_name_mapping[column['column_name']] = column['name']	1✔
176
177	related_map = {}	1✔
178
179	if show_columns is None:	1✔
180	filtered_fields = set([col['column_name'] for col in related_columns])	1✔
181	else:
182	filtered_fields = set([col['column_name'] for col in related_columns if col['id'] in show_columns])	1✔
183
184	for related_view in related_views:	1✔
185	related_dict = TaxLotProperty.model_to_dict_with_mapping(related_view.state,	1✔
186	related_column_name_mapping,
187	fields=filtered_fields,
188	exclude=['extra_data'])
189
190	related_dict[lookups['related_state_id']] = related_view.state.id	1✔
191
192	# custom handling for when it is TaxLotView
193	if lookups['obj_class'] == 'TaxLotView':	1✔
194	if 'campus' in filtered_fields:	1✔
195	related_dict[related_column_name_mapping['campus']] = related_view.property.campus	1✔
196	# Do not make these timestamps naive. They persist correctly.
197	if 'updated' in filtered_fields:	1✔
198	related_dict[related_column_name_mapping['updated']] = related_view.property.updated	1✔
199	if 'created' in filtered_fields:	1✔
200	related_dict[related_column_name_mapping['created']] = related_view.property.created	1✔
201	# Replace the enumerations
202	if 'analysis_state' in filtered_fields:	1✔
203	related_dict[	1✔
204	related_column_name_mapping['analysis_state']] = related_view.state.get_analysis_state_display()
205	elif lookups['obj_class'] == 'PropertyView':	1✔
206	# Do not make these timestamps naive. They persist correctly.
207	if 'updated' in filtered_fields:	1✔
208	related_dict[related_column_name_mapping['updated']] = related_view.taxlot.updated	1✔
209	if 'created' in filtered_fields:	1✔
210	related_dict[related_column_name_mapping['created']] = related_view.taxlot.created	1✔
211
212	related_dict = dict(	1✔
213	related_dict.items() +
214	TaxLotProperty.extra_data_to_dict_with_mapping(
215	related_view.state.extra_data,
216	related_column_name_mapping, fields=show_columns
217	).items()
218	)
219	related_map[related_view.pk] = related_dict	1✔
220
221	# Replace taxlot_view id with taxlot id
222	related_map[related_view.pk]['id'] = getattr(related_view, lookups['select_related']).id	1✔
223
224	# Not sure what this code is really doing, but it only exists for TaxLotViews
225	if lookups['obj_class'] == 'TaxLotView':	1✔
226	# Get whole taxlotstate table:
227	tuple_prop_to_jurisdiction_tl = tuple(	1✔
228	TaxLotProperty.objects.values_list('property_view_id', 'taxlot_view__state__jurisdiction_tax_lot_id')
229	)
230
231	# create a mapping that defaults to an empty list
232	prop_to_jurisdiction_tl = defaultdict(list)	1✔
233
234	# populate the mapping
235	for name, pth in tuple_prop_to_jurisdiction_tl:	1✔
236	prop_to_jurisdiction_tl[name].append(pth)	1✔
237
238	# A mapping of object's view pk to a list of related state info for a related view
239	join_map = {}	1✔
240	for join in joins:	1✔
241	# Another taxlot specific view
242	if lookups['obj_class'] == 'TaxLotView':	1✔
243	jurisdiction_tax_lot_ids = prop_to_jurisdiction_tl[join.property_view_id]	1✔
244
245	# Filter out associated tax lots that are present but which do not have preferred
246	none_in_jurisdiction_tax_lot_ids = None in jurisdiction_tax_lot_ids	1✔
247	jurisdiction_tax_lot_ids = filter(lambda x: x is not None, jurisdiction_tax_lot_ids)	1✔
248
249	if none_in_jurisdiction_tax_lot_ids:	1✔
250	jurisdiction_tax_lot_ids.append('Missing')	×
251
252	join_dict = related_map[getattr(join, lookups['related_view_id'])].copy()	1✔
253	join_dict.update({	1✔
254	# 'primary': 'P' if join.primary else 'S',
255	# 'calculated_taxlot_ids': '; '.join(jurisdiction_tax_lot_ids),
256	lookups['related_view_id']: getattr(join, lookups['related_view_id'])
257	})
258
259	else:
260	join_dict = related_map[getattr(join, lookups['related_view_id'])].copy()	1✔
261	join_dict.update({	1✔
262	# 'primary': 'P' if join.primary else 'S',
263	lookups['related_view_id']: getattr(join, lookups['related_view_id'])
264	})
265
266	join_dict['notes_count'] = getattr(join, lookups['related_view']).notes.count()	1✔
267
268	# remove the measures from this view for now
269	if join_dict.get('measures'):	1✔
270	del join_dict['measures']	×
271
272	try:	1✔
273	join_map[getattr(join, lookups['obj_view_id'])].append(join_dict)	1✔
274	except KeyError:	1✔
275	join_map[getattr(join, lookups['obj_view_id'])] = [join_dict]	1✔
276
277	if show_columns is None:	1✔
278	filtered_fields = set([col['column_name'] for col in obj_columns])	1✔
279	else:
280	filtered_fields = set([col['column_name'] for col in obj_columns if col['id'] in show_columns])	1✔
281
282	for obj in object_list:	1✔
283	# Each object in the response is built from the state data, with related data added on.
284	obj_dict = TaxLotProperty.model_to_dict_with_mapping(obj.state,	1✔
285	obj_column_name_mapping,
286	fields=filtered_fields,
287	exclude=['extra_data'])
288
289	obj_dict = dict(	1✔
290	obj_dict.items() +
291	TaxLotProperty.extra_data_to_dict_with_mapping(
292	obj.state.extra_data,
293	obj_column_name_mapping,
294	fields=show_columns
295	).items()
296	)
297
298	# Use property_id instead of default (state_id)
299	obj_dict['id'] = getattr(obj, lookups['obj_id'])	1✔
300	obj_dict['notes_count'] = obj.notes.count()	1✔
301
302	obj_dict[lookups['obj_state_id']] = obj.state.id	1✔
303	obj_dict[lookups['obj_view_id']] = obj.id	1✔
304
305	# store the property / taxlot data to the object dictionary as well. This is hacky.
306	if lookups['obj_class'] == 'PropertyView':	1✔
307	if 'campus' in filtered_fields:	1✔
308	obj_dict[obj_column_name_mapping['campus']] = obj.property.campus	1✔
309	# Do not make these timestamps naive. They persist correctly.
310	if 'created' in filtered_fields:	1✔
311	obj_dict[obj_column_name_mapping['created']] = obj.property.created	1✔
312	if 'updated' in filtered_fields:	1✔
313	obj_dict[obj_column_name_mapping['updated']] = obj.property.updated	1✔
314	if 'analysis_state' in filtered_fields:	1✔
315	obj_dict[obj_column_name_mapping['analysis_state']] = obj.state.get_analysis_state_display()	1✔
316	elif lookups['obj_class'] == 'TaxLotView':	1✔
317	# Do not make these timestamps naive. They persist correctly.
318	if 'updated' in filtered_fields:	1✔
319	obj_dict[obj_column_name_mapping['updated']] = obj.taxlot.updated	1✔
320	if 'created' in filtered_fields:	1✔
321	obj_dict[obj_column_name_mapping['created']] = obj.taxlot.created	1✔
322
323	# All the related tax lot states.
324	obj_dict['related'] = join_map.get(obj.pk, [])	1✔
325
326	# remove the measures from this view for now
327	if obj_dict.get('measures'):	1✔
328	del obj_dict['measures']	×
329
330	label_string = []	1✔
331	if hasattr(obj, 'property'):	1✔
332	for label in obj.property.labels.all().order_by('name'):	1✔
333	label_string.append(label.name)	×
334	obj_dict['property_labels'] = ','.join(label_string)	1✔
335
336	elif hasattr(obj, 'taxlot'):	1✔
337	for label in obj.taxlot.labels.all().order_by('name'):	1✔
338	label_string.append(label.name)	×
339	obj_dict['taxlot_labels'] = ','.join(label_string)	1✔
340
341	results.append(obj_dict)	1✔
342
343	return results	1✔

SEED-platform / seed / #44

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous