def get_other_details(self):
user_meta = UserMeta.objects.filter(user=self.author)
tags = self.tags() if self.tags() else []
categories = self.categories() if self.categories() else []
# Post Detail
data = {"post_details": model_to_dict(self, ["id", "author", "title", "post_date", "excerpt", "content"])}
data["post_details"].update(PostMeta.get_featured_image(self))
# Author Details
data.update({"author_details":
{"first_name": user_meta.filter(key="first_name").values_list('value', flat=True)[0],
"last_name": user_meta.filter(key="last_name").values_list('value', flat=True)[0],
"description": user_meta.filter(key="description").values_list('value', flat=True)[0]}
})
# Tags Detail
tags_list = []
for tag in tags:
tags_list.append(model_to_dict(tag, ["id", "name", "slug"]))
data.update({"tags": tags_list})
# Categories Detail
categories_list = []
for category in categories:
categories_list.append(model_to_dict(category, ["id", "name", "slug"]))
data.update({"categories": categories_list})
return data
def batch_import(cls, tags, current_vocabularies, current_languages):
result = []
for vocabulary_tag in tags:
voc_dict = vocabulary_tag.attrib
if voc_dict['ID'] == '0':
continue
value = vocabulary_tag.text
if not value:
value = ''
vocabulary = Vocabulary(
id=int(voc_dict['ID']),
language=current_languages[int(voc_dict['langid'])],
value=value
)
try:
if model_to_dict(vocabulary) != model_to_dict(current_vocabularies[vocabulary.id]):
vocabulary.save()
except KeyError:
vocabulary.save()
result.append(vocabulary)
return result
def get_manage(self, request, method=None, pk=None):
s = Auth().is_auth(request)
if not s:
return Auth.routeLogin
from .forms import FormRegister
self.form_obj = FormRegister
self.form = self.form_obj()
if method == 'update':
self.instance = self.model.pp.get(pk=pk)
self.form = self.form_obj(instance=self.instance, data=model_to_dict(self.instance))
else:
self.instance = self.model()
self.form = self.form_obj(instance=self.instance)
self.form = self.form_obj(instance=self.instance, data=model_to_dict(self.instance))
self.set_template("users", "manage.html")
self.set_menu("users", "menu.html")
self.set_form_action(method, pk)
self.page.view = "form-users.html"
self.page.method = method
self.page.obj = self.instance
return render_to_response(
self.template,
{'page': self.page, 'form': self.form},
context_instance=RequestContext(request)
)
def tree_add_from_parent( request, parentid ):
if parentid != None:
parent = get_object_or_404( Evalitem, pk=parentid )
else:
parent = None
if request.method == 'GET':
form = EvalitemCreateForm()
return render( request, "evalitem/tree/add_from_parent.html",
{'parent':parent,
'form': form} )
elif request.method == 'POST':
form = EvalitemCreateForm( request.POST, request.FILES )
if form.is_valid():
obj = form.save( False )
if parent == None:
Evalitem.add_root( **model_to_dict( obj ) )
return HttpResponseRedirect( reverse( tree_root ) )
else:
parent.add_child( **model_to_dict( obj ) )
return HttpResponseRedirect( reverse( tree_from_parent,
kwargs={'parentid':parentid} )
)
else:
return render( request, "evalitem/tree/add_from_parent.html",
{'parent':parent,
'form': form} )
def batch_import(cls, tags, current_texs, current_languages):
result = []
for tex_tag in tags:
tex_dict = tex_tag.attrib
if tex_dict['ID'] == '0':
continue
value = tex_tag.text
if not value:
value = ''
tex = Tex(
id=int(tex_dict['ID']),
language=current_languages[int(tex_dict['langid'])],
value=value
)
try:
if model_to_dict(tex) != model_to_dict(current_texs[tex.id]):
tex.save()
except KeyError:
tex.save()
result.append(tex)
return result
def to_json(self):
config = model_to_dict(self)
config['fuzzy_properties'] = [
model_to_dict(fuzzy_property, exclude=['id']) for fuzzy_property in config['fuzzy_properties']
]
config['ignore_patterns'] = [
model_to_dict(ignore_pattern, exclude=['id']) for ignore_pattern in config['ignore_patterns']
]
return config
def test_citizen_created(self, get_records, open):
citizen = CitizenFactory()
data = model_to_dict(citizen)
citizen.delete()
get_records.return_value = [data]
self.assertFalse(Citizen.objects.exists())
stats = import_citizen_dump(input_filename=None)
self.assertEqual(1, stats.records_read)
new_cit = Citizen.objects.get()
self.assertEqual(data, model_to_dict(new_cit))
def test_citizen_updated(self, get_records, open):
cit1 = CitizenFactory()
cit2 = CitizenFactory()
citizen = CitizenFactory()
data = model_to_dict(citizen)
new_name = 'Jim Bob'
data['first_name'] = new_name
get_records.return_value = [model_to_dict(cit1), model_to_dict(cit2), data]
stats = import_citizen_dump(input_filename=None, max_change_percent=34)
self.assertEqual(3, stats.records_read)
updated_cit = Citizen.objects.get(pk=citizen.pk)
self.assertEqual(new_name, updated_cit.first_name)
def jselaus(request):
junat = list(sql_komentajat.hae_junat())
junat = [model_to_dict(juna) for juna in junat]
junat = json.dumps(junat, default=date_handler)
pysahdykset = list(sql_komentajat.hae_pysahdykset())
pysahdykset = [model_to_dict(pysahdys) for pysahdys in pysahdykset]
pysahdykset[0]["saapumisaika"] = str(pysahdykset[0]["saapumisaika"])
pysahdykset[0]["lahtoaika"] = str(pysahdykset[0]["lahtoaika"])
pysahdykset = json.dumps(pysahdykset, default=date_handler)
return render(request, 'junaApp/jselaus.html', {"junat" : junat, "pysahdykset" : pysahdykset})
def dump_tr_model(self, item, exclude=[]):
result = model_to_dict(item, exclude=exclude)#, exclude=('password',))
#result['author'] = model_to_dict(item.author, exclude=('password',))
result['locale'] = model_to_dict(item.locale)
result['canEdit'] = False
if self.request.user:
result['canEdit'] = self.request.user.id == item.author_id
try:
result['statistic'] = item.grammar().statistic()
except NotImplementedError as _:
pass
result['application'] = model_to_dict(item.application)
return result
def test_too_many_changes(self, get_records, open):
cit1 = CitizenFactory()
cit2 = CitizenFactory()
citizen = CitizenFactory()
data = model_to_dict(citizen)
new_name = 'Jim Bob'
data['first_name'] = new_name
get_records.return_value = [model_to_dict(cit1), model_to_dict(cit2), data]
# Import raises an exception:
with self.assertRaises(TooManyChanges):
import_citizen_dump(input_filename=None, max_change_percent=10)
# Citizen is unchanged:
new_citizen = refresh_model(citizen)
self.assertEqual(citizen.first_name, new_citizen.first_name)
def recent( request ):
_cur_user = request.META.get('HTTP_X_COMICWEB_USER')
logger.debug('get recentlist for user %s' % _cur_user)
ret = []
volumes = []
try:
user = User.objects.get(username=_cur_user)
for r in Reading.objects.filter(user=user).order_by('when').reverse():
if not r.issue.volume in volumes:
volumes.append(r.issue.volume)
ret.append({'issue' : model_to_dict(r.issue), 'volume' : model_to_dict(r.issue.volume), 'latest_reading' : model_to_dict(r.issue.get_latest_reading(user))})
except:
logger.warn("Unable to get recent list :\n%s" % traceback.format_exc())
return HttpResponse(json.dumps(ret, cls=DjangoJSONEncoder), content_type="application/json")
def get(self, request, id):
context = {}
nemov = Nemovitost.objects.get(id=id)
if nemov.typ == 'Stavba':
result = Stavba.objects.get(id=nemov)
context['typ'] = 'Stavba'
else:
result = Parcela.objects.get(id=nemov)
context['nemov'] = model_to_dict(nemov)
context['object'] = model_to_dict(result)
context['dotaz_form'] = self.dotaz_form()
context['navhr_form'] = self.navhr_form()
return render_to_response(self.template, RequestContext(request, context))
def scrumboard_sprint_active_select(context):
from django.forms import model_to_dict
from scrumboard.models import Sprint
active_sprints = [model_to_dict(sprint, fields=['id', 'name']) for sprint in Sprint.get_active_sprints()]
if 'current_sprint_pk' in context.request.session:
current_sprint = Sprint.objects.get(pk=context.request.session['current_sprint_pk'])
else:
current_sprint = Sprint.get_current_sprint()
return {'active_sprints': active_sprints,
'current_sprint': model_to_dict(current_sprint),
'current_url': context.request.get_full_path()}
def getTrip(request):
tripId = request.GET['tripId']
trip = models.Trip.objects.get(id=tripId)
tripValues = models.Trip.objects.values('name', 'type', 'date').get(id=tripId)
tripLegValues = []
tripLegs = trip.tripleg_set.all()
for tripLeg in tripLegs:
tripLegData = {'startAddress': model_to_dict(tripLeg.startAddress),
'endAddress': model_to_dict(tripLeg.endAddress)}
tripLegValues.append(tripLegData)
returnValues = {'trip': tripValues, 'tripLegs': tripLegValues}
return HttpResponse(json.dumps(returnValues, cls=DjangoJSONEncoder), mimetype="application/json")
def getJSONObj():
mainObj = {}
issues = Issue.objects.order_by('categoryName').all()
for issue in issues:
issuekey = issue.keyid
mainObj[issuekey] = model_to_dict(issue)
mainObj[issuekey]['layers'] = {}
layers = issue.layer_set.order_by('subject').all()
#order layers
for layer in layers:
layerkey = layer.keyid
mainObj[issuekey]['layers'][layerkey] = model_to_dict(layer)
return json.dumps(mainObj)
def store_performance_artifact(
self, job_ids, performance_artifact_placeholders):
"""
Store the performance data
"""
# Retrieve list of job signatures associated with the jobs
job_data = self.get_job_signatures_from_ids(job_ids)
job_ref_data_signatures = set()
map(
lambda job_guid: job_ref_data_signatures.add(
job_data[job_guid]['signature']
),
job_data.keys()
)
for perf_data in performance_artifact_placeholders:
job_guid = perf_data["job_guid"]
ref_data_signature = job_data[job_guid]['signature']
ref_data = model_to_dict(ReferenceDataSignatures.objects.get(
signature=ref_data_signature))
# adapt and load data into placeholder structures
if perf_data['name'] == 'talos_data':
load_talos_artifacts(self.project, ref_data, job_data, perf_data)
else:
load_perf_artifacts(self.project, ref_data, job_data, perf_data)
def update(self, request, slug):
"update a project"
p = Project.objects.filter(slug=slug)
if not p:
return rc.NOT_FOUND
elif len(p) > 1:
return rc.BAD_REQUEST
elif "has_admin_perm" in p[0].get_perms(request.user):
p = p[0]
initial = model_to_dict(p)
data = request.PUT
data._mutable = True
if "admins" not in data:
data["admins"] = ",".join([a.username for a in p.admins.all()])
if "members" not in data:
data["members"] = ",".join([m.username for m in p.members.all()])
filt = lambda v: v not in data.keys()
for field in filter(filt, [f.name for f in p._meta.fields]):
data[field] = initial.get(field, None)
form = ProjectEditForm(data=data, instance=p)
if form.is_valid():
p = form.save()
return p
return rc.BAD_REQUEST
else:
return rc.FORBIDDEN
def validate_unique(self):
super(ToleranceForm, self).validate_unique()
if not self.instance.pk:
params = forms.model_to_dict(self.instance)
params.pop("id")
if models.Tolerance.objects.filter(**params).count() > 0:
self._update_errors({forms.models.NON_FIELD_ERRORS: ["Duplicate Tolerance. A Tolerance with these values already exists"]})
def post(self, request):
reviewer_id = request.POST.get('reviewer_id')
movie_id = request.POST.get('movie_id')
rating = request.POST.get('rating')
review_object = Review.objects.create(reviewer_id=reviewer_id, movie_id=movie_id, rating=rating)
review_dict = model_to_dict(review_object)
return HttpResponse(json.dumps(review_dict), status=201, content_type='application/json')
def post(self, request):
pro_id = request.GET.get('id', 1)
prod = Products.objects.get(sku=pro_id)
temp = get_template("pay.html")
paypalform = PaypalForm(request.POST)
html = RequestContext(request, {'form': paypalform})
if paypalform.is_valid():
model_instance = paypalform.save(commit=False)
model_instance.item = prod
model_instance.save()
payinfo = model_to_dict(model_instance)
try:
d = paypal()
item = paypal.convert_items(prod)
payinfo = paypal.convertpaymentinfo(model_instance, item)
q = d.handler(payinfo)
payinfo['result'] = q
if (q):
logging.debug("not succeed")
return HttpResponseRedirect('/thanks/')
else:
return HttpResponseRedirect('/failed/?reason=' + d.getError())
except Exception as E:
return HttpResponseRedirect('/failed/?reas=' + E.message)
html = RequestContext(request, {'form': paypalform, "info": payinfo})
return render_to_response("pay.html", html)
def test_superseded_by_saves(self):
self.item2 = self.itemType.objects.create(name="admin_page_test_oc_2",definition=" ",workgroup=self.wg1,**self.create_defaults)
self.login_editor()
response = self.client.get(reverse("admin:%s_%s_change"%(self.itemType._meta.app_label,self.itemType._meta.model_name),args=[self.item1.pk]))
self.assertResponseStatusCodeEqual(response,200)
updated_item = dict((k,v) for (k,v) in model_to_dict(self.item1).items() if v is not None)
updated_name = updated_item['name'] + " updated!"
updated_item['name'] = updated_name
updated_item.update({
'statuses-TOTAL_FORMS': 0, 'statuses-INITIAL_FORMS': 0, # no statuses
'superseded_by':self.item2.id
})
updated_item.update(self.form_defaults)
response = self.client.post(
reverse("admin:%s_%s_change"%(self.itemType._meta.app_label,self.itemType._meta.model_name),args=[self.item1.pk]),
updated_item
)
# Make sure it saves
self.assertRedirects(response,reverse("admin:%s_%s_changelist"%(self.itemType._meta.app_label,self.itemType._meta.model_name)))
self.item1 = self.itemType.objects.get(pk=self.item1.pk)
self.assertTrue(self.item2 == self.item1.superseded_by.item)
def store_performance_artifact(
self, job_ids, performance_artifact_placeholders):
"""
Store the performance data
"""
# Retrieve list of job signatures associated with the jobs
job_data = self.get_job_signatures_from_ids(job_ids)
job_ref_data_signatures = set()
map(
lambda job_guid: job_ref_data_signatures.add(
job_data[job_guid]['signature']
),
job_data.keys()
)
for perf_data in performance_artifact_placeholders:
job_guid = perf_data["job_guid"]
ref_data_signature = job_data[job_guid]['signature']
# At the moment there could be multiple signatures returned
# by this, but let's just ignore that and take the first
# if there are multiple (since the properties we care about should
# be the same)
ref_data = model_to_dict(ReferenceDataSignatures.objects.filter(
signature=ref_data_signature,
repository=self.project)[0])
# adapt and load data into placeholder structures
load_perf_artifacts(self.project, ref_data, job_data, perf_data)
def retrieve_licenses(request):
try:
type_ = int(request.REQUEST['public_access'])
licenses = License.get_suitable_licenses(type_)
except KeyError:
licenses = License.get_suitable_licenses()
return HttpResponse(json.dumps([model_to_dict(x) for x in licenses]))
def clicks_chart(request, pk):
# TODO: Add a stats page for each link where you can see the traffic for that link for the last 30 days in a line chart.
# FIXME: Add error checking if 0 clicks
thirty_days_ago = timezone.now() - timedelta(days=30)
clicks = Click.objects.filter(bookmark_id=pk).filter(
timestamp__gte=thirty_days_ago) # .annotate(count_recent=Count('click'))
df = pd.DataFrame(model_to_dict(click) for click in clicks)
df['count'] = 1
df.index = df['timestamp']
counts = df['count']
counts = counts.sort_index()
series = pd.expanding_count(counts).resample('D', how=np.max,
fill_method='pad')
response = HttpResponse(content_type='image/png')
fig = plt.figure()
# ax = fig.add_subplot(111)
# ax.plot(series)
series.plot()
plt.title("Total clicks over past 30 days")
plt.xlabel("")
plt.xlim(thirty_days_ago, timezone.now())
canvas = FigureCanvas(fig)
# ax = fig.add_subplot(1, 1, 1, axisbg='red')
# ax.plot(series)
canvas.print_png(response)
return response
def post(self, request, format=None):
print "movie post method"
movie_data = MoviesData()
movie_data.name = request.POST.get('name')
movie_data.ssdb_score = int(request.POST.get('ssdb_score'))
movie_data.popularity = int(request.POST.get('popularity'))
movie_data.director = request.POST.get('director')
movie_data.description = request.POST.get('description')
movie_data.stars = request.POST.get('stars')
movie_data.save()
for genre_id in request.POST.getlist('genre[]'):
movie_data.genre.add(int(genre_id))
dict_data = model_to_dict(movie_data)
print "previous data",request.data
print "dict data",dict_data
# import pdb
# pdb.set_trace()
serializer = MoviesDataSerializer(data=dict_data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def unread_messages(request):
if not request.user.is_authenticated():
data = {
'unread_count':0,
'unread_list':[]
}
return JsonResponse(data)
unread_list = []
messages = Message.objects.filter(recipient=request.user,read=False,deleted=False).order_by('date').reverse()
for n in messages:
struct = model_to_dict(n)
if n.sender:
struct['sender'] = str(n.sender)
if n.recipient:
struct['recipient'] = str(n.recipient)
if n.date:
struct['date'] = defaultfilters.timesince(n.date)
if n.message:
struct['message'] = str(n.message)
struct['link'] = n.url()
unread_list.append(struct)
data = {
'unread_count': messages.count(),
'unread_list': unread_list
}
return JsonResponse(data)
def test_editor_change_item(self):
self.login_editor()
response = self.client.get(reverse("admin:%s_%s_change"%(self.itemType._meta.app_label,self.itemType._meta.model_name),args=[self.item1.pk]))
self.assertResponseStatusCodeEqual(response,200)
updated_item = dict((k,v) for (k,v) in model_to_dict(self.item1).items() if v is not None)
updated_name = updated_item['name'] + " updated!"
updated_item['name'] = updated_name
updated_item.update({
'statuses-TOTAL_FORMS': 0, 'statuses-INITIAL_FORMS': 0 # no statuses
})
updated_item.update(self.form_defaults)
self.assertTrue(self.wg1 in self.editor.profile.editable_workgroups.all())
self.assertEqual([self.wg1],list(response.context['adminform'].form.fields['workgroup'].queryset))
self.assertTrue(perms.user_can_edit(self.editor,self.item1))
self.assertTrue(self.item1.workgroup in self.editor.profile.editable_workgroups.all())
response = self.client.post(
reverse("admin:%s_%s_change"%(self.itemType._meta.app_label,self.itemType._meta.model_name),args=[self.item1.id]),
updated_item
)
self.assertResponseStatusCodeEqual(response,302)
self.item1 = self.itemType.objects.get(pk=self.item1.pk)
self.assertEqual(self.item1.name,updated_name)
def whoami(request, format='json'):
if ServicesMetadata.objects.count() == 1:
services_metadata = ServicesMetadata.objects.all()[0]
_md = model_to_dict(services_metadata)
domain = Site.objects.all()[0].domain
_md['uri'] = 'http://%s' % domain
_md['sk_domain_name'] = domain
# TODO sistemare
_md['endpoint_SOS_url'] = settings.SITEURL + 'observations/sos'
else:
_md = {
'message': 'Missing metadata'
}
# software
_md['software'] = {
'ubuntu': get_ubuntu_release(),
'java': get_java_version(),
'tomcat': get_tomcat_version(),
'postgresql': get_postgres_version(),
'postgis': get_postgis_version(),
'python': sys.version,
'getit': geosk_version(),
'geonode': geonode_version(),
'pycsw': pycsw.__version__,
'django': django_version(),
'sos': get_sos_version()
}
return JsonResponse(_md)
def get_data_api(request, format='json'):
if request.method not in ('GET','POST'):
return HttpResponse(status=405)
rtype = request.REQUEST.get('rtype')
id = request.REQUEST.get('id')
if rtype == 'layer':
r = Layer.objects.get(pk=id)
exclude = LayerForm._meta.exclude
elif rtype == 'map':
r = Map.objects.get(pk=id)
exclude = MapForm._meta.exclude
exclude = exclude + ('owner', 'title', 'distribution_url', 'distribution_description')
data = model_to_dict(r, exclude=exclude)
#f=LayerForm(model_to_dict(l), prefix='layer')
data['keywords'] = r.keyword_csv
# data_prefix = {"layer-%s" % k: v for k, v in data.items()}
results = {
'data': data
}
return HttpResponse(json.dumps(results, cls=DjangoJSONEncoder), mimetype="application/json")
def toJSON(self):
item = model_to_dict(self)
item['gender'] = {'id': self.gender, 'name': self.get_gender_display()}
item['date_birthday'] = self.date_birthday.strftime('%Y-%m-%d')
return item
def section(request, content_id):
section = get_object_or_404(Section, id=content_id)
# 阅读量+1
section.view = section.view + 1
section.save()
note = Note.objects.get(id=section.note_id)
# 上下篇笔记
second = Catalogue.objects.get(section=section.id)
second_min = Catalogue.objects.filter(father=second.father).aggregate(Min('order'))["order__min"]
second_max = Catalogue.objects.filter(father=second.father).aggregate(Max('order'))["order__max"]
first = Catalogue.objects.get(id=second.father)
first_min = Catalogue.objects.filter(note=note).filter(level=1).aggregate(Min('order'))["order__min"]
first_max = Catalogue.objects.filter(note=note).filter(level=1).aggregate(Max('order'))["order__max"]
if second.order == second_min:
if first.order == first_min:
# 第一篇文章
last_content = None
else:
# 上一篇找上一章最后一篇
last_father = Catalogue.objects.filter(note=note).filter(level=1).filter(order=first.order - 1)
last_second_max = Catalogue.objects.filter(father=last_father[0].id).aggregate(Max('order'))["order__max"]
last_content = Catalogue.objects.filter(father=last_father[0].id).filter(order=last_second_max)[0]
next_content = Catalogue.objects.filter(father=first.id).filter(order=second.order + 1)[0]
elif second.order == second_max:
if first.order == first_max:
# 最后一篇文章
next_content = None
else:
# 下一篇找上一章第一篇
next_father = Catalogue.objects.filter(note=note).filter(level=1).filter(order=first.order + 1)
next_second_min = Catalogue.objects.filter(father=next_father[0].id).aggregate(Min('order'))["order__min"]
next_content = Catalogue.objects.filter(father=next_father[0].id).filter(order=next_second_min)[0]
last_content = Catalogue.objects.filter(father=first.id).filter(order=second.order - 1)[0]
else:
last_content = Catalogue.objects.filter(father=first.id).filter(order=second.order - 1)[0]
next_content = Catalogue.objects.filter(father=first.id).filter(order=second.order + 1)[0]
# 笔记目录
first_catalogue = Catalogue.objects.filter(note=note.id).filter(level=1)
num = ["零", "一", "二", "三", "四", "五", "六", "七", "八", "九", "十", "十一", "十二", "十三", "十四", "十五", "十六", "十七", "十八"]
catalogue_list = []
for i in first_catalogue:
catalogue_dict = {}
catalogue_dict["title"] = num[i.order] + "、\t" + i.name
if i.id == first.id:
catalogue_dict["spread"] = 'true'
children_list = []
catalogue_dict["children"] = children_list
second_catalogue = Catalogue.objects.filter(note=note.id).filter(father=i.id)
for j in second_catalogue:
children_dict = {}
children_dict["id"] = str(j.section.id)
children_dict["title"] = str(j.order) + ".\t" + j.section.title
children_dict["href"] = '/blog/section-' + str(j.section.id)
children_list.append(children_dict)
catalogue_list.append(catalogue_dict)
# 用户已登录
article_like = '0'
if request.user.id:
# 添加阅读记录(第一次：添加，已有记录：更新时间)
history = SectionViewHistory.objects.filter(section_id=section.id).filter(user_id=request.user)
if history:
change_history = history[0]
change_history.time = timezone.now()
change_history.save()
else:
new_history = SectionViewHistory()
new_history.section = section
new_history.note = section.note
new_history.user = request.user
new_history.save()
# 判断是否已收藏文章
user_list = SectionViewHistory.objects.filter(section_id=section.id)
for i in user_list:
if request.user == i.user and i.is_like == 1:
article_like = 1
break
# 评论列表
# 全部评论
content_count = SectionMessage.objects.filter(section=section).count()
all_comment = []
for info in SectionMessage.objects.filter(section=section):
# 根评论
if info.reply_id is None:
# 单条记录
record = []
info_dict = model_to_dict(info)
info_dict['username'] = SectionMessage.objects.get(id=info.id).user.username
info_dict['reply_id'] = 'None'
info_dict['root_id'] = 'None'
info_dict['reply_name'] = 'None'
info_dict['photo'] = SectionMessage.objects.get(id=info.id).user.userinfo.photo.name
info_dict['web'] = SectionMessage.objects.get(id=info.id).user.userinfo.web
info_dict['time'] = SectionMessage.objects.get(id=info.id).time.strftime("%Y-%m-%d %H:%M:%S")
record.append(info_dict)
# 根据根留言查找子回复
record = note_record(section, info.id, record)
all_comment.append(record)
# 热门评论
hot_comment = SectionMessage.objects.filter(section=section).filter(level=0).order_by('-like')
# 我的评论
user_id = request.user.id
if user_id:
my_comment = SectionMessage.objects.filter(section=section).filter(level=0).filter(user_id=user_id)
else:
my_comment = None
# 评论统计
comment_count = SectionMessage.objects.filter(section=section).count()
return render(request, 'blog/section.html', locals())
def toJSON(self):
item = model_to_dict(self, exclude=['sale'])
item['prod'] = self.prod.toJSON()
item['price'] = format(self.price, '.2f')
item['subtotal'] = format(self.subtotal, '.2f')
return item
def _convert_to_valid_search_dict(self, contact):
d = model_to_dict(contact)
del d['phone']
del d['organisation']
return d
def queryLists(requests,queryID):
try:
query = model_to_dict(Query.objects.get(id=queryID))
except:
query = {}
return JsonResponse(query)
def test_post_job_artifacts_by_add_artifact(
test_repository,
failure_classifications,
result_set_stored,
monkeypatch,
mock_post_json,
):
"""
test submitting a job with artifacts added by ``add_artifact``
This has pre-parsed logs. Verify parse_status of "parsed" and that it
doesn't parse the logs.
Submitted ``text_log_artifact`` should still trigger generation of the
bug suggestions.
"""
mock_parse = MagicMock(name="parse_line")
monkeypatch.setattr(StepParser, 'parse_line', mock_parse)
job_guid = 'd22c74d4aa6d2a1dcba96d95dccbd5fdca70cf33'
tjc = client.TreeherderJobCollection()
tj = client.TreeherderJob({
'project': test_repository.name,
'revision': result_set_stored[0]['revision'],
"job": {
"artifacts": [],
"job_guid":
job_guid,
"log_references": [{
"name":
"autophone-nexus-one-1.log",
"parse_status":
"parsed",
"url":
"https://autophone-dev.s3.amazonaws.com/pub/mozilla.org/mobile/tinderbox-builds/mozilla-inbound-android-api-9/1432676531/en-US/autophone-autophone-s1s2-s1s2-nytimes-local.ini-1-nexus-one-1.log"
}],
"state":
"completed",
},
})
tls_blob = json.dumps({
"logurl":
"https://autophone-dev.s3.amazonaws.com/pub/mozilla.org/mobile/tinderbox-builds/mozilla-inbound-android-api-9/1432676531/en-US/autophone-autophone-s1s2-s1s2-nytimes-local.ini-1-nexus-one-1.log",
"step_data": {
"steps": [{
"name":
"foobar",
"result":
"testfailed",
"started_linenumber":
1,
"finished_linenumber":
100000,
"started":
"2016-07-13 16:09:31",
"finished":
"2016-07-13 16:09:31",
"errors": [{
"line":
"TEST_UNEXPECTED_FAIL | /sdcard/tests/autophone/s1s2test/nytimes.com/index.html | Failed to get uncached measurement.",
"linenumber": 64435
}]
}]
}
})
ji_blob = json.dumps(
{"job_details": [{
"title": "mytitle",
"value": "myvalue"
}]})
bapi_blob = json.dumps({"buildername": "merd"})
pb_blob = json.dumps({
"build_url": "feh",
"chunk": 1,
"config_file": "mah"
})
tj.add_artifact("text_log_summary", "json", tls_blob)
tj.add_artifact("Job Info", "json", ji_blob)
tj.add_artifact("buildapi", "json", bapi_blob)
tj.add_artifact("privatebuild", "json", pb_blob)
tjc.add(tj)
post_collection(test_repository.name, tjc)
assert JobDetail.objects.count() == 1
assert model_to_dict(JobDetail.objects.get(job__guid=job_guid)) == {
'id': 1,
'job': 1,
'title': 'mytitle',
'value': 'myvalue',
'url': None
}
assert TextLogStep.objects.count() == 1
assert model_to_dict(TextLogStep.objects.get(job__guid=job_guid)) == {
'id': 1,
'job': 1,
'started': datetime.datetime(2016, 7, 13, 16, 9, 31),
'finished': datetime.datetime(2016, 7, 13, 16, 9, 31),
'name': 'foobar',
'result': 1,
'started_line_number': 1,
'finished_line_number': 100000
}
assert TextLogError.objects.count() == 1
text_log_error = TextLogError.objects.get(step__job__guid=job_guid)
assert model_to_dict(text_log_error) == {
'id': 1,
'line':
'TEST_UNEXPECTED_FAIL | /sdcard/tests/autophone/s1s2test/nytimes.com/index.html | Failed to get uncached measurement.',
'line_number': 64435,
'step': 1,
}
# assert that some bug suggestions got generated
assert len(get_error_summary(Job.objects.get(guid=job_guid))) == 1
check_job_log(test_repository, job_guid, JobLog.PARSED)
# ensure the parsing didn't happen
assert mock_parse.called is False
def get(self, request):
produtos = Produto.objects.all()
lista_produtos = []
for p in produtos:
lista_produtos.append(model_to_dict(p))
return JsonResponse(lista_produtos, safe=False)
def api(request):
produtos = Produto.objects.all()
lista_produtos = []
for p in produtos:
lista_produtos.append(model_to_dict(p))
return JsonResponse(lista_produtos, safe=False, status=200)
def handle(self, request, data):
system = data['system']
question_id = request.GET.get('question_id', None)
answer_id = request.GET.get('answer_id', None)
action = request.GET.get('action', 'questions')
question = None
if question_id is not None and question_id != 'new':
question = get_object_or_404(Question, pk=question_id)
data['question'] = question
if action == 'question':
kwargs = {'params': system.parameter_set}
if question is not None:
kwargs['initial'] = model_to_dict(question)
if request.method == 'POST':
form = QuestionForm(request.POST, request.FILES, **kwargs)
form.set_system(system)
form.set_question(question)
if form.is_valid():
question = form.save()
return HttpResponseRedirect(
reverse('office_system',
kwargs={
'sid': system.id,
'section': 'questions'
}))
else:
form = QuestionForm(**kwargs)
form.set_system(system)
form.set_question(question)
data['form'] = form
return render(request, 'office/systems/single/questions_form.html',
data)
elif action == 'delete':
if question is None:
raise Http404
if answer_id is not None:
answer = get_object_or_404(Answer, pk=answer_id)
answer.delete()
return HttpResponse()
else:
question.delete()
return HttpResponse()
elif action == 'answers':
if question is None:
raise Http404
answers = question.answer_set.all()
data['answers'] = answers
return render(request, 'office/systems/single/answers.html', data)
elif action == 'answer':
if question is None:
raise Http404
kwargs = {'question': question}
answer = None
if answer_id is not None and answer_id != 'new':
answer = get_object_or_404(Answer, pk=answer_id)
kwargs['initial'] = model_to_dict(answer)
if request.method == 'POST':
form = AnswerForm(request.POST, request.FILES, **kwargs)
form.set_answer(answer)
if form.is_valid():
answer = form.save()
return HttpResponseRedirect(
reverse('office_system',
kwargs={
'sid': system.id,
'section': 'questions'
}) + ('?question_id=%s&action=%s' %
(question.id, 'answers')))
else:
form = AnswerForm(**kwargs)
form.set_answer(answer)
data['form'] = form
return render(request, 'office/systems/single/answers_form.html',
data)
else:
questions = system.question_set.all()
data['questions'] = questions
return render(request, 'office/systems/single/questions.html',
data)
def withdraw(request):
amount = request.DATA.get("amount", "").strip()
card_id = request.DATA.get("card_id", "").strip()
vcode = request.DATA.get("validate_code", "").strip()
if not amount or not card_id:
return {"ret_code": 20061, "message": u"信息输入不完整"}
user = request.user
if not user.wanglibaouserprofile.id_is_valid:
return {"ret_code": 20062, "message": u"请先进行实名认证"}
if user.wanglibaouserprofile.frozen:
return {"ret_code": 20072, "message": u"用户账户已冻结,请联系客服"}
try:
float(amount)
except:
return {"ret_code": 20063, 'message': u'金额格式错误'}
amount = util.fmt_two_amount(amount)
if len(str(amount)) > 20:
return {"ret_code": 20064, 'message': u'金额格式错误，大于100元且为100倍数'}
margin = user.margin.margin
if amount > margin:
return {"ret_code": 20065, 'message': u'余额不足'}
phone = user.wanglibaouserprofile.phone
status, message = validate_validation_code(phone, vcode)
if status != 200:
# Modify by hb on 2015-12-02
#return {"ret_code": 20066, "message": u"验证码输入错误"}
return {"ret_code": 20066, "message": message}
card = Card.objects.filter(pk=card_id).first()
if not card or card.user != user:
return {"ret_code": 20067, "message": u"请选择有效的银行卡"}
# 检测银行卡是否在黑名单中
black_list = BlackListCard.objects.filter(card_no=card.no).first()
if black_list and black_list.user != user:
return {"ret_code": 20072, "message": u'银行卡号异常,请联系客服'}
# 检查白名单
white_list = WhiteListCard.objects.filter(user=user,
card_no=card.no).first()
if not white_list:
# 增加银行卡号检测功能,检测多张卡
card_count = Card.objects.filter(no=card.no).count()
if card_count > 1:
return {"ret_code": 20073, "message": u'银行卡号有多张重复,请联系客服'}
# 检测银行卡在以前的提现记录中是否为同一个用户
payinfo_record = PayInfo.objects.filter(
card_no=card.no, type='W').order_by('-create_time').first()
if payinfo_record:
if payinfo_record.user != user:
return {"ret_code": 20074, "message": u'银行卡号与身份信息不符,请联系客服'}
# 计算提现费用 手续费 + 资金管理费
bank = card.bank
uninvested = user.margin.uninvested # 充值未投资金额
# 获取费率配置
fee_misc = WithdrawFee()
fee_config = fee_misc.get_withdraw_fee_config()
# 检测提现最大最小金额
if amount > fee_config.get('max_amount') or amount <= 0:
return {"ret_code": 20068, 'message': u'提现金额超出最大提现限额'}
if amount < fee_config.get('min_amount'):
if amount != margin:
return {
"ret_code": 20069,
'message':
u'账户余额小于{}时需要一次性提完'.format(fee_config.get('min_amount'))
}
# 检测银行的单笔最大提现限额,如民生银行
if bank and bank.withdraw_limit:
bank_limit = util.handle_withdraw_limit(bank.withdraw_limit)
bank_max_amount = bank_limit.get('bank_max_amount', 0)
if bank_max_amount:
if amount > bank_max_amount:
return {"ret_code": 20070, 'message': u'提现金额超出银行最大提现限额'}
# 获取计算后的费率
fee, management_fee, management_amount = fee_misc.get_withdraw_fee(
user, amount, margin, uninvested)
# 实际提现金额
actual_amount = amount - fee - management_fee
if actual_amount <= 0:
return {"ret_code": 20071, "message": u'实际到账金额为0,无法提现'}
pay_info = PayInfo()
pay_info.amount = actual_amount
pay_info.fee = fee
pay_info.management_fee = management_fee
pay_info.management_amount = management_amount
pay_info.total_amount = amount
pay_info.type = PayInfo.WITHDRAW
pay_info.user = user
pay_info.card_no = card.no
pay_info.account_name = user.wanglibaouserprofile.name
pay_info.bank = card.bank
pay_info.request_ip = util.get_client_ip(request)
pay_info.status = PayInfo.ACCEPTED
pay_info.channel = "app"
try:
order = OrderHelper.place_order(user,
Order.WITHDRAW_ORDER,
pay_info.status,
pay_info=model_to_dict(pay_info))
pay_info.order = order
keeper = MarginKeeper(user, pay_info.order.pk)
margin_record = keeper.withdraw_pre_freeze(
amount, uninvested=management_amount)
pay_info.margin_record = margin_record
pay_info.save()
return {
"ret_code": 0,
'message': u'提现成功',
"amount": amount,
"phone": phone,
"bank_name": bank.name,
"order_id": order.id
}
except Exception, e:
pay_info.error_message = str(e)
pay_info.status = PayInfo.FAIL
pay_info.save()
return {"ret_code": 20065, 'message': u'余额不足'}
def toJSON(self): # Retorna JSON
item = model_to_dict(self)
return item
def to_dict(self):
model_dict = model_to_dict(self)
model_dict['votes'] = self.votes
model_dict['slug'] = self.slug
return model_dict
def test(request):
articleModel = ArticleModel.objects.all().first()
articleDict = model_to_dict(articleModel)
print articleDict
return HttpResponse(articleDict)
def get(self, request, *args, **kwargs):
defs = {}
for d in Definition.objects.all():
defs[d.get_dict_key()] = model_to_dict(d)
return HttpResponse(simplejson.dumps(defs), content_type='application/json')
def generateDocXReport(month_id, year, lang, film_id):
langMap = dict(fr={
'template': 'template-fr.docx',
'locale': 'fr_FR',
'emptyList': 'Pas Encore.'
},
en={
'template': 'template-en.docx',
'locale': 'en_US',
'emptyList': 'Not yet.'
})
locale.setlocale(locale.LC_TIME, langMap.get(lang).get('locale'))
file_path = os.path.join(MEDIA_ROOT, 'reportTemplate/')
currentFilm = Film.objects.get(id=film_id)
subList = Submission.objects.filter(dateSubmission__year=year).filter(
dateSubmission__month=month_id).filter(film_id=film_id)
selectList = Submission.objects.filter(responseDate__year=year).filter(
responseDate__month=month_id).filter(film_id=film_id).filter(
response__iexact='SELECTIONED')
rejectList = Submission.objects.filter(responseDate__year=year).filter(
responseDate__month=month_id).filter(film_id=film_id).filter(
response__iexact='REFUSED')
subOutput, selectOutput, rejectOutput = [], [], []
for item in subList:
subOutput.append({'festival': model_to_dict(item.festival)})
if not subOutput:
subOutput.append({'festival': {'name': langMap[lang]['emptyList']}})
for item in selectList:
selectOutput.append({'festival': model_to_dict(item.festival)})
if not subOutput:
selectOutput.append({'festival': {'name': langMap[lang]['emptyList']}})
for item in rejectList:
rejectOutput.append({'festival': model_to_dict(item.festival)})
if not subOutput:
rejectOutput.append({'festival': {'name': langMap[lang]['emptyList']}})
document = DocxTemplate(file_path + langMap[lang]['template'])
dic = {
'INSCRIPTIONS_LIST':
subOutput,
'MOVIE_NAME':
currentFilm.name.upper(),
'CURRENT_DATE':
format_datetime(date.today(),
format='dd MMMM YYYY',
locale=langMap[lang]['locale']),
'TARGET_MONTH':
format_datetime(datetime.datetime(1900, int(month_id), 1),
format='MMMM',
locale=langMap[lang]['locale']),
'TARGET_YEAR':
str(year),
'SELECTIONS_LIST':
selectOutput,
'REJECTIONS_LIST':
rejectOutput,
'PROJECTIONS_LIST':
langMap[lang]['emptyList']
}
document.render(dic)
document.core_properties.title = currentFilm.name + "-" + lang
return document
def toJSON(self):
item = model_to_dict(self)
item['cate'] = self.cate.toJSON()
item['pvp'] = format(self.pvp, '.2f')
return item
def toJson(self):
item = model_to_dict(self)
return item
def get_section_dict(section):
""" Returns a dictionary of a section including indicator of whether that section is filled """
section_data = model_to_dict(section)
section_data['is_section_filled'] = section.is_full()
return section_data
def toJSON(self):
item = model_to_dict(self)
return item
def show(request, article_id):
article = get_object_or_404(Article, id=article_id)
# 阅读量+1
article.view = article.view + 1
article.save()
article_like = 0
# 用户已登录
if request.user.id:
# 添加阅读记录(第一次：添加，已有记录：更新时间)
history = ArticleViewHistory.objects.filter(article_id=article_id).filter(user_id=request.user)
if history:
change_history = history[0]
change_history.time = timezone.now()
change_history.save()
else:
new_history = ArticleViewHistory()
new_history.article = article
new_history.category = article.category
new_history.user = request.user
new_history.save()
# 判断是否已收藏文章
user_list = ArticleViewHistory.objects.filter(article_id=article_id)
for i in user_list:
if request.user == i.user and i.is_like == 1:
article_like = 1
break
# 下一篇，找出id大于当前文章id的文章,升序排序后取第一个，即为下一篇
next_article = Article.objects.filter(id__gt=article_id).filter(is_release=True).order_by("id")[:1]
if len(next_article) == 0:
next_article = 0
else:
for next in next_article:
next_article = next
# 上一篇，找出id小于当前文章id的文章，降序排序后取第一个，即为上一篇
last_article = Article.objects.filter(id__lt=article_id).filter(is_release=True).order_by("-id")[:1]
if len(last_article) == 0:
last_article = 0
else:
for last in last_article:
last_article = last
# 评论列表
# 全部评论
all_comment = []
for info in CommentMessage.objects.filter(article=article):
# 根评论
if info.reply_id is None:
# 单条记录
record = []
info_dict = model_to_dict(info)
info_dict['username'] = CommentMessage.objects.get(id=info.id).user.username
info_dict['reply_id'] = 'None'
info_dict['root_id'] = 'None'
info_dict['reply_name'] = 'None'
info_dict['photo'] = CommentMessage.objects.get(id=info.id).user.userinfo.photo.name
info_dict['web'] = CommentMessage.objects.get(id=info.id).user.userinfo.web
info_dict['time'] = CommentMessage.objects.get(id=info.id).time.strftime("%Y-%m-%d %H:%M:%S")
record.append(info_dict)
# 根据根留言查找子回复
record = comment_record(article, info.id, record)
all_comment.append(record)
# 热门评论
hot_comment = CommentMessage.objects.filter(article=article).filter(level=0).order_by('-like')
# 我的评论
user_id = request.user.id
if user_id:
my_comment = CommentMessage.objects.filter(article=article).filter(level=0).filter(user_id=user_id)
else:
my_comment = None
# 评论统计
count = CommentMessage.objects.filter(article=article).count()
# 猜你喜欢
guess1 = Article.objects.filter(is_release=True).filter(tags=article.tags.all()[0]).order_by('?')[:2]
guess2 = Article.objects.filter(is_release=True).filter(tags=article.tags.all()[1]).order_by('?')[:2]
return render(request, 'blog/show.html',
{"article": article, "articke_like": article_like, "next_article": next_article,
"last_article": last_article, "all_comment": all_comment, "hot_comment": hot_comment,
"my_comment": my_comment, "count": count, "aside_dict": aside(), "guess1": guess1, "guess2": guess2})
def to_dict(self):
data = model_to_dict(self)
data.pop('id')
return data
def delete_form_valid(self, object):
success_message = self.get_success_message(model_to_dict(object))
if success_message:
messages.success(self.request, success_message)
def get_item_comment_by_id(cls, comment_id):
try:
model_obj = cls.objects.get(pk=comment_id)
return model_to_dict(model_obj)
except cls.DoesNotExist:
return None
def file(request, project_id):
""" 文件列表 & 添加文件夹 """
parent_object = None
folder_id = request.GET.get('folder', "")
if folder_id.isdecimal():
parent_object = models.FileRepository.objects.filter(
id=int(folder_id), file_type=2,
project=request.tracer.project).first()
# GET 查看页面
if request.method == "GET":
breadcrumb_list = []
parent = parent_object
while parent:
# breadcrumb_list.insert(0, {'id': parent.id, 'name': parent.name})
breadcrumb_list.insert(0, model_to_dict(parent, ['id', 'name']))
parent = parent.parent
# 当前目录下所有的文件 & 文件夹获取到即可
queryset = models.FileRepository.objects.filter(
project=request.tracer.project)
if parent_object:
# 进入了某目录
file_object_list = queryset.filter(
parent=parent_object).order_by('-file_type')
else:
# 根目录
file_object_list = queryset.filter(
parent__isnull=True).order_by('-file_type')
form = FolderModelForm(request, parent_object)
context = {
'form': form,
"file_object_list": file_object_list,
"breadcrumb_list": breadcrumb_list,
'folder_object': parent_object
}
return render(request, 'file.html', context)
# POST 添加文件夹 & 文件夹的修改
fid = request.POST.get('fid', '')
edit_object = None
if fid.isdecimal():
edit_object = models.FileRepository.objects.filter(
id=int(fid), file_type=2, project=request.tracer.project).first()
if edit_object:
form = FolderModelForm(request,
parent_object,
data=request.POST,
instance=edit_object)
else:
form = FolderModelForm(request, parent_object, data=request.POST)
if form.is_valid():
form.instance.project = request.tracer.project
form.instance.file_type = 2
form.instance.update_user = request.tracer.user
form.instance.parent = parent_object
form.save()
return JsonResponse({'status': True})
return JsonResponse({'status': False, 'error': form.errors})
def default(self, o):
if isinstance(o, Model):
return model_to_dict(o)
return super().default(o)
def query(request, document_id):
docJson = model_to_dict(Document.objects.get(pk=document_id))
return JsonResponse(docJson, safe=False)
def get(self, request, *args, **kwargs):
# print(request.GET)
try:
fields_name = [i.name for i in Movie._meta.get_fields()]
queryset = None
if kwargs.get('pk'):
# queryset = Movie.objects.filter(id=kwargs.get('pk')).values()
queryset = Movie.objects.filter(
id=kwargs.get('pk')).prefetch_related()
print(queryset)
main_json = list()
for i in queryset:
data = model_to_dict(i)
data['genres_movie'] = list()
for d in i.genres_movie.values('name'):
data['genres_movie'].append(d.get('name'))
main_json.append(data)
print(main_json)
elif request.GET.get('search_field') == 'year':
if len(request.GET.get('search_term')) > 4:
query_args = {
'released_year__range':
request.GET.get('search_term').split('-')
}
else:
query_args = {
'released_year': request.GET.get('search_term')
}
print(query_args)
# queryset = Movie.objects.filter(**query_args).values()
queryset = Movie.objects.filter(
**query_args).prefetch_related()
print(queryset)
main_json = list()
for i in queryset:
data = model_to_dict(i)
data['genres_movie'] = list()
for d in i.genres_movie.values('name'):
data['genres_movie'].append(d.get('name'))
main_json.append(data)
print(main_json)
elif request.GET.get('search_field') == 'rating':
if request.GET.get('condition') == 'higher':
query_args = {
'{0}__gte'.format(request.GET.get('search_field')):
request.GET.get('search_term')
}
else:
query_args = {
'{0}__lte'.format(request.GET.get('search_field')):
request.GET.get('search_term')
}
queryset = Movie.objects.filter(
**query_args).prefetch_related()
print(queryset)
main_json = list()
for i in queryset:
data = model_to_dict(i)
data['genres_movie'] = list()
for d in i.genres_movie.values('name'):
data['genres_movie'].append(d.get('name'))
main_json.append(data)
print(main_json)
elif request.GET.get('search_field') in fields_name:
query_args = {
'{0}__icontains'.format(request.GET.get('search_field')):
request.GET.get('search_term')
}
# queryset = Movie.objects.filter(**query_args).values()
queryset = Movie.objects.filter(
**query_args).prefetch_related()
print(queryset)
main_json = list()
for i in queryset:
data = model_to_dict(i)
data['genres_movie'] = list()
for d in i.genres_movie.values('name'):
data['genres_movie'].append(d.get('name'))
main_json.append(data)
# print(main_json)
elif request.GET.get('search_field') == 'genres':
query_args = {
'name__icontains': request.GET.get('search_term')
}
queryset = Genres.objects.filter(**query_args).select_related()
# print(queryset)
main_json = list()
for i in queryset:
data = model_to_dict(i.movie)
main_json.append(data)
response = {'message': main_json}
return JsonResponse(response, status=200)
else:
response = {'message': 'Field name not matched.'}
return JsonResponse(response, status=200)
# print(queryset)
if queryset:
response = {'message': main_json}
return JsonResponse(response, status=200)
else:
response = {'message': 'Not found'}
return JsonResponse(response, status=206)
except Exception as e:
print(e)
response = {'message': 'Internal server error'}
return JsonResponse(response, status=500)
def handle(self, request, data):
system = data['system']
object_id = request.GET.get('object_id', None)
if object_id is not None:
if request.method == 'POST':
if request.GET.get('action', None) == 'delete':
obj = get_object_or_404(Object, pk=object_id)
obj.delete()
return HttpResponse()
form = ObjectForm(request.POST, request.FILES)
elif object_id == 'new':
form = ObjectForm()
else:
obj = get_object_or_404(Object, pk=object_id)
form = ObjectForm(initial=model_to_dict(obj))
object_attrs = []
if object_id != 'new':
obj = get_object_or_404(Object, pk=object_id)
form.set_object(obj)
object_attrs = list(obj.objectattributevalue_set.all())
form.set_system(system)
data['form'] = form
attrs = system.attribute_set.prefetch_related(
'attributeallowedvalue_set').all()
attrs_data = []
for attr in attrs:
active = None
for oav in object_attrs:
if oav.attribute_id == attr.id:
active = oav.attribute_value_id
break
allowed = [{
'val': val,
'active': val.id == active
} for val in attr.attributeallowedvalue_set.all()]
attrs_data.append({
'attr': attr,
'allowed_vals': allowed,
})
data['attrs'] = attrs_data
# print(attrs_data)
if request.method == 'POST':
if form.is_valid():
object = form.save()
return HttpResponseRedirect(
reverse('office_system',
kwargs={
'sid': system.id,
'section': 'objects'
}))
return render(request, 'office/systems/single/objects_form.html',
data)
else:
objects = system.object_set.all()
data['objects'] = objects
return render(request, 'office/systems/single/objects.html', data)
def get_inline_address(self):
return '{cus_uid}-{receiver_name}-{receiver_mobile}-{receiver_state},{receiver_city},{receiver_district},{receiver_address}'.format(
**model_to_dict(self)
)
def toJSON(self):
item = model_to_dict(self)
item['cat'] = self.cat.toJSON()
item['image'] = self.get_image()
item['pvp'] = format(self.pvp, '.2f')
return item