Beispiel #1
0
def item_service(request, item_id=None):
    if request.method == 'GET':
        if item_id is not None:
            try:
                obj = ItemDefinition.objects.get(id=item_id)
                if obj is not None:
                    data = json.dumps(obj.asDict(), sort_keys=True, indent=4, separators=(',', ': '))
                    return HttpResponse(data, content_type='application/json')
            except:
                return HttpResponse("Object could not be found", status=404)
        else:
            get_params = request.GET
            simple_query_items = dict()
            complex_query_items = []

            if 'name' in get_params:
                simple_query_items['name__istartswith'] = get_params['name']

            items = ItemDefinition.objects.filter(*complex_query_items, **simple_query_items)

            tagResult = None

            # @TODO This logic should be achievable using a single query
            if 'tags' in get_params:
                tags = get_params['tags'].split(",")
                tagResult = Tag.objects.filter(value__in=tags, owner__in=items)

            filtered_items = []

            if tagResult != None and 'tags' in get_params:
                for tag in tagResult:
                    for item in items.all():
                        if tag.owner.id == item.id and item not in filtered_items:
                            filtered_items.append(item)
            else:
                filtered_items = items.all()

            paginator = Paginator(filtered_items, 3)

            if 'page' in request.GET:
                filtered_items = paginator.page(request.GET['page']).object_list

            if len(filtered_items) > 0:
                cj = []
                for c in filtered_items:
                    cj.append(c.asDict())
                data = json.dumps(cj, sort_keys=True, indent=4, separators=(',', ': '))
                return HttpResponse(data, content_type='application/json')
            else:
                return HttpResponse("No objects found for query", status=404)
    elif request.method == 'POST':
        try:
            in_data = json.loads(request.body)
            item_form = ItemForm(data=in_data)
            if item_form.is_valid():
                if item_id is None:
                    same_name_obj_count = ItemDefinition.objects.filter(name=item_form.cleaned_data["name"]).count()
                
                    if(same_name_obj_count != 0):
                        return HttpResponse("Item with name " + item_form.cleaned_data["name"] + " already exists", status=400)
                    
                    item = ItemDefinition()
                else:
                    try:
                        item = ItemDefinition.objects.get(id=long(item_id))
                    except:
                        return HttpResponse('Item for id ' + item_id + ' could not be found', status=404)
                item.name = item_form.cleaned_data["name"]
                item.description = item_form.cleaned_data["description"]
                item.random = item_form.cleaned_data["random"]
                item.save()

                tags = item.getTags()

                ex_tag_vals = []

                for tag in tags:
                    ex_tag_vals.append(tag.value)

                for t in item_form.cleaned_data["tags"]:
                    if t not in ex_tag_vals:
                        tag = Tag(value=t)
                        tag.owner = item
                        tag.save()

                return HttpResponse('{"status":"created", "id":' + str(item.id) + '}', content_type='application/json')
            else:
                return HttpResponse("Invalid request data - " + item_form.errors.as_json(), status=400)
        except:
            return HttpResponse("Bad post data - " + request.body, status=400)
    elif request.method == 'DELETE':
        if item_id is not None:
            item = ItemDefinition.objects.get(id=item_id)
            gitlab_utility.delete_file(item.texture.imageUrl, PDUser.branch_for_user(user=request.user))
            tex = Texture.objects.get(id=item.texture.id)
            item.delete()
            tex.delete()
            dump_item_textures(request)
            return HttpResponse('Success')
        else:
            return HttpResponse('Item id required', status=400)
    else:
        return HttpResponse("Invalid Method", status=405)
Beispiel #2
0
def component_set_service(request, component_set_id=None):
    if request.method == 'GET':
        try:
            if component_set_id is not None:
                obj = ComponentSet.objects.get(id=component_set_id)
                if obj is not None:
                    data = json.dumps(obj.asDict(), sort_keys=True, indent=4, separators=(',', ': '))
                    return HttpResponse(data, content_type='application/json')
            else:
                get_params = request.GET
                simple_query_items = dict()
                complex_query_items = []

                if 'setType' in get_params:
                    simple_query_items['setType__istartswith'] = get_params['setType']

                if 'name' in get_params:
                    simple_query_items['name__istartswith'] = get_params['name']

                sets = ComponentSet.objects.filter(*complex_query_items, **simple_query_items)

                tagResult = None

                # @TODO This logic should be achievable using a single query
                if 'tags' in get_params:
                    tags = get_params['tags'].split(",")
                    tagResult = Tag.objects.filter(value__in=tags, owner__in=sets)

                filteredSets = []

                if tagResult != None and 'tags' in get_params:
                    for tag in tagResult:
                        for set in sets.all():
                            if tag.owner.id == set.id and set not in filteredSets:
                                filteredSets.append(set)
                else:
                    filteredSets = sets.all()

                paginator = Paginator(filteredSets, 10)

                if 'page' in request.GET:
                    filteredSets = paginator.page(request.GET['page']).object_list

                if len(filteredSets) > 0:
                    cj = []
                    for c in filteredSets:
                        cj.append(c.asDict())
                    data = json.dumps(cj, sort_keys=True, indent=4, separators=(',', ': '))
                    return HttpResponse(data, content_type='application/json')
                else:
                    return HttpResponse("No objects found for query", status=404)
        except:
            return HttpResponse("Object could not be found", status=404)

    elif request.method == 'POST':
        try:
            in_data = json.loads(request.body)
            comp_set_form = ComponentSetForm(data=in_data)
            if comp_set_form.is_valid():
                
                if component_set_id is None:
                    same_name_obj_count = ComponentSet.objects.filter(name=comp_set_form.cleaned_data["name"], setType=comp_set_form.cleaned_data["setType"]).count()
                
                    if(same_name_obj_count != 0):
                        return HttpResponse("Component set with name " + comp_set_form.cleaned_data["name"] + " already exists", status=400)
                    
                    comp_set = ComponentSet()
                else:
                    try:
                        comp_set = ComponentSet.objects.get(id=long(component_set_id))
                    except:
                        return HttpResponse("Could not find component set for id " + str(component_set_id), status=404)

                comp_set.name = comp_set_form.cleaned_data["name"].replace(" ", "_")

                comp_set.description = comp_set_form.cleaned_data["description"]
                comp_set.random = comp_set_form.cleaned_data["random"]

                if component_set_id is None:
                    comp_set.setType = comp_set_form.cleaned_data["setType"]

                    joints_file_name = "components/definitions/" + comp_set_form.cleaned_data["name"].replace(" ", "_") + "_" + comp_set_form.cleaned_data["setType"] + ".json"

                    json_obj = json.loads(comp_set_form.cleaned_data["joints"])

                    gitlab_utility.create_file(gitlab_utility.get_project_name(),
                                               PDUser.branch_for_user(user=request.user),
                                               joints_file_name,
                                               json.dumps(json_obj, sort_keys=True, indent=4, separators=(',', ': ')),
                                               "text")

                    comp_set.jsonRepresentation = joints_file_name

                comp_set.save()

                tags = comp_set.getTags()

                ex_tag_vals = []

                for tag in tags:
                    ex_tag_vals.append(tag.value)

                for t in comp_set_form.cleaned_data["tags"]:
                    if t not in ex_tag_vals:
                        tag = Tag(value=t)
                        tag.owner = comp_set
                        tag.save()

                dump_component_definitions(request)

                return HttpResponse('{"status":"created", "id":' + str(comp_set.id) + '}',
                                    content_type='application/json')
            else:
                return HttpResponse("Invalid request data - " + comp_set_form.errors.as_json(), status=400)
        except:
            return HttpResponse("Bad post data - " + request.body, status=400)
    elif request.method == 'DELETE':
        if component_set_id is not None:
            set = ComponentSet.objects.get(id=component_set_id)
            components = set.get_components()

            branch = PDUser.branch_for_user(user=request.user)

            for comp in components:
                url = comp.texture.imageUrl
                gitlab_utility.delete_file(url, branch)
                comp.texture.delete()
                comp.delete()

            gitlab_utility.delete_file(set.jsonRepresentation, branch)
            set.delete()
            dump_component_definitions(request)
            dump_component_textures(request)
            return HttpResponse('Success')
    else:
        return HttpResponse("Invalid Method", status=405)