def create(self, request, buildingblock_id): user = get_user_authentication(request) received_json = PUT_parameter(request, 'tags') if not received_json: return HttpResponseBadRequest(json_encode({"message":"JSON expected"}), mimetype='application/json; charset=UTF-8') try: bb = BuildingBlock.objects.get(id=buildingblock_id) try: UserTag.objects.filter(user=user, buildingBlock=bb).delete() except UserTag.DoesNotExist: pass tags = simplejson.loads(received_json) bb.update_tags(tags, user) data = simplejson.loads(bb.data) allTags = UserTag.objects.filter(buildingBlock=bb) bbTags = [] for t in allTags: bbTags.append(self.__getTagFromUserTag(t)); data['tags'] = bbTags bb.data = json_encode(data) bb.save() bb.update_catalogue() ok = json_encode({'message':'OK'}) return HttpResponse(ok, mimetype='application/json; charset=UTF-8') except Exception, e: transaction.rollback() return HttpResponseServerError(json_encode({'message':unicode(e)}), mimetype='application/json; charset=UTF-8')
def read(self, request, buildingblock_id): user = get_user_authentication(request) try: bb = BuildingBlock.objects.get(id=buildingblock_id) vote_number = 0 user_vote = 0 try: votes = UserVote.objects.filter(buildingBlock=bb) vote_number = votes.count() vote = votes.filter(user=user)[0] user_vote = vote.value except UserVote.DoesNotExist: pass vote = { 'popularity': bb.popularity, 'user_vote': user_vote, 'vote_number': vote_number } return HttpResponse(json_encode(vote), mimetype='application/json; charset=UTF-8') except Exception, e: transaction.rollback() return HttpResponseServerError(json_encode({'message':unicode(e)}), mimetype='application/json; charset=UTF-8')
def create(self, request): #check params if 'file' not in request.FILES: msg = _("Missing file parameter") else: file = request.FILES['file'] msg = self.check_file(file) # check content-type and size # param errors if msg: if accepts(request, 'application/json'): mimetype = 'application/json; charset=UTF-8' msg = json_encode({"message": msg, "result": "error"}) else: mimetype = 'text/html; charset=UTF-8' return HttpResponseBadRequest(msg, mimetype=mimetype) #store files ordering by user user_path = os.path.join(self.dir_path, request.user.username) #avoid rewriting files: change the filename basename, ext = os.path.splitext(file.name) filename = basename + '_' + unicode(int(time.time())) + ext msg = self.store_file(request.FILES['file'], user_path, filename) #errors if msg: if accepts(request, 'application/json'): mimetype = 'application/json; charset=UTF-8' msg = json_encode({"message": msg, "result": "error"}) return HttpResponseServerError(msg, mimetype) else: mimetype = 'text/html; charset=UTF-8' return HttpResponse(msg, mimetype) #generate the url from deployment.urls import deployment as basePath if (request.META['SERVER_PROTOCOL'].lower().find('https') >= 0): protocol = "https://" else: protocol = "http://" url = os.path.join(protocol, request.get_host(), basePath, self.dir_name, request.user.username, filename) if accepts(request, 'application/json'): mimetype = 'application/json; charset=UTF-8' msg = json_encode({"message": url, 'result': 'error'}) return HttpResponse(msg, mimetype=mimetype) else: mimetype = 'text/html; charset=UTF-8' template = 'upload_success.html' context = {'url': url} return render_to_response(template, context)
def read(self, request): try: user = get_user_authentication(request) profile = UserProfile.objects.get_or_create(user=user)[0] dict = {"user" :{"username": None, "email": None, "first_name": None, "last_name": None}, "profile" : {"ezweb_url": None}} data = json_encode({"user": user, "profile": profile}, fields=dict) return HttpResponse(data, mimetype='application/json; charset=UTF-8') except Http403, ex: return HttpResponseForbidden(json_encode({"message":unicode(ex)}), mimetype='application/json; charset=UTF-8')
def delete(self, request, buildingblock_id): try: user = get_user_authentication(request) bb = BuildingBlock.objects.get(id=buildingblock_id) bb.unshare() ok = json_encode({'message':'OK'}) return HttpResponse(ok, mimetype='application/json; charset=UTF-8') except Exception, e: transaction.rollback() return HttpResponseServerError(json_encode({'message':unicode(e)}), mimetype='application/json; charset=UTF-8')
def create(self, request, bbtype): user = get_user_authentication(request) if not request.POST.has_key('buildingblock'): return HttpResponseBadRequest(json_encode({"message":"JSON expected"}), mimetype='application/json; charset=UTF-8') received_json = request.POST['buildingblock'] try: data = create_bb(simplejson.loads(received_json), bbtype, user, request.build_absolute_uri()) return HttpResponse(data, mimetype='application/json; charset=UTF-8') except Exception, e: transaction.rollback() return HttpResponseServerError(json_encode({'message':unicode(e)}), mimetype='application/json; charset=UTF-8')
def delete(self, request, storage_id): try: user = get_user_authentication(request) st = Storage.objects.get(id=storage_id) st.delete() ok = json_encode({'message':'OK'}) return HttpResponse(ok, mimetype='application/json; charset=UTF-8') except Exception, e: transaction.rollback() return HttpResponseServerError(json_encode({'message':unicode(e)}), mimetype='application/json; charset=UTF-8')
def create(self, request, buildingblock_id): user = get_user_authentication(request) try: bb = BuildingBlock.objects.get(id=buildingblock_id).child_model() bb.compile_code() bb.share() return HttpResponse(json_encode(bb.data), mimetype='application/json; charset=UTF-8') except Exception, e: transaction.rollback() return HttpResponseServerError(json_encode({'message':unicode(e)}), mimetype='application/json; charset=UTF-8')
def update(self, request, workspace_id, share_boolean): user = get_user_authentication(request) try: workspace = WorkSpace.objects.get(id=workspace_id) except WorkSpace.DoesNotExist: msg = 'The workspace does not exist!' result = {'result': 'error', 'description': msg} HttpResponseServerError(json_encode(result), mimetype='application/json; charset=UTF-8') owner = workspace.get_creator() if (owner != user): msg = 'You are not the owner of the workspace, so you can not share it!' result = {'result': 'error', 'description': msg} return HttpResponseServerError(json_encode(result), mimetype='application/json; charset=UTF-8') #Everything right! if not request.REQUEST.has_key('groups'): #Share with everybody #Linking with public user! public_user = get_public_user(request) linkWorkspaceObject(public_user, workspace, owner, link_variable_values=True) url = request.META['HTTP_REFERER'] + 'viewer/workspace/' + workspace_id result = {"result": "ok", "url": url} return HttpResponse(json_encode(result), mimetype='application/json; charset=UTF-8') else: #Share only with the scpecified groups try: groups = simplejson.loads(PUT_parameter(request, 'groups')) queryGroups = Group.objects.filter(id__in=groups) for g in queryGroups: workspace.targetOrganizations.add(g) users = User.objects.filter(groups__in=groups).distinct() for user in users: #link the workspace with each user linkWorkspaceObject(user, workspace, owner, link_variable_values=True) except Exception, e: transaction.rollback() msg = _("workspace cannot be shared: ") + unicode(e) raise TracedServerError(e, groups, request, msg) result = {"result": "ok"} return HttpResponse(json_encode(result), mimetype='application/json; charset=UTF-8')
def read(self, request, bbtype): try: if request.GET.get("all", "false") == "true": include_all = True else: include_all = False user = get_user_authentication(request) bb = [] if bbtype == 'screenflow': if include_all: bb = get_list_or_404(Screenflow) else: bb = get_list_or_404(Screenflow, author=user) elif bbtype == 'screen': if include_all: bb = get_list_or_404(Screen) else: bb = get_list_or_404(Screen, author=user) elif bbtype == 'form': if include_all: bb = get_list_or_404(Form) else: bb = get_list_or_404(Form, author=user) elif bbtype == 'operator': if include_all: bb = get_list_or_404(Operator) else: bb = get_list_or_404(Operator, author=user) elif bbtype == 'resource': if include_all: bb = get_list_or_404(Resource) else: bb = get_list_or_404(Resource, author=user) else: if include_all: bb = get_list_or_404(BuildingBlock) else: bb = get_list_or_404(BuildingBlock, author=user) response = json_encode([simplejson.loads(element.data) for element in bb if element.data]) return HttpResponse(response, mimetype='application/json; charset=UTF-8') except Http404: return HttpResponse(json_encode([]), mimetype='application/json; charset=UTF-8') except Exception, e: return HttpResponseServerError(json_encode({'message':unicode(e)}), mimetype='application/json; charset=UTF-8')
def read(self, request, user_name, screen_id=1): user = user_authentication(user_name) wiring = {} # IGadgets list if not screen_id: screen_id=1 try: screen = Screen.objects.get(user=user, code=screen_id) igadgets = IGadget.objects.filter(screen=screen) igadget_data_list = get_wiring_data(igadgets) wiring['iGadgetList'] = igadget_data_list except Screen.DoesNotExist: wiring['iGadgetList'] = [] # InOut list inouts = InOut.objects.filter(user=user) inout_data = serializers.serialize('python', inouts, ensure_ascii=False) inout_data_list = [get_inout_data(d) for d in inout_data] wiring['inOutList'] = inout_data_list return HttpResponse(json_encode(wiring), mimetype='application/json; charset=UTF-8')
def read(self, request, workspace_id): get_user_authentication(request) wiring = {} try: igadgets = IGadget.objects.filter(tab__workspace__pk=workspace_id) igadget_data_list = get_wiring_data(igadgets) wiring['iGadgetList'] = igadget_data_list tabs = Tab.objects.filter(workspace__pk=workspace_id) wiring['tabList'] = [get_tab_data(tab) for tab in tabs] except WorkSpace.DoesNotExist: wiring['iGadgetList'] = [] wiring['tabList'] = [] # InOut list inouts = InOut.objects.filter(workspace__pk=workspace_id) wiring['inOutList'] = [get_inout_data(inout) for inout in inouts] # Filter list filters = Filter.objects.all() wiring['filterList'] = [get_filter_data(f) for f in filters] return HttpResponse(json_encode(wiring), mimetype='application/json; charset=UTF-8')
def read(self, request, workspace_id, tab_id, igadget_id): user = get_user_authentication(request) igadget = get_list_or_404(IGadget, tab__workspace__user=user, tab__workspace__pk=workspace_id, tab__pk=tab_id, pk=igadget_id) data = serializers.serialize('python', igadget, ensure_ascii=False) igadget_data = get_igadget_data(data[0]) return HttpResponse(json_encode(igadget_data), mimetype='application/json; charset=UTF-8')
def create(self, request, workspace_id): user = get_user_authentication(request) if not request.POST.has_key('tab'): return HttpResponseBadRequest(get_xml_error(_("tab JSON expected")), mimetype='application/xml; charset=UTF-8') #TODO we can make this with deserializers (simplejson) received_json = request.POST['tab'] try: t = simplejson.loads(received_json) if not t.has_key('name'): raise Exception(_('Malformed tab JSON: expecting tab name.')) tab_name = t.get('name') workspace = WorkSpace.objects.get(users__id=user.id, pk=workspace_id) ids = createTab(tab_name, user, workspace) return HttpResponse(json_encode(ids), mimetype='application/json; charset=UTF-8') except Exception, e: transaction.rollback() msg = _("tab cannot be created: ") + unicode(e) log(msg, request) return HttpResponseServerError(get_xml_error(msg), mimetype='application/xml; charset=UTF-8')
def read(self, request, vendor=None, name=None, version=None): """ Gets a price list for a gadget specified by vendor, gadget name and gadget version """ gadget_pricing = None try: # Gets the standard pricing method gadget_pricing = GadgetPricing.objects.filter(gadget__short_name=name, gadget__vendor=vendor, gadget__version=version) if hasattr(settings,'AUTHENTICATION_SERVER_URL'): user = get_user_authentication(request) # Gets the current user categories via ezsteroids API user_categories = _user_categories_tuple(user) gadget_special_pricings = GadgetSpecialPricing.objects.filter(pricing__gadget__short_name=name, pricing__gadget__vendor=vendor, pricing__gadget__version=version) # Refines the special pricing for gadget_special_pricing in gadget_special_pricings: for user_category in user_categories: if user_category[0] == gadget_special_pricing.user_category : for index, gadget_pricing_item in enumerate(gadget_pricing) : if(gadget_pricing_item.id == gadget_special_pricing.pricing.id) and \ (gadget_pricing_item.price > gadget_special_pricing.price) : gadget_pricing[index].price = gadget_special_pricing.price except Exception: return HttpResponseServerError(get_xml_error(_("Error retrieving gadgets pricing")), mimetype='application/xml; charset=UTF-8') return HttpResponse(json_encode(gadget_pricing), mimetype='application/json; charset=UTF-8')
def read(self, request, workspace_id): user = get_user_authentication(request) linkWorkspace(user, workspace_id) result = {"result": "ok"} return HttpResponse(json_encode(result), mimetype='application/json; charset=UTF-8')
def create(self, request): user = get_user_authentication(request) if not request.POST.has_key('workspace'): return HttpResponseBadRequest(get_xml_error(_("workspace JSON expected")), mimetype='application/xml; charset=UTF-8') #TODO we can make this with deserializers (simplejson) received_json = request.POST['workspace'] try: ts = simplejson.loads(received_json) if not ts.has_key('name'): raise Exception(_('Malformed workspace JSON: expecting workspace uri.')) workspace_name = ts.get('name') ids = createWorkSpace (workspace_name, user) workspaces = get_list_or_404(WorkSpace, users__id=user.id, pk=ids['workspace']['id']) data = serializers.serialize('python', workspaces, ensure_ascii=False) concept_data = {} concept_data['user'] = user workspace_data = get_global_workspace_data(data[0], workspaces[0], concept_data, user) return HttpResponse(json_encode(workspace_data), mimetype='application/json; charset=UTF-8') except Exception, e: transaction.rollback() msg = _("workspace cannot be created: ") + unicode(e) log(msg, request) return HttpResponseServerError(get_xml_error(msg), mimetype='application/xml; charset=UTF-8')
def read(self, request, workspace_id): user = get_user_authentication(request) wiring = {} try: igadgets = IGadget.objects.filter(tab__workspace__pk=workspace_id) igadget_data_list = get_wiring_data(igadgets) wiring['iGadgetList'] = igadget_data_list tabs = Tab.objects.filter(workspace__pk=workspace_id) tab_data = serializers.serialize('python', tabs, ensure_ascii=False) wiring['tabList'] = [get_tab_data(d) for d in tab_data] except WorkSpace.DoesNotExist: wiring['iGadgetList'] = [] wiring['tabList'] = [] # InOut list inouts = InOut.objects.filter(workspace__pk=workspace_id) inout_data = serializers.serialize('python', inouts, ensure_ascii=False) wiring['inOutList'] = [get_inout_data(d) for d in inout_data] # Filter list filters = Filter.objects.all() filter_data = serializers.serialize('python', filters, ensure_ascii=False) wiring['filterList'] = [get_filter_data(d) for d in filter_data] return HttpResponse(json_encode(wiring), mimetype='application/json; charset=UTF-8')
def tag_categories(request): categories = {} catQuerySet = Category.objects.filter(parent = None) for cat in catQuerySet: categories[cat.name] =_get_Category_Info(cat) return {'tag_categories': json_encode(categories)}
def read(self, request, user_name, concept_name): user = user_authentication(request, user_name) concepts = get_list_or_404(Concept, concept=concept_name) concept_values = {} concept_values['user'] = user data_list = get_concept_data(concepts, concept_values) return HttpResponse(json_encode(data_list), mimetype='application/json; charset=UTF-8')
def theme_url(request): # Default theme if not hasattr(settings, "DEFAULT_THEME") or settings.DEFAULT_THEME == None: settings.DEFAULT_THEME = "default" # Theme cache if not hasattr(settings, "CACHED_THEMES"): themes_dir = os.path.join(settings.BASEDIR, 'media', 'themes') themes = [] for filename in os.listdir(themes_dir): if filename.startswith('.'): continue pathname = os.path.join(themes_dir, filename) mode = os.stat(pathname)[stat.ST_MODE] if stat.S_ISDIR(mode): themes.append(filename) themes.sort(key=str.lower) settings.CACHED_THEMES = themes settings.CACHED_THEMES_JSON = json_encode(themes) # Process current theme theme = get_user_theme(request.user, settings.DEFAULT_THEME) if not (theme in settings.CACHED_THEMES): theme = settings.DEFAULT_THEME theme_url = settings.MEDIA_URL + "themes/" + theme return {'THEMES': settings.CACHED_THEMES_JSON, 'DEFAULT_THEME': settings.DEFAULT_THEME, 'INITIAL_THEME': theme, 'THEME_URL': theme_url}
def create(self, request): user = get_user_authentication(request) if 'workspace' not in request.POST: return HttpResponseBadRequest(get_xml_error(_("workspace JSON expected")), mimetype='application/xml; charset=UTF-8') #TODO we can make this with deserializers (simplejson) received_json = request.POST['workspace'] try: ts = simplejson.loads(received_json) if 'name' not in ts: raise Exception(_('Malformed workspace JSON: expecting workspace uri.')) workspace_name = ts['name'] workspace = createWorkSpace(workspace_name, user) workspace_data = get_global_workspace_data(workspace, user) return HttpResponse(json_encode(workspace_data), mimetype='application/json; charset=UTF-8') except Exception, e: transaction.rollback() msg = _("workspace cannot be created: ") + unicode(e) raise TracedServerError(e, ts, request, msg)
def read(self, request, workspace_id, tab_id): user = get_user_authentication(request) tab = get_object_or_404(Tab, workspace__users__id=user.id, workspace__pk=workspace_id, pk=tab_id) tab_data = get_tab_data(tab) return HttpResponse(json_encode(tab_data), mimetype='application/json; charset=UTF-8')
def update(self, request, workspace_id): user = get_user_authentication(request) content_type = request.META.get('CONTENT_TYPE', '') if content_type == None: content_type = '' if content_type.startswith('application/json'): received_json = request.raw_post_data else: received_json = PUT_parameter(request, 'variables') if not received_json: return HttpResponseBadRequest(get_xml_error(_("variables JSON expected")), mimetype='application/xml; charset=UTF-8') try: variables = simplejson.loads(received_json) igadgetVariables = variables['igadgetVars'] variables_to_notify = [] for igVar in igadgetVariables: variables_to_notify += set_variable_value(igVar['id'], user, igVar['value']) data = {'igadgetVars': variables_to_notify} return HttpResponse(json_encode(data), mimetype='application/json; charset=UTF-8') except Exception, e: transaction.rollback() msg = _("cannot update variables: ") + unicode(e) raise TracedServerError(e, received_json, request, msg)
def create(self, request, workspace_id): user = get_user_authentication(request) if 'tab' not in request.POST: return HttpResponseBadRequest(get_xml_error(_("tab JSON expected")), mimetype='application/xml; charset=UTF-8') #TODO we can make this with deserializers (simplejson) received_json = request.POST['tab'] try: t = simplejson.loads(received_json) if 'name' not in t: raise Exception(_('Malformed tab JSON: expecting tab name.')) tab_name = t['name'] workspace = WorkSpace.objects.get(users__id=user.id, pk=workspace_id) tab = createTab(tab_name, user, workspace) # Returning created Ids ids = {'id': tab.id, 'name': tab.name} return HttpResponse(json_encode(ids), mimetype='application/json; charset=UTF-8') except Exception, e: transaction.rollback() msg = _("tab cannot be created: ") + unicode(e) raise TracedServerError(e, t, request, msg)
def read(self, request, user_name=None): user = user_authentication(request, user_name) gadgets = Gadget.objects.filter(users=user) data_list = [get_gadget_data(gadget) for gadget in gadgets] return HttpResponse(json_encode(data_list), mimetype='application/json; charset=UTF-8')
def create(self, request, workspace_id, tab_id): user = get_user_authentication(request) if 'igadget' not in request.POST: return HttpResponseBadRequest(get_xml_error(_("iGadget JSON expected")), mimetype='application/xml; charset=UTF-8') # Data checking and parsing try: igadget = simplejson.loads(request.POST['igadget']) except: return HttpResponseBadRequest(get_xml_error(_('iGadget data is not valid JSON'))) initial_variable_values = None if 'variable_values' in request.POST: try: initial_variable_values = simplejson.loads(request.POST['variable_values']) except: return HttpResponseBadRequest(get_xml_error(_('variables_values must be a valid JSON value'))) # iGadget creation try: tab = Tab.objects.get(workspace__users__id=user.id, workspace__pk=workspace_id, pk=tab_id) igadget = SaveIGadget(igadget, user, tab, initial_variable_values) igadget_data = get_igadget_data(igadget, user, tab.workspace) return HttpResponse(json_encode(igadget_data), mimetype='application/json; charset=UTF-8') except Gadget.DoesNotExist, e: msg = _('referred gadget %(gadget_uri)s does not exist.') % {'gadget_uri': igadget['gadget']} raise TracedServerError(e, {'igadget': igadget, 'user': user, 'tab': tab}, request, msg)
def read(self, request, user_name): user = user_authentication(request, user_name) concepts = Concept.objects.all() data_list = {} concept_values = {} concept_values['user'] = user data_list['concepts'] = [get_concept_data(concept, concept_values) for concept in concepts] return HttpResponse(json_encode(data_list), mimetype='application/json; charset=UTF-8')
def read(self, request, workspace_id): user = get_user_authentication(request) workspaces = get_list_or_404(WorkSpace, users__id=user.id, pk=workspace_id) data = serializers.serialize('python', workspaces, ensure_ascii=False) variable_data = get_workspace_channels_data(workspaces[0]) return HttpResponse(json_encode(variable_data), mimetype='application/json; charset=UTF-8')
def create(self, request, bbtype): user = get_user_authentication(request) try: data = simplejson.loads(request.raw_post_data) except Exception, e: msg = 'Error parsing request json: %(errorMsg)s' % {'errorMsg': e.message} return HttpResponseBadRequest(json_encode({"message": msg}), mimetype='application/json; charset=UTF-8')
def read(self, request, workspace_id, tab_id): user = get_user_authentication(request) tab = get_list_or_404(Tab, workspace__users__id=user.id, workspace__pk=workspace_id, pk=tab_id) data = serializers.serialize('python', tab, ensure_ascii=False) tab_data = get_tab_data(data[0]) return HttpResponse(json_encode(tab_data), mimetype='application/json; charset=UTF-8')
def read(self, request, workspace_id, tab_id, igadget_id, var_id): user = get_user_authentication(request) tab = Tab.objects.get(workspace__user__id=user.id, workspace__pk=workspace_id, pk=tab_id) variable = get_object_or_404(Variable, igadget__tab=tab, igadget__pk=igadget_id, vardef__pk=var_id) var_data = get_variable_data(variable) return HttpResponse(json_encode(var_data), mimetype='application/json; charset=UTF-8')
def read(self, request, user_name, workspace_id, tab_id): user = get_user_authentication(request) # Check Tab existance and owned by this user tab = get_object_or_404(Tab, workspace__users__id=user.id, workspace__pk=workspace_id, pk=tab_id) result = get_tab_preference_values(tab, user) return HttpResponse(json_encode(result), mimetype='application/json; charset=UTF-8')
def read(self, request, user_name): user = user_authentication(user_name) gadgets = Gadget.objects.filter(user=user) data = serializers.serialize('python', gadgets, ensure_ascii=False) data_list = [] for d in data: data_fields = get_gadget_data(d) data_list.append(data_fields) return HttpResponse(json_encode(data_list), mimetype='application/json; charset=UTF-8')
def read(self, request, user_name, concept_name): user = user_authentication(request, user_name) concepts = get_list_or_404(Concept, concept=concept_name) data = serializers.serialize('python', concepts, ensure_ascii=False) concept_values = {} concept_values['user'] = user data_list = get_concept_data(data[0], concept_values) return HttpResponse(json_encode(data_list), mimetype='application/json; charset=UTF-8')
def create(self, request, buildingblock_id): user = get_user_authentication(request) if not request.POST.has_key('vote'): return HttpResponseBadRequest(json_encode({"message":"vote expected"}), mimetype='application/json; charset=UTF-8') try: bb = BuildingBlock.objects.get(id=buildingblock_id) uv = UserVote.objects.get_or_create(user=user, buildingBlock=bb)[0] uv.value = request.POST.get('vote') uv.save() self.__updatePopularity(bb) bb.update_in_catalogue() ok = json_encode({'message':'OK'}) return HttpResponse(ok, mimetype='application/json; charset=UTF-8') except Exception, e: transaction.rollback() return HttpResponseServerError(json_encode({'message':unicode(e)}), mimetype='application/json; charset=UTF-8')
def read(self, request, user_name, concept_name): user = user_authentication(request, user_name) data_res ={} concept_data = {} concept_data['user'] = user data_res['value'] = get_concept_value(concept_name, concept_data) return HttpResponse(json_encode(data_res), mimetype='application/json; charset=UTF-8')
def read(self, request, user_name): user = user_authentication(request, user_name) concepts = Concept.objects.all() data = serializers.serialize('python', concepts, ensure_ascii=False) data_list = {} concept_values = {} concept_values['user'] = user data_list ['concepts'] = [get_concept_data(d, concept_values) for d in data] return HttpResponse(json_encode(data_list), mimetype='application/json; charset=UTF-8')
def delete(self, request, igadget_id, user_name=None): # Get the target user, either the user stored in the request or the parameter of the URL try: user = getTargetUser(request.user, user_name) except Exception, e: json = json_encode({"message": str(e), "result": "error"}) return HttpResponseServerError( json, mimetype='application/json; charset=UTF-8')
def complete_bb_data(self, data): if not data.has_key('creator'): data['creator'] = self.author.username if not data.has_key('id') or data.get('id') == None: data['id'] = self.pk if not data.has_key('type'): data['type'] = self.type self.data = json_encode(data) return self.data
def read(self, request, user_name, screen_id=None): user = user_authentication(request, user_name) #TODO by default. Remove in final release if not screen_id: screen_id = 1 data_list = {} try: screen = Screen.objects.get(user=user, code=screen_id) except Screen.DoesNotExist: data_list['iGadgets'] = [] return HttpResponse(json_encode(data_list), mimetype='application/json; charset=UTF-8') igadget = IGadget.objects.filter(screen=screen) data = serializers.serialize('python', igadget, ensure_ascii=False) data_list['iGadgets'] = [get_igadget_data(d) for d in data] return HttpResponse(json_encode(data_list), mimetype='application/json; charset=UTF-8')
def create(self, request, skin_type, skin_name=None): msg = None if not skin_name: #create a new skin skin_name = request.POST['name'] msg = check_name(skin_name) if not msg: properties = request.POST.copy() try: resp = "modified" if 'name' in properties: del properties['name'] properties = json_encode(dict(properties.items())) layout = Layout.objects.get(name=settings.LAYOUT) skin_template = SkinTemplate.objects.get(layout=layout, type=skin_type) try: skin, created = Skin.objects.get_or_create(name=skin_name, layout=layout, skin_template=skin_template, creator=request.user) skin.properties = properties if created: resp = "created" skin.save() result = _("<em style='color: green;'>The skin %(name)s has been %(msg)s successfully. It will be available next time you access to EzWeb.</em>") % {"name": skin_name, "msg": resp} if accepts(request, 'application/json'): mimetype = 'application/json; charset=UTF-8' msg = json_encode({"message": result, 'result': 'ok'}) else: mimetype = 'text/html; charset=UTF-8' msg = '<p style="font-size:80%">' + result + '</p>' return HttpResponse(msg, mimetype=mimetype) except IntegrityError, e: msg = _("Error creating the new skin: the name %s is already in use ") % skin_name except Exception, e: transaction.rollback() msg = _("Error creating the new skin: ") + unicode(e)
def read(self, request, workspace_id): user = get_user_authentication(request) workspaces = get_list_or_404(WorkSpace, users__id=user.id, pk=workspace_id) data = serializers.serialize('python', workspaces, ensure_ascii=False) concept_data = {} concept_data['user'] = user workspace_data = get_global_workspace_data(data[0], workspaces[0], concept_data, user) return HttpResponse(json_encode(workspace_data), mimetype='application/json; charset=UTF-8')
def read(self, request, user_name, vendor, name, version): user = user_authentication(request, user_name) gadget = get_object_or_404(Gadget, user=user, vendor=vendor, name=name, version=version) template = get_object_or_404(gadget.template, id=gadget.template.id) return HttpResponse(json_encode(template), mimetype='application/json; charset=UTF-8')
def create(self, request, user_name=None): if 'template_uri' not in request.POST: msg = _("Missing template URL parameter") json = json_encode({"message": msg, "result": "error"}) return HttpResponseBadRequest( json, mimetype='application/json; charset=UTF-8') # #Get or Create the Gadget in the Showcase # # Get the user whose active workspace will have a new gadget # either the user stored in the request or the parameter of the URL try: user = getTargetUser(request.user, user_name) except Exception, e: json = json_encode({"message": str(e), "result": "error"}) return HttpResponseServerError( json, mimetype='application/json; charset=UTF-8')
def read(self, request, buildingblock_id): user = get_user_authentication(request) bbc = get_object_or_404(BuildingBlockCode, buildingBlock=buildingblock_id) if bbc.unboundCode: return HttpResponse(bbc.unboundCode, mimetype='text/plain; charset=UTF-8') else: return HttpResponseServerError( json_encode({'message':'this Building block does not have unbound code'}), mimetype='application/json; charset=UTF-8')
def read(self, request, user_name): user = get_user_authentication(request) create_platform_preferences( user ) # Create all platform preferences for the user (if not exist) preferences = Preference.objects.filter(user=user) data = serializers.serialize('python', preferences, ensure_ascii=False) data_list = {} data_list['preferences'] = [get_preference_data(d) for d in data] return HttpResponse(json_encode(data_list), mimetype='application/json; charset=UTF-8')
def update(self, request, buildingblock_id): user = get_user_authentication(request) received_json = PUT_parameter(request, 'buildingblock') if not received_json: return HttpResponseBadRequest(json_encode({"message":"JSON expected"}), mimetype='application/json; charset=UTF-8') try: data = simplejson.loads(received_json) bb = BuildingBlock.objects.get(id=buildingblock_id) bb.update_unbound_code(data, request.build_absolute_uri()) json_data = bb.complete_bb_data(data) bb.save() return HttpResponse(json_data, mimetype='application/json; charset=UTF-8') except Exception, e: transaction.rollback() return HttpResponseServerError(json_encode({'message':unicode(e)}), mimetype='application/json; charset=UTF-8')
def read(self, request, buildingblock_id): user = get_user_authentication(request) bb = get_object_or_404(BuildingBlock, id=buildingblock_id) if bb.type == 'form': return HttpResponse(bb.child_model().get_debug_html(), mimetype="text/html; charset=UTF-8") else: return HttpResponseServerError( json_encode({'message':'this Building block does not have unbound code'}), mimetype='application/json; charset=UTF-8')
def read(self, request, user_name, vendor, name, version): user = user_authentication(request, user_name) gadgets = get_list_or_404(Gadget, user=user, vendor=vendor, name=name, version=version) data = serializers.serialize('python', gadgets, ensure_ascii=False) data_fields = get_gadget_data(data[0]) return HttpResponse(json_encode(data_fields), mimetype='application/json; charset=UTF-8')
def tag_categories(request): try: userOrgs = request.user.groups.exclude(name__startswith="cert__") except: userOrgs = {} #Categories whose parent is None are root categories root = _get_Category_Info(None, userOrgs) categories = root['children'] return {'tag_categories': json_encode(categories)}
def read(self, request, from_ws_id, to_ws_id): from_ws = get_object_or_404(WorkSpace, id=from_ws_id) to_ws = get_object_or_404(WorkSpace, id=to_ws_id) user = get_user_authentication(request) packageCloner = PackageCloner() to_workspace = packageCloner.merge_workspaces(from_ws, to_ws, user) result = {'result': 'ok', 'merged_workspace_id': to_workspace.id} return HttpResponse(json_encode(result), mimetype='application/json; charset=UTF-8')
def read(self, request, user_name, igadget_id, var_name, screen_id=None): user = user_authentication(request, user_name) #TODO by default. Remove in final release if not screen_id: screen_id = 1 screen = Screen.objects.get(user=user, code=screen_id) variable = get_list_or_404(Variable, igadget__screen=screen, igadget__code=igadget_id, vardef__name=var_name) data = serializers.serialize('python', variable, ensure_ascii=False) var_data = get_variable_data(data[0]) return HttpResponse(json_encode(var_data), mimetype='application/json; charset=UTF-8')
def read(self, request, workspace_id, tab_id, igadget_id): user = get_user_authentication(request) tab = Tab.objects.get(workspace__users__id=user.id, workspace__pk=workspace_id, pk=tab_id) variables = Variable.objects.filter(igadget__tab=tab, igadget__id=igadget_id) data = serializers.serialize('python', variables, ensure_ascii=False) vars_data = [get_variable_data(d) for d in data] return HttpResponse(json_encode(vars_data), mimetype='application/json; charset=UTF-8')
def read(self, request, workspace_id): user = get_user_authentication(request) cloned_workspace = cloneWorkspace(workspace_id) linkWorkspace(user, cloned_workspace.id) data = serializers.serialize('python', [cloned_workspace], ensure_ascii=False) concept_data = {} concept_data['user'] = user workspace_data = get_global_workspace_data(data[0], cloned_workspace, concept_data, user) return HttpResponse(json_encode(workspace_data), mimetype='application/json; charset=UTF-8')
def read(self, request, user_name=None): """ Gets the current wallet balance of the authenticated user """ user = get_user_authentication(request) user_wallet = None try: user_wallet = Wallet.objects.get(auth_user=user) except Exception: user_wallet = Wallet(auth_user=user, current_balance=0, outstanding_balance=0) user_wallet.save() return HttpResponse(json_encode({'user': user_wallet.auth_user.username, 'current_balance': user_wallet.current_balance}), mimetype='application/json; charset=UTF-8')