class LicenceResource(RalphModelResource):
manufacturer = fields.Field(
column_name='manufacturer',
attribute='manufacturer',
widget=ImportedForeignKeyWidget(assets.Manufacturer),
)
licence_type = fields.Field(
column_name='licence_type',
attribute='licence_type',
widget=ImportedForeignKeyWidget(LicenceType),
)
software = fields.Field(
column_name='software',
attribute='software',
widget=ImportedForeignKeyWidget(Software),
)
region = fields.Field(
column_name='region',
attribute='region',
widget=ImportedForeignKeyWidget(Region),
)
office_infrastructure = fields.Field(
column_name='office_infrastructure',
attribute='office_infrastructure',
widget=ImportedForeignKeyWidget(OfficeInfrastructure),
)
users = ThroughField(column_name='users',
attribute='users',
widget=UserManyToManyWidget(model=LicenceUser),
through_model=LicenceUser,
through_from_field_name='licence',
through_to_field_name='user')
base_objects = ThroughField(column_name='base_objects',
attribute='baseobjectlicence_set',
widget=ManyToManyThroughWidget(
model=BaseObjectLicence,
related_model=base.BaseObject,
through_field='base_object'),
through_model=BaseObjectLicence,
through_from_field_name='licence',
through_to_field_name='base_object')
class Meta:
model = Licence
prefetch_related = ('tags', )
exclude = (
'content_type',
'baseobject_ptr',
)
def get_queryset(self):
return Licence.objects_used_free_with_related.all()
def dehydrate_price(self, licence):
return str(licence.price)
class ServiceResource(RalphModelResource):
profit_center = fields.Field(
column_name='profit_center',
attribute='profit_center',
widget=ImportedForeignKeyWidget(assets.ProfitCenter),
)
business_owners = fields.Field(
column_name='business_owners',
attribute='business_owners',
widget=UserManyToManyWidget(get_user_model()),
)
technical_owners = fields.Field(
column_name='technical_owners',
attribute='technical_owners',
widget=UserManyToManyWidget(get_user_model()),
)
environments = ThroughField(
column_name='environments',
attribute='environments',
widget=widgets.ManyToManyWidget(model=assets.Environment),
through_model=assets.ServiceEnvironment,
through_from_field_name='service',
through_to_field_name='environment')
class Meta:
model = assets.Service
def test_users_through_field(self):
field = ThroughField(
through_model=LicenceUser,
through_from_field_name='licence',
through_to_field_name='user',
attribute='users',
column_name='users',
widget=UserManyToManyWidget(model=get_user_model()))
self.assertEqual(self.licence.users.all().count(), 3)
# Make sure it doesn't touch other licences
self.assertEqual(self.licence2.users.all().count(), 3)
# Add and remove
with self.assertNumQueries(4):
field.save(self.licence,
{'users': ','.join([i.username for i in self.users])})
self.assertEqual(self.licence.users.all().count(), 4)
# Not remove
users = self.users + [UserFactory()]
with self.assertNumQueries(3):
field.save(self.licence,
{'users': ','.join([i.username for i in users])})
self.assertEqual(self.licence.users.all().count(), 5)
# Remove
with self.assertNumQueries(3):
field.save(self.licence,
{'users': ','.join([i.username for i in users[:4]])})
self.assertEqual(self.licence.users.all().count(), 4)
# Update
with self.assertNumQueries(2):
field.save(self.licence,
{'users': ','.join([i.username for i in users[:4]])})
self.assertEqual(self.licence.users.all().count(), 4)
# Make sure it doesn't touch other licences
self.assertEqual(self.licence2.users.all().count(), 3)
class SupportResource(ResourceWithPrice, RalphModelResource):
support_type = fields.Field(
column_name='support_type',
attribute='support_type',
widget=ImportedForeignKeyWidget(SupportType),
)
base_objects = ThroughField(
column_name='base_objects',
attribute='baseobjectssupport_set',
widget=ManyToManyThroughWidget(
model=BaseObjectsSupport,
related_model=base.BaseObject,
through_field='baseobject'
),
through_model=BaseObjectsSupport,
through_from_field_name='support',
through_to_field_name='baseobject'
)
region = fields.Field(
column_name='region',
attribute='region',
widget=ImportedForeignKeyWidget(Region),
)
budget_info = fields.Field(
column_name='budget_info',
attribute='budget_info',
widget=ImportedForeignKeyWidget(assets.BudgetInfo),
)
property_of = fields.Field(
column_name='property_of',
attribute='property_of',
widget=ImportedForeignKeyWidget(assets.AssetHolder),
)
assigned_objects_count = fields.Field(
readonly=True,
column_name='assigned_objects_count',
attribute='assigned_objects_count',
)
class Meta:
model = Support
exclude = ('content_type', 'baseobject_ptr',)
prefetch_related = ('tags',)
def get_queryset(self):
return Support.objects_with_related.all()
def dehydrate_assigned_objects_count(self, support):
# this somehow ignores readonly flag, throwing AttributeError during
# import, but we need it only for export
try:
return support.assigned_objects_count
except AttributeError:
pass
def _get_base_objects_through_field(self):
return ThroughField(column_name='base_objects',
attribute='base_objects',
widget=ManyToManyThroughWidget(
model=BaseObjectLicence,
related_model=BaseObject,
through_field='base_object',
),
through_model=BaseObjectLicence,
through_from_field_name='licence',
through_to_field_name='base_object')