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