def create(request: HttpRequest, course_id: int) -> HttpResponse:
"""Create a new tag."""
course = Course.objects.get(id=course_id)
payload = loads(request.body)
new_tag = Tag(name=payload["name"], course=course)
new_tag.save()
return HttpResponse(dumps(TagService.tag_to_dict(new_tag)))
def search_wikidata(request, limit=15):
"""
Returns wikidata search results for the specified name in the requests GET field.
"""
searched_name = urllib.quote_plus(request.GET["term"])
url = "http://www.wikidata.org//w/api.php?action=wbsearchentities&format=json&search=" + searched_name + "&language=en&type=item&limit=" + str(
limit)
response = urllib.urlopen(url)
data = json.loads(response.read())["search"]
response = []
for tag_data in data:
try:
tag = Tag.objects.get(concepturi=tag_data["concepturi"])
tag.label = tag_data["label"]
tag.url = tag_data["url"]
tag.description = tag_data[
"description"] if "description" in tag_data else None
except:
tag = Tag(label=tag_data["label"],
url=tag_data["url"],
description=tag_data["description"]
if "description" in tag_data else None,
concepturi=tag_data["concepturi"])
tag.save()
response.append(model_to_dict(tag))
return JsonResponse({"results": response})
def saveTag(name):
try:
tag = Tag.objects.get(name=name)
except Tag.DoesNotExist:
tag = Tag(name=name)
tag.save()
return tag
def test_tags(self):
category = Category(name="Test category")
db.session.add(category)
media = Media(path="/foo/bar",
mediainfo={"width": 100,
"height": 100,
"acodec": "aac",
"vcodec": "h.265"},
category=category,
mimetype="video",
lastModified=int(time.time()),
timeLastIndexed=int(time.time()),
sha=b'\x00'*32)
db.session.add(media)
db.session.commit()
tag1 = Tag(name="tag1")
tag2 = Tag(name="tag2")
db.session.add(tag1)
db.session.add(tag2)
media.tags.append(tag1)
media.tags.append(tag2)
medias = Media.query.all()
assert media in medias
assert medias[0].tags == [tag1, tag2]
def create_tag(user_id: int, tag_name: str, tag_desc: str = None) -> Dict:
try:
tag = Tag.objects.get(name=tag_name, author_id=user_id)
return f"Tag with name [{tag.name}] and author [{tag.author_id}] already exists"
except Tag.DoesNotExist:
tag = Tag(name=tag_name, description=tag_desc, author_id=user_id)
tag.save()
return {"tag_id": tag.id, "created_at": tag.created_at}
def load_tag(path, delete_all=False):
if delete_all:
Tag.objects.all().delete()
with open(path) as csvfile:
reader = csv.DictReader(csvfile)
for row in reader:
tag = Tag(tag=row['tag'])
tag.save()
def test_save_duplicate_fails(self):
Tag.objects.create(name='programmer')
t2 = Tag(name='programmer')
with self.assertRaises(ValidationError) as context:
t2.full_clean()
self.assertTrue(
'Tag with this Name already exists.' in str(context.exception))
self.assertEqual(Tag.objects.count(), 1)
def __map_tags_to_tags_bo(self, tags):
tags_bo = []
if tags is not None and len(tags) > 0:
for tagModel in tags:
tag = Tag()
tag.label = tagModel
tags_bo.append(tag)
return tags_bo
def test_context_in_tags(self):
context = Tag(name='test_context', user=self.user)
context.save()
fact = Fact(value='test_value', user=self.user)
fact.save()
self.assertNotIn(context, list(fact.tags.all()))
self.assertIsNone(fact.context)
fact.context = context
fact.save()
self.assertIn(context, list(fact.tags.all()))
self.assertEqual(fact.context, context)
def get_tag(self, tag):
"""
return the tag object given a tag name - if it does not exist then create it
:param name: tag name
:return: Tag object
"""
try:
return Tag.objects.get(name=tag['name'])
except ObjectDoesNotExist:
tag = Tag(name=tag['name'])
tag.save()
return tag
def test_cross_user_tag(self):
tag = Tag(name='t2', user=self.user2)
tag.save()
request = HttpRequest()
request.user = self.user
serializer = AliasSerializer(data={
'name': 't1',
'tag': tag.pk
},
context={'request': request})
self.assertFalse(serializer.is_valid())
self.assertEqual(serializer.errors.keys(), {'tag'})
self.assertEqual(len(serializer.errors['tag']), 1)
self.assertIn("forbidden", serializer.errors['tag'][0])
def add_tags_to_post(user_id: int, role: int, post_author: int,
tag_names: List[str], post_id: str) -> List:
if role < 20:
if user_id != post_author:
return f"User does not own post with id [{post_id}]"
responses = []
for tag_name in tag_names:
try:
tag = Tag.objects.get(name=tag_name, author_id=user_id)
except Tag.DoesNotExist:
tag = Tag(name=tag_name, author_id=user_id)
tag.save()
responses.append(
add_tag_to_post(user_id, role, post_author, tag.id, post_id))
return responses
def test_str(self):
alias = "test_alias"
name = "test_name"
tag_alias = Alias(name=alias,
tag=Tag(name=name, user=self.user),
user=self.user)
self.assertIn(alias, str(tag_alias))
self.assertIn(name, str(tag_alias))
def process_tag(request):
"""
Use this method for operations with tags.
POST: adds tag, GET: returns list of available tags
"""
if request.method == 'POST':
if request.user.is_staff:
tag_information = decode_json(request)
tag = Tag(**tag_information)
tag.save()
return JsonResponse({'status': 'Ok'})
return JsonResponse(generate_response('10'))
if request.method == 'GET':
query = Tag.objects.all()
raw_data = json.loads(serialize('json', query, fields=['name']))
tags_information = {**raw_data['fields'], 'id': raw_data['pk']}
return JsonResponse(tags_information)
def post(self):
name = request.json.get('name')
schema = TagSchema()
if name is not None:
res = schema.dump(Tag.query.filter_by(name=name).first())
if res.data is None or len(res.data) == 0:
db.session.add(Tag(name=name,add_at=datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')))
db.session.commit()
return success()
def _insert_tags_from_path(path: str):
"""Inserts tags from dataset into database
Args:
path: path to the dataset directory
"""
tags_to_create = []
df = pd.read_csv(path / "tags.csv")[["movieId", "tag"]]
for row in df.itertuples(index=False):
tags_to_create.append(Tag(movie_id=row[0], tag=row[1]))
Tag.objects.bulk_create(tags_to_create)
def insert_tags(target, connection, **kwargs):
# Creating list of dictionaries (tags)
tags = [
"Chocolate", "Caramel", "Lactose free", "Coconut", "Peanut", "Sour",
"Nougat"
]
# Adding items to Item table
for tag in tags:
db.session.add(Tag(tag))
db.session.commit()
def save(self, commit=True):
old_tags = [tag for tag in self.obj.tags]
old_tags_texts = [t.text for t in self.obj.tags]
model = super(ModelEditForm, self).save()
tags = self.cleaned_data.get('tags', None)
if tags:
for tag_text in tags:
if tag_text not in old_tags_texts:
t = Tag.query.filter_by(text=tag_text).all()
if len(t):
new_tag = t[0]
else:
new_tag = Tag()
new_tag.text = tag_text
new_tag.save()
old_tags.append(new_tag)
model.tags = [tag for tag in old_tags if tag.text in tags]
model.save()
for tag in old_tags:
tag.update_counter()
features = self.cleaned_data.get('features', None)
if features:
try:
Feature.query.filter_by(
feature_set_id=model.features_set_id).delete()
model.classifier = features['classifier'] or {}
model.features_set.from_dict(features, commit=False)
except Exception as e:
db.session.rollback()
raise DBException(
"Error occurred while updating features: "
"{0}".format(e), e)
else:
db.session.commit()
return model
def test_str(self):
key = "test_key"
value = "test_value"
context = Tag(name='test_name', user=self.user)
fact = Fact(value=value, user=self.user)
self.assertIn(value, str(fact))
fact.context = context
self.assertIn(value, str(fact))
self.assertIn(str(context), str(fact))
fact.key = key
self.assertIn(value, str(fact))
self.assertIn(str(context), str(fact))
self.assertIn(key, str(fact))
fact.context = None
self.assertIn(value, str(fact))
self.assertIn(key, str(fact))
def make_instances(self, validated_data):
user = self.context['user']
dirty_tags_vd = validated_data.pop('tags', [])
# use only tags which are unique
tags = []
for tag_name in dirty_tags_vd:
tag = Tag.objects.filter(
Q(name=tag_name.upper()) or
Q(name=tag_name.lower()) or
Q(name=tag_name)
).first()
if tag is None:
tag = Tag(name=tag_name)
tags.append(tag)
default_image = validated_data.pop('default_image', None)
images = validated_data.pop('images', None)
validated_data['default_image'] = default_image
validated_data['created_by_id'] = user.id
if images is None:
images = []
post = self.Meta.model(**validated_data)
return user, post, images, tags
def add_sessions_speakers_and_tags():
first_tag = Tag(pk=uuid.uuid4(), description="javascript")
last_tag = Tag(pk=uuid.uuid4(), description="python")
first_tag.save()
last_tag.save()
first_session = Session(pk=uuid.uuid4(), name="first")
last_session = Session(pk=uuid.uuid4(), name="last")
first_session.save()
last_session.save()
first_session.tags.add(first_tag)
last_session.tags.add(last_tag)
first_session.save()
last_session.save()
first_speaker = Speaker(pk=uuid.uuid4(), name="foo", session=first_session)
last_speaker = Speaker(pk=uuid.uuid4(), name="bar", session=last_session)
first_speaker.save()
last_speaker.save()
return first_session, last_session, first_speaker, last_speaker, first_tag, last_tag
def handle(self, *args, **options):
# Remove all migrations and database file
path_migrations = "api/migrations"
for file in os.listdir(path_migrations):
if file != "__init__.py":
try:
os.remove(os.path.join(path_migrations, file))
except IsADirectoryError:
shutil.rmtree(os.path.join(path_migrations, file))
path_db = "db.sqlite3"
try:
os.remove(path_db)
except FileNotFoundError:
pass
# Recreate all tables
os.system("./manage.py makemigrations")
os.system("./manage.py migrate")
# Create superuser
superuser_command = (
"""from django.contrib.auth.models import User;""" +
"""User.objects.create_superuser('kmb', '*****@*****.**', 'test')""")
os.system(f'./manage.py shell -c "{superuser_command}"')
# Create users
u1 = User.objects.create_user("test",
"*****@*****.**",
password="******",
first_name="Test",
last_name="Smith")
u1.profile.date_of_birth = datetime.date(1990, 1, 10)
u1.profile.country = "Poland"
u1.profile.city = "Warsaw"
u1.profile.gender = "m"
u1.profile.save()
u2 = User.objects.create_user("test2",
"*****@*****.**",
password="******",
first_name="Diana",
last_name="Davis")
u2.profile.city = "New York"
u2.profile.gender = "f"
u2.profile.save()
# Create tags
tagnames = (
"easy",
"medium",
"hard",
"core",
"legs",
"arms",
"strength",
"mobility",
"endurance",
"popular",
)
for tagname in tagnames:
Tag(name=tagname).save()
# Create youtube videos
CHARSET = string.ascii_letters + string.digits
for i in range(100):
video_code = "".join(random.choices(CHARSET, k=7))
YoutubeLink(
url=f"https://www.youtube.com/watch?v={video_code}").save()
# Create muscles
for muscle_abbrev, muscle_name in Muscle.MUSCLES:
Muscle(name=muscle_abbrev).save()
# Create exercises for user with pk: 2
user = User.objects.get(pk=2)
for exercise_dict in EXERCISES_USER_1:
create_exercise(**exercise_dict, owner=user)
# Create routines for user with pk: 2
r = Routine.objects.create(
name="Leg workout A",
kind="sta",
instructions="This is the first leg workout.",
owner=user,
)
leg_exercises = Exercise.objects.filter(name__in=[
"bulgarian split squat",
"romanian single leg deadlift",
"pistol squat",
"lunges",
"box jumps",
])
r.exercises.set(leg_exercises, through_defaults={"sets": 3})
r = Routine.objects.create(
name="Leg workout B",
instructions="My favourite leg workout.",
kind="cir",
owner=user,
)
leg_exercises = Exercise.objects.filter(name__in=("bridge",
"hip thrust",
"step ups",
"jogging"))
instructions = [lorem.words(n) for n in (5, 10, 20, 40)]
for exercise, instruction in zip(leg_exercises, instructions):
r.exercises.add(exercise,
through_defaults={
"sets": 4,
"instructions": instruction
})
Routine.objects.create(name="Push A",
kind="sta",
owner=user,
forks_count=11)
Routine.objects.create(name="Push B", kind="sta", owner=user)
Routine.objects.create(name="Push C", kind="sta", owner=user)
Routine.objects.create(name="Push D", kind="sta", owner=user)
Routine.objects.create(name="Pull A",
kind="sta",
owner=user,
forks_count=3)
Routine.objects.create(name="Pull B",
kind="sta",
owner=user,
forks_count=2)
Routine.objects.create(name="Pull C", kind="sta", owner=user)
Routine.objects.create(name="Pull D", kind="sta", owner=user)
Routine.objects.create(name="FBW A",
kind="sta",
owner=user,
forks_count=1)
Routine.objects.create(name="FBW B", kind="sta", owner=user)
Routine.objects.create(name="FBW C", kind="sta", owner=user)
Routine.objects.create(name="FBW D", kind="sta", owner=user)
for i in range(30):
Routine.objects.create(name=f"Routine {i}", kind="sta", owner=user)
# Create exercises for user with pk: 3
user = User.objects.get(pk=3)
Exercise(name="bench press", kind="rew", owner=user).save()
Exercise(name="planche", kind="tim", owner=user).save()
Exercise(name="diamond push ups", kind="rep", owner=user).save()
Exercise(name="pike push ups", kind="rep", owner=user).save()
Exercise(name="archer push ups", kind="rep", owner=user).save()
Exercise(name="sphinx push ups", kind="rep", owner=user).save()
Exercise(name="hindu push ups", kind="rep", owner=user).save()
Exercise(name="one arm push ups", kind="rep", owner=user).save()
Exercise(name="push ups", kind="rep", owner=user).save()
Exercise(name="pull ups", kind="rep", owner=user).save()
ex = Exercise(
name="plank",
kind="tim",
instructions="Arms should be straight.",
owner=user,
)
ex.save()
ex.tutorials.set(
[YoutubeLink.objects.all()[60],
YoutubeLink.objects.all()[61]])
ex.muscles.set([Muscle.objects.get(name="abs")])
# Create routines for user with pk:
Routine.objects.create(name="Chest, triceps and shoulders",
kind="sta",
owner=user)
Routine.objects.create(name="Arms", kind="cir", owner=user)
Routine.objects.create(name="Upper body (bodyweight)",
kind="sta",
owner=user)
Routine.objects.create(name="Upper body (weights)",
kind="sta",
owner=user)
Routine.objects.create(name="Powerlifting",
kind="sta",
owner=user,
forks_count=3)
Routine.objects.create(name="Begginers",
kind="sta",
owner=user,
forks_count=2)
Routine.objects.create(name="Advanced abs", kind="sta", owner=user)
Routine.objects.create(name="Quads, hamstrings",
kind="sta",
owner=user)
Routine.objects.create(name="Endurance",
kind="sta",
owner=user,
forks_count=1)
Routine.objects.create(name="Full body", kind="cir", owner=user)
Routine.objects.create(name="Strenght", kind="sta", owner=user)
Routine.objects.create(name="Hypertrophy", kind="sta", owner=user)
# tag create
from api.models import Tag
tag_list = [
'수업', '입학', '등록/복학/휴학/재입학', '졸업', '학사 (학부)', '학사 (대학원)', '제2전공/전과',
'교환학생/유학', '장학', '학부 지도교수', '박사학위예비심사', '자료실', '외부 행사/프로그램',
'인턴/취업 (공식 게시)', '기업게시판', '전문연구요원', '미분류'
]
for i in tag_list:
tag = Tag(name=i)
tag.save()
def addCategoryTag(name, tags):
for tagStr in tags:
tag = Tag(name=tagStr)
tag.save()
categoryTag = CategoryTag(id_tag=tag, name=name)
categoryTag.save()
def list(self, request):
site_name = request.GET.get('community')
tags = Tag(site_name)
return Response(tags.get_all())
api_id="building-1",
image_url="http://image.example.com/1",
latitude=-84.3891,
longitude=33.7771,
name="Test Building 1",
phone_num="(555) 111-1111",
# TODO: The DB data seems to have an unneeded, additional set of outer brackets? What is this format?
shape_coordinates=
"[[[33.777056, -84.3889078], [33.7773726, -84.3889054], [33.7777347, -84.3888919]9438]]]",
website_url="http://web.example.com/1",
zipcode="30308",
tags=[
Tag(tag_id=1,
b_id='1',
tag_name='tag1',
gtuser='******',
auth=0,
times_tag=1,
times_flagged=0,
flag_users=None),
],
categories=[
Category(b_id='1', cat_name='Housing'),
Category(b_id='1', cat_name='Greek')
])
building2 = Building(
address="2 Example Blvd",
city="Atlanta, GA, USA",
b_id="2",
# TODO: 'api_id' is in the DB but missing from JSON- should it be included?
api_id="building-2",
image_url="http://image.example.com/2",
def test_str(self):
name = "test_name"
tag = Tag(name=name, user=self.user)
self.assertIn(name, str(tag))
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)
def setup():
"""
Function that creates and saves elements to the database for demo purposes.
Function assumes that the database starts out empty.
For LOCAL DEV ONLY.
"""
passwords = []
# create example users
passwords.append(UserService.generate_password())
user1 = User.objects.create_user(
"*****@*****.**",
password=passwords[0],
email="*****@*****.**",
first_name="Josiah",
last_name="Carberry",
)
user1.save()
passwords.append(UserService.generate_password())
user2 = User.objects.create_user(
"*****@*****.**",
password=passwords[1],
email="*****@*****.**",
first_name="Blueno",
)
user2.save()
passwords.append(UserService.generate_password())
user3 = User.objects.create_user(
"*****@*****.**",
password=passwords[2],
email="*****@*****.**",
first_name="Random",
last_name="Person",
)
user3.save()
# create course
course1 = Course(name="Course 1")
course1.save()
course1.instructors.add(user1)
course1.students.add(user2)
course1.students.add(user3)
course1.save()
# create posts
post1 = Post(
author=user1,
course=course1,
title="I have a question",
content="idk what im doing",
anonymous=True,
type=Post.Type.QUESTION,
visibility=Post.Visibility.PUBLIC,
)
post1.save()
post2 = Post(
author=user1,
course=course1,
title="I also have a question",
content="i really dont know what im doing",
anonymous=False,
type=Post.Type.NOTE,
visibility=Post.Visibility.PRIVATE,
)
post2.save()
post3 = Post(
author=user3,
course=course1,
title="My code is broken",
content="Hi you can see my name, Student answers welcomed!!",
anonymous=False,
type=Post.Type.NOTE,
visibility=Post.Visibility.PUBLIC,
)
post3.save()
post4 = Post(
author=user2,
course=course1,
title="Could a TA help",
content="Only TAs should be able to see this",
anonymous=False,
type=Post.Type.NOTE,
visibility=Post.Visibility.PRIVATE,
)
post4.save()
post5 = Post(
author=user1,
course=course1,
title="TA Note about posting",
content="Hours Changed from 11 to 2",
anonymous=True,
type=Post.Type.NOTE,
visibility=Post.Visibility.PUBLIC,
)
post5.save()
post6 = Post(
author=user1,
course=course1,
title="Question to Students",
content="TA asking for student replies ",
anonymous=True,
type=Post.Type.QUESTION,
visibility=Post.Visibility.PUBLIC,
)
post6.save()
# create tags
tag1 = Tag(name="Tag 1", course=course1)
tag1.save()
tag2 = Tag(name="Tag 2", course=course1)
tag2.save()
post1.tags.add(tag1, tag2)
post2.tags.add(tag2)
post4.tags.add(tag1)
post6.tags.add(tag1, tag2)
print("setup successful!")
print("user passwords in order: " + str(passwords))
def create_tags(tags=None):
if tags is None:
tags = Helpers.tags
Tag.objects.bulk_create([Tag(**tag) for tag in tags])
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)
def get(self, request):
profile = UserProfile.get(request)
tags = Tag.search(profile=profile, **request.GET)
serializer = TagSerializer(tags, many=True)
return Response(serializer.data)
def setUp(self):
User.objects.create_superuser("jblouse", "*****@*****.**", "password")
user = User.objects.get(username="******")
profile = Profile()
profile.user = user
profile.save()
tag = Tag()
tag.name = "TEST TAG"
tag.save()
tag2 = Tag()
tag2.name = "TEST TAG2"
tag2.save()
self.client.force_authenticate(user=user)
self.user = user
profile_fk_url = "/profiles/{0}/".format(self.user.profile.id)
tag_fk_url = "/tags/{0}/".format(tag.id)
tag2_fk_url = "/tags/{0}/".format(tag2.id)
self.email_url = reverse("email-list")
self.email_data = {"user": self.user.pk, "email_address": "*****@*****.**", "email_profile": profile_fk_url}
self.tag_url = reverse("tag-list")
self.tag_data = {"user": self.user.pk, "name": "code-tag"}
self.project_url = reverse("project-list")
self.project_data = {"description": "test description", "tag": tag_fk_url, "project_profile": profile_fk_url}
self.certification_url = reverse("certification-list")
self.cert_data = {"name": "certified", "date_earned": "2014-05-01", "certification_profile": profile_fk_url}
self.address_url = reverse("address-list")
self.address_data = {
"name": "address",
"street": "123 street",
"line_2": "Suite 1",
"city": "Austin",
"state": "TX",
"zip_code": "78686",
"address_profile": profile_fk_url,
}
self.address_short_data = {
"name": "address",
"city": "Austin",
"state": "TX",
"address_profile": profile_fk_url,
}
self.profile_url = "/profiles/"
self.profile_small_data = {
"username": "******",
"password": "******",
"home_phone": "123-456-7890",
"email": "*****@*****.**",
"skill_list": [{"name": "test skill"}, {"name": "skill 2"}],
}
self.company_url = reverse("employment-list")
self.company_data = {"company": "Corpseware", "tag": tag2_fk_url, "employment_profile": profile_fk_url}
self.school_url = reverse("education-list")
self.school_data = {"school": "Corpseware", "education_profile": profile_fk_url}
self.headline_url = reverse("headline-list")
self.headline_data = {"description": "Experienced python developer.", "headline_profile": profile_fk_url}
self.hobby_url = reverse("hobby-list")
self.hobby_data = {"description": "Karate", "hobby_profile": profile_fk_url}
self.reference_url = reverse("reference-list")
self.reference_data = {"name": "James Smith", "reference_profile": profile_fk_url}
self.skill_url = reverse("skill-list")
self.skill_data = {"name": "python", "level": 9, "years_experience": 7, "skill_profile": profile_fk_url}
self.skill_small_data = {"name": "ruby", "skill_profile": profile_fk_url}
def _init_tag(self):
Tag.objects.all().delete()
Tag.objects.bulk_create(Tag(name=t) for t in tags)
def retrieve(self, request, pk=None):
site_name = request.GET.get('community')
tags = Tag(site_name)
return Response(tags.get_by_name(pk))
