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 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 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, 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 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, 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')
