class SampleResource(resources.ModelResource):
parent_id = fields.Field(column_name='parent_id',
attribute='parent_id',
widget=widgets.ForeignKeyWidget(Sample, 'name'))
sub_sample_id = fields.Field(column_name='sub_sample_id',
attribute='sub_sample_id',
widget=widgets.ManyToManyWidget(Sample,
field='name'))
project = fields.Field(column_name='project',
attribute='project',
widget=widgets.ManyToManyWidget(Project,
field='name'))
class Meta:
model = Sample
exclude = ('id', 'created_at', 'updated_at')
import_id_fields = ['name']
skip_unchanged = True
report_skipped = False
fields = ('name', 'alias', 'sample_type', 'description', 'project',
'author', 'sequence', 'length', 'genbank',
'source_reference', 'comments', 'parent_id', 'organism',
'genus_specie', 'marker', 'application', 'strategy',
'seq_verified', 'origin_rep', 'cloning_system', 'strand',
'order_number', 'part_type', 'moclo_type', 'sub_sample_id',
'primer_id', 'end', 'direction', 'tm')
class ProgressResource(resources.ModelResource):
language = fields.Field("language", "language", widgets.ForeignKeyWidget(Language, "code"), None)
type = fields.Field("type", "type", widgets.ForeignKeyWidget(Document, "code"), None)
methods = fields.Field("methods", "methods", widgets.ManyToManyWidget(Method, ",", "name"), None)
partners = fields.Field("partners", "partners", widgets.ManyToManyWidget(Partner, ",", "name"), None)
class Meta:
model = Progress
fields = ("id", "language", "type", "is_online", "methods", "completion_rate", "completion_date", "qa_level",
"in_door43", "in_uw", "partners", "notes", "is_done")
class PlateResource(resources.ModelResource):
name = fields.Field(
column_name='well',
attribute='name',
)
plate = fields.Field(column_name='plate',
attribute='plate',
widget=widgets.ForeignKeyWidget(Plate, field='name'))
samples = fields.Field(column_name='samples',
attribute='samples',
widget=widgets.ManyToManyWidget(Sample,
field='name'))
alias = fields.Field(column_name='alias',
attribute='samples',
widget=widgets.ManyToManyWidget(Sample,
field='alias'))
# project = fields.Field(
# column_name='project',
# attribute='plate',
# widget=widgets.ManyToManyWidget(Plate, field='project')
# )
# def import_row(self, row, instance_loader, **kwargs):
# # overriding import_row to ignore errors and skip rows that fail to import
# # without failing the entire import
# import_result = super(PlateResource, self).import_row(row, instance_loader, **kwargs)
# if import_result.import_type == RowResult.IMPORT_TYPE_ERROR:
# # Copy the values to display in the preview report
# import_result.diff = [row[val] for val in row]
# # Add a column with the error message
# import_result.diff.append('Errors: {}'.format([err.error for err in import_result.errors]))
# # clear errors and mark the record to skip
# import_result.errors = []
# import_result.import_type = RowResult.IMPORT_TYPE_SKIP
#
# return import_result
class Meta:
exclude = ('id', )
import_id_fields = ['name', 'plate']
# skip_unchanged = True
# report_skipped = True
# raise_errors = False
model = Well
#TODO: Add project column in plate import export files
fields = ('name', 'plate', 'samples', 'alias', 'volume',
'concentration', 'active', 'status')
# export_order = ('plate', 'name', 'samples', 'volume', 'concentration', 'active', 'status')
def get_queryset(self):
return self.model.objects.all().order_by('name')
class EventAttendanceResource(resources.ModelResource):
email = AppendingField(column_name='email',
attribute='attendees',
widget=widgets.ManyToManyWidget(
Person, ',', 'email'))
event_uid = fields.Field(column_name='event_uid',
attribute='uid',
widget=widgets.CharWidget(),
saves_null_values=False)
event_instance_id = fields.Field(column_name='event_instance_id',
attribute='instance_id',
widget=widgets.CharWidget(),
saves_null_values=False)
def skip_row(self, instance, previous):
if instance.uid is None:
return True
return super(EventAttendanceResource,
self).skip_row(instance, previous)
class Meta:
model = Event
instance_loader_class = PartialMatchModelInstanceLoader
import_id_fields = ('event_uid', 'event_instance_id')
fields = ('uid', 'instance_id', 'attendees')
class ManifestResource(BaseContentResource):
"""
Resource for import/export of manifest entities
"""
blobs = fields.Field(
column_name="blobs",
attribute="blobs",
widget=widgets.ManyToManyWidget(Blob, field="digest"),
)
config_blob = fields.Field(
column_name="config_blob",
attribute="config_blob",
widget=widgets.ForeignKeyWidget(Blob, field="digest"),
)
def set_up_queryset(self):
"""
:return: Manifests specific to a specified repo-version.
"""
return Manifest.objects.filter(
pk__in=self.repo_version.content).order_by("content_ptr_id")
class Meta:
model = Manifest
exclude = BaseContentResource.Meta.exclude + ("listed_manifests", )
import_id_fields = model.natural_key_fields()
class CurriculumCourseResource(ModelResource):
class Meta:
model = CurriculumCourse
exclude = ('created_at', 'reg_number', 'inner_id')
id = Field(attribute='id', column_name='id', widget=UUIDWidget())
semester_number = Field(column_name='semester',
attribute='semester_number')
curriculum = fields.Field(column_name='kurikulum',
attribute='curriculum',
widget=widgets.ForeignKeyWidget(
Curriculum, 'code'))
course = fields.Field(column_name='mata_kuliah',
attribute='course',
widget=widgets.ForeignKeyWidget(Course, 'old_code'))
name = Field(column_name='nama_mk', readonly=True)
concentration = fields.Field(column_name='konsentrasi',
attribute='concentration',
widget=widgets.ManyToManyWidget(Concentration,
separator=',',
field='code'))
sks_graduate = Field(column_name='min_sks_lulus', attribute='sks_graduate')
def dehydrate_name(self, obj):
course = getattr(obj, 'course', None)
return '%s' % '' if not course else str(course.name)
class GroupResource(resources.ModelResource):
description = fields.Field(attribute='groupprofile__description',
widget=widgets.PostSaveWidget(widgets.CharWidget()),
readonly=False)
priority = fields.Field(attribute='groupprofile__priority',
widget=widgets.PostSaveWidget(widgets.IntegerWidget()),
readonly=False)
can_sms_notifications = fields.Field(attribute='groupprofile__can_sms_notifications',
widget=widgets.PostSaveWidget(widgets.BooleanWidget()),
readonly=False)
user_set = fields.Field(attribute='user_set',
widget=widgets.ManyToManyWidget(User, field='username', separator=','))
class Meta:
model = Group
fields = ('id', 'name',
'description', 'priority', 'can_sms_notifications', 'user_set')
export_order = ('id', 'name',
'description', 'priority', 'can_sms_notifications', 'user_set')
# save userprofile related fields
def after_post_save_instance(self, instance, row, using_transactions, dry_run):
instance.groupprofile.save()
class AddaResource(resources.ModelResource):
published = fields.Field(column_name='published', attribute='published')
is_sbi_approved = fields.Field(column_name='is_sbi_approved', attribute='is_sbi_approved')
location = fields.Field(column_name='location', attribute='location', widget=widgets.ForeignKeyWidget(Location, 'name'))
brand = fields.Field(column_name='brand', attribute='brand', widget=widgets.ForeignKeyWidget(Brand, 'name'))
category = fields.Field(column_name='category', attribute='category', widget=widgets.ForeignKeyWidget(Category, 'name'))
possession = fields.Field(column_name='possession', attribute='possession', widget=widgets.ForeignKeyWidget(Possession, 'name'))
configuration = fields.Field(column_name='configuration', attribute='configuration', widget=widgets.ManyToManyWidget(Configuration, ',', 'name'))
fuel_type = fields.Field(column_name='fuel_type', attribute='fuel_type', widget=widgets.ForeignKeyWidget(FuelType, 'name'))
two_wheeler_categories = fields.Field(column_name='two_wheeler_categories', attribute='two_wheeler_categories', widget=widgets.ForeignKeyWidget(TwoWheelerCategory, 'name'))
two_wheeler_transmission = fields.Field(column_name='two_wheeler_transmission', attribute='two_wheeler_transmission', widget=widgets.ForeignKeyWidget(TwoWheelerTransmission, 'name'))
four_wheeler_type = fields.Field(column_name='four_wheeler_type', attribute='four_wheeler_type', widget=widgets.ForeignKeyWidget(FourWheelerCategory, 'name'))
four_wheeler_transmission = fields.Field(column_name='four_wheeler_transmission', attribute='four_wheeler_transmission', widget=widgets.ForeignKeyWidget(FourWheelerTransmission, 'name'))
tags = fields.Field(column_name='tags', attribute='tags', widget=widgets.ManyToManyWidget(Tag, ',', 'name'))
class Meta:
model = Adda
skip_unchanged = True
report_skipped = False
fields = ('id', 'title', 'published', 'is_sbi_approved', 'short_description', 'rich_text_description', 'featured_image',
'address', 'location', 'state', 'country', 'virtual_tour_link', 'brochure_link', 'price_sheet_link', 'market_price',
'brand', 'category', 'joined_users', 'favorited_users', 'possession', 'possession_date', 'configuration', 'ex_showroom_price', 'fuel_type', 'two_wheeler_categories', 'two_wheeler_transmission',
'two_wheeler_max_power', 'four_wheeler_type', 'four_wheeler_transmission', 'four_wheeler_bhp', 'mileage', 'tags')
export_order = ('id', 'title', 'published', 'is_sbi_approved', 'short_description', 'rich_text_description', 'featured_image',
'address', 'location', 'state', 'country', 'virtual_tour_link', 'brochure_link', 'price_sheet_link', 'market_price',
'brand', 'category', 'joined_users', 'favorited_users', 'possession', 'possession_date', 'configuration', 'ex_showroom_price', 'fuel_type', 'two_wheeler_categories', 'two_wheeler_transmission',
'two_wheeler_max_power', 'four_wheeler_type', 'four_wheeler_transmission', 'four_wheeler_bhp', 'mileage', 'tags')
class UserResource(resources.ModelResource):
name = fields.Field(attribute='profile__name')
about = fields.Field(attribute='profile__about')
organizations = fields.Field(widget=widgets.ManyToManyWidget(model=Organization, field='key'),
attribute='profile__organizations')
_profile = Profile()
def init_instance(self, row=None):
usr = super(UserResource, self).init_instance(row)
usr.is_active = True
self._profile.language = Language.objects.get(key=DEFAULT_USER_LANGUAGE)
usr.profile = self._profile
return usr
def before_save_instance(self, instance, using_transactions, dry_run):
if not using_transactions and dry_run:
# we don't have transactions and we want to do a dry_run
pass
else:
instance.set_password(instance.password)
def after_save_instance(self, instance, using_transactions, dry_run):
if not using_transactions and dry_run:
# we don't have transactions and we want to do a dry_run
pass
else:
Profile.objects.update_or_create(user=instance, defaults=self._profile)
class Meta:
model = User
fields = ('username', 'password', 'email',)
export_order = ('username', 'email', 'name', 'about', 'organizations')
import_id_fields = ('username',)
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
class BookM2MResource(resources.ModelResource):
categories = fields.Field(attribute='categories',
widget=widgets.ManyToManyWidget(
Category,
field='name',
separator='|'))
class Meta:
model = Book
class LogBookResource(resources.ModelResource):
project = fields.Field(column_name='project',
attribute='project',
widget=widgets.ManyToManyWidget(Project,
field='name'))
class Meta:
model = LogBook
fields = ('user', 'supervisor', 'time_used', 'comments', 'machine')
class EquipmentSetResource(resources.ModelResource):
equipmentitem_set = fields.Field(attribute='equipmentitem_set',
widget=widgets.ManyToManyWidget(
Equipment, field='id', separator=','))
class Meta:
model = EquipmentSet
fields = ('id', 'name', 'type', 'default')
export_order = ('id', 'name', 'type', 'default')
class InstitutionResource(resources.ModelResource):
tags = resources.Field(
attribute="tags",
column_name="tags",
widget=widgets.ManyToManyWidget(Tag, field="name"),
)
class Meta:
model = Institution
fields = ["name", "comment", "id"]
class OperationResource(RalphModelResource):
type = fields.Field(
column_name='type',
attribute='type',
widget=ImportedForeignKeyWidget(OperationType),
)
base_objects = fields.Field(
column_name='base_objects',
attribute='base_objects',
widget=widgets.ManyToManyWidget(model=base.BaseObject),
default=[],
)
assignee = fields.Field(
column_name='assignee',
attribute='assignee',
widget=UserWidget(get_user_model()),
)
reporter = fields.Field(
column_name='reporter',
attribute='reporter',
widget=UserWidget(get_user_model()),
)
service_name = fields.Field(
column_name='base_objects_service_names',
attribute='base_objects',
widget=BaseObjectServiceNamesM2MWidget(model=base.BaseObject),
default=[],
readonly=True
)
service_name._skip_str_field = True
class Meta:
select_related = (
'assignee', 'reporter', 'type', 'status'
)
prefetch_related = (
'tags',
Prefetch(
lookup='base_objects',
queryset=BaseObject.polymorphic_objects.polymorphic_filter(
operations__in=Operation.objects.all()
).select_related(
'service_env',
'service_env__service',
'service_env__environment'
).polymorphic_select_related(
Cluster=['type'],
ServiceEnvironment=['service', 'environment']
)
)
)
model = Operation
class EntityAttrResource(AironeModelResource):
_IMPORT_INFO = {
'header': [
'id', 'name', 'type', 'refer', 'entity', 'created_user',
'is_mandatory'
],
'mandatory_keys': ['name', 'type', 'entity', 'created_user'],
'resource_module':
'entity.admin',
'resource_model_name':
'EntityAttrResource',
}
COMPARING_KEYS = [
'name', 'is_mandatory', 'referral', 'parent_entity', 'created_user'
]
DISALLOW_UPDATE_KEYS = ['parent_entity', 'created_user']
user = fields.Field(column_name='created_user',
attribute='created_user',
widget=widgets.ForeignKeyWidget(User, 'username'))
refer = fields.Field(column_name='refer',
attribute='referral',
widget=widgets.ManyToManyWidget(model=ACLBase,
field='name'))
entity = fields.Field(column_name='entity',
attribute='parent_entity',
widget=widgets.ForeignKeyWidget(model=Entity,
field='name'))
class Meta:
model = EntityAttr
fields = ('id', 'name', 'type', 'is_mandatory')
def after_save_instance(self, instance, using_transactions, dry_run):
# If a new EntityAttr object is created,
# this processing append it to the associated Entity object.
if not dry_run:
entity = instance.parent_entity
if not entity.attrs.filter(id=instance.id).exists():
entity.attrs.add(instance)
def import_obj(self, instance, data, dry_run):
if not Entity.objects.filter(name=data['entity']).exists():
raise RuntimeError('failed to identify entity object')
if data['refer'] and not Entity.objects.filter(
name=data['refer']).exists():
raise RuntimeError('refer to invalid entity object')
super(EntityAttrResource, self).import_obj(instance, data, dry_run)
class UserResource(ModelResource):
class Meta:
model = get_user_model()
fields = ('id', 'first_name', 'username', 'email', 'is_active',
'is_student', 'is_teacher', 'is_employee', 'is_management',
'is_matriculant', 'is_applicant')
id = Field(attribute='id', column_name='id', widget=UUIDWidget())
first_name = Field(column_name='full_name', attribute='first_name')
email = Field(column_name='email', attribute='email')
new_password = Field(column_name='new_password', attribute='new_password')
confirm_password = Field(column_name='confirm_password',
attribute='confirm_password')
password = Field(column_name='password',
attribute='password',
readonly=True)
groups = fields.Field(column_name='group',
attribute='groups',
widget=widgets.ManyToManyWidget(Group,
separator=',',
field='name'))
def check_confirm_password(self, psw, confirm):
return psw == confirm
def get_or_init_instance(self, instance_loader, row):
"""
Either fetches an already existing user or initializes a new one.
"""
new_password = row.pop('new_password')
confirm_password = row.pop('confirm_password')
if new_password != confirm_password:
raise ValueError(_("Password doesn't match !"))
instance = self.get_instance(instance_loader, row)
if instance:
instance.new_password = new_password
instance.confirm_password = confirm_password
return (instance, False)
else:
new_instance = self.init_instance(row)
new_instance.new_password = new_password
new_instance.confirm_password = confirm_password
return (new_instance, True)
def before_save_instance(self, instance, using_transactions, dry_run):
"""
Set password if new one is available
"""
if instance.new_password not in ['', None]:
validate_password(instance.new_password, instance)
instance.set_password(instance.new_password)
class RosterResource(resources.ModelResource):
user_name = fields.Field(column_name='User Name',
attribute='user',
widget=widgets.ForeignKeyWidget(
auth.models.User, 'username'))
semester_name = fields.Field(column_name='Semester Name',
attribute='semester',
widget=widgets.ForeignKeyWidget(
core.models.Semester, 'name'))
unit_list = fields.Field(column_name='Unit List',
attribute='curriculum',
widget=widgets.ManyToManyWidget(core.models.Unit,
separator=';'))
class ProductResource(resources.ModelResource):
class Meta:
model = Product
exclude = ('parent', 'slug', 'modified', 'lft', 'rght', 'tree_id', 'level')
title = Field(attribute='title', column_name='Title')
slug = Field(attribute='slug', column_name='slug')
short_description = Field(attribute='short_description', column_name='short_description')
general_description = Field(attribute='general_description', column_name='general_description')
func_description = Field(attribute='func_description', column_name='func_description')
tech_description = Field(attribute='tech_description', column_name='tech_description')
meta_keywords = Field(attribute='meta_keywords', column_name='meta_keywords')
meta_description = Field(attribute='meta_description', column_name='meta_description')
qualifier = Field(attribute='qualifier', column_name='qualifier')
rub_price = Field()
usd_price = Field()
eur_price = Field()
prices = Field(
attribute='prices',
widget=widgets.ManyToManyWidget(
ProductXCurrency,
field='price',
separator='|')
)
def save(self, commit=True):
rub_price = self.cleaned_data.get('rub_price', None)
# ...do something with extra_field here...
return super(ProductResource, self).save(commit=commit)
def dehydrate_rub_price(self, product: Product):
rub_price = product.prices.filter(currency_id='RUB').first()
return getattr(rub_price, 'price', '-')
def dehydrate_usd_price(self, product: Product):
usd_price = product.prices.filter(currency_id='USD').first()
return getattr(usd_price, 'price', '-')
def dehydrate_eur_price(self, product: Product):
eur_price = product.prices.filter(currency_id='EUR').first()
return getattr(eur_price, 'price', '-')
class DCHostResource(RalphModelResource):
hostname = fields.Field(
readonly=True,
column_name='hostname',
attribute='hostname',
)
service_env = fields.Field(
column_name='service_env',
attribute='service_env',
widget=AssetServiceEnvWidget(assets.ServiceEnvironment, 'name'),
)
ips = fields.Field(
column_name='ip_addresses',
attribute='ipaddresses',
widget=widgets.ManyToManyWidget(model=networks.IPAddress),
)
class Meta:
model = hosts.DCHost
exclude = ('parent', )
class StudentIEResource(RosterResource):
semester_name = fields.Field(column_name='Semester Name',
attribute='semester',
widget=widgets.ForeignKeyWidget(
Semester, 'name'))
unit_list = fields.Field(column_name='Unit List',
attribute='curriculum',
widget=widgets.ManyToManyWidget(Unit,
separator=';'))
class Meta:
skip_unchanged = True
model = Student
fields = (
'id',
'user__first_name',
'user__last_name',
'user__email',
'semester_name',
'user_name',
'track',
'legit',
)
export_order = fields
class TeacherResource(ModelResource):
class Meta:
model = Teacher
fields = ('id', 'account', 'tid', 'rmu', 'courses', 'is_active')
id = Field(attribute='id', column_name='id', widget=UUIDWidget())
name = Field(column_name='name', readonly=True)
tid = Field(column_name='nidn', attribute='tid')
account = fields.Field(column_name='email_account',
attribute='account',
widget=widgets.ForeignKeyWidget(
get_user_model(), 'email'))
rmu = fields.Field(column_name='program_studi',
attribute='rmu',
widget=widgets.ForeignKeyWidget(ManagementUnit, 'code'))
courses = fields.Field(column_name='mata_kuliah',
attribute='courses',
widget=widgets.ManyToManyWidget(Course,
separator=',',
field='old_code'))
def dehydrate_name(self, obj):
account = getattr(obj, 'account', None)
return '%s' % account
def setUp(self):
self.widget = widgets.ManyToManyWidget(Category)
self.widget_name = widgets.ManyToManyWidget(Category, field="name")
self.cat1 = Category.objects.create(name=u'Cat úňíčóďě')
self.cat2 = Category.objects.create(name='Cat 2')
class EntityAttrResource(AironeModelResource):
_IMPORT_INFO = {
"header": [
"id",
"name",
"type",
"refer",
"entity",
"created_user",
"is_mandatory",
],
"mandatory_keys": ["name", "entity", "created_user"],
"resource_module":
"entity.admin",
"resource_model_name":
"EntityAttrResource",
}
COMPARING_KEYS = [
"name",
"is_mandatory",
"referral",
"parent_entity",
"created_user",
]
DISALLOW_UPDATE_KEYS = ["parent_entity", "created_user"]
user = fields.Field(
column_name="created_user",
attribute="created_user",
widget=widgets.ForeignKeyWidget(User, "username"),
)
refer = fields.Field(
column_name="refer",
attribute="referral",
widget=widgets.ManyToManyWidget(model=Entity, field="name"),
)
entity = fields.Field(
column_name="entity",
attribute="parent_entity",
widget=widgets.ForeignKeyWidget(model=Entity, field="name"),
)
class Meta:
model = EntityAttr
fields = ("id", "name", "type", "is_mandatory")
def after_save_instance(self, instance, using_transactions, dry_run):
# If a new EntityAttr object is created,
# this processing append it to the associated Entity object.
if not dry_run:
entity = instance.parent_entity
if not entity.attrs.filter(id=instance.id).exists():
entity.attrs.add(instance)
def import_obj(self, instance, data, dry_run):
if not Entity.objects.filter(name=data["entity"]).exists():
raise RuntimeError("failed to identify entity object")
if data["refer"] and not all([
Entity.objects.filter(name=x).exists()
for x in data["refer"].split(",")
]):
raise RuntimeError("refer to invalid entity object")
# The processing fails when 'type' parameter is not existed for creating a new instance
if not instance.pk and not data["type"]:
raise RuntimeError(
"The parameter 'type' is mandatory when a new EntityAtter create"
)
# Set event handler for custom-view. When it returns not None, then it abort to import.
if custom_view.is_custom("import_entity_attr"):
error = custom_view.call_custom("import_entity_attr", None,
instance, data)
if error:
raise RuntimeError(error)
# Do not allow to change type when instance is already created
if instance.pk:
data["type"] = instance.type
super(EntityAttrResource, self).import_obj(instance, data, dry_run)
def setUp(self):
self.widget = widgets.ManyToManyWidget(Category)
self.cat1 = Category.objects.create(name='Cat 1')
self.cat2 = Category.objects.create(name='Cat 2')
class EntityAttrResource(AironeModelResource):
_IMPORT_INFO = {
'header': [
'id', 'name', 'type', 'refer', 'entity', 'created_user',
'is_mandatory'
],
'mandatory_keys': ['name', 'entity', 'created_user'],
'resource_module':
'entity.admin',
'resource_model_name':
'EntityAttrResource',
}
COMPARING_KEYS = [
'name', 'is_mandatory', 'referral', 'parent_entity', 'created_user'
]
DISALLOW_UPDATE_KEYS = ['parent_entity', 'created_user']
user = fields.Field(column_name='created_user',
attribute='created_user',
widget=widgets.ForeignKeyWidget(User, 'username'))
refer = fields.Field(column_name='refer',
attribute='referral',
widget=widgets.ManyToManyWidget(model=Entity,
field='name'))
entity = fields.Field(column_name='entity',
attribute='parent_entity',
widget=widgets.ForeignKeyWidget(model=Entity,
field='name'))
class Meta:
model = EntityAttr
fields = ('id', 'name', 'type', 'is_mandatory')
def after_save_instance(self, instance, using_transactions, dry_run):
# If a new EntityAttr object is created,
# this processing append it to the associated Entity object.
if not dry_run:
entity = instance.parent_entity
if not entity.attrs.filter(id=instance.id).exists():
entity.attrs.add(instance)
def import_obj(self, instance, data, dry_run):
if not Entity.objects.filter(name=data['entity']).exists():
raise RuntimeError('failed to identify entity object')
if data['refer'] and not all([
Entity.objects.filter(name=x).exists()
for x in data['refer'].split(',')
]):
raise RuntimeError('refer to invalid entity object')
# The processing fails when 'type' parameter is not existed for creating a new instance
if not instance.pk and not data['type']:
raise RuntimeError(
"The parameter 'type' is mandatory when a new EntityAtter create"
)
# Set event handler for custom-view. When it returns not None, then it abort to import.
if custom_view.is_custom('import_entity_attr'):
error = custom_view.call_custom('import_entity_attr', None,
instance, data)
if error:
raise RuntimeError(error)
# Do not allow to change type when instance is already created
if instance.pk:
data['type'] = instance.type
super(EntityAttrResource, self).import_obj(instance, data, dry_run)
class ProductResource(VerboseNameModelResource):
brand = Field(attribute='brand',
column_name='Бренд',
widget=widgets.ForeignKeyWidget(Brand, field='code'))
enable = Field(attribute='enable',
column_name='Показывать',
widget=MyBooleanWidget())
categories = Field(attribute='categories',
column_name='Категории',
widget=widgets.ManyToManyWidget(Category,
field='full_name',
separator='\n'))
description = TranslatableField(attribute='description',
column_name="Описание",
widget=widgets.JSONWidget(),
saves_null_values=False)
content = TranslatableField(attribute='content',
column_name="Состав",
widget=widgets.JSONWidget(),
saves_null_values=False)
thumbnail = Field(
attribute='thumbnail',
column_name='Превью',
# widget=widgets.ForeignKeyWidget(MediaFile, field='link')
widget=MyGetForeignKeyWidget(MediaFile, field='link'))
media_files = Field(
attribute='media_files',
column_name='Медиа файлы',
# widget=widgets.ManyToManyWidget(MediaFile, field='link', separator='\n')
widget=MyGetManyToManyWidget(MediaFile, field='link', separator='\n'))
video_files = Field(
attribute='video_files',
column_name='Видео',
# widget=widgets.ManyToManyWidget(MediaFile, field='link', separator='\n')
widget=MyGetManyToManyWidget(MediaFile, field='link', separator='\n'))
def get_locales(self, product, order=("ru", "en")):
available_locales = product.get_available_languages(
include_unsaved=True)
export_order = order + tuple(
l for l in available_locales if l not in order)
return [l for l in export_order if l in available_locales]
def dehydrate_description(self, product):
return {
loc: product.safe_translation_getter('description',
language_code=loc)
for loc in self.get_locales(product)
}
def dehydrate_content(self, product):
return {
loc: product.safe_translation_getter('content', language_code=loc)
for loc in self.get_locales(product)
}
class Meta:
model = Product
skip_unchanged = False
report_skipped = True
import_id_fields = ('sku', )
exclude = ('id', )
widgets = {
'pub_date': {
'format': '%d.%m.%y %H:%M'
},
'mod_date': {
'format': '%d.%m.%y %H:%M'
},
}
fields = (
'sku',
'model',
'brand',
'enable',
'categories',
'description',
'content',
'thumbnail',
'media_files',
'video_files',
'price',
)
export_order = fields
class AttrValueResource(AironeModelResource):
_IMPORT_INFO = {
"header": [
"id",
"refer",
"value",
"attribute_id",
"created_time",
"created_user",
"status",
"data_arr",
],
"mandatory_keys": ["id", "attribute_id", "created_user", "status"],
"resource_module": "entry.admin",
"resource_model_name": "AttrValueResource",
}
COMPARING_KEYS = []
DISALLOW_UPDATE_KEYS = [
"created_time",
"created_user",
"parent_attr",
"value",
"referral",
"status",
]
attr_id = fields.Field(
column_name="attribute_id",
attribute="parent_attr",
widget=widgets.ForeignKeyWidget(model=Attribute, field="id"),
)
refer = fields.Field(
column_name="refer",
attribute="referral",
widget=widgets.ForeignKeyWidget(model=ACLBase, field="id"),
)
user = fields.Field(
column_name="created_user",
attribute="created_user",
widget=widgets.ForeignKeyWidget(User, "username"),
)
data_arr = fields.Field(
column_name="data_arr",
attribute="data_array",
widget=widgets.ManyToManyWidget(model=AttributeValue, field="id"),
)
class Meta:
model = AttributeValue
fields = ("id", "name", "value", "created_time", "status")
skip_unchanged = True
instance_loader_class = CachedInstanceLoader
def after_save_instance(self, instance, using_transactions, dry_run):
# If a new AttributeValue object is created,
# this processing append it to the associated Entity object.
self._saved_instance = None
if not dry_run:
attr = instance.parent_attr
# register data_type parameter which is same with EntityAttr's type
instance.data_type = attr.schema.type
if not attr.values.filter(id=instance.id).exists() and (
not attr.schema.type & AttrTypeValue["array"]
or (
attr.schema.type & AttrTypeValue["array"]
and instance.get_status(AttributeValue.STATUS_DATA_ARRAY_PARENT)
)
):
# clear is_latest flag of old attrs and set it to new one.
instance.is_latest = True
attr.values.add(instance)
attr.unset_latest_flag(exclude_id=instance.id)
# the case of leaf AttributeValue
elif attr.schema.type & AttrTypeValue["array"] and not instance.get_status(
AttributeValue.STATUS_DATA_ARRAY_PARENT
):
# For a leaf AttributeValue, 'is_latest' flag will not be set.
# Instaed, these objects have
# parent_attrv parameter to identify parent AttributeValue.
instance.is_latest = False
instance.parent_attrv = attr.get_latest_value()
instance.save(update_fields=["is_latest", "data_type", "parent_attrv"])
self._saved_instance = instance
attr.parent_entry.register_es()
@classmethod
def after_import_completion(self, results):
# make relation between the array of AttributeValue
for data in [
x["data"]
for x in results
if x["data"]["status"] & AttributeValue.STATUS_DATA_ARRAY_PARENT
]:
attr_value = AttributeValue.objects.get(id=data["id"])
for child_id in [int(x) for x in data["data_arr"].split(",")]:
if (
AttributeValue.objects.filter(id=child_id).exists()
and not attr_value.data_array.filter(id=child_id).exists()
):
# append related AttributeValue if it's not existed
attr_value.data_array.add(AttributeValue.objects.get(id=child_id))
attr_value.parent_attr.parent_entry.register_es()
class AttrValueResource(AironeModelResource):
_IMPORT_INFO = {
'header': [
'id', 'refer', 'value', 'attribute_id', 'created_time',
'created_user', 'status', 'data_arr'
],
'mandatory_keys': ['id', 'attribute_id', 'created_user', 'status'],
'resource_module':
'entry.admin',
'resource_model_name':
'AttrValueResource',
}
COMPARING_KEYS = []
DISALLOW_UPDATE_KEYS = [
'created_time', 'created_user', 'parent_attr', 'value', 'referral',
'status'
]
attr_id = fields.Field(column_name='attribute_id',
attribute='parent_attr',
widget=widgets.ForeignKeyWidget(model=Attribute,
field='id'))
refer = fields.Field(column_name='refer',
attribute='referral',
widget=widgets.ForeignKeyWidget(model=ACLBase,
field='id'))
user = fields.Field(column_name='created_user',
attribute='created_user',
widget=widgets.ForeignKeyWidget(User, 'username'))
data_arr = fields.Field(column_name='data_arr',
attribute='data_array',
widget=widgets.ManyToManyWidget(
model=AttributeValue, field='id'))
class Meta:
model = AttributeValue
fields = ('id', 'name', 'value', 'created_time', 'status')
skip_unchanged = True
instance_loader_class = CachedInstanceLoader
def after_save_instance(self, instance, using_transactions, dry_run):
# If a new AttributeValue object is created,
# this processing append it to the associated Entity object.
self._saved_instance = None
if not dry_run:
attr = instance.parent_attr
# register data_type parameter which is same with EntityAttr's type
instance.data_type = attr.schema.type
if (not attr.values.filter(id=instance.id).exists()
and (not attr.schema.type & AttrTypeValue['array'] or
(attr.schema.type & AttrTypeValue['array']
and instance.get_status(
AttributeValue.STATUS_DATA_ARRAY_PARENT)))):
# clear is_latest flag of old attrs and set it to new one.
instance.is_latest = True
attr.values.add(instance)
attr.unset_latest_flag(exclude_id=instance.id)
# the case of leaf AttributeValue
elif (attr.schema.type & AttrTypeValue['array']
and not instance.get_status(
AttributeValue.STATUS_DATA_ARRAY_PARENT)):
# For a leaf AttributeValue, 'is_latest' flag will not be set.
# Instaed, these objects have
# parent_attrv parameter to identify parent AttributeValue.
instance.is_latest = False
instance.parent_attrv = attr.get_latest_value()
instance.save(
update_fields=['is_latest', 'data_type', 'parent_attrv'])
self._saved_instance = instance
attr.parent_entry.register_es()
@classmethod
def after_import_completion(self, results):
# make relation between the array of AttributeValue
for data in [
x['data'] for x in results if x['data']['status']
& AttributeValue.STATUS_DATA_ARRAY_PARENT
]:
attr_value = AttributeValue.objects.get(id=data['id'])
for child_id in [int(x) for x in data['data_arr'].split(',')]:
if (AttributeValue.objects.filter(id=child_id).exists()
and not attr_value.data_array.filter(
id=child_id).exists()):
# append related AttributeValue if it's not existed
attr_value.data_array.add(
AttributeValue.objects.get(id=child_id))
attr_value.parent_attr.parent_entry.register_es()