class ProductResource(resources.ModelResource):
group = resources.Field(attribute='group',
column_name='group',
widget=ForeignKeyWidget(Group, 'code'))
operator = resources.Field(attribute='operator',
column_name='operator',
widget=ForeignKeyWidget(Operator, 'code'))
class Meta:
model = Product
fields = [
'code',
'product_name',
'type_product',
'operator',
'group',
'nominal',
'price',
'commision',
]
export_order = [
'code',
'product_name',
'type_product',
'operator',
'group',
'nominal',
'price',
'commision',
]
import_id_fields = ['code']
skip_unchanged = True
report_skipped = False
class PartnerExport(resources.ModelResource):
risk_rating = resources.Field()
agreement_count = resources.Field()
intervention_count = resources.Field()
active_staff_members = resources.Field()
class Meta:
model = PartnerOrganization
# TODO add missing fields:
# Blocked Flag (new property)
# Bank Info (just the number of accounts synced from VISION)
fields = ('vendor_number', 'vision_synced', 'deleted_flag', 'name', 'short_name', 'alternate_id',
'alternate_name', 'partner_type', 'cso_type', 'address', 'email', 'phone_number',
'risk_rating', 'type_of_assessment', 'last_assessment_date', 'total_ct_cp', 'total_ct_cy',
'agreement_count', 'intervention_count', 'active_staff_members')
export_order = fields
def dehydrate_risk_rating(self, partner_organization):
return partner_organization.rating
def dehydrate_agreement_count(self, partner_organization):
return partner_organization.agreements.count()
def dehydrate_intervention_count(self, partner_organization):
if partner_organization.partner_type == PartnerType.GOVERNMENT:
return partner_organization.work_plans.count()
intervention_count = 0
# TODO: Nik revisit this... move this into a single query
for agr in partner_organization.agreements.all():
intervention_count += agr.interventions.count()
return intervention_count
def dehydrate_active_staff_members(self, partner_organization):
return ', '.join([sm.get_full_name() for sm in partner_organization.staff_members.all()])
class PhraseResource(resources.ModelResource):
english = resources.Field(attribute='content', column_name='ENGLISH')
translated_text = resources.Field(column_name='TRANSLATED_TEXT',
default='')
audio_url = resources.Field(column_name='AUDIO_URL', default='')
class Meta:
model = Phrase
fields = ['english', 'translated_text', 'audio_url']
class TicketSaleResource(resources.ModelResource):
ticket_type = resources.Field()
email = resources.Field()
class Meta:
model = TicketSale
fields = ('the_ticket_id', 'full_name', 'diet', 'tagline', 'ticket')
def dehydrate_ticket_type(self, obj):
return obj.ticket.ticket_type
def dehydrate_email(self, obj):
return obj.user.email
class DeliveryBatchResource(resources.ModelResource):
box_count = resources.Field()
tshirt_sizes = resources.Field()
class Meta:
model = models.DeliveryBatch
fields = ('note', 'created', 'campaign__name', 'dispatched')
export_order = ('note', 'created', 'campaign__name', 'dispatched',
'box_count', 'tshirt_sizes')
def dehydrate_box_count(self, db):
return db.box_count()
def dehydrate_tshirt_sizes(self, db):
t_shirts = db.t_shirt_size_counts()
return ';'.join('%s;%i' % (k, v) for k, v in t_shirts)
class GovernmentExport(resources.ModelResource):
sectors = resources.Field()
cash_transfer = resources.Field()
year = resources.Field()
class Meta:
model = GovernmentIntervention
fields = ('number', 'partner__name', 'result_structure__name', 'sectors', 'cash_transfer',
'year')
export_order = fields
def dehydrate_sectors(self, government):
return ''
def dehydrate_cash_transfer(self, government):
return sum([r.planned_amount for r in government.results.all()])
def dehydrate_year(self, government):
return government.result_structure.to_date.year
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 ConfigurationResource(resources.ModelResource):
name = resources.Field()
# measure = resources.Field(column_name='measure') # column name represent the name of column in exported data
# dimension = resources.Field(column_name='dimension')
# full_title = resources.Field()
class Meta:
model = Configuration
fields = ('name',)
def dehydrate_name(self,Configuration):
return '%s' %(Configuration.user_defined_name)
class OperatorResource(resources.ModelResource):
group = resources.Field(attribute='group',
column_name='group',
widget=ManyToManyWidget(model=Group, field='slug'))
class Meta:
model = Operator
fields = ['slug', 'operator_name', 'group']
export_order = ['slug', 'operator_name', 'group']
import_id_fields = ['slug']
skip_unchanged = True
report_skipped = False
class AgRegistrationResource(resources.ModelResource):
assembly = resources.Field(attribute='assembly__name',
column_name=_('Assembly'))
registration_date = resources.Field(attribute='date',
column_name=_('Registration date'))
member_fullname = resources.Field(attribute='member__full_name',
column_name=_('Member name'))
member_number = resources.Field(attribute='member__www_soci',
column_name=_('Membership number'))
member_vat = resources.Field(attribute='member__username',
column_name=_('DNI/NIF/NIE'))
member_email = resources.Field(attribute='member__email',
column_name=_('Email'))
class Meta:
model = AgRegistration
fields = ('member_name', 'member_number', 'member_vat',
'registration_date', 'member_email')
import_id_fields = (
'registration_date',
'member_vat',
)
class AlumnoResource(resources.ModelResource):
campus = resources.Field()
grupo = resources.Field()
proyecto = resources.Field()
institucion = resources.Field()
class Meta:
model = Alumno
fields = ('matricula', 'nombre', 'email', 'campus', 'nivel', 'grupo',
'proyecto', 'institucion')
export_order = ('matricula', 'nombre', 'email', 'campus', 'nivel',
'grupo', 'proyecto', 'institucion')
def dehydrate_campus(self, obj):
grupo = obj.get_grupo()
if grupo:
return grupo.campus
else:
return "N/A"
def dehydrate_grupo(self, obj):
grupo = obj.get_grupo()
if grupo:
return "{}-{}".format(grupo.nivel, grupo.grupo)
else:
return "N/A"
def dehydrate_proyecto(self, obj):
proyecto = obj.proyecto_set.last()
if proyecto:
return proyecto.nombre
else:
return "N/A"
def dehydrate_institucion(self, obj):
proyecto = obj.proyecto_set.last()
if proyecto:
return proyecto.institucion.nombre
else:
return "N/A"
class DeliveryBatchResource(resources.ModelResource):
box_count = resources.Field()
tshirt_sizes = resources.Field()
class Meta:
model = models.DeliveryBatch
fields = ("note", "created", "campaign__name", "dispatched")
export_order = (
"note",
"created",
"campaign__name",
"dispatched",
"box_count",
"tshirt_sizes",
)
def dehydrate_box_count(self, db):
return db.box_count()
def dehydrate_tshirt_sizes(self, db):
t_shirts = db.t_shirt_size_counts()
return ";".join("%s;%i" % (k, v) for k, v in t_shirts)
class TwitterProposalResource(resources.ModelResource):
talk_title = resources.Field()
speaker = resources.Field()
photo = resources.Field()
class Meta:
model = ProposalResult
fields = ("talk_title", "speaker","proposal__speaker__twitter_username", "photo", )
def dehydrate_talk_title(self, book):
return book.proposal.title
def get_speaker(self, obj):
return obj.proposal.speaker
def dehydrate_speaker(self, book):
speaker = self.get_speaker(book)
return speaker.name
def dehydrate_photo(self, book):
speaker = self.get_speaker(book)
if speaker.photo:
return speaker.photo.url
class ParticipateGameListResource(resources.ModelResource):
class Meta:
model = ParticipateGameListAdminProxy
fields = [
'research', 'participant', 'game', 'finished_dt', 'response_time',
'score', 'result'
]
export_order = [
'research', 'participant', 'game', 'finished_dt', 'response_time',
'score', 'result'
]
research = resources.Field(column_name='연구')
participant = resources.Field(column_name='피험자(아이디)')
game = resources.Field(column_name='game')
finished_dt = resources.Field(attribute='finished_dt', column_name='참여일시')
response_time = resources.Field(column_name='평균응답시간(초)')
score = resources.Field(column_name='정답률')
result = resources.Field(attribute='result', column_name='응답원본')
def dehydrate_research(self, obj):
return obj.participate.research.project_title
def dehydrate_participant(self, obj):
return obj.participate.participant.__str__()
def dehydrate_game(self, obj):
return obj.game.game_title
def dehydrate_finished_dt(self, obj):
local_tz = pytz.timezone('Asia/Seoul')
return obj.finished_dt.replace(tzinfo=pytz.utc).astimezone(local_tz)
def dehydrate_response_time(self, obj):
result = obj.calculate_score()
return round(result['avg_rt'], 2)
def dehydrate_score(self, obj):
result = obj.calculate_score()
try:
score = result['score']['correct'] / result['score']['count']
except:
score = 0
return round(score * 100, 2)
class AgreementExport(resources.ModelResource):
reference_number = resources.Field()
signed_by_partner = resources.Field()
signed_by_unicef = resources.Field()
authorized_officers = resources.Field()
start_date = resources.Field()
end_date = resources.Field()
class Meta:
model = Agreement
# TODO add missing fields:
# Attached Signed Agreement Link
# Amendments (comma separated list of amended fields)
fields = ('reference_number', 'partner__vendor_number', 'partner__name', 'partner__short_name',
'start_date', 'end_date', 'signed_by_partner', 'signed_by_partner_date',
'signed_by_unicef', 'signed_by_unicef_date', 'authorized_officers')
export_order = fields
def dehydrate_reference_number(self, agreement):
return agreement.reference_number
def dehydrate_signed_by_partner(self, agreement):
if agreement.partner_manager:
return agreement.partner_manager.get_full_name()
return None
def dehydrate_signed_by_unicef(self, agreement):
if agreement.signed_by:
return agreement.signed_by.get_full_name()
return ''
def dehydrate_authorized_officers(self, agreement):
names = [ao.officer.get_full_name() for ao in agreement.authorized_officers.all()]
return ', '.join(names)
def dehydrate_start_date(self, agreement):
return agreement.start
def dehydrate_end_date(self, agreement):
return agreement.end
class LocalGroupsResource(resources.ModelResource):
name = resources.Field(attribute='name')
data = resources.Field(attribute='data', )
full_name = resources.Field(attribute='full_name')
alias = resources.Field(attribute='alias')
email = resources.Field(attribute='email')
logo = resources.Field(attribute='logo')
class Meta:
model = LocalGroups
fields = ('name', 'data', 'full_name', 'alias', 'email', 'logo')
import_id_fields = ('name', )
def import_data(self,
dataset,
dry_run=False,
raise_errors=False,
use_transactions=None,
collect_failed_rows=False,
**kwargs):
new_data = [{
'name': header,
'data': dataset[header][0]
} for header in dataset.headers]
new_dataset = tablib.Dataset()
new_dataset.dict = new_data
return super().import_data(new_dataset,
dry_run=dry_run,
raise_errors=raise_errors,
use_transactions=use_transactions,
collect_failed_rows=collect_failed_rows,
**kwargs)
class ParticipateResource(resources.ModelResource):
class Meta:
model = ParticipateAdminProxy
fields = [
'research', 'participate_at', 'participant', 'agree_name', 'agree',
'poll'
]
export_order = [
'research', 'participate_at', 'participant', 'agree_name', 'agree',
'poll'
]
research = resources.Field(attribute='research', column_name='연구')
participate_at = resources.Field(attribute='participate_at',
column_name='연구참여일시')
participant = resources.Field(attribute='participant',
column_name='피험자(아이디)')
agree_name = resources.Field(attribute='agree_name', column_name='동의자명')
agree = resources.Field(attribute='agree', column_name='동의여부')
poll = resources.Field(attribute='poll', column_name='설문')
def dehydrate_research(self, obj):
return obj.research.project_title
def dehydrate_participate_at(self, obj):
local_tz = pytz.timezone('Asia/Seoul')
return obj.participate_at.replace(tzinfo=pytz.utc).astimezone(local_tz)
def dehydrate_participant(self, obj):
return obj.participant.__str__()
def dehydrate_agree(self, obj):
if obj.agree:
return '동의'
else:
return '미동의'
class LocalityResource(resources.ModelResource):
id = resources.Field(attribute="id", widget=LocalityWidget())
class Meta:
model = Locality
exclude = ("state", "updated")
class InterventionExport(resources.ModelResource):
reference_number = resources.Field()
locations = resources.Field()
sectors = resources.Field()
partner_manager_name = resources.Field()
unicef_manager_name = resources.Field()
supplies = resources.Field()
days_from_submission_to_signed = resources.Field()
days_from_review_to_signed = resources.Field()
total_unicef_cash = resources.Field()
total_budget = resources.Field()
class Meta:
model = PCA
# TODO add missin fields:
# UNICEF Office (new property)
# Completed Visits (# of completed trips)
# FR Numbers (comma separated)
# Number of Active Action Points
fields = ('title', 'reference_number', 'status', 'partner__name', 'partnership_type', 'sectors', 'start_date',
'end_date', 'result_structure__name', 'locations', 'initiation_date', 'submission_date',
'review_date', 'days_from_submission_to_signed', 'days_from_review_to_signed',
'signed_by_partner_date', 'partner_manager_name', 'signed_by_unicef_date', 'unicef_manager_name',
'total_unicef_cash', 'supplies', 'total_budget', 'planned_visits')
export_order = fields
def dehydrate_reference_number(self, intervention):
return intervention.reference_number
def dehydrate_locations(self, intervention):
location_names = [l.location.name for l in intervention.locations.all() if l.location]
return ', '.join(location_names)
def dehydrate_sectors(self, intervention):
return intervention.sector_names
def dehydrate_partner_manager_name(self, intervention):
if intervention.partner_manager:
return intervention.partner_manager.get_full_name()
return ''
def dehydrate_unicef_manager_name(self, intervention):
if intervention.unicef_manager:
return intervention.unicef_manager.get_full_name()
return ''
def dehydrate_supplies(self, intervention):
supply_names = [sp.item.name for sp in intervention.supply_plans.all()]
return ', '.join(supply_names)
def dehydrate_days_from_submission_to_signed(self, intervention):
return intervention.days_from_submission_to_signed
def dehydrate_days_from_review_to_signed(self, intervention):
return intervention.days_from_review_to_signed
def dehydrate_total_unicef_cash(self, intervention):
return intervention.total_unicef_cash
def dehydrate_total_budget(self, intervention):
return intervention.total_budget
class ProvinceResource(resources.ModelResource):
id = resources.Field(attribute="id", widget=ProvinceWidget())
class Meta:
model = Province
class DistrictResource(resources.ModelResource):
id = resources.Field(attribute="id", widget=DistrictWidget())
class Meta:
model = District
