def get(self, request, pk):
instance = self.get_object(request, pk)
data = serialize(instance, **self.template)
for i in range(len(data['results'])):
data['results'][i]['variant'] = VariantResource.get(
request, data['results'][i]['variant_id'])
data['results'][i].pop('variant_id')
result_id = data['results'][i]['id']
data['results'][i]['num_assessments'] = Assessment.objects.filter(
sample_result__id=result_id,
sample_result__resultset__id=pk).count()
try:
assessment = Assessment.objects.get(
sample_result__id=result_id,
sample_result__resultset__id=pk,
user=request.user.id)
data['results'][i]['assessment'] = \
serialize(assessment, **api.templates.ResultAssessment)
except Assessment.DoesNotExist:
data['results'][i]['assessment'] = {}
return data
def get(self, request, pk):
related = ['type', 'chr']
try:
variant = self.model.objects.select_related(*related).get(pk=pk)
except self.model.DoesNotExist:
raise Http404
data = serialize(variant, **self.template)
# Roll up unique set of genes and effects for this variant since
# this is quite important
genes = set()
effects = set()
for eff in data['effects']:
effects.add(eff['type'])
if eff.get('transcript') and eff['transcript'].get('gene'):
if eff['transcript']['gene']:
genes.add(eff['transcript']['gene']['symbol'])
data['unique_genes'] = sorted(genes)
data['unique_effects'] = sorted(effects)
# Augment resource with cohort-related details (e.g. allele frequencies)
perms = Q(cohort__user=None, cohort__published=True) | \
Q(cohort__user=request.user)
cohort_variants = CohortVariant.objects.filter(
perms, variant=variant).order_by('-cohort__order',
'cohort__name').distinct()
data['cohorts'] = serialize(cohort_variants,
**api.templates.CohortVariant)
return data
def get_context_data(self, **kwargs):
application = get_object_or_404(Application, pk=self.args[0])
if application.hard_copy is not None:
application.licence_type.application_schema, application.data = \
append_app_document_to_schema_data(application.licence_type.application_schema, application.data,
application.hard_copy.file.url)
convert_documents_to_url(application.data, application.documents.all(),
'')
kwargs['application'] = serialize(application,
posthook=format_application)
kwargs['assessments'] = serialize(
Assessment.objects.filter(application=application),
posthook=format_assessment)
kwargs['payment_status'] = payment_utils.PAYMENT_STATUSES.get(
payment_utils.get_application_payment_status(application))
kwargs['log_entry_form'] = ApplicationLogEntryForm(
to=get_log_entry_to(application),
fromm=self.request.user.get_full_name())
return super(ViewReadonlyOfficerView, self).get_context_data(**kwargs)
def get_context_data(self, **kwargs):
ctx = super(CurateReturnView, self).get_context_data(**kwargs)
ret = ctx['return']
ctx['return'] = serialize(
ret,
posthook=format_return,
exclude=['application', 'applicationrequest_ptr', 'licence'])
if ret.proxy_customer is None:
to = ret.licence.holder
else:
to = ret.proxy_customer
ctx['log_entry_form'] = ReturnsLogEntryForm(
to=to.get_full_name(),
fromm=self.request.user.get_full_name(),
)
ctx['amendment_request_form'] = ReturnAmendmentRequestForm(
ret=ret, officer=self.request.user)
amendment_requests = ReturnAmendmentRequest.objects.filter(ret=ret)
ctx['amendment_requests'] = serialize(amendment_requests,
fields=['status', 'reason'])
return ctx
def format_application(instance, attrs):
attrs['processing_status'] = PROCESSING_STATUSES[
attrs['processing_status']]
attrs['id_check_status'] = ID_CHECK_STATUSES[attrs['id_check_status']]
attrs['returns_check_status'] = RETURNS_CHECK_STATUSES[
attrs['returns_check_status']]
attrs['character_check_status'] = CHARACTER_CHECK_STATUSES[
attrs['character_check_status']]
attrs['review_status'] = REVIEW_STATUSES[attrs['review_status']]
attrs['licence_type']['default_conditions'] = serialize([
ap.condition
for ap in instance.licence_type.defaultcondition_set.order_by('order')
])
attrs['conditions'] = serialize([
ap.condition
for ap in instance.applicationcondition_set.order_by('order')
])
attrs['applicant_profile']['user'] = serialize(
instance.applicant_profile.user,
exclude=['postal_address', 'residential_address', 'billing_address'])
attrs['applicant_profile']['postal_address'] = serialize(
instance.applicant_profile.postal_address,
exclude=['user', 'oscar_address'])
if instance.applicant.identification is not None and instance.applicant.identification.file is not None:
attrs['applicant']['identification'][
'url'] = instance.applicant.identification.file.url
if instance.applicant.senior_card is not None and instance.applicant.senior_card.file is not None:
attrs['applicant']['senior_card'][
'url'] = instance.applicant.senior_card.file.url
return attrs
def get(self, request, pk):
related = ['type', 'chr']
try:
variant = self.model.objects.select_related(*related).get(pk=pk)
except self.model.DoesNotExist:
raise Http404
data = serialize(variant, **self.template)
# Roll up unique set of genes and effects for this variant since
# this is quite important
genes = set()
effects = set()
for eff in data['effects']:
effects.add(eff['type'])
if eff.get('transcript') and eff['transcript'].get('gene'):
if eff['transcript']['gene']:
genes.add(eff['transcript']['gene']['symbol'])
data['unique_genes'] = sorted(genes)
data['unique_effects'] = sorted(effects)
# Augment resource with cohort-related details (e.g. allele frequencies)
perms = Q(cohort__user=None, cohort__published=True) | \
Q(cohort__user=request.user)
cohort_variants = CohortVariant.objects.filter(perms,
variant=variant).order_by('-cohort__order', 'cohort__name').distinct()
data['cohorts'] = serialize(cohort_variants,
**api.templates.CohortVariant)
return data
def serialize_to_python(self, data):
"""
Invoked by ``postprocess``.
Serializes ``data`` to python data structures, according to the
handler's ``template`` attribute, or request-level field selection
defined by querystring parameter ``field``.
Args:
data: Result of the handler's operation
Returns:
Serialized data.
"""
# NOTE: The request level field selection doesn not work if the
# handler's ``template`` attribute uses ``django-preserialize``'s
# pseudo selectors
# See
# <https://github.com/bruth/django-preserialize#my-model-has-a-ton-of-fields-and-i-dont-want-to-type-them-all-out-what-do-i-do>
# It only works when the ``fields`` are defined one by one in a list.
field_selection = set(self.request.GET.getlist('field'))
if field_selection:
intersection = field_selection.intersection(
set(self.template['fields']))
template = {key: value for key, value in self.template.items()}
template['fields'] = intersection
return preserializer.serialize(data, **template)
return preserializer.serialize(data, **self.template)
def _build_data(self, request, application):
with open('%s/json/%s.json' % (APPLICATION_SCHEMA_PATH, application.licence_type.code)) as data_file:
form_structure = json.load(data_file)
officers = [{'id': officer.id, 'text': render_user_name(officer)} for officer in get_all_officers()]
officers.insert(0, {'id': 0, 'text': 'Unassigned'})
current_ass_groups = [ass_request.assessor_group for ass_request in Assessment.objects.filter(application=application)]
ass_groups = [{'id': ass_group.id, 'text': ass_group.name} for ass_group in
AssessorGroup.objects.all().exclude(id__in=[ass_group.pk for ass_group in current_ass_groups])]
previous_application_data = []
for revision in revisions.get_for_object(application).filter(revision__comment='Details Modified').order_by('-revision__date_created'):
previous_application_data.append({'lodgement_number': revision.object_version.object.lodgement_number +
'-' + str(revision.object_version.object.lodgement_sequence),
'date': formats.date_format(revision.revision.date_created, 'd/m/Y', True),
'data': revision.object_version.object.data})
data = {
'user': serialize(request.user),
'application': serialize(application, posthook=format_application),
'form_structure': form_structure,
'officers': officers,
'amendment_requests': serialize(AmendmentRequest.objects.filter(application=application), posthook=format_amendment_request),
'assessor_groups': ass_groups,
'assessments': serialize(Assessment.objects.filter(application=application),
posthook=format_assessment),
'previous_application_data': serialize(previous_application_data),
'csrf_token': str(csrf(request).get('csrf_token'))
}
return data
def get(self, request, pk):
instance = self.get_object(request, pk)
data = serialize(instance, **self.template)
for i in range(len(data['results'])):
data['results'][i]['variant'] = VariantResource.get(
request, data['results'][i]['variant_id'])
data['results'][i].pop('variant_id')
result_id = data['results'][i]['id']
data['results'][i]['num_assessments'] = Assessment.objects.filter(
sample_result__id=result_id,
sample_result__resultset__id=pk).count()
try:
assessment = Assessment.objects.get(
sample_result__id=result_id,
sample_result__resultset__id=pk,
user=request.user.id)
data['results'][i]['assessment'] = \
serialize(assessment, **api.templates.ResultAssessment)
except Assessment.DoesNotExist:
data['results'][i]['assessment'] = {}
return data
def serialize_to_python(self, data):
"""
Invoked by ``postprocess``.
Serializes ``data`` to python data structures, according to the
handler's ``template`` attribute, or request-level field selection
defined by querystring parameter ``field``.
Args:
data: Result of the handler's operation
Returns:
Serialized data.
"""
# NOTE: The request level field selection doesn not work if the
# handler's ``template`` attribute uses ``django-preserialize``'s
# pseudo selectors
# See
# <https://github.com/bruth/django-preserialize#my-model-has-a-ton-of-fields-and-i-dont-want-to-type-them-all-out-what-do-i-do>
# It only works when the ``fields`` are defined one by one in a list.
field_selection = set(self.request.GET.getlist("field"))
if field_selection:
intersection = field_selection.intersection(set(self.template["fields"]))
template = {key: value for key, value in self.template.items()}
template["fields"] = intersection
return preserializer.serialize(data, **template)
return preserializer.serialize(data, **self.template)
def get_context_data(self, **kwargs):
application = get_object_or_404(Application, pk=self.args[0])
if application.hard_copy is not None:
application.licence_type.application_schema, application.data = \
append_app_document_to_schema_data(application.licence_type.application_schema, application.data,
application.hard_copy.file.url)
convert_documents_to_url(application.data, application.documents.all(), '')
kwargs['application'] = serialize(application, posthook=format_application)
kwargs['form_structure'] = application.licence_type.application_schema
assessment = get_object_or_404(Assessment, pk=self.args[1])
kwargs['assessment'] = serialize(assessment, post_hook=format_assessment,exclude=['application','applicationrequest_ptr'])
kwargs['other_assessments'] = serialize(Assessment.objects.filter(application=application).
exclude(id=assessment.id).order_by('id'), posthook=format_assessment,exclude=['application','applicationrequest_ptr'])
kwargs['log_entry_form'] = ApplicationLogEntryForm(to=get_log_entry_to(application),
fromm=self.request.user.get_full_name())
if application.processing_status == 'declined':
message = "This application has been declined."
details = ApplicationDeclinedDetails.objects.filter(application=application).first()
if details and details.reason:
message += "<br/>Reason:<br/>{}".format(details.reason.replace('\n', '<br/>'))
kwargs['application']['declined_reason'] = details.reason
messages.error(self.request, message)
return super(ViewReadonlyAssessorView, self).get_context_data(**kwargs)
def get_context_data(self, **kwargs):
application = get_object_or_404(Application, pk=self.args[0])
assessment = get_object_or_404(Assessment, pk=self.args[1])
if application.hard_copy is not None:
application.licence_type.application_schema, application.data = \
append_app_document_to_schema_data(application.licence_type.application_schema, application.data,
application.hard_copy.file.url)
convert_documents_to_url(application.data, application.documents.all(), '')
kwargs['application'] = serialize(application, posthook=format_application)
kwargs['form_structure'] = application.licence_type.application_schema
kwargs['assessment'] = serialize(assessment, post_hook=format_assessment)
kwargs['other_assessments'] = serialize(Assessment.objects.filter(application=application).
exclude(id=assessment.id).order_by('id'), posthook=format_assessment)
assessors = [{'id': assessor.id, 'text': assessor.get_full_name()} for assessor in
assessment.assessor_group.members.all().order_by('first_name')]
assessors.insert(0, {'id': 0, 'text': 'Unassigned'})
kwargs['assessors'] = assessors
kwargs['log_entry_form'] = ApplicationLogEntryForm(to=get_log_entry_to(application),
fromm=self.request.user.get_full_name())
return super(EnterConditionsAssessorView, self).get_context_data(**kwargs)
def get_context_data(self, **kwargs):
application = get_object_or_404(Application, pk=self.args[0])
if application.hard_copy is not None:
application.licence_type.application_schema, application.data = \
append_app_document_to_schema_data(application.licence_type.application_schema, application.data,
application.hard_copy.file.url)
convert_documents_to_url(application.data, application.documents.all(),
'')
kwargs['application'] = serialize(application,
posthook=format_application)
kwargs['form_structure'] = application.licence_type.application_schema
assessment = get_object_or_404(Assessment, pk=self.args[1])
kwargs['assessment'] = serialize(assessment,
post_hook=format_assessment)
kwargs['other_assessments'] = serialize(Assessment.objects.filter(
application=application).exclude(id=assessment.id).order_by('id'),
posthook=format_assessment)
kwargs['log_entry_form'] = ApplicationLogEntryForm(
to=get_log_entry_to(application),
fromm=self.request.user.get_full_name())
return super(ViewReadonlyAssessorView, self).get_context_data(**kwargs)
def _build_data(self, request, application):
officers = [{'id': officer.id, 'text': render_user_name(officer)} for officer in get_all_officers()]
officers.insert(0, {'id': 0, 'text': 'Unassigned'})
current_ass_groups = [ass_request.assessor_group for ass_request in
Assessment.objects.filter(application=application)]
ass_groups = [{'id': ass_group.id, 'text': ass_group.name} for ass_group in
AssessorGroup.objects.all().exclude(id__in=[ass_group.pk for ass_group in current_ass_groups])]
# extract and format the previous lodgements of the application
previous_lodgements = []
for revision in revisions.get_for_object(application).filter(revision__comment='Details Modified').order_by(
'-revision__date_created'):
previous_lodgement = revision.object_version.object
if previous_lodgement.hard_copy is not None:
previous_lodgement.licence_type.application_schema, previous_lodgement.data = \
append_app_document_to_schema_data(previous_lodgement.licence_type.application_schema, previous_lodgement.data,
previous_lodgement.hard_copy.file.url)
# reversion won't reference the previous many-to-many sets, only the latest one, so need to get documents as per below
previous_lodgement_documents = Document.objects.filter(pk__in=revision.field_dict['documents'])
convert_documents_to_url(previous_lodgement.licence_type.application_schema, previous_lodgement.data,
previous_lodgement_documents)
previous_lodgements.append({'lodgement_number': '{}-{}'.format(previous_lodgement.lodgement_number,
previous_lodgement.lodgement_sequence),
'date': formats.date_format(revision.revision.date_created, 'd/m/Y', True),
'data': previous_lodgement.data})
previous_application_returns_outstanding = False
if application.previous_application is not None:
previous_application_returns_outstanding = Return.objects.filter(licence=application.previous_application.licence).\
exclude(status='accepted').exclude(status='submitted').exists()
if application.hard_copy is not None:
application.licence_type.application_schema, application.data = \
append_app_document_to_schema_data(application.licence_type.application_schema, application.data,
application.hard_copy.file.url)
convert_documents_to_url(application.licence_type.application_schema, application.data, application.documents.all())
data = {
'user': serialize(request.user),
'application': serialize(application, posthook=format_application),
'form_structure': application.licence_type.application_schema,
'officers': officers,
'amendment_requests': serialize(AmendmentRequest.objects.filter(application=application),
posthook=format_amendment_request),
'assessor_groups': ass_groups,
'assessments': serialize(Assessment.objects.filter(application=application),
posthook=format_assessment),
'previous_versions': serialize(previous_lodgements),
'returns_outstanding': previous_application_returns_outstanding,
'csrf_token': str(csrf(request).get('csrf_token'))
}
return data
def epSuccessPayment(request):
KEYS = [settings.MERCHANT_KEY, request.POST['txnid'], request.POST['amount'],request.POST['productinfo'], request.POST['firstname'], request.POST['email'],'', '', '', '', '','', '', '', '', '']
status = request.POST['status']
result={}
if verify_hash(KEYS, status) == request.POST['hash']:
return JsonResponse({'status':'200','success':serialize(request)})
else :
return JsonResponse({'status':'404','error':serialize(request)})
def transform_player_stats(audit_date, stat_recs, clv_recs,
stats_time='1 month', clv_time='12 month'):
s_recs = []
stat_df = pd.DataFrame.from_records(stat_recs, index='player_id')
clv_summary = calc_clv(clv_recs, audit_date)
combine_df = pd.concat([clv_summary, stat_df], axis=1)
combine_dict = combine_df.to_dict(orient='index')
player_ids = combine_dict.keys()
for player_id in player_ids:
try:
rec = clean_stat_dict_values(combine_dict[player_id])
rec['player_id'] = int(player_id)
rec['start_date'] = parse(audit_date)
date_dim = DateDimension.objects.get(full_date=rec['start_date'])
#convert dates to UTC
date_dim.full_date = local_to_utc(date_dim.full_date)
date_dim.week_begin_date = local_to_utc(date_dim.week_begin_date)
player = get_player_rec(rec)
player_age = calculate_age(audit_date, player.birth_date)
full_name = player.first_name + " " + player.last_name
player_tier = get_player_tier(audit_date, player.player_id)
#geo_point for player
geo_point = create_geo_point(player)
date_s = serialize(date_dim)
player_s = serialize(player)
# clean up field the user does not need to see
player_s.pop('effective_date', None)
player_s.pop('expiration_date', None)
player_s.pop('addr_lon', None)
player_s.pop('addr_lat', None)
player_s.pop('current', None)
player_s['home_geo_point'] = serialize(geo_point)
player_s['age'] = player_age
player_s['full_name'] = full_name
player_s['grc_rank'] = player_tier
rec['player']=player_s
rec['gaming_date']=date_s
rec['clv_T']=rec.pop('T')
rec['clv_frequency']=rec.pop('frequency')
rec['clv_monetary_value']=rec.pop('monetary_value')
rec['clv_recency']=rec.pop('recency')
rec['stats_timeframe']=stats_time
rec['clv_timeframe']=clv_time
rec.pop('player_id', None)
rec.pop('start_date', None)
s_recs.append(rec)
except Exception, e:
print e
def get_context_data(self, **kwargs):
application = get_object_or_404(Application, pk=self.args[0])
with open('%s/json/%s.json' % (APPLICATION_SCHEMA_PATH, application.licence_type.code)) as data_file:
form_structure = json.load(data_file)
kwargs['application'] = serialize(application, posthook=format_application)
kwargs['form_structure'] = form_structure
kwargs['assessments'] = serialize(Assessment.objects.filter(application=application), posthook=format_assessment)
kwargs['action_url'] = reverse('applications:submit_conditions', args=[application.pk])
return super(EnterConditionsView, self).get_context_data(**kwargs)
def epSuccessPayment(request):
KEYS = [
settings.MERCHANT_KEY, request.POST['txnid'], request.POST['amount'],
request.POST['productinfo'], request.POST['firstname'],
request.POST['email'], '', '', '', '', '', '', '', '', '', ''
]
status = request.POST['status']
result = {}
if verify_hash(KEYS, status) == request.POST['hash']:
return JsonResponse({'status': '200', 'success': serialize(request)})
else:
return JsonResponse({'status': '404', 'error': serialize(request)})
def get_context_data(self, **kwargs):
application = get_object_or_404(Application, pk=self.args[0])
if application.hard_copy is not None:
application.licence_type.application_schema, application.data = \
append_app_document_to_schema_data(application.licence_type.application_schema, application.data,
application.hard_copy.file.url)
convert_documents_to_url(application.data, application.documents.all(), '')
kwargs['application'] = serialize(application,posthook=format_application,
related={
'applicant': {'exclude': ['residential_address','postal_address','billing_address']},
'applicant_profile':{'fields':['email','id','institution','name']},
'previous_application':{'exclude':['applicant','applicant_profile','previous_application','licence']},
'licence':{'related':{
'holder':{'exclude': ['residential_address','postal_address','billing_address']},
'issuer':{'exclude': ['residential_address','postal_address','billing_address']},
'profile':{'related': {'user': {'exclude': ['residential_address','postal_address','billing_address']}},
'exclude': ['postal_address']}
},'exclude':['holder','issuer','profile','licence_ptr']}
})
kwargs['form_structure'] = application.licence_type.application_schema
assessment = get_object_or_404(Assessment, pk=self.args[1])
kwargs['assessment'] = serialize(assessment, post_hook=format_assessment,exclude=['application','applicationrequest_ptr'],
related={'assessor_group':{'related':{'members':{'exclude':['residential_address']}}},
'officer':{'exclude':['residential_address']},
'assigned_assessor':{'exclude':['residential_address']}})
kwargs['other_assessments'] = serialize(Assessment.objects.filter(application=application).exclude(id=assessment.id).order_by('id'),
posthook=format_assessment,exclude=['application','applicationrequest_ptr'],
related={'assessor_group':{'related':{'members':{'exclude':['residential_address']}}},
'officer':{'exclude':['residential_address']},
'assigned_assessor':{'exclude':['residential_address']}})
kwargs['log_entry_form'] = ApplicationLogEntryForm(to=get_log_entry_to(application),
fromm=self.request.user.get_full_name())
if application.processing_status == 'declined':
message = "This application has been declined."
details = ApplicationDeclinedDetails.objects.filter(application=application).first()
if details and details.reason:
message += "<br/>Reason:<br/>{}".format(details.reason.replace('\n', '<br/>'))
kwargs['application']['declined_reason'] = details.reason
messages.error(self.request, message)
return super(ViewReadonlyAssessorView, self).get_context_data(**kwargs)
def get_context_data(self, **kwargs):
application = get_object_or_404(Application, pk=self.args[0])
assessment = get_object_or_404(Assessment, pk=self.args[1])
if application.hard_copy is not None:
application.licence_type.application_schema, application.data = \
append_app_document_to_schema_data(application.licence_type.application_schema, application.data,
application.hard_copy.file.url)
convert_documents_to_url(application.data, application.documents.all(), '')
#kwargs['application'] = serialize(application, posthook=format_application)
kwargs['application'] = serialize(application,posthook=format_application,
related={
'applicant': {'exclude': ['residential_address','postal_address','billing_address']},
'applicant_profile':{'fields':['email','id','institution','name']},
'previous_application':{'exclude':['applicant','applicant_profile','previous_application','licence']},
'licence':{'related':{
'holder':{'exclude': ['residential_address','postal_address','billing_address']},
'issuer':{'exclude': ['residential_address','postal_address','billing_address']},
'profile':{'related': {'user': {'exclude': ['residential_address','postal_address','billing_address']}},
'exclude': ['postal_address']}
},'exclude':['holder','issuer','profile','licence_ptr']}
})
kwargs['form_structure'] = application.licence_type.application_schema
kwargs['assessment'] = serialize(assessment, post_hook=format_assessment,
exclude=['application','applicationrequest_ptr'],
related={'assessor_group':{'related':{'members':{'exclude':['residential_address']}}},
'officer':{'exclude':['residential_address']},
'assigned_assessor':{'exclude':['residential_address']}})
kwargs['other_assessments'] = serialize(Assessment.objects.filter(application=application).
exclude(id=assessment.id).order_by('id'),
posthook=format_assessment,exclude=['application','applicationrequest_ptr'],
related={'assessor_group':{'related':{'members':{'exclude':['residential_address']}}},
'officer':{'exclude':['residential_address']},
'assigned_assessor':{'exclude':['residential_address']}})
assessors = [{'id': assessor.id, 'text': assessor.get_full_name()} for assessor in
assessment.assessor_group.members.all().order_by('first_name')]
assessors.insert(0, {'id': 0, 'text': 'Unassigned'})
kwargs['assessors'] = assessors
kwargs['log_entry_form'] = ApplicationLogEntryForm(to=get_log_entry_to(application),
fromm=self.request.user.get_full_name())
return super(EnterConditionsAssessorView, self).get_context_data(**kwargs)
def get(self, request, poll_pk):
poll = m.Poll.objects.get(pk=poll_pk)
data = serialize(poll, fields=['subject', 'content'])
data['options'] = {}
data['total'] = 0
for option in poll.options.all():
o = serialize(option, fields=['text', 'index', 'count'])
data['options'][unicode(option.index)] = o
data['count'] += o['count']
if request.user.is_authenticated():
try:
data['vote'] = q.votes.get(user=request.user).option.index
except m.Vote.DoesNotExist:
data['vote'] = None
return data
def prepare(self, instance):
obj = serialize(instance, **self.template)
# Augment the links
obj['_links'] = {
'self': {
'rel': 'self',
'href': reverse('serrano:datafield', args=[instance.pk]),
},
'values': {
'rel': 'data',
'href': reverse('serrano:datafield-values',
args=[instance.pk]),
},
}
if stats_capable(instance):
obj['_links']['stats'] = {
'rel': 'data',
'href': reverse('serrano:datafield-stats', args=[instance.pk]),
}
# Add distribution link only if the relevent dependencies are
# installed.
if OPTIONAL_DEPS['scipy']:
obj['_links']['distribution'] = {
'rel':
'data',
'href':
reverse('serrano:datafield-distribution',
args=[instance.pk]),
}
return obj
def serialize_sc_channel(sc_channel, exclude_fields=None):
"""JSON serializer
Serializes the given spacecraft channel.
:param sc_channel: The Spacecraft channel object to be serialized
:param exclude_fields: List of fields to be excluded from the object
:return: JSON serialization
"""
if not exclude_fields:
exclude_fields = ['id', 'spacecraft']
return serialize(sc_channel,
camelcase=True,
exclude=exclude_fields,
related={
'modulation': {
'fields': ['modulation']
},
'bandwidth': {
'fields': ['bandwidth']
},
'bitrate': {
'fields': ['bitrate']
},
'polarization': {
'fields': ['polarization']
}
})
def post(self, request, *args, **kwargs):
application = get_object_or_404(Application, pk=request.POST['applicationID'])
ass_group = get_object_or_404(AssessorGroup, pk=request.POST['assGroupID'])
assessment = Assessment.objects.get_or_create(
application=application,
assessor_group=ass_group,
defaults={
'officer': self.request.user
}
)[0]
assessment.status = 'awaiting_assessment'
assessment.save()
application.processing_status = determine_processing_status(application)
application.save()
application.log_user_action(
ApplicationUserAction.ACTION_SEND_FOR_ASSESSMENT_TO_.format(ass_group),
request)
send_assessment_requested_email(assessment, request)
# need to only set and save this after the email was sent in case the email fails whereby it should remain null
assessment.date_last_reminded = date.today()
assessment.save()
return JsonResponse({'assessment': serialize(assessment, posthook=format_assessment),
'processing_status': PROCESSING_STATUSES[application.processing_status]},
safe=False, encoder=WildlifeLicensingJSONEncoder)
def get_context_data(self, **kwargs):
application = get_object_or_404(Application, pk=self.args[0])
kwargs['application'] = serialize(application, posthook=format_application)
# if reissue
if application.licence:
kwargs['issue_licence_form'] = IssueLicenceForm(instance=application.licence)
else:
purposes = '\n\n'.join(Assessment.objects.filter(application=application).values_list('purpose', flat=True))
if hasattr(application.licence_type, 'returntype'):
return_frequency = application.licence_type.returntype.month_frequency
else:
return_frequency = -1
kwargs['issue_licence_form'] = IssueLicenceForm(purpose=purposes, is_renewable=application.licence_type.is_renewable,
return_frequency=return_frequency)
if application.proxy_applicant is None:
to = application.applicant_profile.user
else:
to = application.proxy_applicant
kwargs['log_entry_form'] = CommunicationsLogEntryForm(to=to.get_full_name(), fromm=self.request.user.get_full_name())
return super(IssueLicenceView, self).get_context_data(**kwargs)
def get(self, request, namespace=None):
params = {}
if namespace:
params['app'] = request.app.clients[namespace]
else:
params['app__in'] = request.app.clients.values_list('child__pk', flat=True)
return serialize(m.Rule.objects.request(request, **params))
def epFailPayment(request):
KEYS = [settings.MERCHANT_KEY, request.POST['txnid'], request.POST['amount'],request.POST['productinfo'], request.POST['firstname'], request.POST['email'],'', '', '', '', '','', '', '', '', '']
status = request.POST['status']
if verify_hash(KEYS, status) == request.POST['hash']:
return JsonResponse({'status':'false','cancelreason':serialize(request)})
else:
return JsonResponse({'status':'false','reason':'unethical activity detected, transaction stands cancelled'})
def player_stats_etl(audit_date):
es = Elasticsearch([es_host])
batch_chunks = []
iterator = 0
stats_ext = player_stats_extract(audit_date, 30) #30
clv_data_ext = player_clv_data(audit_date, 360) #360
stats_trans = transform_player_stats(audit_date, stats_ext, clv_data_ext)
for rec in stats_trans:
s = serialize(rec)
data_dict = {
"_index":
"slot_player_stats",
"_type":
"stats",
"_id":
str(s['player']['player_id']) + '_' +
str(s['gaming_date']['datekey']),
"_source":
s
}
batch_chunks.append(data_dict)
if iterator % 100 == 0:
try:
helpers.bulk(es, batch_chunks, request_timeout=60)
except:
pass
del batch_chunks[:]
iterator = iterator + 1
if len(batch_chunks) != 0:
helpers.bulk(es, batch_chunks)
def get(self, request, *args, **kwargs):
application = get_object_or_404(Application, pk=args[0])
data = serialize(
ApplicationUserAction.objects.filter(application=application),
**self.serial_template
)
return JsonResponse({'data': data}, safe=False, encoder=WildlifeLicensingJSONEncoder)
def get(self, request, *args, **kwargs):
application = get_object_or_404(Application, pk=args[0])
data = serialize(
ApplicationUserAction.objects.filter(application=application),
**self.serial_template
)
return JsonResponse({'data': data}, safe=False, encoder=WildlifeLicensingJSONEncoder)
def post(self, request, *args, **kwargs):
amendment_request_form = AmendmentRequestForm(request.POST)
if amendment_request_form.is_valid():
amendment_request = amendment_request_form.save()
application = amendment_request.application
application.review_status = 'awaiting_amendments'
application.customer_status = determine_customer_status(
application)
application.processing_status = determine_processing_status(
application)
application.save()
send_amendment_requested_email(amendment_request, request=request)
response = {
'review_status':
REVIEW_STATUSES[application.review_status],
'processing_status':
PROCESSING_STATUSES[application.processing_status],
'amendment_request':
serialize(amendment_request, posthook=format_amendment_request)
}
return JsonResponse(response,
safe=False,
encoder=WildlifeLicensingJSONEncoder)
else:
return JsonResponse(amendment_request_form.errors,
safe=False,
encoder=WildlifeLicensingJSONEncoder)
def get(self, request, *args, **kwargs):
ret = get_object_or_404(Return, pk=args[0])
data = serialize(ReturnLogEntry.objects.filter(ret=ret),
posthook=format_communications_log_entry,
exclude=['ret', 'communicationslogentry_ptr', 'customer', 'officer']),
return JsonResponse({'data': data[0]}, safe=False, encoder=WildlifeLicensingJSONEncoder)
def _cache_data(self, request, pk, key):
related = ['sample', 'variant', 'genotype']
try:
result = self.model.objects.select_related(*related).get(pk=pk)
except self.model.DoesNotExist:
raise Http404
data = serialize(result, **self.template)
data['_links'] = {
'self': {
'rel': 'self',
'href': reverse('api:samples:variant',
kwargs={'pk': data['id']})
},
'sample': {
'rel': 'related',
'href': reverse('api:samples:sample',
kwargs={'pk': data['sample']['id']})
},
'variant': {
'rel': 'related',
'href': reverse('api:variants:variant',
kwargs={'pk': data['variant_id']}),
}
}
# Integrate the Variant resource data
data['variant'] = VariantResource.get(request, data['variant_id'])
data.pop('variant_id')
cache.set(key, data, timeout=api.CACHE_TIMEOUT)
return data
def get(self, request, namespace=None):
params = {}
if namespace:
params['user'] = request.user.accounts[namespace]
else:
params['user__in'] = request.user.accounts.values_list('child__pk', flat=True)
return serialize(m.Trigger.objects.request(request, **params))
def test_fields(self):
obj = serialize(self.hackers, fields=['website'], values_list=True)
self.assertEqual(obj, [
'http://ejohn.org',
'https://github.com/jashkenas',
'http://holovaty.com',
])
def get_context_data(self, **kwargs):
application = get_object_or_404(Application, pk=self.args[0])
kwargs['application'] = serialize(application, posthook=format_application)
# if reissue
if application.licence:
kwargs['issue_licence_form'] = IssueLicenceForm(instance=application.licence)
kwargs['extracted_fields'] = application.licence.extracted_fields
else:
purposes = '\n\n'.join(Assessment.objects.filter(application=application).values_list('purpose', flat=True))
if hasattr(application.licence_type, 'returntype'):
return_frequency = application.licence_type.returntype.month_frequency
else:
return_frequency = -1
kwargs['issue_licence_form'] = IssueLicenceForm(purpose=purposes, is_renewable=application.licence_type.is_renewable,
return_frequency=return_frequency)
kwargs['extracted_fields'] = extract_licence_fields(application.licence_type.application_schema, application.data)
if application.proxy_applicant is None:
to = application.applicant
else:
to = application.proxy_applicant
kwargs['log_entry_form'] = ApplicationLogEntryForm(to=to.get_full_name(), fromm=self.request.user.get_full_name())
kwargs['payment_status'] = payment_utils.PAYMENT_STATUSES.get(payment_utils.
get_application_payment_status(application))
return super(IssueLicenceView, self).get_context_data(**kwargs)
def test_prehook_shorthand(self):
obj = serialize(self.hackers, prehook={'user__first_name': 'John'},
fields=['user'], related={'user': {'fields': ['first_name']}})
self.assertEqual(obj, [{
'user': '******',
}])
def get_context_data(self, **kwargs):
application = get_object_or_404(Application, pk=self.args[0])
if application.hard_copy is not None:
application.licence_type.application_schema, application.data = \
append_app_document_to_schema_data(application.licence_type.application_schema, application.data,
application.hard_copy.file.url)
convert_documents_to_url(application.data, application.documents.all(), '')
kwargs['application'] = serialize(application, posthook=format_application)
if is_officer(self.request.user):
kwargs['customer'] = application.applicant
kwargs['log_entry_form'] = ApplicationLogEntryForm(to=get_log_entry_to(application),
fromm=self.request.user.get_full_name())
else:
kwargs['payment_status'] = payment_utils.PAYMENT_STATUSES.get(payment_utils.
get_application_payment_status(application))
if application.processing_status == 'declined':
message = "This application has been declined."
details = ApplicationDeclinedDetails.objects.filter(application=application).first()
if details and details.reason:
message += "<br/>Reason:<br/>{}".format(details.reason.replace('\n', '<br/>'))
kwargs['application']['declined_reason'] = details.reason
messages.error(self.request, message)
return super(ViewReadonlyView, self).get_context_data(**kwargs)
def player_stats_etl(audit_date):
es = Elasticsearch([es_host])
batch_chunks = []
iterator = 0
stats_ext = player_stats_extract(audit_date, 30) #30
clv_data_ext = player_clv_data(audit_date, 360) #360
stats_trans = transform_player_stats(audit_date, stats_ext, clv_data_ext)
for rec in stats_trans:
s = serialize(rec)
data_dict = {
"_index": "slot_player_stats",
"_type": "stats",
"_id": str(s['player']['player_id']) + '_' + str(s['gaming_date']['datekey']),
"_source": s
}
batch_chunks.append(data_dict)
if iterator % 100 == 0:
try:
helpers.bulk(es, batch_chunks, request_timeout=60)
except:
pass
del batch_chunks[:]
iterator = iterator + 1
if len(batch_chunks) != 0:
helpers.bulk(es, batch_chunks)
def budget_etl():
es = Elasticsearch([es_host])
batch_chunks = []
iterator = 0
budget_ext = DailyBudgetDimension.objects.all().values()
budget_trans = transform_daily_budget(budget_ext)
for rec in budget_trans:
s = serialize(rec)
id_ = str(s['location']['casino']) + '_' + str(
s['gaming_date']['datekey'])
data_dict = {
"_index": "daily_budget",
"_type": "daily_budget",
"_id": id_,
"_source": s
}
batch_chunks.append(data_dict)
if iterator % 100 == 0:
helpers.bulk(es, batch_chunks, request_timeout=60)
del batch_chunks[:]
iterator = iterator + 1
if len(batch_chunks) != 0:
helpers.bulk(es, batch_chunks)
def post(self, request, *args, **kwargs):
application = get_object_or_404(Application, pk=request.POST['applicationID'])
ass_group = get_object_or_404(AssessorGroup, pk=request.POST['assGroupID'])
assessment = Assessment.objects.get_or_create(application=application, assessor_group=ass_group)[0]
assessment.status = 'awaiting_assessment'
assessment.save()
application.processing_status = determine_processing_status(application)
application.save()
application.log_user_action(
ApplicationUserAction.ACTION_SEND_FOR_ASSESSMENT_TO_.format(ass_group),
request)
send_assessment_requested_email(assessment, request)
# need to only set and save this after the email was sent in case the email fails whereby it should remain null
assessment.date_last_reminded = date.today()
assessment.save()
return JsonResponse({'assessment': serialize(assessment, posthook=format_assessment),
'processing_status': PROCESSING_STATUSES[application.processing_status]},
safe=False, encoder=WildlifeLicensingJSONEncoder)
def get_context_data(self, **kwargs):
ret = get_object_or_404(Return, pk=self.args[0])
kwargs['return'] = serialize(ret, posthook=format_return)
kwargs['tables'] = []
for resource in ret.return_type.resources:
resource_name = resource.get('name')
schema = Schema(resource.get('schema'))
table = {'name': resource_name, 'title': resource.get('title', resource.get('name')),
'headers': schema.headers}
try:
return_table = ret.returntable_set.get(name=resource_name)
rows = [return_row.data for return_row in return_table.returnrow_set.all()]
validated_rows = list(schema.rows_validator(rows))
table['data'] = validated_rows
except ReturnTable.DoesNotExist:
pass
kwargs['tables'].append(table)
kwargs['upload_spreadsheet_form'] = UploadSpreadsheetForm()
if ret.proxy_customer is None:
to = ret.licence.holder
else:
to = ret.proxy_customer
kwargs['log_entry_form'] = CommunicationsLogEntryForm(to=to.get_full_name(), fromm=self.request.user.get_full_name())
return super(CurateReturnView, self).get_context_data(**kwargs)
def get_weblog_history(request):
try:
if request.method == 'GET':
# current_user = request.user
weblog_id = str(request.GET.get('weblog_id', ''))
webh_query_set = WeblogHistory.objects.filter(
weblog_id=weblog_id).order_by('-created_at')
# webh_json = serializers.serialize("json", webh_query_set)
webh_json = serialize(webh_query_set,
fields=[
'id', 'weblog_id', 'version',
'created_at', 'verdict', 'old_verdict',
'author_name'
],
exclude=['weblog'],
aliases={
'author_name': 'get_author_name',
'created_at': 'created_at_txt'
})
return JsonResponse(
dict(data=json.dumps(webh_json),
msg='WeblogHistory Consulst DONE'))
else:
return HttpResponseServerError("Only POST request")
except Exception as e:
print_exception()
return HttpResponseServerError("There was a error in the Server")
def get(self, request, *args, **kwargs):
ret = get_object_or_404(Return, pk=args[0])
data = serialize(ReturnLogEntry.objects.filter(ret=ret),
posthook=format_communications_log_entry,
exclude=['ret', 'communicationslogentry_ptr', 'customer', 'officer']),
return JsonResponse({'data': data[0]}, safe=False, encoder=WildlifeLicensingJSONEncoder)
def slot_revenue_etl(audit_date):
es = Elasticsearch([es_host])
batch_chunks = []
iterator = 0
revenue_ext = slot_revenue_extract(audit_date)
revenue_trans = transform_slot_revenue(audit_date, revenue_ext)
for rec in revenue_trans:
s = serialize(rec)
id_ = str(s['slotgame']['slot_number']) + '_' + str(
s['gaming_date']['datekey'])
data_dict = {
"_index": "slot_revenue",
"_type": "slot_revenue",
"_id": id_,
"_source": s
}
batch_chunks.append(data_dict)
if iterator % 100 == 0:
helpers.bulk(es, batch_chunks, request_timeout=60)
del batch_chunks[:]
iterator = iterator + 1
if len(batch_chunks) != 0:
helpers.bulk(es, batch_chunks)
def _create_from_context(self, request, instance):
context = self.get_context(request)
results = context.apply()
instance.bulk(results)
content = serialize(instance, **self.template)
return self.render(request, content=content, status=codes.created)
def post(self, request, **kwargs):
instance = self.get_object(request, **kwargs)
if self._requestor_can_fork(request, instance):
fork = DataQuery(name=instance.name,
description=instance.description,
view_json=instance.view_json,
context_json=instance.context_json,
parent=instance)
if getattr(request, 'user', None):
fork.user = request.user
elif request.session.session_key:
fork.session_key = request.session.session_key
fork.save()
request.session.modified = True
posthook = functools.partial(query_posthook, request=request)
data = serialize(fork, posthook=posthook, **templates.Query)
return self.render(request, data, status=codes.created)
data = {
'message': 'Cannot fork query',
}
return self.render(request, data, status=codes.unauthorized)
def post(self, request, **kwargs):
instance = self.get_object(request, **kwargs)
if self._requestor_can_fork(request, instance):
fork = DataQuery(name=instance.name,
description=instance.description,
view_json=instance.view_json,
context_json=instance.context_json,
parent=instance)
if getattr(request, 'user', None):
fork.user = request.user
elif request.session.session_key:
fork.session_key = request.session.session_key
fork.save()
request.session.modified = True
posthook = functools.partial(query_posthook, request=request)
data = serialize(fork, posthook=posthook, **templates.Query)
return self.render(request, data, status=codes.created)
data = {
'message': 'Cannot fork query',
}
return self.render(request, data, status=codes.unauthorized)
def _create_from_context(self, request, instance):
context = self.get_context(request)
results = context.apply()
instance.bulk(results)
content = serialize(instance, **self.template)
return self.render(request, content=content, status=codes.created)
def test_fields(self):
obj = serialize(self.hackers, fields=['website'], values_list=True)
self.assertEqual(obj, [
'http://ejohn.org',
'https://github.com/jashkenas',
'http://holovaty.com',
])
def get(self, request, poll_pk, option_idx=None):
if option_idx is None:
options = m.Option.objects.filter(poll_pk=poll_pk)
else:
options = m.Option.objects.get(poll_pk=poll_pk, index=option_idx)
return serialize(options, fields=['text', 'index', 'count', 'poll'],
related={'poll': ['subject', 'content']})
def get(self, request, pk):
page = request.GET.get('page', 1)
related = ['sample', 'variant', 'variant__chr', 'genotype']
results = self.model.objects.select_related(*related)\
.filter(sample__pk=pk)
# Paginate the results
paginator = Paginator(results, api.PAGE_SIZE)
try:
page = page = paginator.page(page)
except PageNotAnInteger:
page = paginator.page(1)
except EmptyPage:
page = paginator.page(paginator.num_pages)
resp = {
'result_count': paginator.count,
'results': serialize(page.object_list, **self.template),
}
# Augment the links
for obj in resp['results']:
obj['_links'] = {
'self': {
'rel': 'self',
'href': reverse('api:samples:variant',
kwargs={'pk': obj['id']})
},
'sample': {
'rel': 'related',
'href': reverse('api:samples:sample',
kwargs={'pk': obj['sample']['id']})
},
'variant': {
'rel': 'related',
'href': reverse('api:variants:variant',
kwargs={'pk': obj['variant_id']}),
}
}
obj.pop('variant_id')
links = {}
if page.number != 1:
links['prev'] = {
'rel': 'prev',
'href': reverse('api:samples:variants',
kwargs={'pk': pk}) + '?page=' + str(page.number - 1)
}
if page.number < paginator.num_pages - 1:
links['next'] = {
'rel': 'next',
'href': reverse('api:samples:variants',
kwargs={'pk': pk}) + '?page=' + str(page.number + 1)
}
if links:
resp['_links'] = links
return resp
def prepare(self, request, instance, template=None, embed=False):
if template is None:
template = self.template
posthook = functools.partial(
revision_posthook, request=request,
object_uri=self.object_model_base_uri,
object_template=self.object_model_template, embed=embed)
return serialize(instance, posthook=posthook, **template)
def concept_posthook(instance, data, request, embed, brief, categories=None):
"""Concept serialization post-hook for augmenting per-instance data.
The only two arguments the post-hook takes is instance and data. The
remaining arguments must be partially applied using `functools.partial`
during the request/response cycle.
"""
uri = request.build_absolute_uri
if categories is None:
categories = {}
if 'category_id' in data:
# This relies on categories being passed in as a dict with the key
# being the primary key. This makes it must faster since the
# categories are pre-cached.
category = categories.get(data.pop('category_id'))
data['category'] = serialize(category, **templates.Category)
if data['category']:
parent = categories.get(data['category'].pop('parent_id'))
data['category']['parent'] = serialize(parent,
**templates.Category)
# Embed first parent as well, but no others since this is the
# bound in Avocado's DataCategory parent field.
if data['category']['parent']:
data['category']['parent'].pop('parent_id')
if not brief:
data['_links'] = {
'self': {
'href': uri(reverse('serrano:concept', args=[instance.pk])),
},
'fields': {
'href':
uri(reverse('serrano:concept-fields', args=[instance.pk])),
}
}
# Embeds the related fields directly in the concept output
if not brief and embed:
resource = ConceptFieldsResource()
data['fields'] = resource.prepare(request, instance)
return data
def get(self, request, *args, **kwargs):
query = request.GET.get('q')
q = Q(code__icontains=query) | Q(text__icontains=query) & Q(one_off=False)
conditions = serialize(Condition.objects.filter(q))
return JsonResponse(conditions, safe=False, encoder=WildlifeLicensingJSONEncoder)
def post(self, request, *args, **kwargs):
try:
response = serialize(Condition.objects.create(code=request.POST.get('code'), text=request.POST.get('text'),
one_off=not request.POST.get('addToGeneralList', False)))
except IntegrityError:
response = 'This code has already been used. Please enter a unique code.'
return JsonResponse(response, safe=False, encoder=WildlifeLicensingJSONEncoder)
def format_assessment(instance, attrs):
attrs['conditions'] = serialize(
instance.assessmentcondition_set.all().order_by('order'),
fields=['acceptance_status', 'id', 'condition'],
posthook=format_assessment_condition)
attrs['status'] = ASSESSMENT_STATUSES[attrs['status']]
return attrs
def prepare(self, request, instance, tree, template=None):
if template is None:
template = self.template
tree = trees[tree]
posthook = functools.partial(
context_posthook, request=request, tree=tree)
return serialize(instance, posthook=posthook, **template)
def proceedToPayment(request, txnId):
uname = request.POST['payer'].strip()
amount = request.POST['amount'].strip()
uemail = request.POST['email'].strip()
uphone = request.POST['phone'].strip()
KEYS = [
settings.MERCHANT_KEY, txnId, amount, 'anyText', uname, uemail, '', '',
'', '', '', '', '', '', '', ''
]
hash = generate_hash(KEYS)
item = {
"key": settings.MERCHANT_KEY,
"txnid": txnId,
"amount": amount,
"productinfo": "anyText",
"firstname": uname,
"phone": uphone,
"email": uemail,
"surl": request.build_absolute_uri(reverse('epSuccessPayment')),
"furl": request.build_absolute_uri(reverse('epFailPayment')),
"hash": hash,
"udf1": "",
"udf2": "",
"udf3": "",
"udf4": "",
"udf5": ""
}
resp = get_redirect_url(item)
r = serialize(resp.content)
r = json.loads(r)
if r['status'] == 0:
return JsonResponse({'status': '201', 'error': r['data']})
elif r['status'] == 1:
link_id = r['data']
url = settings.URL_PAY + link_id
print url
return HttpResponse("""
<html>
<head><title>Redirecting...</title></head>
<body>
<form action='%s' method='post' name="paywitheasebuzz">
redirecting to pay.easebuzz.in ....
</form>
</body>
<script language='javascript'>
window.onload = function(){
document.forms['paywitheasebuzz'].submit()
}
</script>
</html>
""" % url)
else:
return JsonResponse({
'status':
'202',
'error':
'Due To security concerns we reject this transaction'
})
def test_related(self):
template = {
'fields': [':pk', 'website', 'user', 'libraries'],
'related': {
'user': {
'exclude': ['groups', 'password', 'user_permissions'],
'merge': True,
'prefix': '%(accessor)s_',
},
'libraries': {
'fields': ['name'],
'values_list': True,
}
},
}
obj = serialize(self.hackers, **template)
self.assertEqual(
obj,
[{
'user_is_superuser': True,
'website': 'http://ejohn.org',
'user_id': 1,
'user_is_active': True,
'user_is_staff': True,
'user_first_name': 'John',
'user_last_name': 'Resig',
'user_username': '******',
'libraries': ['jQuery'],
'user_date_joined': datetime.datetime(2009, 5, 16, 15, 52, 40),
'user_last_login': datetime.datetime(2010, 3, 3, 17, 40, 41),
'user_email': ''
}, {
'user_is_superuser': False,
'website': 'https://github.com/jashkenas',
'user_id': 2,
'user_is_active': True,
'user_is_staff': True,
'user_first_name': 'Jeremy',
'user_last_name': 'Ashkenas',
'user_username': '******',
'libraries': ['Backbone', 'CoffeeScript'],
'user_date_joined': datetime.datetime(2009, 5, 16, 15, 52, 40),
'user_last_login': datetime.datetime(2010, 3, 3, 17, 40, 41),
'user_email': ''
}, {
'user_is_superuser': True,
'website': 'http://holovaty.com',
'user_id': 3,
'user_is_active': False,
'user_is_staff': True,
'user_first_name': 'Adrian',
'user_last_name': 'Holovaty',
'user_username': '******',
'libraries': ['Django'],
'user_date_joined': datetime.datetime(2009, 5, 16, 15, 52, 40),
'user_last_login': datetime.datetime(2010, 3, 3, 17, 40, 41),
'user_email': ''
}])
