def barcode(request,barcode):
try:
bcstored=Item.objects.get(bc=barcode)
JSONserializer=serializers.get_serializer("json")
json_serializer=JSONserializer();
response=HttpResponse()
json_serializer.serialize(Item.objects.filter(bc=barcode),stream=response,use_natural_keys=True)
return response
except Item.DoesNotExist:
baseurl="https://www.googleapis.com/shopping/search/v1/public/products?key="
baseurl+=key;
baseurl+="&&country=US&q="
baseurl+=smart_str(barcode);
baseurl+="&alt=json";
result=json.load(urllib.urlopen(baseurl));
resp='Not in DataBase yet using google shopper name'
try:
p=Item(bc=long(barcode),name=smart_str(result["items"][0]["product"]["title"]),maker=smart_str(result["items"][0]["product"]["brand"]),imageurl=result["items"][0]["product"]["images"][0]["link"],rating=0,raters=0)
p.save()
JSONserializer=serializers.get_serializer("json")
json_serializer=JSONserializer();
response=HttpResponse()
json_serializer.serialize(Item.objects.filter(bc=barcode),stream=response,use_natural_keys=True)
except KeyError:
response="Not Found by google shopper"
return response
def handle(self, *app_labels, **options):
from django.db.models import get_app, get_apps, get_models
format = options.get("format", "json")
indent = options.get("indent", None)
show_traceback = options.get("traceback", False)
if len(app_labels) == 0:
app_list = get_apps()
else:
app_list = [get_app(app_label) for app_label in app_labels]
# Check that the serialization format exists; this is a shortcut to
# avoid collating all the objects and _then_ failing.
if format not in serializers.get_public_serializer_formats():
raise CommandError("Unknown serialization format: %s" % format)
try:
serializers.get_serializer(format)
except KeyError:
raise CommandError("Unknown serialization format: %s" % format)
objects = []
for app in app_list:
for model in get_models(app):
objects.extend(model._default_manager.all())
try:
return serializers.serialize(format, objects, indent=indent)
except Exception, e:
if show_traceback:
raise
raise CommandError("Unable to serialize database: %s" % e)
def handle(self, *app_labels, **options):
format = options.get('format','json')
indent = options.get('indent',None)
exclude = options.get('exclude',[])
show_traceback = options.get('traceback', False)
excluded_apps = [get_app(app_label) for app_label in exclude]
if len(app_labels) == 0:
app_list = [app for app in get_apps() if app not in excluded_apps]
else:
app_list = [get_app(app_label) for app_label in app_labels]
# Check that the serialization format exists; this is a shortcut to
# avoid collating all the objects and _then_ failing.
try:
serializers.get_serializer(format)
except KeyError:
raise CommandError("Unknown serialization format: %s" % format)
objects = []
collected = set()
for app in app_list: #Yey for ghetto recusion
objects, collected = _relational_dumpdata(app, collected)
#****End New stuff
try:
return serializers.serialize(format, objects, indent=indent)
except Exception, e:
if show_traceback:
raise
raise CommandError("Unable to serialize database: %s" % e)
def handle(self, *args, **options):
namespaces = options.get('namespaces', [])
show_traceback = options.get('traceback', False)
format = options.get('format', 'json')
if format not in serializers.get_public_serializer_formats():
raise CommandError("Unknown serialization format: %s" % format)
try:
serializers.get_serializer(format)
except KeyError:
raise CommandError("Unknown serialization format: %s" % format)
objects = []
if not namespaces:
objects.extend(models.Schema.objects.all())
objects.extend(models.ParameterName.objects.all())
else:
schemas = models.Schema.objects.filter(namespace__in=namespaces)
if not schemas:
raise CommandError('No schemas found')
schema_set = set([s.namespace for s in schemas])
arg_set = set(args)
skipped = arg_set - schema_set
if skipped:
sys.stderr.write('Schema not found: {0}\n'.format(
', '.join(skipped)))
objects.extend(schemas)
objects.extend(models.ParameterName.objects.filter(schema__namespace__in=args))
try:
return serializers.serialize(
format, objects, indent=4, use_natural_foreign_keys=True)
except Exception as e:
if show_traceback:
raise
raise CommandError("Unable to serialize database: %s" % e)
def export_data(filetype):
"""
Export the data currently being in the database
and save it in folder 'exported_data'.
"""
from django.core import serializers
if filetype == "xml":
serializer = serializers.get_serializer("xml")
elif filetype == "json":
serializer = serializers.get_serializer("json")
else:
raise RuntimeError("Extension must be either 'xml' or 'json'!")
if not os.path.isdir("exported_data"):
os.mkdir("exported_data")
dump_file = "cocos_dump_" + str(datetime.today()).replace(" ", "_") + "." + filetype
output = open("exported_data/" + dump_file, "w")
new_serializer = serializer()
all_objects = list(CorpusDescription.objects.all()) + \
list(FeedbackMessage.objects.all())
new_serializer.serialize(all_objects, stream=output)
output.close()
print "\tModel data successfully written to", dump_file
def _validate_serializer(self, format):
# Check that the serialization format exists; this is a shortcut to
# avoid collating all the objects and _then_ failing.
try:
serializers.get_serializer(format)
except KeyError:
raise CommandError("Unknown serialization format: %s" % format)
def dump_data(request,appname):
app_list = SortedDict()
try:
if request.POST:
for appname in request.POST.getlist('apps'):
app = get_app(appname)
app_list[app] = None
appname = 'choices'
else:
app = get_app(appname)
app_list[app] = None
except ImproperlyConfigured:
if appname == 'all':
for app in get_apps():
app_list[app] = None
if(len(app_list) > 0):
objects = []
for model in sort_dependencies(app_list.items()):
if not model._meta.proxy and router.allow_syncdb(DEFAULT_DB_ALIAS, model):
objects.extend(model._default_manager.using(DEFAULT_DB_ALIAS).all())
serializers.get_serializer('json')
json = serializers.serialize('json', objects, indent=2,use_natural_keys=True)
response = HttpResponse(json, mimetype='application/json');
response['Content-Disposition'] = 'attachment; filename=%s_%s_fixture.json' % (date.today().__str__(),appname)
return response
return render_to_response('diagnostic/dumpdata.html',context_instance=RequestContext(request))
def handle_models(self, models, **options):
format = options.get('format','json')
indent = options.get('indent',None)
show_traceback = options.get('traceback', False)
propagate = options.get('propagate', True)
# Check that the serialization format exists; this is a shortcut to
# avoid collating all the objects and _then_ failing.
if format not in serializers.get_public_serializer_formats():
raise CommandError("Unknown serialization format: %s" % format)
try:
serializers.get_serializer(format)
except KeyError:
raise CommandError("Unknown serialization format: %s" % format)
objects = []
for model, slice in models:
if isinstance(slice, basestring):
objects.extend(model._default_manager.filter(pk__exact=slice))
elif not slice or type(slice) is list:
items = model._default_manager.all()
if slice and slice[0]:
items = items.filter(pk__gte=slice[0])
if slice and slice[1]:
items = items.filter(pk__lt=slice[1])
items = items.order_by(model._meta.pk.attname)
objects.extend(items)
else:
raise CommandError("Wrong slice: %s" % slice)
all = objects
if propagate:
collected = set([(x.__class__, x.pk) for x in all])
while objects:
related = []
for x in objects:
if DEBUG:
print "Adding %s[%s]" % (model_name(x), x.pk)
for f in x.__class__._meta.fields + x.__class__._meta.many_to_many:
if isinstance(f, ForeignKey):
new = getattr(x, f.name) # instantiate object
if new and not (new.__class__, new.pk) in collected:
collected.add((new.__class__, new.pk))
related.append(new)
if isinstance(f, ManyToManyField):
for new in getattr(x, f.name).all():
if new and not (new.__class__, new.pk) in collected:
collected.add((new.__class__, new.pk))
related.append(new)
objects = related
all.extend(objects)
try:
return serializers.serialize(format, all, indent=indent)
except Exception, e:
if show_traceback:
raise
raise CommandError("Unable to serialize database: %s" % e)
def handle_noargs(self, **options):
"""
Generates a dump of Django CMS database.
"""
format = options.get('format')
indent = options.get('indent')
use_natural_keys = options.get('use_natural_keys')
show_traceback = options.get('traceback')
# Check that the serialization format exists; this is a shortcut to
# avoid collating all the objects and _then_ failing.
if format not in serializers.get_public_serializer_formats():
raise base.CommandError("Unknown serialization format: %s" % format)
try:
serializers.get_serializer(format)
except KeyError:
raise base.CommandError("Unknown serialization format: %s" % format)
pages = cms_models.Page.objects.filter(published=True)
placeholders = cms_models.Placeholder.objects.filter(page__in=pages)
blog_entries = blog_models.Entry.published.all()
blog_placeholders = cms_models.Placeholder.objects.filter(entry__in=blog_entries)
plugins = cms_models.CMSPlugin.objects.filter(Q(placeholder__in=placeholders) | Q(placeholder__in=blog_placeholders))
def plugin_objects():
for plugin in plugins:
instance = plugin.get_plugin_instance()[0]
if instance is None:
raise base.CommandError("Invalid plugin instance: %s from placeholder %s" % (plugin.pk, plugin.placeholder.pk))
yield instance
objects = itertools.chain(
sites_models.Site.objects.all(),
contenttypes_models.ContentType.objects.all(),
placeholders,
pages,
cms_models.Title.objects.filter(page__in=pages),
blog_placeholders,
blog_entries,
blog_models.EntryTitle.objects.filter(entry__in=blog_entries),
plugins,
plugin_objects(),
filer_models.Folder.objects.all(),
filer_models.File.objects.non_polymorphic().filter(is_public=True),
filer_models.Image.objects.non_polymorphic().filter(is_public=True),
filer_image_models.ThumbnailOption.objects.all(),
snippet_models.Snippet.objects.all(),
)
try:
return serializers.serialize(format, objects, indent=indent, use_natural_keys=use_natural_keys)
except Exception, e:
if show_traceback:
raise
raise base.CommandError("Unable to serialize database: %s" % e)
def handle(self, *app_labels, **options):
format = options.get('format','json')
indent = options.get('indent',None)
exclude = options.get('exclude',[])
exclude_models = options.get('excludem',[])
#includem = options.get('includem',[])
show_traceback = options.get('extrasort', False)
extrasort = options.get('traceback', False)
excluded_apps = [get_app(app_label) for app_label in exclude]
excluded_models = [(get_app(app_label.split('.')[0]),
get_model(app_label.split('.')[0],
app_label.split('.')[1])
) for app_label in exclude_models]
if len(app_labels) == 0:
app_list = [app for app in get_apps() if app not in excluded_apps]
else:
app_list = [get_app(app_label) for app_label in app_labels]
# Check that the serialization format exists; this is a shortcut to
# avoid collating all the objects and _then_ failing.
if format not in serializers.get_public_serializer_formats():
raise CommandError("Unknown serialization format: %s" % format)
try:
serializers.get_serializer(format)
except KeyError:
raise CommandError("Unknown serialization format: %s" % format)
objects = []
models=[]
for app in app_list:
for model in get_models(app):
if intuplelist0(excluded_models, app) and\
intuplelist1(excluded_models, model):
pass
else:
models.append(model)
if extrasort:
models = sort_by_relation(models)
for model in models:
try:
objects.extend(model._default_manager.all().order_by(pk))
except:
objects.extend(model._default_manager.all())
try:
return serializers.serialize(format, objects, indent=indent)
except Exception, e:
if show_traceback:
raise
raise CommandError("Unable to serialize database: %s" % e)
def dump_selected(modeladmin, request, queryset):
objects = []
for doc in queryset.all():
rev = Revision.objects.get(id=doc.current_revision.id)
doc.current_revision = None
objects.append(doc)
objects.append(rev)
serializers.get_serializer("json")
filename = "documents_%s.%s" % (datetime.now().isoformat(), SMUGGLER_FORMAT)
response = HttpResponse(mimetype="text/plain")
response["Content-Disposition"] = "attachment; filename=%s" % filename
return serialize_to_response(objects, response)
def filter(request, model):
info = ""
status = GOOD_REQUEST
if request.method == "GET":
body = request.GET
try:
if model == "rooms":
qSet = filterutils.filter_rooms(body)
elif model == "courses":
qSet = filterutils.filter_courses(body)
elif model == "schedules":
qSet = filterutils.filter_schedules(body)
else:
info = {"Error" : "Unable to filter. No such model named " + model}
status = BAD_REQUEST
JSONSerializer = serializers.get_serializer("json")
s = JSONSerializer()
s.serialize(qSet)
data = s.getvalue()
status = GOOD_REQUEST
return HttpResponse(content = data, status = status)
except Exception as e:
info = {"Error" : "Error while filtering: " + str(e)}
status = INTERNAL_ERROR
else:
info = {"Error" : "Unable to filter."}
status = INTERNAL_ERROR
data = json.dumps(info)
return HttpResponse(content = data, status = status)
def read(self, request, formdef_id):
""" lists all metadata associated with all instances submitted
to a particular schema
"""
# CSV
metadata = Metadata.objects.filter(formdefmodel=formdef_id).order_by('id')
if not metadata:
return HttpResponseBadRequest("Metadata of schema with id %s not found." % formdef_id)
if request.REQUEST.has_key('start-id'):
metadata = metadata.filter(pk__gte=request.GET['start-id'])
if request.REQUEST.has_key('end-id'):
metadata = metadata.filter(pk__lte=request.GET['end-id'])
if request.REQUEST.has_key('start-date'):
date = datetime.strptime(request.GET['start-date'],"%Y-%m-%d")
metadata = metadata.filter(attachment__submission__submit_time__gte=date)
if request.REQUEST.has_key('end-date'):
date = datetime.strptime(request.GET['end-date'],"%Y-%m-%d")
metadata = metadata.filter(attachment__submission__submit_time__lte=date)
if request.REQUEST.has_key('format'):
if request.GET['format'].lower() == 'xml':
response = HttpResponse(mimetype='text/xml')
xml_serializer = serializers.get_serializer("xml")()
xml_serializer.serialize(metadata, stream=response, fields = \
('formname','formversion','deviceid','timestart','timeend',\
'username','chw_id','uid','raw_data') )
return response
return get_csv_from_django_query(metadata)
def createPDF(self):
XMLSerializer = serializers.get_serializer("xml")
xml_serializer = XMLSerializer()
out = open(settings.PDF_OUTPUT_ROOT+"purchaseorder_"+str(self.id)+".xml", "w")
objectsToSerialize = list(PurchaseOrder.objects.filter(id=self.id))
objectsToSerialize += list(Contact.objects.filter(id=self.supplier.id))
objectsToSerialize += list(Currency.objects.filter(id=self.currency.id))
objectsToSerialize += list(PurchaseOrderPosition.objects.filter(contract=self.id))
for position in list(PurchaseOrderPosition.objects.filter(contract=self.id)):
objectsToSerialize += list(Position.objects.filter(id=position.id))
objectsToSerialize += list(Product.objects.filter(id=position.product.id))
objectsToSerialize += list(Unit.objects.filter(id=position.unit.id))
objectsToSerialize += list(auth.models.User.objects.filter(id=self.staff.id))
userExtension = djangoUserExtension.models.UserExtension.objects.filter(user=self.staff.id)
if (len(userExtension) == 0):
raise UserExtensionMissing(_("During PurchaseOrder PDF Export"))
phoneAddress = djangoUserExtension.models.UserExtensionPhoneAddress.objects.filter(userExtension=userExtension.id)
objectsToSerialize += list(userExtension)
objectsToSerialize += list(phoneAddress)
templateset = djangoUserExtension.models.TemplateSet.objects.filter(id=userExtension[0].defaultTemplateSet.id)
if (len(userExtentemplatesettion) == 0):
raise TemplateSetMissing(_("During PurchaseOrder PDF Export"))
objectsToSerialize += list(templateset)
objectsToSerialize += list(auth.models.User.objects.filter(id=self.lastmodifiedby.id))
objectsToSerialize += list(PostalAddressForContact.objects.filter(person=self.supplier.id))
for address in list(PostalAddressForContact.objects.filter(person=self.supplier.id)):
objectsToSerialize += list(PostalAddress.objects.filter(id=address.id))
xml_serializer.serialize(objectsToSerialize, stream=out, indent=3)
out.close()
system('bash -c "fop -c '+userExtension[0].defaultTemplateSet.fopConfigurationFile.path+' -xml '+settings.PDF_OUTPUT_ROOT+' purchaseorder_'+str(self.id)+'.xml -xsl ' +userExtension[0].defaultTemplateSet.purchaseorderXSLFile.xslfile.path+' -pdf '+settings.PDF_OUTPUT_ROOT+' purchaseorder_'+str(self.id)+'.pdf"')
return settings.PDF_OUTPUT_ROOT+"purchaseorder_"+str(self.id)+".pdf"
def get(self, request, contact_id=None, **kwargs):
json_serializer = serializers.get_serializer('json')()
if contact_id:
contacts = json_serializer.serialize(Contact.objects.filter(pk=contact_id))
else:
contacts = json_serializer.serialize(Contact.objects.all())
return HttpResponse(contacts, content_type='application/json', status=200)
def convertir(obj):
dic= obj.__dict__
json_serializer=serializers.get_serializer('json')()
llaves= dic.keys()
cadena="{"
for i in range(len(llaves)):
llave= llaves[i]
if llave== "_state":
continue
valor= dic[llave]
newval=''
if type(valor)== unicode:
newval=dumps(valor)
if i==0:
cadena = cadena +'"' +llave + '":' +newval+ ''
else:
cadena= cadena +',"' +llave + '":' +newval +''
else:
newval=str(valor)
if i==0:
cadena = cadena +'"' +llave + '":"' +newval+ '"'
else:
cadena= cadena +',"' +llave + '":"' +newval +'"'
cadena=cadena+"}"
return cadena
def handle(self, **opts):
if opts['filename'][-7:] == '.tar.gz' or opts['filename'][-4:] == '.tgz':
compression = 'gz'
else:
compression = 'bz2'
if opts['filename'][-8:] != '.tar.bz2':
opts['filename'] += '.tar.bz2'
def serialize(serializer, model, tar):
serializer.serialize(model.objects.all())
tarinfo = tarfile.TarInfo('%s-%s.json' %
(datetime.now().date(), model.__name__.lower()))
tarinfo.size = serializer.stream.len
serializer.stream.seek(0)
tar.addfile(tarinfo, serializer.stream)
self.stdout.write('Saving models... ', ending='')
with tarfile.open(opts['filename'], 'w:%s' % compression) as out:
serial = serializers.get_serializer('json')()
for model in _models:
if not opts[model.__name__]:
serialize(serial, model, out)
self.stdout.write('done!')
if opts['uploads']:
self.stdout.write('Compressing uploads... ', ending='')
out.add(settings.MEDIA_ROOT)
self.stdout.write('done!')
def get_uid_list(request, role_id):
role = Role.objects.get(id=role_id)
mimetype = 'application/json'
json_serializer = serializers.get_serializer("json")()
data = json_serializer.serialize(role.uids().filter(completer=None),
ensure_ascii=False, fields=('uid', 'extra_details'))
return HttpResponse(data, mimetype)
def BarDrinksOfType (request, bar_id, type_id):
if request.method == 'GET':
drinks_to_return = BarDrink.objects.filter(bar=bar_id) if type_id == '0' else BarDrink.objects.filter(
bar=bar_id, drink_type=type_id)
json_serializer = serializers.get_serializer("json")()
response = json_serializer.serialize(drinks_to_return, ensure_ascii=False)
return HttpResponse(response, mimetype="application/json")
def backup(request):
all_paths = Path.objects.all()
response = HttpResponse()
response['mimetype'] = 'application/json'
json_srlzr = serializers.get_serializer("json")()
json_srlzr.serialize(all_paths, ensure_ascii=False, stream=response)
return response
def BarDrinkTypes (request, bar_id):
if request.method == 'GET':
drinks = BarDrink.objects.filter(bar=bar_id)
types_to_return = VenueDrinkType.objects.filter(bardrink__in=drinks).distinct()
json_serializer = serializers.get_serializer("json")()
response = json_serializer.serialize(types_to_return, ensure_ascii=False)
return HttpResponse(response, mimetype="application/json")
def handle(self, **kwargs):
singleObject = not True;
obj = None
queryset = None
if singleObject:
# obj = Entity.objects.get(id=4)
pass
else:
# queryset = User.objects.all()
# queryset = Battle.objects.all()
queryset = Player.objects.all()
pass
# Save to file
out = open("model_fixture.json", "w")
json_serializer = serializers.get_serializer("json")()
if singleObject:
json_serializer.serialize([obj], stream = out, sort_keys = True, indent = 4)
else:
items = []
print "Total rows: %d " % len(queryset)
for item in queryset:
items.append(item)
json_serializer.serialize(items, stream = out, sort_keys = True, indent = 4)
out.close()
def json_all(request):
news = load_from_db()
json_serializer = serializers.get_serializer("json")()
data = json_serializer.serialize(news, ensure_ascii=False)
#news = list(news)
#data = json_encode(news)
return HttpResponse(data, mimetype='application/json')
def all_genres(request):
genres = Genres.objects.all()
json_serializer = serializers.get_serializer("json")
json_data = json_serializer()
json_data.serialize(genres)
data = json_data.getvalue()
return HttpResponse(data)
def _serialize_batch(batch, start=0, limit=25, statuses=None, name=None):
"""
Hack around the problem of serializing
an object AND it's child objects.
"""
taskqset = batch.tasks.all()
if statuses:
taskqset = batch.tasks.filter(status__in=statuses)
if name:
taskqset = taskqset.filter(page_name__icontains=name)
task_count = taskqset.count()
pyserializer = serializers.get_serializer("python")()
batchsl = pyserializer.serialize(
[batch],
extras=("estimate_progress", "is_complete",),
relations={
"user": {"fields": ("username")},
"comparison": {"fields": ()},
},
)
taskssl = pyserializer.serialize(
taskqset.order_by("page_name")[start:start + limit],
excludes=("args", "kwargs", "traceback",),
)
batchsl[0]["fields"]["tasks"] = taskssl
batchsl[0]["extras"]["task_count"] = task_count
return batchsl
def evaluation_comment(request, app_id):
application = get_object_or_404(Application, id=app_id)
if request.method == 'POST':
if request.POST.get('key', None):
key = request.POST.get('key', None)
comment = request.POST.get('comment', None)
if comment:
evalcomment, created = EvaluationComment.objects.get_or_create(evaluation=application.evaluation,
key=key)
evalcomment.comment = comment
evalcomment.save()
else:
comment = get_object_or_none(EvaluationComment,
evaluation=application.evaluation,
key=key)
if comment:
comment.delete()
return HttpResponse("success")
elif request.is_ajax():
comments = EvaluationComment.objects.filter(evaluation=application.evaluation)
json = serializers.get_serializer('json')()
response = HttpResponse(mimetype='application/json')
json.serialize(comments, stream=response)
return response
return HttpResponse("invalid")
def evaluation_interview_answer(request, app_id):
application = get_object_or_404(Application, id=app_id)
if request.method == 'POST':
if request.POST.get('key', None):
key = request.POST.get('key', None)
question = get_object_or_404(InterviewQuestion, id=key, session=application.session)
comment = request.POST.get('comment', None)
if comment:
answer, created = Answer.objects.get_or_create(application=application,
question=question)
answer.answer = comment
answer.save()
else:
answer = get_object_or_none(Answer,
application=application,
question=question)
if answer:
answer.delete()
return HttpResponse("success")
elif request.is_ajax():
answers = Answer.objects.filter(application=application)
json = serializers.get_serializer('json')()
response = HttpResponse(mimetype='application/json')
json.serialize(comments, stream=response)
return response
return HttpResponse("invalid")
def bugs_to_json_response(data, bunch_of_bugs, callback_function_name=''):
""" The search results page accesses this view via jQuery's getJSON method,
and loads its results into the DOM."""
# Purpose of this code: Serialize the list of bugs
# Step 1: Pull the bugs out of the database, getting them back
# as simple Python objects
obj_serializer = serializers.get_serializer('python')()
bugs = obj_serializer.serialize(bunch_of_bugs)
# Step 2: With a (tragically) large number of database calls,
# loop over these objects, replacing project primary keys with project
# display names.
for bug in bugs:
project = Project.objects.get(pk=int(bug['fields']['project']))
bug['fields']['project'] = project.display_name
# Step 3: Create a JSON-happy list of key-value pairs
data_list = [{'bugs': bugs}]
# Step 4: Create the string form of the JSON
json_as_string = simplejson.dumps(data_list, default=encode_datetime)
# Step 5: Prefix it with the desired callback function name
json_string_with_callback = callback_function_name + \
'(' + json_as_string + ')'
# Step 6: Return that.
return HttpResponse(json_string_with_callback)
def handle_label(self, project_slug, **options):
# pdb.set_trace()
try:
project = Project.objects.get(slug=project_slug)
out = open(options['output'], 'w') if options['output'] else sys.stdout
format = options['format']
FormatSerializer = serializers.get_serializer(format)
serializer = FormatSerializer()
documents = Document.objects.filter(project=project)
transcripts = []
scans = []
citations = []
for d in documents:
if d.transcript: transcripts.append(d.transcript)
if d.scan_count: scans.extend(d.scans.all())
for c in d.citations.all(): citations.append(c)
notes = Note.objects.filter(project=project)
topics = Topic.objects.filter(project=project)
serializer.serialize([project]+
transcripts+
scans+
citations+
list(notes)+
list(topics),
#chain(documents, notes, topics),
stream=out)
if out != sys.stdout:
out.close()
except TypeError as e:
raise
def GetUserOrderHistory (request):
if request.method == 'GET':
if request.user.is_authenticated():
orders = BarOrder.objects.filter(appuser=request.user.appuser).order_by('-id')[:100]
json_serializer = serializers.get_serializer("json")()
serialized_response = json_serializer.serialize(orders, ensure_ascii=False)
return HttpResponse(serialized_response, mimetype="application/json")
def getToStops(request):
in_route=request.GET.get('travelroute')
in_direction=request.GET.get('direction')
in_from=request.GET.get('from')
#query database for route, direction and stops greater than fromstopid
stops = m.MapStops.objects.filter(route=in_route).filter(direction=in_direction).filter(map_stop_id__gt=in_from)
#translate stops into JSON format
XMLSerializer = serializers.get_serializer("json")
xml_serializer = XMLSerializer()
xml_serializer.serialize(stops)
data = xml_serializer.getvalue()
return HttpResponse(data, content_type='application/json')
def serialize(self, output_format):
"""
Serialize machine with its relations. Valid output formats are JSON and Yaml.
"""
output_format = output_format.lower()
if not Serializer.Format.is_valid(output_format):
logger.warning("Unknown serialize format! Continues with JSON...")
output_format = Serializer.Format.JSON
if output_format == Serializer.Format.YAML:
try:
import yaml
except ImportError:
logger.warning(
"YAML module not available! Continues with JSON...")
output_format = Serializer.Format.JSON
querysets = [
[self],
self.networkinterfaces.all(),
[self.remotepower] if self.has_remotepower() else None,
[self.serialconsole] if self.has_serialconsole() else None,
self.annotations.all(),
self.reservationhistory_set.all(),
]
serializer = serializers.get_serializer(output_format)()
chunks = []
for i, queryset in enumerate(querysets):
if queryset is None:
continue
chunks.append(
serializer.serialize(queryset,
indent=4,
use_natural_foreign_keys=True,
use_natural_primary_keys=True))
data = '\n'.join(chunks)
return (data, output_format)
def home(request, index=1):
# print(request.user)
user = request.user
user_maps = Map.objects.filter(user=request.user)
# print("this is: " + str(type(user_maps)))
curr_map = user_maps[0]
if index != 1:
curr_map.curr_map_ref = index
curr_map.save()
ref_map = user_maps.get(pk=index)
for booth in curr_map.booths.all():
booth.delete()
for project in ref_map.booths.all():
booth = Booth()
booth.project_id = project.project_id
booth.length = project.length
booth.width = project.width
booth.area = project.area
booth.project_name = project.project_name
booth.industry = project.industry
booth.length_pixel = project.length_pixel
booth.width_pixel = project.width_pixel
booth.rotation = project.rotation
booth.position_x = project.position_x
booth.position_y = project.position_y
booth.in_campus_centre = project.in_campus_centre
booth.saved_map = curr_map
booth.save()
# print(user_maps[0].booths.all())
booth = curr_map.booths.all()
if request.method == 'POST':
allocate(booth)
json_serializer = serializers.get_serializer("json")()
booths = json_serializer.serialize(booth, ensure_ascii=False)
# maps = json_serializer.serialize(user_maps, ensure_ascii = False)
obj = {
'booths': json_serializer.serialize(booth, ensure_ascii=False),
'maps': json_serializer.serialize(user_maps, ensure_ascii=False)
}
obj_json = json.dumps(obj)
# return render(request,'capstone/home.html',{'booth':booths})
return render(request, 'capstone/home.html', {'obj': obj_json})
def test_get_unknown_serializer(self):
"""
#15889: get_serializer('nonsense') raises a SerializerDoesNotExist
"""
with self.assertRaises(SerializerDoesNotExist):
serializers.get_serializer("nonsense")
with self.assertRaises(KeyError):
serializers.get_serializer("nonsense")
# SerializerDoesNotExist is instantiated with the nonexistent format
with self.assertRaisesMessage(SerializerDoesNotExist, "nonsense"):
serializers.get_serializer("nonsense")
def handle(self, *args, **options):
translation.activate('en')
submission = PlanSubmission.objects.get(pk=options['submission_id'])
output_path = '{}.html'.format(submission.pk)
if os.path.exists(output_path):
print('Report file already exists!')
return
template = loader.get_template('submission_summary.html')
# We're going to reuse the summary panel from the main map editing page
score_panel = ScorePanel.objects.filter(
name='plan_submission_summary_17')[0]
districts = [
d for d in submission.plan.district_set.all()
if not d.is_unassigned
]
# The above Score Display is split into two ScorePanels: the top summary panel and the
# bottom panel of per-district scores. We want the summary panel.
# The type field is apparently limited to three options: 1) plan 2) plan_summary 3) district
scores_html = score_panel.render(submission.plan)
GeoJSONSerializer = serializers.get_serializer('geojson')
serializer = GeoJSONSerializer()
# is_unassigned is a property so we can't use queryset filtering
# The unassigned district is a catch-all for geounits that haven't been assigned to a real
# district. We don't want to display this on the submission map, so filter it out here.
geojson = serializer.serialize(districts,
geometry_field='geom',
fields=('short_label', 'long_label'))
leaflet_css = staticfiles_storage.open('leaflet/leaflet.css').read()
leaflet_js = staticfiles_storage.open('leaflet/leaflet.js').read()
context = dict(plan_url='https://{host}{path}'.format(
host='map.drawthelinespa.org',
path=reverse('plan-view', args=[submission.plan_id])),
submission=submission,
scores_html=scores_html,
leaflet_css=leaflet_css,
leaflet_js=leaflet_js,
geojson=geojson)
print('Writing report to {}'.format(output_path))
with codecs.open(output_path, 'wb', 'UTF-8') as outfile:
outfile.write(template.render(context))
print('Done.')
def to_json(content, indent=None):
"""
Serializes a python object as JSON
This method uses the DJangoJSONEncoder to to ensure that python objects
such as Decimal objects are properly serialized. It can also serialize
Django QuerySet objects.
"""
if isinstance(content, QuerySet):
json_serializer = serializers.get_serializer('json')()
serialized_content = json_serializer.serialize(content,
ensure_ascii=False,
indent=indent)
else:
serialized_content = json.dumps(content,
cls=DjangoJSONEncoder,
ensure_ascii=False,
indent=indent)
return serialized_content
def getStops(request):
#get inputs
in_route=request.GET.get('travelroute')
in_direction=request.GET.get('direction')
#query database for route, day of week and 5 minutes before and after selected time
stops = m.MapStops.objects.filter(route=in_route).filter(direction=in_direction)
#translate stops into JSON format
XMLSerializer = serializers.get_serializer("json")
xml_serializer = XMLSerializer()
xml_serializer.serialize(stops)
data = xml_serializer.getvalue()
#return stops in JSON format
return HttpResponse(data, content_type='application/json')
def handle(self, *args, **options):
jsonfile = open('/home/ServalChan/jihanki.json', 'w')
fieldnames = ("jihanki_id", "address", "coordinate_X", "coordinate_Y",
"change")
jihanki = Jihanki.objects.all()
json_serializer = serializers.get_serializer('json')()
jsonfile.write('[')
for j in jihanki:
data = cl.OrderedDict()
data = [[fieldnames[0], j.jihanki_id], [fieldnames[1], j.address],
[fieldnames[2], j.coordinate_X],
[fieldnames[3], j.coordinate_Y], [fieldnames[4], j.change]]
jsonfile.write(',')
json.dump(dict(data), jsonfile, ensure_ascii=False)
jsonfile.write(']')
for j in jihanki:
jadd = j.address
print(jadd)
def backwards(self, orm):
import tempfile, os, sys
sys.stderr.write("WARNING, destroying PlaceType.map_icon_url column\n")
sys.stderr.write("WARNING, destroying PlaceType.map_color column\n")
# Want to dump a fixture here. Can't just use
# call_command('dumpdata') because it knows about *current*
# model code, not South's own ORM state.
tmpdir = tempfile.mkdtemp()
tmpname = os.path.join(tmpdir, 'placetypes_icons_colors.json')
sys.stderr.write("... will try to save data in %s\n" % tmpname)
try:
dumpfile = open(tmpname, 'w')
ptypes = orm.PlaceType.objects.all()
from django.core import serializers
serializer = serializers.get_serializer('json')()
serializer.serialize(ptypes, stream=dumpfile)
sys.stderr.write("\n... saved\n")
except Exception, e:
sys.stderr.write("\n... failed to save data:\n%s\n" % e)
def handle_noargs(self, **options):
"""Handle the command."""
models = []
for app in get_apps():
models.extend(get_models(app))
OBJECT_LIMIT = 150
serializer = serializers.get_serializer("json")()
totalobjs = 0
for model in models:
totalobjs += model.objects.count()
prev_pct = -1
i = 0
self.stderr.write("Dump the database. This may take a while...\n")
self.stdout.write("# dbdump v1 - %s objects" % totalobjs)
for model in models:
count = model.objects.count()
j = 0
while j < count:
for obj in model.objects.all()[j:j + OBJECT_LIMIT].iterator():
value = serializer.serialize([obj])
if value != "[]":
self.stdout.write(value[1:-1]) # Skip the "[" and "]"
i += 1
pct = i * 100 / totalobjs
if pct != prev_pct:
self.stderr.write(" [%s%%]\r" % pct)
self.stderr.flush()
prev_pct = pct
j += OBJECT_LIMIT
self.stderr.write("\nDone.\n")
def set_home_page_variables(posts, user, number=1):
home_page_dict = {}
if posts:
json_serializer = serializers.get_serializer("json")()
markers_json = json_serializer.serialize(posts , ensure_ascii=False)
user_names = [ p.user.username for p in posts ]
user_names_json = json.dumps(user_names, cls=DjangoJSONEncoder)
image_urls = [ p.user.profile.image.url for p in posts ]
image_urls_json = json.dumps(image_urls, cls=DjangoJSONEncoder)
ids = [ p.pk for p in posts ]
ids_json = json.dumps(ids, cls=DjangoJSONEncoder)
num_likes = [Like.objects.filter(post=p).count() for p in posts]
num_likes_json = json.dumps(num_likes, cls=DjangoJSONEncoder)
liked = [0] * posts.count()
user_id = int(user.id)
for i, p in enumerate(posts):
likes = Like.objects.filter(post=p).values()
for l in likes:
if user_id == l['user_id']: liked[i] = 1
liked_json = json.dumps(liked, cls=DjangoJSONEncoder)
posts_list = posts.values()
datetimes = [ d['dateNtime'] for d in posts_list ]
min_datetime = str(min(datetimes))
max_datetime = str(max(datetimes))
min_datetime_json = json.dumps(min_datetime, cls=DjangoJSONEncoder)
max_datetime_json = json.dumps(max_datetime, cls=DjangoJSONEncoder)
home_page_dict = {'markers_json': markers_json,
'user_names' : user_names_json,
'image_urls' : image_urls_json,
'ids' : ids_json,
'num_likes' : num_likes_json,
'liked' : liked_json,
'min_datetime': min_datetime_json,
'max_datetime': max_datetime_json,
'number' : number}
return home_page_dict
def crime_status(request):
if request.method == 'GET':
crime_id= request.GET.get('crime_id')
global detail
detail= FIR_REPORT.objects.filter(ID = crime_id)
report = CRIME_TIMELINE.objects.filter(CRIME_ID = crime_id)
json_serializer = serializers.get_serializer("json")()
reports = json_serializer.serialize(report, ensure_ascii=False)
details= json_serializer.serialize(detail, ensure_ascii=False)
users = json_serializer.serialize(USER.objects.all(), ensure_ascii = False)
form = UPDATE_FORM()
context = {
'reports': reports,
'details': details,
'users': users,
'form': form
}
return render(request, 'status_report.html', context)
def handle(self, *args, **options):
jsonfile = open('/home/ServalChan/jihankiproduct.json', 'w')
fieldnames = ("jihanki", "product", "stock", "price", "xy")
jproduct = JihankiProduct.objects.all()
json_serializer = serializers.get_serializer('json')()
jsonfile.write('[')
for jp in jproduct:
data = cl.OrderedDict()
data = [[fieldnames[0], jp.jihanki.jihanki_id],
[fieldnames[1], jp.product.jan_code],
[fieldnames[2], jp.stock], [fieldnames[3], jp.price],
[fieldnames[4], jp.xy]]
jsonfile.write(',')
json.dump(dict(data), jsonfile, ensure_ascii=False)
jsonfile.write(']')
for jp in jproduct:
jid = jp.jihanki.jihanki_id
print(jid)
def home(request):
grid = Grid.objects.select_related('gridcolumn_set', 'gridrow_set',
'gridcell_set').get(pk=1)
grid_columns = grid.gridcolumn_set.all().order_by("ordinal")
grid_rows = grid.gridrow_set.all().order_by("ordinal")
# serialize grid & all its associated data & dump it as json onto the page.
json_serializer = serializers.get_serializer("json")()
columns_json = json_serializer.serialize(grid_columns)
rows_json = json_serializer.serialize(grid_rows)
return render_to_response('home.html', {
'grid': grid,
'grid_columns': grid_columns,
'grid_rows': grid_rows,
'columns_json': columns_json,
'rows_json': rows_json
},
context_instance=RequestContext(request))
def serialize(self, obj, **options):
self.options = options
self.stream = options.pop("stream", StringIO())
self.selectedFields = options.pop("fields", None)
self.ignoredFields = options.pop("ignored", None)
self.use_natural_keys = options.pop("use_natural_keys", False)
self.currentLoc = ''
self.django_json_serializer = serializers.get_serializer("json")()
self.level = 0
self.start_serialization()
self.handle_object(obj)
self.end_serialization()
return self.getvalue()
def index(request, website_url):
try:
cache_value_for_website = cache.get(website_url)
if cache_value_for_website == None:
user_info = UserInfo.objects.filter(website_url = website_url)[0]
cache.set(user_info.website_address, user_info.hit_counter + 1 )
else:
cache.set(user_info.website_address, cache_value_for_website + 1 )
user_info = UserInfo()
user_info.hit_counter = cache_value_for_website + 1
user_info.website_address = website_address
user_info.website_name = website_address
json_serializer = serializers.get_serializer("json")()
json_serializer.serialize(user_info, ensure_ascii=False, stream=response)
except Exception, e:
pass
def qualcancel(request):
if request.method == 'GET':
name = request.GET.get('name')
objs = TbQualCancel.objects.filter(enterprise__icontains=name).all()
print(objs)
if len(objs) > 0:
data = serializers.serialize('json', objs)
print(type(data))
print(data)
json_serializer = serializers.get_serializer('json')()
resp = json_serializer.serialize(objs, ensure_ascii=False)
print(type(json_serializer))
return HttpResponse(eval(resp),
content_type='application/json,charset=utf-8')
else:
print('can not find the result {}'.format(name))
response = json.dumps([{'result': '0'}])
return HttpResponse(response,
content_type='application/json,charset=utf-8')
def mojeWydarzeniaAND(request):
if post(request):
student = studPost(request)
uzytkownik = student.uzytkownik
if not czyZmienicHaslo(uzytkownik):
dataMin = datetime.date.today()
ileWydarzen = uzytkownik.ileMoichWydarzen
dataMax = dataMin + datetime.timedelta(days=ileWydarzen + 1)
mojeWydarzenia = uzytkownik.wydarzenie_set.filter(
dataWydarzenia__gte=dataMin,
dataWydarzenia__lte=dataMax).order_by('dataWydarzenia',
'godzinaOd')
json_serializer = serializers.get_serializer("json")()
wynik = json_serializer.serialize(mojeWydarzenia,
ensure_ascii=False)
return HttpResponse(wynik, mimetype="application/json")
else:
return HttpResponse('-4')
return HttpResponse("Fail")
def license_holder_export( stream ):
arr = []
# Add the categories required by LicenseCheckState.
LicenseCheckState.refresh()
category_format_seen = set()
for category_format in CategoryFormat.objects.filter( pk__in=LicenseCheckState.objects.all().values_list('category__format',flat=True).distinct() ):
arr.append( category_format )
arr.extend( category_format.category_set.all() )
category_format_seen.add( category_format.id )
# Add the categories required by CategoryHints.
update_category_hints()
arr.extend( Discipline.objects.filter( pk__in=CategoryHint.objects.all().values_list('discipline',flat=True).distinct() ) )
for category_format in CategoryFormat.objects.filter( pk__in=CategoryHint.objects.all().values_list('category__format',flat=True).distinct() ):
if category_format.id not in category_format_seen:
arr.append( category_format )
arr.extend( category_format.category_set.all() )
update_team_hints()
arr.extend( Team.objects.filter( pk__in=TeamHint.objects.filter(team__isnull=False).values_list('team',flat=True).distinct() ) )
arr.extend( LicenseHolder.objects.all() )
arr.extend( TeamHint.objects.all() )
arr.extend( CategoryHint.objects.all() )
arr.extend( ReportLabel.objects.filter( pk__in=LicenseCheckState.objects.all().values_list('report_label_license_check',flat=True).distinct() ) )
arr.extend( LicenseCheckState.objects.all() )
for ns in NumberSet.objects.all():
arr.append( ns )
arr.extend( ns.numbersetentry_set.all() )
for sp in SeasonsPass.objects.all():
arr.append( sp )
arr.extend( sp.seasonspassholder_set.all() )
for le in LegalEntity.objects.all():
arr.append( le )
arr.extend( le.waiver_set.all() )
# Serialize all the objects to json.
json_serializer = serializers.get_serializer("json")()
json_serializer.serialize(arr, indent=0, stream=stream)
return arr
def _dump_qs(form, queryset, data, filename):
fmt = form.cleaned_data.get('serializer')
json = ser.get_serializer(fmt)()
ret = json.serialize(data,
use_natural_foreign_keys=form.cleaned_data.get(
'use_natural_key', False),
indent=form.cleaned_data.get('indent'))
response = HttpResponse(content_type='application/json')
if not form.cleaned_data.get('on_screen', False):
filename = filename or "%s.%s" % (
queryset.model._meta.verbose_name_plural.lower().replace(" ",
"_"), fmt)
response['Content-Disposition'] = ('attachment;filename="%s"' %
filename).encode(
'us-ascii', 'replace')
response.content = ret
return response
def test_get_unknown_serializer(self):
"""
#15889: get_serializer('nonsense') raises a SerializerDoesNotExist
"""
with self.assertRaises(SerializerDoesNotExist):
serializers.get_serializer("nonsense")
with self.assertRaises(KeyError):
serializers.get_serializer("nonsense")
# SerializerDoesNotExist is instantiated with the nonexistent format
with self.assertRaises(SerializerDoesNotExist) as cm:
serializers.get_serializer("nonsense")
self.assertEqual(cm.exception.args, ("nonsense", ))
def handle(self, *args, **kwargs):
api = Api()
categories = api.CATEGORIES
JSONSerializer = serializers.get_serializer("json")
first_loop = True
for category in categories:
products = Product.objects.filter(categories__name=category)[:200]
nutriments = Nutriments.objects.filter(
id__in=[p.nutriments_id for p in products])
brands = Brand.objects.filter(
id__in=[p.brand_id for p in products])
hierarchies = Hierarchy.objects.filter(product__in=products)
categories_id = set([h.category_id for h in hierarchies])
categories = Category.objects.filter(id__in=categories_id)
if first_loop is True:
all_products = products
all_nutriments = nutriments
all_brands = brands
all_hierarchies = hierarchies
all_categories = categories
else:
all_products.union(products)
all_nutriments.union(nutriments)
all_brands.union(brands)
all_hierarchies.union(hierarchies)
all_categories.union(categories)
data = list(
chain(all_nutriments, all_brands, all_categories, all_products,
all_hierarchies))
json_serializer = JSONSerializer()
with open(f"fixtures/db.json", "w") as out:
json_serializer.serialize(data, stream=out)
def export(self):
""" Writes all objects matching
"""
try:
self.collect_data()
data = list(chain(*self.to_serialize))
CurrentSerializer = serializers.get_serializer(self.format)
serializer = CurrentSerializer()
with open(self.target_file, "w") as out:
serializer.serialize(data,
indent=self.indent,
stream=out,
use_natural_foreign_keys=True,
use_natural_primary_keys=True)
except Exception as e:
if self.show_traceback:
raise
raise CommandError("Unable to serialize database: %s" % e)
def company_backpay(request):
if request.method == 'GET':
name = request.GET.get('name')
obj = TbBackpaylist.objects.filter(enterprise__icontains=name).all()
if len(obj) > 0:
data = serializers.serialize('json', obj)
print(type(data))
print(data)
json_serializer = serializers.get_serializer('json')()
resp = json_serializer.serialize(obj, ensure_ascii=False)
print(type(json_serializer))
return HttpResponse(simplejson.dumps(resp, ensure_ascii=False),
content_type='application/json,charset=utf-8')
else:
print('can not find the result {}'.format(name))
response = json.dumps([{'result': '0'}])
return HttpResponse(response,
content_type='application/json,charset=utf-8')
def crearAutor(request):
"""
Vista de acceso al usuario con rol de Docente, que le permite crear autores para los objetos.
"""
laut=[]
if 'naut' in request.GET and request.GET['naut']:
nombre = request.GET['naut']
if 'aaut' in request.GET and request.GET['aaut']:
apellido = request.GET['aaut']
if 'raut' in request.GET and request.GET['raut']:
rol = request.GET['raut']
else:
rol="Autor"
objAutor,creado=Autor.objects.get_or_create(nombres=nombre, apellidos=apellido, rol=rol)
if creado: #Si ya existe el Autor se obvia el proceso de guardarlo en la bd
objAutor.save() #se guarda el Autor en la bd
laut.append(objAutor)
json_serializer = serializers.get_serializer("json")()
data = json_serializer.serialize(laut, ensure_ascii=False)
return HttpResponse(data, content_type='application/json')
def listaWykladowcowAND(request):
wykladowcy = models.Prowadzacy.objects.all().order_by('nazwisko')
konsultacje = models.Konsultacje.objects.all()
kategoria = models.KategoriaMiejsca.objects.get(id=1)
budynki = models.Miejsce.objects.filter(kategoria=kategoria)
grupy = models.Grupa.objects.all().order_by('godzinaOd')
kursy = models.Kurs.objects.all()
wydzialy = models.Wydzial.objects.all()
lista = list(kursy) + list(wykladowcy) + list(konsultacje) + list(
grupy) + list(budynki)
json_serializer = serializers.get_serializer("json")()
wynik = json_serializer.serialize(
lista,
ensure_ascii=False,
fields=('id', 'nazwa', 'rodzaj', 'nazwisko', 'imie', 'tytul',
'konflikt', 'prowadzacy', 'dzienTygodnia', 'parzystosc',
'godzinaOd', 'godzinaDo', 'budynek', 'sala', 'inneInformacje',
'miejsce', 'kurs'))
return HttpResponse(wynik, mimetype="application/json")
def add_bounty(request):
if request.method == "POST":
form = BountyForm(request.POST)
you = ""
hunters = [hunter for hunter in Hunter.objects.all()]
for hunter in hunters:
if hunter.name == request.user.username:
you = hunter
form.hunter = hunter
if form.is_valid():
form.save()
json_serializer = serializers.get_serializer("json")()
bs = json_serializer.serialize(Bounty.objects.all(),
ensure_ascii=False)
context = {"bounties": bs}
return render(request, 'bounties/bounties.html', context)
else:
return render(request, "bounties/create.html", {'form': BountyForm()})
def to_testpack(self):
s = get_serializer("json")()
to_serialize = list(self.get_testpack_dependencies())
dependencies = []
kwargs = {
"use_natural_foreign_keys": True,
"use_natural_primary_keys": True
}
for model, qs in to_serialize:
dependencies += json.loads(
s.serialize(qs, fields=model.get_testpack_fields(), **kwargs))
fields = json.loads(
s.serialize([self],
fields=self._meta.model.get_testpack_fields(),
**kwargs))[0]
return json.dumps({
'key': self.natural_key(),
'object': fields,
'dependencies': dependencies
})
def show(request):
if request.method == 'GET':
name = request.GET.get('name')
if name:
print('name ', name)
obj = TbBasicInfo.objects.filter(name=name).all()
print('len of obj: ', len(obj))
# data = serializers.serialize('json',obj)
json_serializer = serializers.get_serializer('json')()
resp = json_serializer.serialize(obj, ensure_ascii=False)
# ret = eval(data)
return HttpResponse(eval(resp),
content_type='text/json,charset=utf-8')
else:
data = [{'result': '0'}]
return HttpResponse(json.dumps(data, ensure_ascii=False),
content_type='text/json,charset=utf-8')
return HttpResponse('None')
def update_workflows(request):
"""ajax function for updating available workflows from galaxy"""
logger.debug("analysis_manager.views.update_workflows")
if request.is_ajax():
workflow_engines = WorkflowEngine.objects.all()
workflows = 0
for engine in workflow_engines:
# function for updating workflows from galaxy instance
get_workflows(engine)
new_workflow_count = engine.workflow_set.all().count()
logger.debug("Engine: %s - %s workflows after", engine.name,
str(new_workflow_count))
workflows += new_workflow_count
# getting updated available workflows
workflows = Workflow.objects.all()
json_serializer = serializers.get_serializer("json")()
return HttpResponse(json_serializer.serialize(workflows,
ensure_ascii=False),
content_type='application/javascript')
return HttpResponse(status=400)
