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)