def saveTag(name):
try:
tag = Tag.objects.get(name=name)
except Tag.DoesNotExist:
tag = Tag(name=name)
tag.save()
return tag
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 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_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 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 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 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
# tag create
from api.models import Tag
tag_list = [
'수업', '입학', '등록/복학/휴학/재입학', '졸업', '학사 (학부)', '학사 (대학원)', '제2전공/전과',
'교환학생/유학', '장학', '학부 지도교수', '박사학위예비심사', '자료실', '외부 행사/프로그램',
'인턴/취업 (공식 게시)', '기업게시판', '전문연구요원', '미분류'
]
for i in tag_list:
tag = Tag(name=i)
tag.save()
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 addCategoryTag(name, tags):
for tagStr in tags:
tag = Tag(name=tagStr)
tag.save()
categoryTag = CategoryTag(id_tag=tag, name=name)
categoryTag.save()
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 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 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))
