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 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, 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:
msg = _('referred 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 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 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 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 update(self, request, user_name, vendor, name, version):
try:
format = PUT_parameter(request, 'format')
except:
format = 'default'
user = user_authentication(request, user_name)
# Get the vote from the request
vote = PUT_parameter(request, 'vote')
# Get the gadget's id for those vendor, name and version
gadget = get_object_or_404(GadgetResource,
short_name=name,
vendor=vendor,
version=version)
# Insert the vote for these resource and user in the database
try:
userVote = get_object_or_404(UserVote,
idUser=user,
idResource=gadget)
userVote.vote = vote
userVote.save()
except Exception, ex:
log(ex, request)
return HttpResponseServerError(
get_xml_error(unicode(ex)),
mimetype='application/xml; 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, 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 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 = eval(received_json)
tab = Tab.objects.get(workspace__user=user, 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)
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 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 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 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):
if not request.REQUEST.has_key('data'):
return HttpResponseBadRequest(
get_xml_error(_("mashup data expected")),
mimetype='application/xml; charset=UTF-8')
received_json = request.REQUEST['data']
try:
mashup = simplejson.loads(received_json)
if not mashup.has_key('name'):
raise Exception(
_('Malformed mashup JSON: expecting mashup name.'))
if not mashup.has_key('vendor'):
raise Exception(
_('Malformed mashup JSON: expecting mashup vendor.'))
if not mashup.has_key('version'):
raise Exception(
_('Malformed mashup JSON: expecting mashup version.'))
except Exception, e:
transaction.rollback()
msg = _("mashup cannot be published: ") + 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, 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_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 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 delete(self,request,user_name,vendor,name,version, tag):
try:
user = user_authentication(request, user_name)
except Http403, e:
msg = _("This tag cannot be deleted: ") + unicode(e)
log (msg, request)
return HttpResponseForbidden(get_xml_error(msg), mimetype='application/xml; charset=UTF-8')
def create(self, request, account_id=None, wallet_id=None):
# Gets the attached wallet
try:
user_wallet = Wallet.objects.get(id=wallet_id)
account = Account.objects.get(id=account_id)
except Exception, e:
log(e, request)
return HttpResponseServerError(get_xml_error(_("Error getting objects")), mimetype='application/xml; charset=UTF-8')
def delete(self,request,user_name,vendor,name,version, tag):
try:
user = user_authentication(request, user_name)
except Http403, e:
msg = _("This tag cannot be deleted: ") + unicode(e)
log (msg, request)
return HttpResponseForbidden(get_xml_error(msg), mimetype='application/xml; charset=UTF-8')
def create(self, request, account_id=None, wallet_id=None):
# Gets the attached wallet
try:
user_wallet = Wallet.objects.get(id=wallet_id)
account = Account.objects.get(id=account_id)
except Exception, e:
log(e, request)
return HttpResponseServerError(get_xml_error(_("Error getting objects")), mimetype='application/xml; charset=UTF-8')
def read(self, request, username, vendor, name, version):
# Get info deployment
info = InfoDeployment(request)
try:
user_authentication(request, request.user.username)
except Http403, e:
msg = _("This gadget could not be exported") + unicode(e)
log(msg, request)
return HttpResponseForbidden(get_xml_error(msg), mimetype='application/xml; charset=UTF-8')
def read(self, request):
user = get_user_authentication(request)
data_list = {}
try:
workspaces = WorkSpace.objects.filter(users__id=user.id)
if workspaces.count()==0:
createWorkSpace('MyWorkSpace', user)
workspaces = WorkSpace.objects.filter(users__id=user.id)
except Exception, e:
log(e, request)
return HttpResponseBadRequest(get_xml_error(unicode(e)), mimetype='application/xml; charset=UTF-8')
def update(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)
xhtml = gadget.xhtml;
try:
xhtml.code = download_http_content(xhtml.url)
xhtml.save()
except Exception, e:
msg = _("XHTML code is not accessible")
log(msg, request)
return HttpResponseServerError(get_xml_error(msg))
def update(self, request, user_name, vendor, name, version):
user = user_authentication(user_name)
gadget = get_object_or_404(Gadget, user=user, vendor=vendor, name=name, version=version)
xhtml = gadget.xhtml;
try:
urlcleanup()
xhtml.code = urlopen(xhtml.url).read()
xhtml.save()
except Exception, e:
log(e, 'PUT', 'user/id/gadgets/xhtml', user_name)
return HttpResponseServerError(_("XHTML code is not accessible"))
def read(self, request):
user = get_user_authentication(request)
data_list = {}
try:
workspaces = WorkSpace.objects.filter(users__id=user.id)
if workspaces.count()==0:
createWorkSpace('MyWorkSpace', user)
workspaces = WorkSpace.objects.filter(users__id=user.id)
except Exception, e:
log(e, request)
return HttpResponseBadRequest(get_xml_error(unicode(e)), mimetype='application/xml; charset=UTF-8')
def create(self, request):
# Deployment Info
info = InfoDeployment(request)
user_action = True
if 'user_action' in request.POST:
user_action = request.POST['user_action'] == '1'
try:
user = user_authentication(request, request.user.username)
except Http403, e:
msg = _("This gadget cannot be created") + unicode(e)
log(msg, request)
return HttpResponseForbidden(get_xml_error(msg), mimetype='application/xml; charset=UTF-8')
def create(self,request, user_name):
template_uri = request.__getitem__('template_uri')
templateParser = None
try:
templateParser = TemplateParser(template_uri, user_name)
templateParser.parse()
transaction.commit()
except IntegrityError, e:
# Gadget already exists. Rollback transaction
transaction.rollback()
log(e, 'POST', 'user/id/resources', user_name)
return HttpResponseServerError(get_xml_error(str(sys.exc_info()[1])),mimetype='text/xml; charset=UTF-8')
def update(self, request, vendor, name, version, user_name=None):
user = user_authentication(request, user_name)
gadget = get_object_or_404(Gadget, users=user, vendor=vendor, name=name, version=version)
xhtml = gadget.xhtml;
try:
xhtml.code = download_http_content(xhtml.url)
xhtml.save()
except Exception:
msg = _("XHTML code is not accessible")
log(msg, request)
return HttpResponseServerError(get_xml_error(msg))
return HttpResponse('ok')
def create(self,request, user_name):
user = user_authentication(request, user_name)
template_uri = request.POST.__getitem__('template_uri')
templateParser = None
try:
templateParser = TemplateParser(template_uri, user)
templateParser.parse()
transaction.commit()
except IntegrityError, e:
# Gadget already exists. Rollback transaction
transaction.rollback()
log(e, request)
return HttpResponseServerError(get_xml_error(unicode(sys.exc_info()[1])), mimetype='application/xml; charset=UTF-8')
class GadgetsCollection(Resource):
@transaction.commit_manually
def create(self, request, user_name):
template_uri = request.__getitem__('template_uri')
templateParser = None
try:
templateParser = TemplateParser(template_uri, user_name)
templateParser.parse()
transaction.commit()
except IntegrityError, e:
# Gadget already exists. Rollback transaction
transaction.rollback()
log(e, 'POST', 'user/id/resources', user_name)
return HttpResponseServerError(get_xml_error(str(
sys.exc_info()[1])),
mimetype='text/xml; charset=UTF-8')
except TemplateParseException, e:
transaction.rollback()
log(e, 'POST', 'user/id/resources', user_name)
return HttpResponseServerError(
"<error>%s</error>" % e,
mimetype='application/xml; charset=UTF-8')
def read(self, request, workspace_id):
workspace = get_object_or_404(WorkSpace, id=workspace_id)
user = get_user_authentication(request)
#Checking if user is already linked to workspace
if (len(workspace.users.filter(id=user.id))>0):
msg = _("already linked workspace")
log(msg, request)
return HttpResponseServerError(get_xml_error(msg), mimetype='application/xml; charset=UTF-8')
packageLinker = PackageLinker()
packageLinker.link_workspace(workspace, user)
return HttpResponse("{'result': 'ok'}", mimetype='application/json; charset=UTF-8')
def update(self, request, user_name):
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)
update_preferences(user, preferences_json)
return HttpResponse('ok')
except Exception, e:
transaction.rollback()
msg = _("Platform Preferences cannot be updated: ") + unicode(e)
log(msg, request)
return HttpResponseServerError(get_xml_error(msg), mimetype='application/xml; charset=UTF-8')
class GadgetsCollection(Resource):
@transaction.commit_manually
def create(self, request, user_name):
user = user_authentication(request, user_name)
template_uri = request.__getitem__('template_uri')
templateParser = None
try:
templateParser = TemplateParser(template_uri, user)
templateParser.parse()
transaction.commit()
except IntegrityError, e:
# Gadget already exists. Rollback transaction
transaction.rollback()
log(e, request)
return HttpResponseServerError(
get_xml_error(unicode(sys.exc_info()[1])),
mimetype='application/xml; charset=UTF-8')
except TemplateParseException, e:
transaction.rollback()
log(e, request)
return HttpResponseServerError(
get_xml_error(unicode(e)),
mimetype='application/xml; charset=UTF-8')
class GadgetCollection(Resource):
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')
@transaction.commit_manually
def create(self, request, user_name):
user = user_authentication(user_name)
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:
templateParser = TemplateParser(templateURL, user)
templateParser.parse()
transaction.commit()
except TemplateParseException, e:
log(e, 'POST', 'user/id/gadgets', user_name)
transaction.rollback()
return HttpResponseServerError(get_xml_error(unicode(e)), mimetype='application/xml; charset=UTF-8')
except IntegrityError:
log(_("Gadget already exists"), 'POST', 'user/id/gadgets', user_name)
# Gadget already exists. Rollback transaction
transaction.rollback()
class PaypalTransactionIPN(Resource):
"""
Registers a Payment transaction and updates the wallet balance
"""
def create(self, request, account_id=None, wallet_id=None):
# Gets the attached wallet
try:
user_wallet = Wallet.objects.get(id=wallet_id)
account = Account.objects.get(id=account_id)
except Exception, e:
log(e, request)
return HttpResponseServerError(get_xml_error(_("Error getting objects")), mimetype='application/xml; charset=UTF-8')
# Creates the transaction
try:
transaction = Transaction()
transaction.wallet = user_wallet
transaction.creation_date = datetime.now()
transaction.transaction_type = 'R'
transaction.concept = _('Wallet Recharge')
transaction.amount = Decimal(request.POST.__getitem__("mc_gross"))
if(request.POST.__getitem__("payment_status")=="Completed"):
transaction.status = 'C'
if(request.POST.__getitem__("payment_status")=="Pending"):
transaction.status = 'P'
transaction.gadget_pricing = None
transaction.finish_date = transaction.creation_date
transaction.payment_account = account
transaction.save()
except Exception, e:
log(e, request)
return HttpResponseServerError(get_xml_error(_("Error creating transaction")), mimetype='application/xml; charset=UTF-8')
class GadgetVotesCollection(Resource):
def create(self, request, user_name, vendor, name, version):
try:
format = request.GET.__getitem__('format')
except:
format = 'default'
user = user_authentication(request, user_name)
# Get the vote from the request
vote = request.POST.__getitem__('vote')
# Get the gadget's id for those vendor, name and version
gadget = get_object_or_404(GadgetResource,
short_name=name,
vendor=vendor,
version=version)
# Insert the vote for these resource and user in the database
try:
UserVote.objects.create(vote=vote, idUser=user, idResource=gadget)
except Exception, ex:
log(ex, request)
return HttpResponseServerError(
get_xml_error(unicode(ex)),
mimetype='application/xml; charset=UTF-8')
try:
update_popularity(gadget)
except Exception, ex:
log(ex, request)
return HttpResponseServerError(
get_xml_error(unicode(ex)),
mimetype='application/xml; charset=UTF-8')
def create(self, request, user_name, vendor, name, version):
try:
format = request.POST.__getitem__('format')
except:
format = 'default'
user = user_authentication(request, user_name)
# Get the xml containing the tags from the request
tags_xml = request.POST.__getitem__('tags_xml')
tags_xml = tags_xml.encode("utf-8")
# Parse the xml containing the tags
parser = make_parser()
handler = TagsXMLHandler()
# Tell the parser to use our handler
parser.setContentHandler(handler)
# Parse the input
try:
from StringIO import StringIO
except ImportError:
from cStringIO import StringIO
inpsrc = InputSource()
inpsrc.setByteStream(StringIO(tags_xml))
parser.parse(inpsrc)
# Get the gadget's id for those vendor, name and version
gadget = get_object_or_404(GadgetResource,
short_name=name,
vendor=vendor,
version=version)
# Insert the tags for these resource and user in the database
for e in handler._tags:
try:
UserTag.objects.get_or_create(tag=e,
idUser=user,
idResource=gadget)
except Exception, ex:
log(ex, request)
return HttpResponseServerError(
get_xml_error(unicode(ex)),
mimetype='application/xml; charset=UTF-8')
def create(self, request, user_name, vendor, name, version):
format = request.GET.get('format', 'default')
user = user_authentication(request, user_name)
# Get the vote from the request
vote = request.POST.get('vote')
resource = get_object_or_404(CatalogueResource, short_name=name, vendor=vendor, version=version)
# Insert the vote for these resource and user in the database
try:
UserVote.objects.create(vote=vote, idUser=user, idResource=resource)
except Exception, ex:
log(ex, request)
return HttpResponseServerError(get_xml_error(unicode(ex)),
mimetype='application/xml; charset=UTF-8')
def __call__(self, request, *args, **kwargs):
try:
return self.dispatch(request, self, *args, **kwargs)
except HttpMethodNotAllowed:
response = HttpResponseNotAllowed(self.permitted_methods)
response.mimetype = self.mimetype
return response
except:
exc_info = sys.exc_info()
msg_array = traceback.format_exception(exc_info[0], exc_info[1], exc_info[2])
msg = ""
for line in msg_array:
msg += line
log(msg, request)
msg = "[" + unicode(exc_info[0]) + "] " + unicode(exc_info[1])
return HttpResponseServerError(get_xml_error(msg), mimetype='application/xml; charset=UTF-8')
def delete(self, request, workspace_id):
user = get_user_authentication(request)
workspaces = WorkSpace.objects.filter(users__id=user.id).exclude(pk=workspace_id)
if workspaces.count()==0:
msg = _("workspace cannot be deleted")
log(msg, request)
return HttpResponseServerError(get_xml_error(msg), mimetype='application/xml; charset=UTF-8')
# Gets Igadget, if it does not exist, a http 404 error is returned
workspace = get_object_or_404(WorkSpace, users__id=user.id, pk=workspace_id)
workspace.delete()
#set a new active workspace (first workspace by default)
activeWorkspace=workspaces[0]
setActiveWorkspace(user, activeWorkspace)
return HttpResponse('ok')
def create(self, request, user_name):
user = user_authentication(user_name)
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:
templateParser = TemplateParser(templateURL, user)
templateParser.parse()
transaction.commit()
except TemplateParseException, e:
log(e, 'POST', 'user/id/gadgets', user_name)
transaction.rollback()
return HttpResponseServerError("<error>%s</error>" % e, mimetype='application/xml; charset=UTF-8')
def read(self, request, workspace_id):
workspace = get_object_or_404(WorkSpace, id=workspace_id)
user = get_user_authentication(request)
#Checking if user is already linked to workspace
if (len(workspace.users.filter(id=user.id)) > 0):
msg = _("already linked workspace")
log(msg, request)
return HttpResponseServerError(
get_xml_error(msg), mimetype='application/xml; charset=UTF-8')
packageLinker = PackageLinker()
packageLinker.link_workspace(workspace, user)
return HttpResponse("{'result': 'ok'}",
mimetype='application/json; charset=UTF-8')
def delete(self, request, workspace_id):
user = get_user_authentication(request)
workspaces = WorkSpace.objects.filter(users__id=user.id).exclude(pk=workspace_id)
if workspaces.count()==0:
msg = _("workspace cannot be deleted")
log(msg, request)
return HttpResponseServerError(get_xml_error(msg), mimetype='application/xml; charset=UTF-8')
# Gets Igadget, if it does not exist, a http 404 error is returned
workspace = get_object_or_404(WorkSpace, users__id=user.id, pk=workspace_id)
workspace.delete()
#set a new active workspace (first workspace by default)
activeWorkspace=workspaces[0]
setActiveWorkspace(user, activeWorkspace)
return HttpResponse('ok')
def update(self, request, user_name):
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)
update_preferences(user, preferences_json)
return HttpResponse('ok')
except Exception, e:
transaction.rollback()
msg = _("Platform Preferences 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):
user = user_authentication(user_name)
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:
templateParser = TemplateParser(templateURL, user)
templateParser.parse()
transaction.commit()
except TemplateParseException, e:
log(e, 'POST', 'user/id/gadgets', user_name)
transaction.rollback()
return HttpResponseServerError(get_xml_error(unicode(e)), mimetype='application/xml; charset=UTF-8')
def create(self, request, workspace_id):
if not request.REQUEST.has_key('data'):
return HttpResponseBadRequest(get_xml_error(_("mashup data expected")), mimetype='application/xml; charset=UTF-8')
received_json = request.REQUEST['data']
try:
mashup = simplejson.loads(received_json)
if not mashup.has_key('name'):
raise Exception(_('Malformed mashup JSON: expecting mashup name.'))
if not mashup.has_key('vendor'):
raise Exception(_('Malformed mashup JSON: expecting mashup vendor.'))
if not mashup.has_key('version'):
raise Exception(_('Malformed mashup JSON: expecting mashup version.'))
except Exception, e:
transaction.rollback()
msg = _("mashup cannot be published: ") + 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):
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')
if t.has_key('locked'):
if t.get('locked') == 'true':
tab.locked = True
else:
tab.locked = False
tab.save()
return HttpResponse('ok')
except Exception, e:
transaction.rollback()
msg = _("tab cannot be updated: ") + 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, 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 update(self, request, user_name, igadget_id, var_name, screen_id=None):
user = user_authentication(request, user_name)
# Gets value parameter from request
if not request.PUT.has_key('value'):
return HttpResponseBadRequest(get_xml_error(_("iGadget JSON expected")), mimetype='application/xml; charset=UTF-8')
new_value = request.PUT['value']
#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_object_or_404(Variable, igadget__screen=screen, igadget__code=igadget_id, vardef__name=var_name)
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, 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 create(self,request, user_name, vendor, name, version):
try:
format = request.__getitem__('format')
except:
format = 'default'
user = user_authentication(request, user_name)
# Get the vote from the request
vote = request.__getitem__('vote')
# Get the gadget's id for those vendor, name and version
gadget = get_object_or_404(GadgetResource, short_name=name,vendor=vendor,version=version)
# Insert the vote for these resource and user in the database
try:
UserVote.objects.create(vote=vote, idUser=user, idResource=gadget)
except Exception, ex:
log (ex, request)
return HttpResponseServerError(get_xml_error(unicode(ex)), mimetype='application/xml; charset=UTF-8')
def delete(self, request, workspace_id, tab_id):
user = get_user_authentication(request)
tabs = Tab.objects.filter(workspace__pk=workspace_id).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')
# Gets Igadget, if it does not exist, a http 404 error is returned
tab = get_object_or_404(Tab, workspace__pk=workspace_id, pk=tab_id)
#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 delete(self, request, workspace_id, tab_id):
user = get_user_authentication(request)
tabs = Tab.objects.filter(workspace__pk=workspace_id).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')
# Gets Igadget, if it does not exist, a http 404 error is returned
tab = get_object_or_404(Tab, workspace__pk=workspace_id, pk=tab_id)
#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')
