def update(self, request): get_user_authentication(request) channel_json = None try: channel_json = request.POST['channels'] except KeyError: return HttpResponseServerError('{"error": "Missing channel list!"}', mimetype='application/json; charset=UTF-8') try: channel_list = simplejson.loads(channel_json) except: return HttpResponseServerError('{"error": "Not valid JSON argument!"}', mimetype='application/json; charset=UTF-8') for channel_data in channel_list: channel = RemoteChannel.objects.get(id=channel_data['id']) channel.value = channel_data['value'] channel.save() if hasattr(settings, 'REMOTE_CHANNEL_NOTIFIER_URL'): url = settings.REMOTE_CHANNEL_NOTIFIER_URL + '?channels=%s' % channel_json request = urllib2.Request(url) return urllib2.urlopen(url) return HttpResponse('{"result": "ok"}', 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 update(self, request, workspace_id, tab_id, igadget_id): user = get_user_authentication(request) received_json = PUT_parameter(request, 'igadget') if not received_json: return HttpResponseBadRequest( get_xml_error(_("iGadget JSON expected")), mimetype='application/xml; charset=UTF-8') try: igadget = simplejson.loads(received_json) tab = Tab.objects.get(workspace__users__id=user.id, workspace__pk=workspace_id, pk=tab_id) UpdateIGadget(igadget, user, tab) return HttpResponse('ok') except Tab.DoesNotExist: msg = _('referred tab %(tab_id)s does not exist.') log(msg, request) return HttpResponseBadRequest(get_xml_error(msg)) except Exception, e: transaction.rollback() msg = _("iGadget cannot be updated: ") + unicode(e) log(msg, request) return HttpResponseServerError( get_xml_error(msg), mimetype='application/xml; charset=UTF-8')
def read(self, request, user_name=None): user = get_user_authentication(request) user_wallet = None try: user_wallet = Wallet.objects.get(auth_user=user) except Exception, e: return HttpResponseServerError(get_xml_error(unicode(e)), mimetype='application/xml; charset=UTF-8')
def delete(self, request, workspace_id, tab_id): user = get_user_authentication(request) #set new order tabs = Tab.objects.filter(workspace__pk=workspace_id).order_by('position') # Get tab, if it does not exist, an http 404 error is returned tab = get_object_or_404(Tab, workspace__pk=workspace_id, pk=tab_id) #decrease the position of the following tabs for t in range(tab.position, tabs.count()): tabs[t].position = tabs[t].position - 1 tabs = tabs.exclude(pk=tab_id) if tabs.count()==0: msg = _("tab cannot be deleted") log(msg, request) return HttpResponseServerError(get_xml_error(msg), mimetype='application/xml; charset=UTF-8') #Delete WorkSpace variables too! deleteTab(tab, user) #set a new visible tab (first tab by default) activeTab=tabs[0] setVisibleTab(user, workspace_id, activeTab) return HttpResponse('ok')
def update(self, request, workspace_id, tab_id): user = get_user_authentication(request) received_json = PUT_parameter(request, 'igadgets') if not received_json: return HttpResponseBadRequest(get_xml_error(_("iGadget JSON expected")), mimetype='application/xml; charset=UTF-8') try: tab = Tab.objects.get(workspace__users__id=user.id, workspace__pk=workspace_id, pk=tab_id) received_data = simplejson.loads(received_json) igadgets = received_data.get('iGadgets') for igadget in igadgets: UpdateIGadget(igadget, user, tab) transaction.commit() return HttpResponse('ok') except Tab.DoesNotExist: msg = _('referred tab %(tab_id)s does not exist.') log(msg, request) return HttpResponseBadRequest(get_xml_error(msg)) except Exception, e: transaction.rollback() msg = _("iGadgets cannot be updated: ") + unicode(e) log(msg, request) return HttpResponseServerError(get_xml_error(msg), mimetype='application/xml; charset=UTF-8')
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 create(self, request, user_name=None): user = get_user_authentication(request) if request.POST.has_key('url'): templateURL = request.POST['url'] else: return HttpResponseServerError('<error>Url not specified</error>', mimetype='application/xml; charset=UTF-8') ########### Template Parser templateParser = None try: # Gadget is created only once templateParser = TemplateParser(templateURL) gadget_uri = templateParser.getGadgetUri() try: gadget = Gadget.objects.get(uri=gadget_uri) except Gadget.DoesNotExist: # Parser creates the gadget. It's made only if the gadget does not exist templateParser.parse() gadget = templateParser.getGadget() # A new user has added the gadget in his showcase gadget.users.add(user) transaction.commit() except TemplateParseException, e: log(e, request) transaction.rollback() return HttpResponseServerError(get_xml_error(unicode(e)), mimetype='application/xml; 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, workspace_id): user = get_user_authentication(request) linkWorkspace(user, workspace_id) return HttpResponse("{'result': 'ok'}", 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, 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 delete(self, request, workspace_id, tab_id, igadget_id): user = get_user_authentication(request) # Gets Igadget, if it does not exist, a http 404 error is returned igadget = get_object_or_404(IGadget, tab__workspace__user=user, tab__workspace__pk=workspace_id, tab__pk=tab_id, pk=igadget_id) # Delete all IGadget's variables variables = Variable.objects.filter(igadget=igadget) for var in variables: if (var.vardef.aspect == "SLOT"): Out.objects.get( abstract_variable=var.abstract_variable).delete() if (var.vardef.aspect == "EVEN"): In.objects.get(variable=var).delete() var.abstract_variable.delete() var.delete() # Delete IGadget and its position position = igadget.position position.delete() igadget.delete() return HttpResponse('ok')
def update(self, request, workspace_id, tab_id): user = get_user_authentication(request) if not request.PUT.has_key('igadgets'): return HttpResponseBadRequest( get_xml_error(_("iGadget JSON expected")), mimetype='application/xml; charset=UTF-8') #TODO we can make this with deserializers (simplejson) received_json = request.PUT['igadgets'] try: tab = Tab.objects.get(workspace__user=user, workspace__pk=workspace_id, pk=tab_id) received_data = eval(received_json) igadgets = received_data.get('iGadgets') for igadget in igadgets: UpdateIGadget(igadget, user, tab) transaction.commit() return HttpResponse('ok') except Tab.DoesNotExist: msg = _('refered tab %(tab_id)s does not exist.') log(msg, request) return HttpResponseBadRequest(get_xml_error(msg)) except Exception, e: transaction.rollback() msg = _("iGadgets cannot be updated: ") + unicode(e) log(msg, request) return HttpResponseServerError( get_xml_error(msg), mimetype='application/xml; charset=UTF-8')
def update(self, request, user_name, workspace_id, tab_id): user = get_user_authentication(request) received_json = PUT_parameter(request, 'preferences') if not received_json: return HttpResponseBadRequest( get_xml_error(_("Platform Preferences JSON expected")), mimetype='application/xml; charset=UTF-8') try: preferences_json = simplejson.loads(received_json) # 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) update_tab_preferences(tab, preferences_json) return HttpResponse('ok') except Exception, e: transaction.rollback() msg = _("Tab Preferences could not be updated: ") + unicode(e) raise TracedServerError(e, {}, request, msg)
def read(self, request, user_name): user = get_user_authentication(request) result = parseValues(PlatformPreference.objects.filter(user=user)) return HttpResponse(json_encode(result), mimetype='application/json; charset=UTF-8')
def read(self, request): try: user = get_user_authentication(request) playerData = None if request.GET.has_key( 'screenflow') and not request.GET.has_key('screen'): playerData = getGadgetData(request.GET['screenflow']) elif request.GET.has_key( 'screen') and not request.GET.has_key('screenflow'): playerData = getScreenData(request.GET['screen']) else: raise Exception('Invalid URL') playerHTML = getPlayerHTML( playerData, '/'.join([settings.MEDIA_URL, 'gadget'])) return HttpResponse(playerHTML, mimetype='text/html; charset=UTF-8') except Http404: return HttpResponseServerError( json_encode({"message": "Object not found"}), mimetype='application/json; charset=UTF-8') except Exception, e: return HttpResponseServerError( json_encode({'message': unicode(e)}), 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 create(self, request, workspace_id, tab_id): user = get_user_authentication(request) if not request.POST.has_key('igadget'): return HttpResponseBadRequest( get_xml_error(_("iGadget JSON expected")), mimetype='application/xml; charset=UTF-8') try: received_json = request.POST['igadget'] igadget = simplejson.loads(received_json) tab = Tab.objects.get(workspace__users__id=user.id, workspace__pk=workspace_id, pk=tab_id) ids = SaveIGadget(igadget, user, tab) return HttpResponse(json_encode(ids), mimetype='application/json; charset=UTF-8') except WorkSpace.DoesNotExist, e: msg = _('referred workspace %(workspace_id)s does not exist.') % { 'workspace_id': workspace_id } raise TracedServerError(e, {'workspace': workspace_id}, request, msg)
def update(self, request, workspace_id): user = get_user_authentication(request) 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 = eval(received_json) igadgetVariables = variables['igadgetVars'] workSpaceVariables = variables['workspaceVars'] for wsVar in workSpaceVariables: wsVarDAO = WorkSpaceVariable.objects.get(pk=wsVar['id']) wsVarDAO.abstract_variable.value=wsVar['value']; wsVarDAO.abstract_variable.save(); for igVar in igadgetVariables: igVarDAO = Variable.objects.get(pk=igVar['id']) igVarDAO.abstract_variable.value=igVar['value']; igVarDAO.abstract_variable.save(); return HttpResponse(str('OK')) except Exception, e: transaction.rollback() msg = _("cannot update variables: ") + unicode(e) log(msg, request) return HttpResponseServerError(get_xml_error(msg), mimetype='application/xml; charset=UTF-8')
def update(self, request, workspace_id, tab_id, igadget_id): user = get_user_authentication(request) received_json = PUT_parameter(request, 'igadget') if not received_json: return HttpResponseBadRequest( get_xml_error(_("iGadget JSON expected")), mimetype='application/xml; charset=UTF-8') try: igadget = simplejson.loads(received_json) tab = Tab.objects.get(workspace__users__id=user.id, workspace__pk=workspace_id, pk=tab_id) UpdateIGadget(igadget, user, tab) return HttpResponse('ok') except Tab.DoesNotExist, e: msg = _('referred tab %(tab_id)s does not exist.') % { 'tab_id': tab_id } raise TracedServerError(e, { 'workspace': workspace_id, 'tab': tab_id }, request, msg)
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 delete(self, request, workspace_id, last_user=''): user = get_user_authentication(request) user_workspaces = UserWorkSpace.objects.select_related('workspace') try: user_workspace = user_workspaces.get(user__id=user.id, workspace__id=workspace_id) except UserWorkSpace.DoesNotExist: raise Http404 workspace = user_workspace.workspace if workspace.creator != user or user_workspace.manager != '': return HttpResponseForbidden() # Check if the user does not have any other workspace workspaces = WorkSpace.objects.filter(users__id=user.id).exclude(pk=workspace_id) if workspaces.count() == 0: msg = _("workspace cannot be deleted") raise TracedServerError(None, {'workspace': workspace_id}, request, msg) # Remove the workspace PublishedWorkSpace.objects.filter(workspace=workspace).update(workspace=None) igadgets = IGadget.objects.filter(tab__workspace=workspace) for igadget in igadgets: deleteIGadget(igadget, user) workspace.delete() # Set a new active workspace (first workspace by default) activeWorkspace = workspaces[0] setActiveWorkspace(user, activeWorkspace) return HttpResponse('ok')
def update(self, request, workspace_id, tab_id, igadget_id): user = get_user_authentication(request) received_json = PUT_parameter(request, 'variables') # Gets JSON parameter from request if not received_json: return HttpResponseBadRequest(get_xml_error(_("iGadget variables JSON expected")), mimetype='application/xml; charset=UTF-8') try: received_variables = eval(received_json) tab = Tab.objects.get(workspace__user=user, workspace__pk=workspace_id, pk=tab_id) server_variables = Variable.objects.filter(igadget__tab=tab) # Gadget variables collection update for varServer in server_variables: for varJSON in received_variables: if (varServer.vardef.pk == varJSON['pk'] and varServer.igadget.pk == varJSON['iGadget']): varServer.value = varJSON['value'] varServer.save() transaction.commit() except Tab.DoesNotExist: msg = _('refered tab %(tab_id)s does not exist.') log(msg, request) return HttpResponseBadRequest(get_xml_error(msg)) except Exception, e: transaction.rollback() log(e, request) return HttpResponseServerError(get_xml_error(unicode(e)), mimetype='application/xml; charset=UTF-8')
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 update(self, request, workspace_id, tab_id): user = get_user_authentication(request) received_json = PUT_parameter(request, 'tab') if not received_json: return HttpResponseBadRequest(get_xml_error(_("tab JSON expected")), mimetype='application/xml; charset=UTF-8') try: t = simplejson.loads(received_json) tab = Tab.objects.get(workspace__users__id=user.id, workspace__pk=workspace_id, pk=tab_id) if t.has_key('visible'): visible = t.get('visible') if (visible == 'true'): #Only one visible tab setVisibleTab(user, workspace_id, tab) else: tab.visible = False if t.has_key('name'): tab.name = t.get('name') tab.save() return HttpResponse('ok') except Exception, e: transaction.rollback() msg = _("tab cannot be updated: ") + unicode(e) raise TracedServerError(e, t, request, msg)
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 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 '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 create(self, request, workspace_id, tab_id): user = get_user_authentication(request) if not request.POST.has_key('igadget'): return HttpResponseBadRequest( get_xml_error(_("iGadget JSON expected")), mimetype='application/xml; charset=UTF-8') try: received_json = request.POST['igadget'] igadget = simplejson.loads(received_json) tab = Tab.objects.get(workspace__users__id=user.id, workspace__pk=workspace_id, pk=tab_id) ids = SaveIGadget(igadget, user, tab) return HttpResponse(json_encode(ids), mimetype='application/json; charset=UTF-8') except WorkSpace.DoesNotExist: msg = _('referred workspace %(workspace_id)s does not exist.') log(msg, request) return HttpResponseBadRequest(get_xml_error(msg)) except Exception, e: transaction.rollback() msg = _("iGadget 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) cloned_workspace = cloneWorkspace(workspace_id, user) result = {'result': 'ok', 'new_workspace_id': cloned_workspace.id} return HttpResponse(json_encode(result), mimetype='application/json; charset=UTF-8')
def update(self, request, workspace_id, tab_id, igadget_id, var_id): user = get_user_authentication(request) received_json = PUT_parameter(request, 'value') # Gets value parameter from request if not received_json: return HttpResponseBadRequest( get_xml_error(_("iGadget JSON expected")), mimetype='application/xml; charset=UTF-8') new_value = received_json tab = Tab.objects.get(workspace__users__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) try: variable.value = new_value variable.save() except Exception, e: transaction.rollback() log(e, request) return HttpResponseServerError( get_xml_error(e), mimetype='application/xml; charset=UTF-8')
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 update(self, request, workspace_id, last_user=''): user = get_user_authentication(request) received_json = PUT_parameter(request, 'workspace') if not received_json: return HttpResponseBadRequest(get_xml_error(_("workspace JSON expected")), mimetype='application/xml; charset=UTF-8') try: ts = simplejson.loads(received_json) workspace = WorkSpace.objects.get(users__id=user.id, pk=workspace_id) if 'active' in ts: active = ts['active'] if (active == 'true'): #Only one active workspace setActiveWorkspace(user, workspace) else: currentUserWorkspace = UserWorkSpace.objects.get(workspace=workspace, user=user) currentUserWorkspace.active = True currentUserWorkspace.save() if 'name' in ts: workspace.name = ts['name'] workspace.save() return HttpResponse('ok') except Exception, e: transaction.rollback() msg = _("workspace cannot be updated: ") + unicode(e) raise TracedServerError(e, ts, request, msg)
def update(self, request, workspace_id, tab_id, igadget_id): user = get_user_authentication(request) received_json = PUT_parameter(request, 'variables') # Gets JSON parameter from request if not received_json: return HttpResponseBadRequest(get_xml_error(_("iGadget variables JSON expected")), mimetype='application/xml; charset=UTF-8') try: received_variables = simplejson.loads(received_json) tab = Tab.objects.get(workspace__users__id=user.id, workspace__pk=workspace_id, pk=tab_id) server_variables = Variable.objects.filter(igadget__tab=tab) # Gadget variables collection update for varServer in server_variables: for varJSON in received_variables: if (varServer.vardef.pk == varJSON['pk'] and varServer.igadget.pk == varJSON['iGadget']): varServer.value = varJSON['value'] varServer.save() transaction.commit() except Tab.DoesNotExist, e: msg = _('referred tab %(tab_id)s does not exist.') % {'tab_id': tab_id} raise TracedServerError(e, {'workspace': workspace_id, 'tab': tab_id, 'igadget': igadget_id}, request, msg)
def update(self, request, workspace_id): user = get_user_authentication(request) received_json = PUT_parameter(request, 'workspace') if not received_json: return HttpResponseBadRequest(get_xml_error(_("workspace JSON expected")), mimetype='application/xml; charset=UTF-8') try: ts = simplejson.loads(received_json) workspace = WorkSpace.objects.get(users__id=user.id, pk=workspace_id) if ts.has_key('active'): active = ts.get('active') if (active == 'true'): #Only one active workspace setActiveWorkspace(user, workspace) else: workspace.active = False if ts.has_key('name'): workspace.name = ts.get('name') workspace.save() return HttpResponse('ok') except Exception, e: transaction.rollback() msg = _("workspace cannot be updated: ") + unicode(e) log(msg, request) return HttpResponseServerError(get_xml_error(msg), mimetype='application/xml; charset=UTF-8')
def create(self, request, user_name=None): user = get_user_authentication(request) if request.POST.has_key('url'): templateURL = request.POST['url'] else: return HttpResponseServerError( '<error>Url not specified</error>', mimetype='application/xml; charset=UTF-8') ########### Template Parser templateParser = None try: # Gadget is created only once templateParser = TemplateParser(templateURL) gadget_uri = templateParser.getGadgetUri() try: gadget = Gadget.objects.get(uri=gadget_uri) except Gadget.DoesNotExist: # Parser creates the gadget. It's made only if the gadget does not exist templateParser.parse() gadget = templateParser.getGadget() # A new user has added the gadget in his showcase gadget.users.add(user) transaction.commit() except TemplateParseException, e: log(e, request) transaction.rollback() return HttpResponseServerError( get_xml_error(unicode(e)), mimetype='application/xml; charset=UTF-8')
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) 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 = eval(received_json) igadgetVariables = variables['igadgetVars'] workSpaceVariables = variables['workspaceVars'] for wsVar in workSpaceVariables: wsVarDAO = WorkSpaceVariable.objects.get(pk=wsVar['id']) wsVarDAO.abstract_variable.value = wsVar['value'] wsVarDAO.abstract_variable.save() for igVar in igadgetVariables: igVarDAO = Variable.objects.get(pk=igVar['id']) igVarDAO.abstract_variable.value = igVar['value'] igVarDAO.abstract_variable.save() return HttpResponse(str('OK')) except Exception, e: transaction.rollback() msg = _("cannot update variables: ") + unicode(e) log(msg, request) return HttpResponseServerError( get_xml_error(msg), mimetype='application/xml; charset=UTF-8')
def update(self, request): try: user = get_user_authentication(request) # Get the gadget data from the request preferences = simplejson.loads( PUT_parameter(request, 'preferences')) user.email = preferences['email'] user.first_name = preferences['first_name'] user.last_name = preferences['last_name'] profile = UserProfile.objects.get(user=request.user) profile.ezweb_url = preferences["ezweb_url"] profile.save() user.save() ok = json_encode({"message": "OK"}) return HttpResponse(ok, mimetype='application/json; charset=UTF-8') except Http403, ex: return HttpResponseForbidden( json_encode({"message": unicode(ex)}), 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 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, user_name=None): """ Gets a list of purchased gadgets by the authenticated user """ user = get_user_authentication(request) purchased_gadgets = {} try: # gets the user wallet to locate any gadgets related to it user_wallet = Wallet.objects.get(auth_user=user) # gets purchase transaction transactions = Transaction.objects.filter(wallet=user_wallet,transaction_type='P') # creates the dict to return for transaction in transactions: resource = transaction.gadget_pricing.gadget resource_index = u'%s' % (resource.short_name) if transaction.gadget_pricing.periodicity == 'P': purchased_gadgets[resource_index] = True continue if transaction.finish_date >= datetime.now(): finish_date_text = str(transaction.finish_date) purchased_gadgets[resource_index] = finish_date_text[8:10] + "-" + finish_date_text[5:7] + "-" + finish_date_text[0:4] continue pass except Exception, e: purchased_gadgets = {}
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, 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 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')