class BaseImportExportResource(resources.ModelResource):
project_code = fields.Field(
attribute='project_code',
widget=widgets.ForeignKeyWidget(ProjectCode, 'code'),
)
collab_id = fields.Field(
attribute='collab_id',
widget=widgets.CharWidget(),
)
sample_type = fields.Field(
attribute='sample_type',
widget=widgets.ForeignKeyWidget(SampleType, 'code'),
)
nucleic_acid_type = fields.Field(
attribute='nucleic_acid_type',
widget=widgets.ForeignKeyWidget(NucleicAcidType, 'code'),
)
sequencing_type = fields.Field(
attribute='sequencing_type',
widget=widgets.ForeignKeyWidget(SequencingType, 'code'),
)
notes = fields.Field(
attribute='notes',
widget=widgets.CharWidget(),
)
raise_errors = True
skip_unchanged = True
report_skipped = True
class Meta:
abstract = True
class ArticleRevisionResource(resources.ModelResource):
article = fields.Field(
column_name='article_id',
attribute='article',
widget=NullForeignKeyWidget(Article))
content = fields.Field(attribute='content', widget=widgets.CharWidget())
title = fields.Field(attribute='title', widget=widgets.CharWidget())
def skip_row(self, instance, original):
try:
return not instance.article
except ObjectDoesNotExist:
return True
def save_instance(self, instance, using_transactions=True, dry_run=False):
ss = ms.Supersense.objects.filter(article__pk=instance.article.pk)
# from https://stackoverflow.com/a/33208227
instance.parent = instance # Set the parent to itself
instance.pk = None
instance.save()
if ss:
ss[0].link_current_to_article_revision(article_revision=instance, commit=True)
instance.article.current_revision = instance
instance.article.save()
class Meta:
model = ms.ArticleRevision
import_id_fields = ('article',)
fields = ('article', 'content')
instance_loader_class = ArticleRevisionInstanceLoader
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 PersonResource(ModelResource):
class Meta:
model = Person
fields = (
'id', 'inner_id', 'reg_number', 'phone', 'email', 'reg_number',
'title', 'front_title', 'fullname', 'back_title', 'gender',
'religion', 'nation', 'place_of_birth', 'date_of_birth', 'last_education_level',
'last_education_institution', 'last_education_name', 'year_graduate', 'created_at',
'is_employee_applicant')
# id = Field(attribute='id', column_name='id', widget=UUIDWidget())
inner_id = Field(attribute='inner_id', column_name='inner_id', readonly=True, widget=widgets.CharWidget())
pid = Field(attribute='pid', column_name='pid', widget=widgets.CharWidget())
reg_number = Field(attribute='reg_number', column_name='reg_number', readonly=True, widget=widgets.IntegerWidget())
phone = Field(attribute='phone2', column_name='phone2', widget=widgets.CharWidget())
email = Field(attribute='email', column_name='email', widget=widgets.CharWidget())
title = Field(attribute='title', column_name='title', widget=widgets.CharWidget())
front_title = Field(attribute='front_title', column_name='front_title', widget=widgets.CharWidget())
fullname = Field(attribute='fullname', column_name='fullname', widget=widgets.CharWidget())
back_title = Field(attribute='back_title', column_name='back_title', widget=widgets.CharWidget())
gender = Field(attribute='gender', column_name='gender', widget=widgets.CharWidget())
religion = Field(attribute='religion', column_name='religion', widget=widgets.CharWidget())
nation = Field(attribute='nation', column_name='nation', widget=widgets.CharWidget())
place_of_birth = Field(attribute='place_of_birth', column_name='place_of_birth', widget=widgets.CharWidget())
# date_of_birth = Field(attribute='date_of_birth', column_name='date_of_birth', widget=ExcelDateWidget(date_format='%d/%m/%Y'))
last_education_level = Field(attribute='last_education_level', column_name='last_education_level',widget=widgets.CharWidget())
last_education_institution = Field(attribute='last_education_institution', column_name='last_education_institution', widget=widgets.CharWidget())
last_education_name = Field(attribute='last_education_name', column_name='last_education_name',widget=widgets.CharWidget())
year_graduate = Field(attribute='year_graduate', column_name='year_graduate', widget=widgets.CharWidget())
# created_at = fields.Field(attribute='created_at', column_name='created_at',widget=ExcelDateWidget(date_format='%d/%m/%Y %H:%M'))
is_employee_applicant = fields.Field(attribute='is_employee_applicant',column_name='is_employee_applicant',widget=widgets.BooleanWidget())
is_teacher_applicant = fields.Field(attribute='is_teacher_applicant',column_name='is_teacher_applicant',widget=widgets.BooleanWidget())
is_matriculant = fields.Field(attribute='is_matriculant',column_name='is_matriculant',widget=widgets.BooleanWidget())
class CorpusSentenceResource(resources.ModelResource):
corpus = fields.Field(
column_name='corpus_name',
attribute='corpus',
widget=CorpusForeignKeyWidget(ms.Corpus, 'name'))
language = fields.Field(
column_name='language_name',
attribute='language',
widget=ForeignKeyWidget(ms.Language, 'name'))
sent_id = fields.Field(attribute='sent_id', widget=widgets.CharWidget())
orthography = fields.Field(attribute='orthography', widget=widgets.CharWidget())
is_parallel = fields.Field(attribute='is_parallel', widget=widgets.BooleanWidget())
doc_id = fields.Field(attribute='doc_id', widget=widgets.CharWidget())
text = fields.Field(attribute='text', widget=widgets.CharWidget())
tokens = fields.Field(attribute='tokens', widget=widgets.CharWidget())
word_gloss = fields.Field(attribute='word_gloss', widget=widgets.CharWidget())
sent_gloss = fields.Field(attribute='sent_gloss', widget=widgets.CharWidget())
note = fields.Field(attribute='note', widget=widgets.CharWidget())
mwe_markup = fields.Field(attribute='mwe_markup', widget=widgets.CharWidget())
class Meta:
model = ms.CorpusSentence
import_id_fields = ('sent_id',)
fields = ('corpus', 'sent_id', 'language', 'orthography', 'is_parallel', 'doc_id',
'text', 'tokens', 'word_gloss', 'sent_gloss', 'note', 'mwe_markup')
class SerieResource(resources.ModelResource):
def get_queryset(self):
return self.Meta.model.objects.all().order_by("id")
def before_import(self, dataset, using_transactions, dry_run, **kwargs):
imported_ids = []
if not dry_run:
for row in dataset:
imported_ids.append(row[0])
filtered_ids = list(filter(None, imported_ids))
prepeared_for_deletion_models = self.Meta.model.objects.all(
).exclude(id__in=filtered_ids)
prepeared_for_deletion_models.delete()
def save_instance(self, instance, using_transactions=True, dry_run=False):
if not dry_run:
super().save_instance(instance, using_transactions, dry_run)
title = fields.Field(attribute='title', widget=widgets.CustomCharWidget())
brand = fields.Field(attribute="brand", widget=widgets.CustomBrandWidget())
dry = fields.Field(attribute="dry", widget=resource_widget.IntegerWidget())
wet = fields.Field(attribute="wet", widget=resource_widget.IntegerWidget())
offroad = fields.Field(attribute="offroad",
widget=resource_widget.IntegerWidget())
comfort = fields.Field(attribute="comfort",
widget=resource_widget.IntegerWidget())
noise = fields.Field(attribute="noise",
widget=resource_widget.IntegerWidget())
treadware = fields.Field(attribute="treadware",
widget=resource_widget.IntegerWidget())
snow = fields.Field(attribute="snow",
widget=resource_widget.IntegerWidget())
value = fields.Field(attribute="value",
widget=resource_widget.IntegerWidget())
description = fields.Field(attribute="description",
widget=resource_widget.CharWidget())
extra = fields.Field(attribute="extra",
widget=resource_widget.CharWidget())
image_url = fields.Field(attribute="image_url",
widget=resource_widget.CharWidget())
class Meta:
model = Serie
fields = ("id", "title", "brand", "dry", "wet", "offroad", "comfort",
"noise", "treadware", "snow", "value", "description",
"extra", "image_url")
skip_unchanged = True
export_order = ("id", "title", "brand", "dry", "wet", "offroad",
"comfort", "noise", "treadware", "snow", "value",
"description", "extra", "image_url")
class FamilyResource(resources.ModelResource):
family = fields.Field(column_name='Family', attribute='family', widget=widgets.CharWidget())
husband = fields.Field(column_name='Husband', attribute='husband', widget=widgets.CharWidget())
wife = fields.Field(column_name='Wife', attribute='wife', widget=widgets.CharWidget())
marriagedate = fields.Field(column_name='Marriage Date', attribute='marriagedate', widget=widgets.CharWidget())
children = fields.Field(column_name='Marriage Date', attribute='marriagedate', widget=widgets.CharWidget())
class Meta:
model = Family
skip_unchanged = True
exclude = ('id',)
fields = ("family", "husband", "wife", "children", "marriagedate")
export_order = ["family", "husband", "wife", "children", "marriagedate"]
import_id_fields = ["family", "husband", "wife", "children", "marriagedate"]
class GroupAmbulancePermissionResource(resources.ModelResource):
group_name = fields.Field(attribute='group__name',
widget=widgets.CharWidget(),
readonly=True)
ambulance_identifier = fields.Field(attribute='ambulance__identifier',
widget=widgets.CharWidget(),
readonly=True)
class Meta:
model = GroupAmbulancePermission
fields = ('id', 'group_name', 'ambulance_identifier',
'can_read', 'can_write')
export_order = ('id', 'group_name', 'ambulance_identifier',
'can_read', 'can_write')
class GroupHospitalPermissionResource(resources.ModelResource):
group_name = fields.Field(attribute='group__name',
widget=widgets.CharWidget(),
readonly=True)
hospital_name = fields.Field(attribute='hospital__name',
widget=widgets.CharWidget(),
readonly=True)
class Meta:
model = GroupHospitalPermission
fields = ('id', 'group_name', 'hospital_name',
'can_read', 'can_write')
export_order = ('id', 'group_name', 'hospital_name',
'can_read', 'can_write')
class EntryResource(resources.ModelResource):
username = fields.Field(attribute='user__username',
widget=widgets.PostSaveWidget(
widgets.CharWidget()),
readonly=False)
class Meta:
model = Role
fields = ('id', )
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:
# create user, this would usually be done by a signal
instance.user = User.objects.create(username='******')
def after_post_save_instance(self, instance, data,
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.user.save()
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 BookResource(resources.ModelResource):
name = fields.Field(attribute='name',
column_name='book_name',
widget=widgets.CharWidget())
class Meta:
model = Book
import_id_fields = ['name']
class ConstrualResource(resources.ModelResource):
role = fields.Field(column_name='role_id',
attribute='role',
widget=NullForeignKeyWidget(ms.Supersense))
function = fields.Field(column_name='function_id',
attribute='function',
widget=NullForeignKeyWidget(ms.Supersense))
special = fields.Field(attribute='special', widget=widgets.CharWidget())
def skip_row(self, instance, original):
m = instance
if not m.role and not m.function and ms.Construal.objects.filter(
special=m.special):
return True
if m.role and m.function and ms.Construal.objects.filter(
role__pk=m.role.pk, function__pk=m.function.pk):
return True
return False
def save_instance(self, instance, using_transactions=True, dry_run=False):
try:
ex_article = Article.objects.get(
current_revision__title='Locus--Locus')
except AttributeError:
raise Exception(
"Xposition Import: Please create Construal 'Locus--Locus' to use as a model!"
)
m = instance
if not m.role and not m.function and ms.Construal.objects.filter(
special=m.special):
return
if m.role and m.function and ms.Construal.objects.filter(
role__pk=m.role.pk, function__pk=m.function.pk):
return
role_name = deepest_instance(
m.role.current_revision).name if m.role else None
function_name = deepest_instance(
m.function.current_revision).name if m.function else None
name = self.get_construal_slug(role_name, function_name, m.special)
# slug will be the same as name
newarticle = ArticleMetadataFormFunctions(
ADMIN_REQUEST).newArticle_without_category(name=name,
slug=name,
ex_article=ex_article,
parent=None)
m.article = newarticle
m.save()
def get_construal_slug(cls, role_name, function_name, special):
return role_name + '--' + function_name if role_name and function_name else special
class Meta:
model = ms.Construal
import_id_fields = ('role', 'function', 'special')
fields = ('role', 'function', 'special')
class PersonResource(resources.ModelResource):
person = fields.Field(column_name='Person', attribute='person_id', widget=widgets.CharWidget())
surname = fields.Field(column_name='Surname', attribute='surname', widget=widgets.CharWidget())
given = fields.Field(column_name='Given', attribute='givenname', widget=widgets.CharWidget())
call = fields.Field(column_name='Call', attribute='call', widget=widgets.CharWidget())
nickname = fields.Field(column_name='Nickname', attribute='nickname', widget=widgets.CharWidget())
prefix = fields.Field(column_name='Prefix', attribute='prefix', widget=widgets.CharWidget())
title = fields.Field(column_name='Title', attribute='title', widget=widgets.CharWidget())
gender = fields.Field(column_name='Gender', attribute='gender', widget=widgets.CharWidget())
birthdate = fields.Field(column_name='Birth date', attribute='birthdate', widget=widgets.CharWidget())
birthplace = fields.Field(column_name='Birth place', attribute='birthplace', widget=widgets.CharWidget())
deathdate = fields.Field(column_name='Death date', attribute='deathdate', widget=widgets.CharWidget())
deathplace = fields.Field(column_name='Death place', attribute='deathplace', widget=widgets.CharWidget())
class Meta:
model = Person
skip_unchanged = True
exclude = ('id', )
fields = ("person_id", "surname", "givenname", "nickname", "gender")
export_order = ["person_id", "surname", "givenname", "nickname", "gender"]
import_id_fields = ["person_id", "surname", "givenname", "nickname", "gender"]
class OilOrderResource(resources.ModelResource):
payment = fields.Field(attribute="payment_type",
widget=PaymentWidget(OilOrder.PAYMENT_CHOICES))
vol = fields.Field(attribute="oil__volume",
column_name="volume",
widget=widgets.CharWidget())
class Meta:
model = OilOrder
fields = ("id", "phone", 'name', 'product_title', 'email',
'order_date')
export_order = ("id", "phone", 'name', 'product_title', 'vol', 'email',
'payment', 'order_date')
class RozetkaProductResource(resources.Resource):
rozetka_product_id = fields.Field(column_name='ID товара в розетке',
widget=widgets.CharWidget())
customer_product_id = fields.Field(column_name='ID товара у продавца',
widget=widgets.CharWidget())
product_name = fields.Field(column_name='Название товара',
widget=widgets.CharWidget())
uploader_status = fields.Field(column_name='Статус в uploader',
widget=widgets.CharWidget())
rozetka_status = fields.Field(column_name='Статус в розетке',
widget=widgets.CharWidget())
rozetka_sell_status = fields.Field(column_name='Sell-статус в розетке',
widget=widgets.CharWidget())
rozetka_category_id = fields.Field(column_name='ID категории в розетке',
widget=widgets.CharWidget())
rozetka_category_name = fields.Field(
column_name='Название категории в розетке',
widget=widgets.CharWidget())
customer_category_id = fields.Field(column_name='ID категории у продавца',
widget=widgets.CharWidget())
customer_category_name = fields.Field(
column_name='Название категории у продавца',
widget=widgets.CharWidget())
class SupersenseRevisionResource(resources.ModelResource):
name = fields.Field(attribute='name',
column_name='supersense_name',
widget=widgets.CharWidget())
# handle revision creation
def save_instance(self, instance, using_transactions=True, dry_run=False):
try:
ex_article = Article.objects.get(current_revision__title='Locus')
except AttributeError:
raise Exception(
"Xposition Import: Please create Supersense 'Locus' to use as a model!"
)
m = instance
if ms.Supersense.objects.filter(
current_revision__metadatarevision__supersenserevision__name=m.
name):
return
# code taken from wiki/plugins/metadata/forms.py
newarticle, newcategory = ArticleMetadataFormFunctions(
ADMIN_REQUEST).newArticle_ArticleCategory(name=m.name,
ex_article=ex_article)
# associate the article with the SupersenseRevision
m.article = newarticle
# create the Supersense, add the article, category, and revision
supersense = ms.Supersense()
supersense.article = newarticle
supersense.category = newcategory
if m.parent:
supersense.category.parent = m.parent.category # the parent category is stored both on the revision and on the Supersense.category
else:
supersense.category.parent = None
supersense.add_revision(
m,
ADMIN_REQUEST,
article_revision=newarticle.current_revision,
save=True) # cannot delay saving the new supersense revision
m.save()
supersense.save()
class Meta:
model = ms.SupersenseRevision
import_id_fields = ('name', )
fields = ('name', )
class OfferResource(CustomModelResource):
name = fields.Field(
column_name='name',
attribute='name',
default=None,
widget=widgets.CharWidget(),
)
price = fields.Field(
column_name='price',
attribute='price',
default=0,
widget=widgets.DecimalWidget(),
)
product = fields.Field(
column_name='product',
attribute='product',
widget=widgets.ForeignKeyWidget(Product, field='name'),
)
is_active = fields.Field(column_name='is_active',
attribute='is_active',
default=1,
widget=widgets.BooleanWidget())
attributes = fields.Field(column_name='attributes',
attribute='attributes',
default={},
widget=widgets.CharWidget())
class Meta:
model = Offer
fields = ('name', 'product', 'price', 'is_active', 'attributes')
export_order = ('name', 'product', 'attributes', 'is_active', 'price')
import_id_fields = ('name', )
def __new__(cls, *args, **kwargs):
new_class = super(CustomModelResourceMetaclass,
cls).__new__(cls, *args, **kwargs)
CustomModelResource = globals().get("CustomModelResource", None)
if CustomModelResource and issubclass(new_class, CustomModelResource):
opts = new_class._meta
# Setup choice fields
for field_name in opts.choice_fields:
new_class.fields[field_name] = fields.Field(
attribute='get_%s_display' % field_name,
column_name=field_name)
# Setup str fields
for field_name in opts.str_fields:
new_class.fields[field_name].widget = widgets.CharWidget()
return new_class
class UserResource(resources.ModelResource):
is_dispatcher = fields.Field(attribute='userprofile__is_dispatcher',
widget=widgets.PostSaveWidget(widgets.BooleanWidget()),
readonly=False)
mobile_number = fields.Field(attribute='userprofile__mobile_number',
widget=widgets.PostSaveWidget(widgets.CharWidget()),
readonly=False)
class Meta:
model = User
fields = ('id', 'username', 'first_name', 'last_name', 'email', 'mobile_number',
'is_staff', 'is_dispatcher', 'is_active')
export_order = ('id', 'username', 'first_name', 'last_name', 'email', 'mobile_number',
'is_staff', 'is_dispatcher', 'is_active')
# save userprofile related fields
def after_post_save_instance(self, instance, row, using_transactions, dry_run):
instance.userprofile.save()
class StaffPageResource(PageResource):
legacy_staff_id = Field(
attribute="legacy_staff_id",
column_name="id",
default=None,
widget=widgets.IntegerWidget(),
)
staff_title = Field(
attribute="staff_title",
column_name="title_prefix",
default="",
widget=widgets.CharWidget(),
)
class Meta:
model = StaffPage
# If not set, diffing pages triggers 'pickle' errors
skip_diff = True
# Pages clean themselves automatically on save()
clean_model_instances = False
import_id_fields = ("legacy_staff_id", )
fields = (
"legacy_staff_id",
"title",
"slug",
"staff_title",
"first_name",
"last_name",
)
def before_save_instance(self,
instance,
using_transactions=True,
dry_run=False):
"""
Add missing required field values.
"""
if not instance.title:
instance.title = instance.name
class AdpositionRevisionResource(import_export.resources.ModelResource):
name = fields.Field(column_name='adposition_name', attribute='name', widget=widgets.CharWidget())
lang = fields.Field(
column_name='language_name',
attribute='lang',
widget=ForeignKeyWidget(ms.Language, 'name'))
morphtype = fields.Field(attribute='morphtype', widget=MorphTypeWidget())
transitivity = fields.Field(attribute='transitivity', widget=TransitivityWidget())
obj_cases = fields.Field(column_name='obj_case', attribute='obj_cases', widget=ObjCasesWidget())
is_pp_idiom = fields.Field(column_name='is_pp_idiom', attribute='is_pp_idiom', widget=widgets.BooleanWidget())
def skip_row(self, instance, original):
m = instance
if ms.Adposition.objects.filter(current_revision__metadatarevision__adpositionrevision__lang__name=m.lang.name,
current_revision__metadatarevision__adpositionrevision__name=m.name):
return True
return False
# handle revision creation
def save_instance(self, instance, using_transactions=True, dry_run=False):
try:
ex_article = ms.Adposition.objects.get(current_revision__metadatarevision__adpositionrevision__lang__name='English',
current_revision__metadatarevision__adpositionrevision__name='at').article
except AttributeError:
raise Exception("Xposition Import: Please create Adposition 'at' to use as a model!")
m = instance
lang_article = ms.Language.objects.get(name=m.lang.name).article
if ms.Adposition.objects.filter(current_revision__metadatarevision__adpositionrevision__lang__name=m.lang.name,
current_revision__metadatarevision__adpositionrevision__name=m.name):
# thep = ms.Adposition.objects.get(current_revision__metadatarevision__adpositionrevision__lang__name=m.lang.name,
# current_revision__metadatarevision__adpositionrevision__name=m.name)
# thep.newRevision(ADMIN_REQUEST,
# commit=True,
# name=m.name,
# lang=m.lang,
# morphtype=m.morphtype,
# transitivity=m.transitivity,
# obj_cases=m.obj_cases,
# is_pp_idiom=m.is_pp_idiom)
return
# code taken from wiki/plugins/metadata/forms.py
newarticle = ArticleMetadataFormFunctions(ADMIN_REQUEST).newArticle_without_category(name=m.name,
ex_article=ex_article,
parent=lang_article.urlpath_set.all()[0],
slug=m.name)
# associate the article with the SupersenseRevision
m.article = newarticle
# create the Supersense, add the article, category, and revision
p = ms.Adposition()
p.article = newarticle
p.add_revision(m, ADMIN_REQUEST, article_revision=newarticle.current_revision,
save=True) # cannot delay saving the new adposition revision
m.save()
p.save()
class Meta:
model = ms.AdpositionRevision
import_id_fields = ('name', 'lang',)
fields = ('name', 'lang', 'morphtype', 'transitivity', 'obj_cases', 'is_pp_idiom')
instance_loader_class = AdpositionRevisionInstanceLoader
class PTokenAnnotationResource(resources.ModelResource):
token_indices = fields.Field(attribute='token_indices', widget=widgets.CharWidget())
obj_head = fields.Field(attribute='obj_head', widget=widgets.CharWidget())
gov_head = fields.Field(attribute='gov_head', widget=widgets.CharWidget())
gov_obj_syntax = fields.Field(attribute='gov_obj_syntax', widget=widgets.CharWidget())
adp_pos = fields.Field(attribute='adp_pos', widget=widgets.CharWidget())
gov_pos = fields.Field(attribute='gov_pos', widget=widgets.CharWidget())
obj_pos = fields.Field(attribute='obj_pos', widget=widgets.CharWidget())
gov_supersense = fields.Field(attribute='gov_supersense', widget=widgets.CharWidget())
obj_supersense = fields.Field(attribute='obj_supersense', widget=widgets.CharWidget())
is_gold = fields.Field(attribute='is_gold', widget=widgets.BooleanWidget())
annotator_cluster = fields.Field(attribute='annotator_cluster', widget=widgets.CharWidget())
is_transitive = fields.Field(attribute='is_transitive', widget=widgets.BooleanWidget())
gov_head_index = fields.Field(attribute='gov_head_index', widget=widgets.IntegerWidget())
obj_head_index = fields.Field(attribute='obj_head_index', widget=widgets.IntegerWidget())
is_typo = fields.Field(attribute='is_typo', widget=widgets.BooleanWidget())
is_abbr = fields.Field(attribute='is_abbr', widget=widgets.BooleanWidget())
mwe_subtokens = fields.Field(attribute='mwe_subtokens', widget=widgets.CharWidget())
main_subtoken_indices = fields.Field(attribute='main_subtoken_indices', widget=widgets.CharWidget())
main_subtoken_string = fields.Field(attribute='main_subtoken_string', widget=widgets.CharWidget())
obj_case = fields.Field(
column_name='obj_case',
attribute='obj_case',
widget=ObjCaseWidget())
adposition = fields.Field(
column_name='adposition_id',
attribute='adposition',
widget=ForeignKeyWidget(ms.Adposition))
construal = fields.Field(
column_name='construal_id',
attribute='construal',
widget=ForeignKeyWidget(ms.Construal))
sentence = fields.Field(
column_name='sent_id',
attribute='sentence',
widget=SentenceForeignKeyWidget(ms.CorpusSentence, 'sent_id'))
usage = fields.Field(
column_name='usage_id',
attribute='usage',
widget=ForeignKeyWidget(ms.Usage))
class Meta:
model = ms.PTokenAnnotation
import_id_fields = ('sentence', 'token_indices')
fields = ('token_indices', 'adposition', 'construal', 'usage', 'sentence',
'obj_case', 'obj_head', 'gov_head', 'gov_obj_syntax', 'adp_pos', 'gov_pos', 'obj_pos',
'gov_supersense', 'obj_supersense', 'is_gold', 'annotator_cluster', 'is_transitive',
'gov_head_index', 'obj_head_index', 'is_typo', 'is_abbr', 'mwe_subtokens',
'main_subtoken_indices', 'main_subtoken_string')
def setUp(self):
self.value = 'asdf'
self.widget = widgets.CharWidget()
class ItemResource(resources.ModelResource):
client_name = fields.Field(attribute='device__client__name',
column_name='Hospital name')
manufacturer_name = fields.Field(
attribute='device__product__manufacturer__name',
column_name='Manufacturer name')
hospital_number = fields.Field(attribute='device__hospital_number',
column_name='Hospital part #',
widget=widgets.CharWidget())
model_number = fields.Field(attribute='device__product__model_number',
column_name='Manufacturer part #',
widget=widgets.CharWidget())
cost_type = fields.Field(attribute='cost_type', column_name='Cost type')
serial_number = fields.Field(attribute='serial_number',
column_name='Serial number',
widget=widgets.CharWidget())
lot_number = fields.Field(attribute='lot_number',
column_name='Lot number',
widget=widgets.CharWidget())
purchased_date = fields.Field(attribute='purchased_date',
column_name='Purchased date',
widget=widgets.DateWidget())
expired_date = fields.Field(attribute='expired_date',
column_name='Expiry date',
widget=widgets.DateWidget())
bulk_discount_percent = fields.Field(attribute='bulk_discount_percent',
column_name='Bulk discount percent',
widget=widgets.NumberWidget())
bulk_discount_value = fields.Field(attribute='bulk_discount_value',
column_name='Bulk discount value',
widget=widgets.NumberWidget())
discount_order = fields.Field(attribute='discount_order',
column_name='Discount order',
widget=widgets.NumberWidget())
discount_start_date = fields.Field(attribute='discount_start_date',
column_name='Discount start date',
widget=widgets.DateWidget())
discount_end_date = fields.Field(attribute='discount_end_date',
column_name='Discount end date',
widget=widgets.DateWidget())
COST_TYPES_DICT = dict((name, value) for value, name in COST_TYPES)
class Meta:
model = Item
fields = ('id', 'client_name', 'manufacturer_name', 'hospital_number',
'model_number', 'serial_number', 'lot_number',
'purchased_date', 'expired_date', 'cost_type',
'bulk_discount_percent', 'bulk_discount_value',
'discount_order', 'discount_start_date', 'discount_end_date')
export_order = ('id', 'client_name', 'manufacturer_name',
'hospital_number', 'model_number', 'serial_number',
'lot_number', 'purchased_date', 'expired_date',
'cost_type', 'bulk_discount_percent',
'bulk_discount_value', 'discount_order',
'discount_start_date', 'discount_end_date')
@staticmethod
def _build_bulk_discount(item):
return (item.id and item.bulk_discount) or Discount()
def dehydrate_cost_type(self, item):
return item.get_cost_type_display()
def dehydrate_bulk_discount_percent(self, item):
return self._build_bulk_discount(item).percent
def dehydrate_bulk_discount_value(self, item):
return self._build_bulk_discount(item).value
def dehydrate_discount_order(self, item):
return self._build_bulk_discount(item).order
def dehydrate_discount_start_date(self, item):
return self._build_bulk_discount(item).start_date
def dehydrate_discount_end_date(self, item):
return self._build_bulk_discount(item).end_date
def get_field_value(self, field_name, row, default=None):
return row.get(self.fields.get(field_name).column_name) or default
def before_import_row(self, row, **kwargs):
field = 'cost_type'
row[self.fields[field].column_name] = self.COST_TYPES_DICT.get(
self.get_field_value(field, row), UNIT_COST)
def init_instance(self, row=None):
instance = super().init_instance(row)
client = Client.objects.get(
name=self.get_field_value('client_name', row))
product = Product.objects.get(
model_number=self.get_field_value('model_number', row))
instance.device = Device.objects.get_or_create(client=client,
product=product)[0]
return instance
def get_or_init_instance(self, instance_loader, row):
instance, created = super().get_or_init_instance(instance_loader, row)
hospital_number = self.get_field_value('hospital_number', row)
if hospital_number and (instance.device.hospital_number !=
hospital_number):
device = instance.device
device.hospital_number = hospital_number
device.save()
bulk_discount_percent = self.get_field_value('bulk_discount_percent',
row,
default=0)
bulk_discount_value = self.get_field_value('bulk_discount_value',
row,
default=0)
if bulk_discount_percent or bulk_discount_value:
device = instance.device
client_price = ClientPrice.objects.get_or_create(
client=device.client, product=device.product)[0]
bulk_discount = client_price.discount_set.get_or_create(
name='Bulk',
cost_type=self.get_field_value('cost_type', row),
order=self.get_field_value('discount_order', row),
start_date=self.get_field_value('discount_start_date',
row,
default=None),
end_date=self.get_field_value('discount_end_date',
row,
default=None),
apply_type=PRE_DOCTOR_ORDER,
discount_type=PERCENT_DISCOUNT
if bulk_discount_percent > 0 else VALUE_DISCOUNT,
percent=bulk_discount_percent,
value=bulk_discount_value,
)[0]
instance.build_bulk_discount(bulk_discount)
return instance, created
def after_save_instance(self, instance, using_transactions, dry_run):
another_cost_type_orphan_discounts = instance.discounts.exclude(
cost_type=instance.cost_type).all()
instance.discounts.remove(*another_cost_type_orphan_discounts)
instance.save_bulk_discount()
class ProductResource(CustomModelResource):
# id = fields.Field(default=generate_Jid(prefix='J'),
# readonly=True,
# widget=widgets.CharWidget(),
# )
name = fields.Field(
column_name='name',
attribute='name',
default=None,
widget=widgets.CharWidget(),
)
# price = fields.Field(column_name='price', attribute='price',
# default=0,
# widget=widgets.DecimalWidget(),
# )
description = fields.Field(
column_name='description',
attribute='description',
default=None,
widget=widgets.CharWidget(),
)
# producer = fields.Field(column_name='producer', attribute='producer',
# default=None,
# widget=widgets.CharWidget(),
# )
category = fields.Field(
column_name='category',
attribute='category',
default=None,
widget=widgets.ForeignKeyWidget(ProductCategory, field='name'),
)
producer = fields.Field(
column_name='producer',
attribute='producer',
default=None,
widget=widgets.ForeignKeyWidget(Producer, field='name'),
)
attributes = fields.Field(
column_name='attributes',
attribute='attributes',
default=None,
widget=CustomManyToManyWidget(ProductAttribute, field="name"),
)
is_active = fields.Field(column_name='is_active',
attribute='is_active',
default=1,
widget=widgets.BooleanWidget())
discount_policy = fields.Field(column_name='discount_policy',
attribute='discount_policy',
default={},
widget=widgets.CharWidget())
# delete = fields.Field(column_name='delete', attribute='delete',
# default=0,
# widget=widgets.BooleanWidget())
# def for_delete(self, row, instance):
# return self.fields['delete'].clean(row)
class Meta:
model = Product
fields = ('id', 'name', 'description', 'producer', 'category',
'is_active', 'attributes', 'discount_policy')
export_order = ('id', 'name', 'producer', 'is_active', 'category',
'attributes', 'description', 'discount_policy')
# import_id_fields = ('name',)
def dehydrate_str_choices(self, obj):
if obj.id:
return obj.str_choices()
class TireResource(resources.ModelResource):
def get_queryset(self):
return Tire.objects.all()
def export(self,queryset,*args,**kwargs):
tires = Tire.objects.available()
return super().export(tires,*args,**kwargs)
def before_import(self,dataset, using_transactions, dry_run, **kwargs):
imported_ids = []
if not dry_run:
for row in dataset:
imported_ids.append(row[0])
filtered_ids = list(filter(None,imported_ids))
tires = Tire.objects.all()
tires.backup()
tires.exclude(id__in=filtered_ids).delete()
origin = fields.Field(
attribute="brand__country", widget=widgets.CustomCountryWidget()
)
manufacturer = fields.Field(
attribute="manufacturer", widget=widgets.CustomCountryWidget()
)
season = fields.Field(attribute="season", widget=widgets.CustomSeasonWidget())
brand = fields.Field(attribute="brand", widget=widgets.CustomBrandWidget())
serie = fields.Field(attribute="serie", widget=widgets.CustomSerieWidget())
ZR = fields.Field(attribute="ZR", widget=widgets.CustomBooleanWidget())
MS = fields.Field(
column_name="M+S", attribute="MS", widget=widgets.CustomBooleanWidget()
)
OE = fields.Field(attribute="OE", widget=resource_widget.CharWidget())
RF = fields.Field(attribute="RF", widget=widgets.CustomBooleanWidget())
SL = fields.Field(attribute="SL", widget=widgets.CustomBooleanWidget())
taksit_active = fields.Field(
column_name="Taksit active",
attribute="taksit_active",
widget=widgets.CustomBooleanWidget()
)
taksit_2 = fields.Field(
column_name="Taksit 2 ay",
attribute="taksit_2",
widget=widgets.CustomDecimalWidget(2),
)
taksit_2_active = fields.Field(
column_name="Taksit 2 active",
attribute="taksit_2_active",
widget=widgets.CustomBooleanWidget(),
)
taksit_3 = fields.Field(
column_name="Taksit 3 ay",
attribute="taksit_3",
widget=widgets.CustomDecimalWidget(3),
)
taksit_3_active = fields.Field(
column_name="Taksit 3 active",
attribute="taksit_3_active",
widget=widgets.CustomBooleanWidget(),
)
taksit_6 = fields.Field(
column_name="Taksit 6 ay",
attribute="taksit_6",
widget=widgets.CustomDecimalWidget(6),
)
taksit_6_active = fields.Field(
column_name="Taksit 6 active",
attribute="taksit_6_active",
widget=widgets.CustomBooleanWidget(),
)
taksit_9 = fields.Field(
column_name="Taksit 9 ay",
attribute="taksit_9",
widget=widgets.CustomDecimalWidget(9),
)
taksit_9_active = fields.Field(
column_name="Taksit 9 active",
attribute="taksit_9_active",
widget=widgets.CustomBooleanWidget(),
)
taksit_12 = fields.Field(
column_name="Taksit 12 ay",
attribute="taksit_12",
widget=widgets.CustomDecimalWidget(12),
)
taksit_12_active = fields.Field(
column_name="Taksit 12 active",
attribute="taksit_12_active",
widget=widgets.CustomBooleanWidget(),
)
kredit_active = fields.Field(
column_name="Kredit active",
attribute="kredit_active",
widget=widgets.CustomBooleanWidget()
)
taksit_active = fields.Field(
column_name="Taksit active",
attribute="taksit_active",
widget=widgets.CustomBooleanWidget()
)
kredit_3 = fields.Field(
column_name="Kredit 3 ay",
attribute="kredit_3",
widget=widgets.CustomDecimalWidget(3),
)
kredit_3_active = fields.Field(
column_name="Kredit 3 active",
attribute="kredit_3_active",
widget=widgets.CustomBooleanWidget(),
)
kredit_3_dif = fields.Field(
column_name="Bahalaşma 3 %",
attribute="kredit_3_dif",
widget=widgets.DecimalWidget(),
)
kredit_6 = fields.Field(
column_name="Kredit 6 ay",
attribute="kredit_6",
widget=widgets.CustomDecimalWidget(6),
)
kredit_6_active = fields.Field(
column_name="Kredit 6 active",
attribute="kredit_6_active",
widget=widgets.CustomBooleanWidget(),
)
kredit_6_dif = fields.Field(
column_name="Bahalaşma 6 %",
attribute="kredit_6_dif",
widget=widgets.DecimalWidget(),
)
kredit_9 = fields.Field(
column_name="Kredit 9 ay",
attribute="kredit_9",
widget=widgets.CustomDecimalWidget(9),
)
kredit_9_active = fields.Field(
column_name="Kredit 9 active",
attribute="kredit_9_active",
widget=widgets.CustomBooleanWidget(),
)
kredit_9_dif = fields.Field(
column_name="Bahalaşma 9 %",
attribute="kredit_9_dif",
widget=widgets.DecimalWidget(),
)
kredit_12 = fields.Field(
column_name="Kredit 12 ay",
attribute="kredit_12",
widget=widgets.CustomDecimalWidget(12),
)
kredit_12_active = fields.Field(
column_name="Kredit 12 active",
attribute="kredit_12_active",
widget=widgets.CustomBooleanWidget(),
)
kredit_12_dif = fields.Field(
column_name="Bahalaşma 12 %",
attribute="kredit_12_dif",
widget=widgets.DecimalWidget(),
)
price = fields.Field(
column_name="price", attribute="price", widget=resource_widget.DecimalWidget()
)
sale = fields.Field(
column_name="sale", attribute="sale", widget=resource_widget.DecimalWidget()
)
sale_active = fields.Field(
column_name="sale active",
attribute="sale_active",
widget=widgets.CustomBooleanWidget()
)
montaj_balance = fields.Field(
column_name="Montaj+Balance",
attribute="montaj_balance",
widget=resource_widget.DecimalWidget(),
)
Class = fields.Field(
column_name="class", attribute="Class", widget=widgets.CustomClassWidget()
)
size = fields.Field(attribute="size", widget=widgets.CustomSizeWidget())
release_date = fields.Field(
attribute="release_date",
widget=resource_widget.CharWidget()
)
db= fields.Field(attribute="db",widget=resource_widget.IntegerWidget())
fuel = fields.Field(attribute="fuel",widget=resource_widget.CharWidget())
contact = fields.Field(attribute="contact",widget=resource_widget.CharWidget())
kredit_initial_price = fields.Field(column_name="kredit initial price %",attribute="kredit_initial_price",widget=resource_widget.FloatWidget())
new = fields.Field(attribute="new",widget=widgets.CustomNewBooleanWidget())
outlet = fields.Field(attribute="outlet",widget=widgets.CustomOutletBooleanWidget())
class Meta:
model = Tire
import_id_fields = ("id",'code')
# instance_loader_class = CustomModelInstanceLoader
fields = (
"id",
"code",
"brand",
"serie",
"manufacturer",
"size",
"ZR",
"MS",
"OE",
"SL",
"RF",
"tradeware",
"weight",
"speed",
"razval",
"year",
"Class",
"quantity",
"kredit_active",
"kredit_12_dif",
"kredit_9_dif",
"kredit_6_dif",
"kredit_3_dif",
"kredit_3",
"kredit_3_active",
"kredit_6",
"kredit_6_active",
"kredit_9",
"kredit_9_active",
"kredit_12",
"kredit_12_active",
"taksit_active",
"taksit_2",
"taksit_2_active",
"taksit_3",
"taksit_3_active",
"taksit_6",
"taksit_6_active",
"taksit_9",
"taksit_9_active",
"taksit_12",
"taksit_12_active",
"price",
"sale",
"sale_active",
"release_date",
"db",
"fuel",
"contact",
"kredit_initial_price",
"new",
"outlet",
"birkart",
"tamkart",
"bolkart",
"albalikart",
"kredit",
"stickers",
'campaigns'
)
skip_unchanged = True
export_order = (
"id",
"code",
"brand",
"serie",
"origin",
"manufacturer",
"size",
"ZR",
"MS",
"OE",
"SL",
"RF",
"season",
"tradeware",
"weight",
"speed",
'db',
"fuel",
"contact",
"price",
"sale",
"sale_active",
"montaj_balance",
"razval",
"year",
"Class",
"taksit_active",
"taksit_2",
"taksit_2_active",
"taksit_3",
"taksit_3_active",
"taksit_6",
"taksit_6_active",
"taksit_9",
"taksit_9_active",
"taksit_12",
"taksit_12_active",
"kredit_active",
"kredit_3",
"kredit_3_dif",
"kredit_3_active",
"kredit_initial_price",
"kredit_6",
"kredit_6_dif",
"kredit_6_active",
"kredit_9",
"kredit_9_dif",
"kredit_9_active",
"kredit_12",
"kredit_12_dif",
"kredit_12_active",
"quantity",
"release_date",
"new",
"outlet"
)
class ProductoResource(resources.ModelResource):
Ref_Producto = fields.Field(column_name='Ref_Producto', attribute='Ref_Producto', widget=widgets.CharWidget())
class Meta:
model = Producto
fields = ('Tipo', 'Ref_Producto', 'Nombre_producto', 'Linea', 'Observaciones', 'Impuesto',)
import_id_fields = ['Ref_Producto']
class ProductResource(VerboseNameModelResource):
order = 1
sku = Field(
attribute='sku',
column_name='Артикул',
widget=widgets.CharWidget()
)
model = Field(
attribute='model',
column_name='Модель / Цвет',
# widget=MyModelWidget()
widget=widgets.CharWidget()
)
# tags = Field(
# attribute='tags',
# column_name = 'Модель / Цвет',
# widget=widgets.CharWidget()
# )
content = Field(
attribute='content',
column_name='Состав',
widget=widgets.CharWidget()
)
brand = Field(
attribute='brand',
column_name='Бренд',
widget=MyGetForeignKeyWidget(model=Brand, field='name')
)
categories = Field(
attribute='categories',
column_name='Доп. параметры',
widget=MyCategoriesWidget(model=Category, field='name', separator=';')
)
colors = Field(
attribute='colors',
column_name='Цвет',
widget=MyGetManyToManyWidget(model=Color, field='name', separator=';')
)
total_count = Field(
attribute='total_count',
column_name='Кол-во',
widget=widgets.IntegerWidget()
)
price_ret = Field(default=0, attribute='price_ret', column_name='Розничная цена, р', widget=widgets.IntegerWidget())
price_opt_m = Field(default=0, attribute='price_opt_m', column_name='Мелкий опт от 10шт.',
widget=widgets.IntegerWidget())
price_opt_1 = Field(default=0, attribute='price_opt_1', column_name='Опт. от 15000р',
widget=widgets.IntegerWidget())
price_opt_2 = Field(default=0, attribute='price_opt_2', column_name='- 3% от 30000р',
widget=widgets.IntegerWidget())
price_opt_3 = Field(default=0, attribute='price_opt_3', column_name='- 7% от 70000р',
widget=widgets.IntegerWidget())
price_opt_4 = Field(default=0, attribute='price_opt_4', column_name='- 11% от 110000р',
widget=widgets.IntegerWidget())
size_ns = Field(default=0, attribute='size_ns', column_name='*', widget=widgets.IntegerWidget())
size_xs = Field(default=0, attribute='size_xs', column_name='XS (42)', widget=widgets.IntegerWidget())
size_s = Field(default=0, attribute='size_s', column_name='S (44)', widget=widgets.IntegerWidget())
size_m = Field(default=0, attribute='size_m', column_name='M (46)', widget=widgets.IntegerWidget())
size_l = Field(default=0, attribute='size_l', column_name='L (48)', widget=widgets.IntegerWidget())
size_xl = Field(default=0, attribute='size_xl', column_name='XL (50)', widget=widgets.IntegerWidget())
size_2xl = Field(default=0, attribute='size_2xl', column_name='XXL (52)', widget=widgets.IntegerWidget())
size_3xl = Field(default=0, attribute='size_3xl', column_name='XXХL (54-56)', widget=widgets.IntegerWidget())
size_4xl = Field(default=0, attribute='size_4xl', column_name='4ХL (58)', widget=widgets.IntegerWidget())
def skip_row(self, instance, original):
if instance.total_count is None:
skip = True
else:
skip = False
return skip
def get_img(self, sku, brand):
return '/static/img/products/%s/%s/%s.jpg' % (brand, sku, sku)
def before_save_instance(self, instance, using_transactions, dry_run):
def switcher(argument):
return {
'(Светится в темноте и ультрафиолете)': (False, False, False, True, True),
'(Светится в ультрафиолете)': (False, False, False, False, True),
'(Светится в темноте)': (False, False, False, True, False),
'SALE!': (False, False, True, False, False),
'ХИТ!': (True, False, False, False, False),
'NEW!': (False, True, False, False, False),
}.get(argument, (False, False, False, False, False))
temp = instance.model.split('\n')
result_list = []
instance.model = temp[0]
for item in temp:
result_list.append(switcher(item))
(instance.hit,
instance.new,
instance.sale,
instance.glow_in_th_dark,
instance.glow_in_th_uv) = map(any, zip(*result_list))
instance.thumbnail = MediaFile.objects.get_or_create(
link=self.get_img(
instance.sku,
slugify(instance.brand.name)
)
)[0]
instance.my_order = self.order
self.order += 1
return instance
def after_save_instance(self, instance, using_transactions, dry_run):
imgs = get_images(slugify(instance.brand.name), instance.sku)
for img in imgs:
(media_file, success) = MediaFile.objects.get_or_create(link=img)
if (success):
instance.media_files.add(media_file)
(tag, success) = Tag.objects.get_or_create(name=instance.model)
instance.tags.add(tag)
return instance
def before_import(self, dataset, using_transactions, dry_run, **kwargs):
del dataset[0:8]
dataset.headers = (
'Артикул',
'Превью',
'Модель / Цвет',
'Раздел',
'Бренд',
'Описание',
'Доп. параметры',
'Цвет',
'Состав',
'Розничная цена, р',
'Мелкий опт от 10шт.',
'Комиссия, р',
'Опт. от 15000р',
'- 3% от 30000р',
'- 7% от 70000р',
'- 11% от 110000р',
'',
'Кол-во',
'*',
'',
'',
'XS (42)',
'S (44)',
'M (46)',
'L (48)',
'XL (50)',
'XXL (52)',
'XXХL (54-56)',
'4ХL (58)'
)
class Meta:
model = Product
skip_unchanged = False
report_skipped = True
import_id_fields = ('sku',)
exclude = ('id',)
fields = ('sku', 'model', 'content', 'brand', 'categories')
export_order = fields
