def update(item_id):
try:
name = request.json['name']
loc = request.json['location']
category = request.json['category']
desc = request.json['description']
new_item = Item(name, loc, category, desc)
item = db.session.query(Item).filter(Item.id == item_id).one()
new_item.update_item(item)
db.session.commit()
db.session.close()
resp = jsonify({"Action": 'Item Updated Successfully'})
resp.status_code = 200
return resp
except KeyError as k:
resp = jsonify({"error": k.args[0] + ' Value is missing'})
# Status Code 400 is used when the request made by the client is not understandable by the server
resp.status_code = 400
return resp
except SQLAlchemyError:
resp = jsonify({"error": 'something went wrong'})
resp.status_code = 500
return resp
def load_levels():
for level in LEVELS:
new_level = DungeonLevel(
level_id=level['id'],
level_name=level['name'],
level_desc=level['desc'],
max_room_size=level['max_room_size'],
min_room_size=level['min_room_size'],
max_rooms=level['max_rooms'],
is_final_level=level['is_final_level']
)
new_level.save()
# load any items for the level
for item in level['items']:
new_item = Item(
level_id=level['id'],
name=item['name'],
description=item['desc'],
ascii_char=item['ascii_char'],
inventory_list=item['inventory_list'],
category=item['category'],
stat_mod=item['stat_mod'],
operation=item['op'],
value=item['value'],
fgcolor=json.dumps(item['fgcolor']),
bgcolor=json.dumps(item['bgcolor'])
)
new_item.save()
load_monsters(level)
def add_item(target):
user = User.objects.get(u_id=target.user_id)
host = Host.objects.get(user=user)
items = Item.objects.filter(i_id=target.id)
for i in items:
i.delete()
if re.search('house', target.type):
i_type = Item.House
elif re.search('apartment', target.type):
i_type = Item.Apartment
else:
i_type = Item.Flat
item = Item(
i_id=target.id,
owner=host,
i_type=i_type,
title=target.title,
album_first='static/album/{}/{}/0.jpg'.format(target.user_id,
target.id),
album=albums(target.user_id, target.id),
desc='desc test test',
address=target.address,
longitude=target.longitude,
latitude=target.latitude,
avaliable=avai_date(),
price_per_day=target.price,
guest_num=target.guest_num,
bedroom_num=target.bedroom_num,
bed_num=target.bed_num,
bathroom_num=target.bathroom_num)
item.save()
def create():
try:
name = request.json['name']
loc = request.json['location']
category = request.json['category']
desc = request.json['description']
item = Item(name, loc, category, desc)
db.session.add(item)
db.session.commit()
db.session.close()
resp = jsonify({"Action": 'Item Added Successfully'})
resp.status_code = 201
return resp
except KeyError as k:
resp = jsonify({"error": k.args[0] + ' Value is missing'})
# Status Code 400 is used when the request made by the client is not understandable by the server
resp.status_code = 400
return resp
except SQLAlchemyError as e:
resp = jsonify({"error": 'Something went wrong'})
resp.status_code = 500
return resp
def AddItem():
form=ProductForm()
name=request.form.get('name')
description=request.form.get('description')
new_item=Item(name=name,description=description)
db.session.add(new_item)
db.session.commit()
return redirect('/')
def addMedia(request):
'''
takes {
id: oshash
filename: string,
item: string
info: {}
}
returns {
item: id,
}
'''
response = json_response({})
data = json.loads(request.POST['data'])
oshash = data.pop('id')
if not request.user.get_profile().capability('canAddItems'):
response = json_response(status=403, text='permissino denied')
elif models.File.objects.filter(oshash=oshash).count() > 0:
f = models.File.objects.get(oshash=oshash)
if f.available:
response['status']['text'] = 'file exists'
response['data']['item'] = f.item.itemId
response['data']['itemUrl'] = request.build_absolute_uri('/%s' %
f.item.itemId)
else:
if 'item' in data:
i = Item.objects.get(itemId=data['item'])
else:
title = ox.parse_movie_path(os.path.splitext(
data['filename'])[0])['title']
i = Item()
i.data = {
'title': title,
'director': data.get('director', []),
}
i.user = request.user
i.save()
i.make_poster(True)
f = models.File(oshash=oshash, item=i)
f.path = data.get('filename', 'Untitled')
extension = f.path.split('.')
if len(extension) > 1:
extension = extension[-1]
else:
#wafaa
#extension = 'webm'
extension = 'png'
f.selected = True
if 'info' in data and data['info']:
f.info = data['info']
f.info['extension'] = extension
f.parse_info()
f.save()
response['data']['item'] = i.itemId
response['data']['itemUrl'] = request.build_absolute_uri('/%s' %
i.itemId)
return render_to_json_response(response)
def setUp(self):
self.title = 'Test title'
self.user = User(
name='test', user_name='te-st', email='*****@*****.**', age=20)
self.user.save()
self.category = Category(category_name=1)
self.category.save()
self.item = Item(title=self.title, user=self.user,
category=self.category)
def setUp(self):
# create user
self.client = Client(enforce_csrf_checks=False)
user = User.objects.create_user(
username="******", email="test", password="******")
# create Tags
tag_black = Tag(name="black", user=user)
tag_black.save()
tag_white = Tag(name="white", user=user)
tag_white.save()
tag_red = Tag(name="red", user=user)
tag_red.save()
tag_fancy = Tag(name="fancy", user=user)
tag_fancy.save()
tag_verypretty = Tag(name="verypretty", user=user)
tag_verypretty.save()
# create Items
item1 = Item(category="Outer", user=user)
item1.save()
item1.tags.add(tag_black, tag_white)
item2 = Item(category="UpperBody", user=user)
item2.save()
item2.tags.add(tag_black, tag_red)
item3 = Item(category="Accessories", user=user)
item3.save()
item3.tags.add(tag_black, tag_fancy)
item4 = Item(category="verypretty", user=user)
item4.save()
item4.tags.add(tag_verypretty)
# create Outfit
outfit1 = Outfit(user=user, image_link="", date="2019-11-11",
tempAvg=3, tempIcon="happy", satisfaction=5)
outfit1.save()
outfit1.items.add(item1, item2, item3, item4)
outfit1.save()
def add(request, order_id, meal_id):
order = get_object_or_404(Order, pk=order_id)
meal = get_object_or_404(Meal, pk=meal_id)
user = get_object_or_404(User, pk=request.user.id)
item = Item()
if not request.user.groups.filter(id=order.group.id):
messages.warning(request, 'To zamówienie nie należy do Twojej grupy')
return redirect('profile:index')
else:
item.order = order
item.meal = meal
item.user = user
item.save()
messages.success(request, 'Dodano do listy')
return HttpResponseRedirect(reverse('order:details', args=[order.id]))
def insert_products():
with open(CSV_PATH_PRODUCTS) as in_file:
data_reader = csv.reader(in_file)
next(data_reader, None)
for row in data_reader:
fourth_category = row[2]
title = row[3]
description = row[4]
price = int(row[5].replace(",", ""))
labels = row[6].replace("[", "").replace("]", "").replace("'", "").split(", ")
benefits = row[7].replace("[", "").replace("]", "").replace("'", "").split(", ")
main_image = row[8]
default_image = row[9]
hover_image = row[10]
if fourth_category not in FourthCategory.objects.values_list('name', flat=True):
FourthCategory.objects.create(name=fourth_category)
images = ItemImage.objects.create(
main_url = main_image,
front_url = default_image,
hover_url = hover_image
)
cur_item = Item(
main_category = MainCategory.objects.get(name="Shop"),
sub_category = SubCategory.objects.get(name="Tea Shop"),
third_category = ThirdCategory.objects.get(name=row[1]),
fourth_category = FourthCategory.objects.get(name=fourth_category),
title = title,
description = description,
price = price,
images = images
)
cur_item.save()
cur_item.set_benefits(benefits)
cur_item.save()
if labels[0] != "":
for each_label in labels:
print(each_label)
ItemLabel.objects.create(
label = Label.objects.get(name=each_label),
item = cur_item
)
def add_item(request):
add_item = True
msg = None
if request.method == 'POST':
image_path = request.FILES.get('img', None)
item_obj = Item(name=request.POST['name'],
description=request.POST['desc'],
price=request.POST['price'],
item_image=image_path)
item_obj.save()
msg = f'Item - "{item_obj.name}" Added Successfully...'
add_item = False
items = Item.objects.filter(active='Y')
return render(request, 'item/welcome.html', {
'items': items,
'add': add_item,
'msg': msg
})
def setup():
form = SetupForm()
error = ""
if form.validate_on_submit():
author = Author(form.fullname.data, form.email.data,
form.username.data, form.password.data, True)
db.session.add(author)
db.session.flush()
if author.id:
item = Item(form.title.data, author.id)
db.session.add(item)
db.session.flush()
else:
db.session.rollback()
error = "Error creating user"
if author.id and item.id:
db.session.commit()
flash('Item created')
return redirect(url_for('admin'))
else:
db.session.rollback()
error = "Error creating item"
return render_template('item/setup.html', form=form)
def add_item(request):
if request.method == 'GET':
last_item_info = Item.objects.last()
unit_list = Unit.objects.all()
return render(request, 'item/add_item.html', locals())
else:
item_index = request.POST.get('item_index')
item_chinese_name = request.POST.get('item_chinese_name')
item_english_name = request.POST.get('item_english_name')
item_method = request.POST.get('item_method')
item_unit = request.POST.get('item_unit')
is_calc = request.POST.get('is_calc')
is_use = request.POST.get('is_use')
unit_info = Unit.objects.get(id=item_unit)
new_item = Item(item_index=int(item_index),
item_chinese_name=item_chinese_name,
item_english_name=item_english_name,
item_method=item_method,
item_unit=unit_info,
is_calc=str_to_bool(is_calc),
is_use=str_to_bool(is_use))
new_item.save()
return redirect('/item/item/')
def setup(self):
self.movie = Movie.objects.create(item=Item(),
runtime=-100,
critic_score=94)
self.id = Movie.objects.get(runtime=self.movie.runtime).pk
def outfit(request):
user1 = request.user
if request.method == 'GET':
response_array = []
for _outfit in Outfit.objects.filter(user=user1).all():
weather_dict = {
"tempAvg": _outfit.tempAvg,
"icon": _outfit.tempIcon
}
items_array = []
for item in _outfit.items.all():
item_to_add = {
"id": item.id,
"category": item.category,
"tags": [tag.name for tag in item.tags.all()]
}
items_array.append(item_to_add)
outfit_dict = {
"id": _outfit.id,
"image": _outfit.image_link,
"date": _outfit.dateWithTime,
"satisfactionValue": _outfit.satisfaction,
"weather": weather_dict,
"items": items_array
}
response_array.append(outfit_dict)
return JsonResponse(response_array, safe=False, status=200)
elif request.method == 'POST':
try:
body = request.body.decode()
request_dict = json.loads(body)
date = request_dict["date"]
satisfaction = request_dict["satisfactionValue"]
tempIcon = request_dict["weather"]["icon"]
tempAvg = request_dict["weather"]["tempAvg"]
image = request_dict["image"]
items = request_dict["items"]
items_for_new_outfit = []
for item in items:
tags_per_item = []
itemExists = True
item_candidates = []
i = 0
print("tag names array from front: ")
print(item["tags"])
for tag_name in item[
"tags"]: # tags=["black", "white", "2019"]
try:
print("current tag name: ")
print(tag_name)
tag = Tag.objects.get(name=tag_name)
tags_per_item.append(tag)
if itemExists:
if i is 0:
item_candidates = [
item
for item in tag.items_with_this_tag.all()
]
print("item_candidates first print: ")
print(item_candidates)
i = 1
else:
item_candidates_read = copy.deepcopy(
item_candidates)
for item_candidate in item_candidates_read:
print("item_candidate, tag: ")
print(item_candidate, tag.name)
itemExists = tag in item_candidate.tags.all(
)
print("itemExists_in item candidate: ")
print(itemExists)
print(tag.name + ": ")
print(item_candidates)
if not itemExists:
item_candidates.remove(item_candidate)
print(tag.name + "(after remove): ")
print(item_candidates)
# 지금 보고있는 tag의 itmes들을 가져온다
# 이전에 저장되어 있던 item_candidate와의 교집합을 찾는다 (?)
# 교집한 없으면 itemExists 에 false를 넣는다
except Tag.DoesNotExist:
# check user
print("Inside New Tag")
itemExists = False
item_candidates = []
new_tag = Tag(name=tag_name, user=user1)
new_tag.save()
print("New Tag: ")
print(new_tag.name)
tags_per_item.append(new_tag)
# tag 없는 애는 생성, 있는애는 객체로 받아서 받아서 tags안에 다 들어있음
# itemExists 이미 존재하는 item이 잇는지 확인 끝
item_candidates = filter(
lambda x: x.category == item["category"] and x.tags.all().
count() == len(item["tags"]), item_candidates)
# convert filter object to list
item_candidates = list(item_candidates)
print("item_candidates: ")
print(item_candidates)
if len(item_candidates) > 1:
print("...it is literally disaster")
print(item_candidates)
itemExists = len(item_candidates) == 1
if itemExists:
assert len(item_candidates) == 1, "...inside itemExists"
items_for_new_outfit.append(item_candidates[0])
print("items_for_new_outfit: ")
print(items_for_new_outfit)
else:
new_item = Item(category=item["category"],
user=user1) # check user
new_item.save()
for tag in tags_per_item:
new_item.tags.add(tag)
new_item.save()
items_for_new_outfit.append(new_item)
# true -> itemCandidates 안에 list item id.
# category가 같은 애들 먼저 filter
# finally tags length equality check -> itemExtist true? 바로 그 item을 get해와서 item 배열에 넣고 : false면 새로 item생성해서 배열에 넣고
print("itemExists_received: ")
print(itemExists)
new_outfit = Outfit(image_link=image,
dateWithTime=date,
date=change_date_format(date),
satisfaction=satisfaction,
tempIcon=tempIcon,
tempAvg=tempAvg,
user=user1)
new_outfit.save()
print("items_for_new_outfit: right before saving outfit: ")
print(items_for_new_outfit)
for item in items_for_new_outfit:
new_outfit.items.add(item)
new_outfit.save()
response_dict_weather = {
"tempAvg": new_outfit.tempAvg,
"icon": new_outfit.tempIcon
}
response_dict_items = []
for item in new_outfit.items.all():
item_to_add = {
"id": item.id,
"category": item.category,
"tags": [tag.name for tag in item.tags.all()]
}
response_dict_items.append(item_to_add)
response_dict = {
"id": new_outfit.id,
"image": new_outfit.image_link,
"date": new_outfit.dateWithTime,
"satisfactionValue": new_outfit.satisfaction,
"weather": response_dict_weather,
"items": response_dict_items
}
print(response_dict)
return JsonResponse(response_dict, status=201)
except (KeyError, JSONDecodeError) as e:
return HttpResponseBadRequest()
else:
return HttpResponseNotAllowed(['GET', 'POST'])
def create_item(request):
try:
username = request.META.get("HTTP_USERNAME")
user = User.objects.get(username=username)
host = Host.objects.get(user=user)
data = request.data
valid_address = 0
if 'address' in data:
geo_response = geocoding(data['address'])
if geo_response['status'] == 'OK':
latitude = geo_response['results'][0]['geometry']['location'][
'lat']
longitude = geo_response['results'][0]['geometry']['location'][
'lng']
valid_address = 1
item = Item(
owner=host,
title=data['title'],
desc=data['desc'],
i_type=data['i_type'],
price_per_day=data['price_per_day'],
guest_num=data['guest_num'],
bedroom_num=data['bedroom_num'],
bed_num=data['bed_num'],
bathroom_num=data['bathroom_num'],
address=data['address'],
rules=data['rules'],
features=data['features'],
avaliable=data['avaliable'],
album='')
if valid_address:
item.latitude = latitude
item.longitude = longitude
item.save()
if 'album' in data:
files = set(data['album'].split(','))
if item.album == '':
origin_files = set()
else:
origin_files = set(item.album.split(','))
files_to_add = files - origin_files
files_to_delete = origin_files - files
for file in files_to_add:
new_album = save_image(file, user.u_id, item.i_id)
if item.album == '':
item.album += new_album
else:
item.album += ',' + new_album
for file in files_to_delete:
item.album = delete_image(file, item.album, user.u_id,
item.i_id)
clear_tmp()
item.album_first = item.album.split(',')[0]
item.save()
result = {
'code': status.HTTP_200_OK,
'msg': 'creation successful',
'data': {
'item_id': item.i_id
}
}
except User.DoesNotExist:
result = {
'code': status.HTTP_400_BAD_REQUEST,
'msg': 'user not found',
}
except Host.DoesNotExist:
result = {
'code': status.HTTP_400_BAD_REQUEST,
'msg': 'invalid host',
}
except Exception as e:
result = {
'code': status.HTTP_400_BAD_REQUEST,
'msg': str(e),
}
return Response(result, status=result['code'])
def create(self, validated_data):
items = [Item(**item) for item in validated_data]
return Item.objects.create(items)
def specificOutfit(request, outfit_id):
user1 = request.user
try:
outfit = Outfit.objects.get(pk=outfit_id)
except Outfit.DoesNotExist:
return HttpResponse(status=404)
if request.method == 'GET':
response_dict_weather = {
"tempAvg": outfit.tempAvg,
"icon": outfit.tempIcon
}
response_dict_items = []
for item in outfit.items.all():
item_to_add = {
"id": item.id,
"category": item.category,
"tags": [tag.name for tag in item.tags.all()]
}
response_dict_items.append(item_to_add)
response_dict = {
"id": outfit.id,
"image": outfit.image_link,
"date": outfit.dateWithTime,
"satisfactionValue": outfit.satisfaction,
"weather": response_dict_weather,
"items": response_dict_items
}
return JsonResponse(response_dict, status=200)
elif request.method == 'DELETE':
for item in outfit.items.all():
# print("item list in this outfit : "+list(outfit.items))
if item.outfits_having_this_item.all().count() == 1:
for tag in item.tags.all():
if tag.items_with_this_tag.all().count == 1:
tag.delete()
item.delete()
# if item.outfits_having_this_item 의 length가 1이면. item도 지워줘
# if tag.items_with_this_tag의 length가 1이면 tag도 지워줘
outfit.delete()
return HttpResponse(status=200)
else: # PUT
try:
body = request.body.decode()
# body로 들어온 outfit의 dict형태가 response_dict에 들어있음
request_dict = json.loads(body)
date = request_dict["date"]
satisfaction = request_dict["satisfactionValue"]
tempIcon = request_dict["weather"]["icon"]
tempAvg = request_dict["weather"]["tempAvg"]
# image는 edit page에서 애초에 바꿀 수 없으므로 image관련된 put작업은 생략
items = request_dict["items"]
#items_in_current_outfit = outfit.items.all()
items_for_edited_outfit = []
for item in items:
tags_per_item = []
itemExists = True
item_candidates = []
i = 0
for tag_name in item["tags"]:
try:
tag = Tag.objects.get(name=tag_name)
tags_per_item.append(tag) #이미 존재하는 태그라면 바로 넣어준다
if itemExists:
if i is 0: #현재 아이템의 첫번째 태그를 보고 있다면 여기로 들어온다 - itemExists가 당연 true 였을 것이다.
item_candidates = [
item
for item in tag.items_with_this_tag.all()
] #현재 보고있는 태그가 포함된 모든 item이 후보가 될 수 있으므로 다 넣어준다
i = 1 #두번째 태그 볼때부터는 여기에 못들어오도록 i 값 update
else: #현재 아이템의 첫번째 태그를 보고 있는게 아니라면
item_candidates_read = copy.deepcopy(
item_candidates
) #원래의 item_cadidates를 해치지 않기 위해 값만 복사한 read용 array만든다 for문의 이상한 특징을 방어하기 위해 만듬.
for item_candidate in item_candidates_read:
itemExists = tag in item_candidate.tags.all(
) #지금 보고 있는 태그가 itemCandidate 안에 들어있는 지 확인
if not itemExists: #현재 보고 있는 item candidate에 지금 보고 있는 tag가 없다는게 발각되면.. 그 아이템을 후보에서 지워준다
item_candidates.remove(item_candidate)
except Tag.DoesNotExist: #없는 태그라면
itemExists = False
item_candidates = [] #후보 item candidate 다 비워준다
new_tag = Tag(name=tag_name, user=user1) #새로운 태그를 생성하고
new_tag.save() #태그를 저장해준다
tags_per_item.append(
new_tag) #그리고 그 태그를 아이템에 들어가있는 태그 리스트에 추가해준다
# 현재 넘어온 outfit 객체의 생김새
# id 가 outfit id인 애를 찾았잖아 우선?
item_candidates = filter(
lambda x: x.category == item["category"] and x.tags.all(
).count() == len(item["tags"]), item_candidates
) #item candidate에 들어있는 애들 중에 category도 같고, tag 개수도 같은 애들만 filtering
item_candidates = list(item_candidates)
assert len(item_candidates) <= 1, "...it is literally disaster"
itemExists = len(item_candidates) == 1
if itemExists:
assert len(item_candidates) == 1, "...inside itemExists"
items_for_edited_outfit.append(
item_candidates[0]) #이미 있는 item임을 확인했으니 그냥 그 친구를 넣어준다
#item을 포함하고 있는 outfit이 1개이고, item_candidate[0]의 id가 지금보고있는 item의 id가 다르면 지금 item을 지우자
else:
new_item = Item(category=item["category"], user=user1)
new_item.save()
for tag in tags_per_item:
new_item.tags.add(tag)
new_item.save()
items_for_edited_outfit.append(new_item)
#item을 포함하고 있는 outfit이 1개였다면 바로 지운다.
outfit.dateWithTime = date
outfit.date = change_date_format(date)
outfit.satisfaction = satisfaction
outfit.tempIcon = tempIcon
outfit.tempAvg = tempAvg
for prev_item in outfit.items.all():
if prev_item in items_for_edited_outfit:
pass
else:
if prev_item.outfits_having_this_item.all().count() == 1:
for prev_tag in prev_item.tags.all():
if prev_tag.items_with_this_tag.all().count() == 1:
prev_tag.delete()
prev_item.delete()
#만약에 prev_item이 items_for_edited_outfit 에 들어있지 않고,
# prev_item.outfits_having_this_item의 길이가 1이라면
#for prev_tag in prev_item.tags.all()
#if prev_tag.items_with_this_tag.all().count == 1
#prev_tag.delete()
# prev_item.delete()
#'''
outfit.items.clear() #기존에 있던 모든 item관게를 끊어준다
for item in items_for_edited_outfit:
outfit.items.add(item)
outfit.save()
response_dict_weather = {
"tempAvg": outfit.tempAvg,
"icon": outfit.tempIcon
}
response_dict_items = []
for item in outfit.items.all():
item_to_add = {
"id": outfit.id,
"category": item.category,
"tags": [tag.name for tag in item.tags.all()]
}
response_dict_items.append(item_to_add)
response_dict = {
"id": outfit.id,
"image": outfit.image_link,
"date": outfit.dateWithTime,
"satisfactionValue": outfit.satisfaction,
"weather": response_dict_weather,
"items": response_dict_items
}
return JsonResponse(response_dict, status=200)
except (KeyError, JSONDecodeError) as e:
print(e)
return HttpResponseBadRequest()
import django
import os
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'pj.settings')
django.setup()
from item.models import Item
item = Item(name='coke', price=120)
item.save()
