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))