def get_user_profile_snap(request, user_id=None):
thumbnail = False
if 'thumbnail' in request.GET :
thumbnail = request.GET['thumbnail']
session = get_session()
profile_image = session.query(UserProfileSnap).filter(UserProfileSnap.user_id==user_id).order_by(UserProfileSnap.id.desc()).first()
if profile_image :
profile_image = profile_image.user_profile_snap_image
session.close()
if profile_image :
if thumbnail :
return HttpResponse(profile_image.thumbnail_image, mimetype='image/jpeg')
else :
return HttpResponse(profile_image.image, mimetype='image/jpeg')
else :
result = dict(success = False, message=u'users.views.get_user_profile_snap: this user has no profile image')
return HttpResponse(dumps(result))
else :
profile_image = session.query(Snap).filter(Snap.user_id==user_id).order_by(Snap.snap_id.desc()).first()
profile_image = profile_image.image
session.close()
if profile_image :
if thumbnail :
return HttpResponse(profile_image.thumbnail_image, mimetype='image/jpeg')
else :
return HttpResponse(profile_image.image, mimetype='image/jpeg')
else :
result = dict(success=False, message=u'users.views.get_user_profile_snap: this user has no snap either')
return HttpResponse(dumps(result))
def get_image(request, image_id = None) :
size = dict(
original = 0,
thumbnail1 = 1,
thumbnail2 = 2,
)
image_to_send = size['original']
if 'size' in request.GET :
image_to_send = size[request.GET['size']]
session = get_session()
image = session.query(Image).get(image_id)
session.close()
if not image :
result = dict(success=False, message=u'images.views.get_image: No image %s' % image_id)
return HttpResponse(dumps(result))
if image_to_send == size['original'] :
return HttpResponse(image.image, mimetype='image/jpeg')
elif image_to_send == size['thumbnail1'] :
return HttpResponse(image.thumbnail1_image, mimetype='image/jpeg')
elif image_to_send == size['thumbnail2'] :
return HttpResponse(image.thumbnail2_image, mimetype='image/jpeg')
else :
return HttpResponse(image.image, mimetype='image/jpeg')
def get_snaps(request):
session = get_session()
snaps = session.query(Snap).all()
session.close()
result = dict(success=True, message=u'haha', data=to_dict(snaps))
return HttpResponse(dumps(result))
def get_spot_list(request, user_id=None) :
session = get_session()
try :
spot_list = session.query(SpotUserAssociation).filter_by(user_id=user_id).all()
except :
session.rollback()
session.close()
result = dict(success = False, message=u'users.views.get_spot_list: spot_list_db_error')
return HttpResponse(dumps(result))
spot_list = [ spot_assoc.spot for spot_assoc in spot_list ]
physical_spot_list = list()
logical_spot_list = list()
for spot in spot_list :
if spot.is_physical :
physical_spot_list.append(spot)
else :
logical_spot_list.append(spot)
data = dict(
physical_spot_list = to_dict(physical_spot_list),
logical_spot_list = to_dict(logical_spot_list),
)
session.close()
result = dict(success = True, message=u'users.views.get_spot_list: spot_list_success', data=data)
return HttpResponse(dumps(result))
def dislike_snap(request, snap_id=None):
user_id = get_user_id(request.META)
session = get_session()
if not user_id :
session.close()
result = dict(success=False, message=u'snaps.views.dislike_snap: no user id')
return HttpResponse(dumps(result))
snap = session.query(Snap).get(snap_id)
if not snap :
session.close()
result = dict(success=False, message=u'snaps.views.dislike_snap: no snap with snap id {snap_id}'.format(snap_id=snap_id))
return HttpResponse(dumps(result))
snap_like = session.query(SnapLike).filter_by(snap_id=snap_id, user_id=user_id).first()
if not snap_like :
session.close()
result = dict(success=True, message=u'snaps.views.dislike_snap: you already dislike this snap')
return HttpResponse(dumps(result))
try :
session.delete(snap_like)
snap.num_of_likes -= 1
session.merge(snap)
session.commit()
session.close()
except :
session.rollback()
session.close()
result = dict(success=False, message=u'snaps.views.dislike_snap: database error')
return HttpResponse(dumps(result))
result = dict(success=True, message=u'snaps.views.dislike_snap: user {user_id} dislike snap {snap_id}'.format(user_id=user_id, snap_id=snap_id))
return HttpResponse(dumps(result))
def search_users(request, spot_id=None):
request_data = loads(request.raw_post_data)
if "search_keyword" not in request_data:
result = dict(success=False, message=u"spots.views.search_users: no search keyword in request data")
return HttpResponse(dumps(result))
keyword = request_data["search_keyword"]
session = get_session()
try:
result = session.execute(
u"select * from user_infos where user_id in (select user_id from spot_user where spot_id = {spot_id}) and nickname like '{keyword}%'".format(
spot_id=spot_id, keyword=keyword
)
)
except:
session.rollback()
session.close()
result = dict(success=False, message=u"spots.views.search_users: failed to search users")
return HttpResponse(dumps(result))
user_infos = to_dict(result)
session.close()
data = dict(user_infos=user_infos)
result = dict(
success=True,
message=u"spots.views.search_users: users search with {keyword} in spot {spot_id}".format(
keyword=keyword, spot_id=spot_id
),
data=data,
)
return HttpResponse(dumps(result))
def create_snap_comment(request, snap_id=None):
request_data = loads(request.raw_post_data)
user_id = get_user_id(request.META)
if not request_data :
result = dict(success=False, message=u'no request data')
return HttpResponse(dumps(result))
if not user_id :
result = dict(success=False, message=u'no user id')
return HttpResponse(dumps(result))
else :
request_data['user_id'] = user_id
session = get_session()
snap = session.query(Snap).get(snap_id)
if not snap :
result = dict(success=False, message=u'snaps.views.get_snap_comments: no snap with snap id {snap_id}'.format(snap_id=snap_id))
return HttpResponse(dumps(result))
request_data['snap_id'] = snap_id
remove_keys(request_data, SnapComment)
new_snap_comment = SnapComment(**request_data)
try :
session.add(new_snap_comment)
snap.num_of_comments += 1
session.merge(snap)
session.commit()
session.close()
except :
session.rollback()
result = dict(success=False, message=u'database error')
return HttpResponse(dumps(result))
result = dict(success=True, message=u'snap comment created')
return HttpResponse(dumps(result))
def post_spot_profile_image(request, spot_id=None):
request_data = loads(request.POST["data"])
user_id = get_user_id(request.META)
if user_id is None:
result = dict(success=False, message=u"spots.views.post_spot_profile_image: not user id found")
return HttpResponse(dumps(result))
request_data["user_id"] = user_id
if not request_data:
result = dict(success=False, message=u"spots.views.post_spot_profile_image: no request data")
return HttpResponse(dumps(result))
else:
if not spot_id:
if "spot_id" not in request_data:
result = dict(success=False, message=u"spots.views.post_spot_profile_image: no spot id found")
return HttpResponse(dumps(result))
filename = None
for temp_filename in request.FILES:
filename = temp_filename
if filename is None:
result = dict(success=False, message=u"spots.views.post_spot_profile_image: no image attached")
return HttpResponse(dumps(result))
# profile image size 가 정해지지 않아서 임시로 300,300 과 100,100을 지정했음
profile_image_size = (300, 300)
thumbnail_size = (100, 100)
upload_image = Image.open(request.FILES[filename])
profile_image_buff = StringIO.StringIO()
thumbnail_image_buff = StringIO.StringIO()
try:
profile_image.thumbnail_image(profile_image_size, Image.BICUBIC)
profile_image.save(profile_image, "jpeg")
profile_image.thumbnail_image(thumbnail_image_buff, Image.BICUBIC)
profile_image.save(thumbnail_image_buff, "jpeg")
except:
result = dict(
success=False, message=u"spots.views.post_spot_profile_image: error occur while resizing the image"
)
return HttpResponse(dumps(result))
spot_profile_image = SpotProfileImage(
image=profile_image_buff.getvalue(), thumbnail_image=thumbnail_image_buff.getvalue()
)
session = get_session()
try:
session.add(spot_profile_image)
session.commit()
session.close()
except:
session.rollback()
session.close()
result = dict(success=True, message=u"spots.views.post_spot_profile_image: uploaded complete")
return HttpResponse(dumps(result))
def get_users(request) :
limit, offset = get_paginate_info(request.GET)
session = get_session()
users = session.query(UserInfo).limit(limit).offset(offset).all()
session.close()
data = dict(
user_list = to_dict(users),
)
result = dict(success=True, message=u'users.views.get_users: user list from {start} to {end}'.format(start=offset, end=limit+offset), data=data, start=offset, end=limit+offset)
return HttpResponse(dumps(result, True))
def get_snap(request, snap_id=None):
session = get_session()
snap = session.query(Snap).get(snap_id)
data = dict(
snap = to_dict(snap)
)
session.close()
result = dict(success=True, message=u'snaps.views.get_snap: here you are ^^', data=data)
return HttpResponse(dumps(result))
def update_snap(request, snap_id=None):
request_data = loads(request.raw_post_data)
if not request_data :
result = dict(success=False, message=u'snaps.views.update_snap: no request data')
return HttpResponse(dumps(result))
user_id = get_user_id(request.META)
if not user_id :
result = dict(success=False, message=u'snaps.views.update_snap: no user id found')
return HttpResponse(dumps(result))
session = get_session()
snap = session.query(Snap).get(snap_id)
if not snap :
result = dict(success=False, message=u'snaps.views.update_snap: no snap with snap id {}'.format(snap_id))
return HttpResponse(dumps(result))
if snap.user_id != user_id :
result = dict(success=False, message=u"snaps.views.update_snap: trying to change other user's snap")
return HttpResponse(dumps(result))
request_data['user_id'] = user_id
request_data['snap_id'] = snap_id
remove_keys(request_data, Snap)
if 'snaptime' in request_data :
del request_data['snaptime']
if 'image_id' in request_data :
del request_data['image_id']
if 'lat' in request_data :
del request_data['lat']
if 'lng' in request_data :
del request_data['lng']
for key, value in request_data.items():
setattr(snap, key, value)
try:
session.merge(snap)
session.commit()
session.close()
except :
session.rollback()
session.close()
result = dict(success=False, message=u'snaps.views.update_snap: failed to update snap')
return HttpResponse(dumps(result))
result = dict(success=True, message=u'snaps.views.update_snap: update success')
return HttpResponse(dumps(result))
def get_images(request):
limit, offset = get_paginate_info(request.GET)
session = get_session()
image_id_list = session.query(Image.image_id).limit(limit).offset(offset).all()
session.close()
image_id_list = [ y for x in image_id_list for y in x ]
data = dict(
image_list = image_id_list
)
result = dict(success=True, message=u'images.views.get_images: images from {start} to {end}'.format(start=offset, end=offset+limit), data=data)
return HttpResponse(dumps(result))
def get_spot_info(request, spot_id=None):
session = get_session()
spot = session.query(Spot).get(spot_id)
Spot.relations.append("king")
Spot.relations.append("queen")
data = dict(spot=to_dict(spot))
Spot.relations.remove("king")
Spot.relations.remove("queen")
session.close()
result = dict(success=True, message=u"spots.views.get_spot_info: here you are ^^", data=data)
return HttpResponse(dumps(result, True))
def get_user_profile(request, user_id=None) :
session = get_session()
try:
user_profile = session.query(UserInfo).get(user_id)
except :
session.rollback()
session.close()
result = dict(success = False, message=u'users.views.get_user_profile: db error while catching user profile')
return HttpResponse(dumps(result))
if not user_profile :
result = dict(success=False, message=u'users.views.get_user_profile: user profile does not exist')
return HttpResponse(dumps(result))
try:
spot_list = session.query(SpotUserAssociation).filter_by(user_id=user_id).all()
snap_list = session.query(Snap).filter_by(user_id=user_id).all()
except:
session.rollback()
session.close()
result = dict(success = False, message=u'users.views.get_user_profile: db error while catching spotlist and snap list')
return HttpResponse(dumps(result))
user_profile = to_dict(user_profile)
del user_profile['is_admin']
del user_profile['created']
spot_list = [ spot_assoc.spot for spot_assoc in spot_list ]
physical_spot_list = list()
logical_spot_list = list()
for spot in spot_list :
if spot.is_physical :
physical_spot_list.append(spot)
else :
logical_spot_list.append(spot)
# 모델의 릴레이션스는 to_dict에서 참조하므로 여기서 없앴다가 살림
Snap.relations.remove('userinfo')
SpotUserAssociation.relations.append('spot')
data = dict(
user_info = user_profile,
physical_spot_list = to_dict(physical_spot_list),
logical_spot_list = to_dict(logical_spot_list),
snap_list = to_dict(snap_list),
)
Snap.relations.append('userinfo')
SpotUserAssociation.relations.remove('spot')
session.close()
result = dict(success = True, message=u'users.views.get_user_profile: user_profile_success', data=data)
return HttpResponse(dumps(result, True))
def get_profile_image(request, user_id=None) :
thumbnail = request.GET.get('thumbnail', False)
session = get_session()
profile_image = session.query(UserProfileImage).get(user_id)
session.close()
if not profile_image :
result = dict(success = False, message=u'users.views.get_profile_image: this user has no profile image')
return HttpResponse(dumps(result))
if thumbnail :
return HttpResponse(profile_image.thumbnail_image, mimetype='image/jpeg')
else :
return HttpResponse(profile_image.image, mimetype='image/jpeg')
def like_check(request, snap_id=None):
user_id = get_user_id(request.META)
if not user_id :
result = dict(success=False, message=u'snaps.views.like_check: no user id found')
return HttpResponse(dumps(result))
session = get_session()
snap_like = session.query(SnapLike).filter_by(snap_id=snap_id, user_id=user_id).first()
data = dict()
if not snap_like :
data['liked'] = False
else :
data['liked'] = True
result = dict(success=True, message=u'snaps.views.like_check: result of checking if the user likes snap', data=data)
return HttpResponse(dumps(result))
def get_spot_snaps(request, spot_id=None):
limit, offset = get_paginate_info(request.GET)
session = get_session()
snaps = session.query(Snap).filter_by(spot_id=spot_id).limit(limit).offset(offset).all()
data = dict(snap_list=to_dict(snaps))
session.close()
result = dict(
success=True,
message=u"spots.views.get_spot_snaps: snaps from {start} to {end}".format(start=offset, end=offset + limit),
data=data,
)
return HttpResponse(dumps(result))
def get_favorite_snaps(request, user_id=None):
session = get_session()
favorite_snap_id_list = session.query(SnapLike).filter_by(user_id=user_id).all()
favorite_snap_id_list = [ snap.snap_id for snap in favorite_snap_id_list ]
if not favorite_snap_id_list :
favorite_snap_list = []
else :
favorite_snap_list = session.query(Snap).filter(Snap.snap_id.in_(favorite_snap_id_list)).all()
data = dict(
favorite_snap_list = to_dict(favorite_snap_list),
)
session.close()
result = dict(success=True, message=u'users.views.get_favorite_snaps: favorite snaps', data=data)
return HttpResponse(dumps(result))
def get_spot_users(request, spot_id=None):
limit, offset = get_paginate_info(request.GET)
session = get_session()
SpotUserAssociation.relations.append("userinfo")
spot_user_list = session.query(SpotUserAssociation).filter_by(spot_id=spot_id).limit(limit).offset(offset).all()
data = dict(spot_user_list=to_dict(spot_user_list))
session.close()
result = dict(
success=True, message=u"spots.views.get_spot_users: spot {spot_id} user list".format(spot_id=spot_id), data=data
)
return HttpResponse(dumps(result))
def post_user_profile_snap(request, user_id=None):
image_size = (640, 1136)
thumbnail_image_size = (320, 568)
filename = None
for temp_filename in request.FILES :
filename = temp_filename
if not filename :
result = dict(success=False, message=u'users.views.post_user_profile_snap: no file attached')
return HttpResponse(dumps(result))
image_buff = StringIO.StringIO()
thumbnail_image_buff = StringIO.StringIO()
try :
uploaded_image = Image.open(request.FILES[filename])
except :
result = dict(success=False, message=u'users.views.post_user_profile_snap: fail to open uploaded file')
return HttpResponse(dumps(result))
uploaded_image.thumbnail(image_size, Image.ANTIALIAS)
uploaded_image.save(image_buff, 'jpeg')
uploaded_image.thumbnail(thumbnail_image_size, Image.ANTIALIAS)
uploaded_image.save(thumbnail_image_buff, 'jpeg')
profile_snap_image = UserProfileSnapImage(image = image_buff.getvalue(), thumbnail_image = thumbnail_image_buff.getvalue())
session = get_session()
try :
session.add(profile_snap_image)
session.commit()
except :
session.rollback()
session.close()
result = dict(success=False, message=u'users.views.post_user_profile_snap: fail to insert profile snap image')
return HttpResponse(dumps(result))
profile_snap = UserProfileSnap(user_id=user_id, image_id=profile_snap_image.image_id)
try:
session.merge(profile_snap)
session.commit()
except :
session.rollback()
session.close()
result = dict(success=False, message=u'users.views.post_user_profile_snap: fail to insert profile snap')
return HttpResponse(dumps(result))
session.close()
result = dict(success=True, message=u'users.views.post_user_profile_snap: upload success')
return HttpResponse(dumps(result))
def create_spot(request):
request_data = loads(request.raw_post_data)
remove_keys(request_data, Spot)
new_spot = Spot(**request_data)
session = get_session()
try:
session.add(new_spot)
session.commit()
except:
session.rollback()
session.close()
result = dict(success=True, message=u"spots.views.create_spot: new spot created")
return HttpResponse(dumps(result))
def get_spot_list(request):
limit, offset = get_paginate_info(request.GET)
session = get_session()
spot_list = session.query(Spot).limit(limit).offset(offset).all()
data = dict(spot_list=to_dict(spot_list))
session.close()
result = dict(
success=True,
message=u"spots.views.get_spot_list: the list of spots from {start} to {end}".format(
start=offset, end=offset + limit
),
data=data,
)
return HttpResponse(dumps(result, True))
def add_spot_users(request, spot_id=None):
# 이부분 정리 필요함
user_id = get_user_id(request.META)
if not user_id:
request_data = loads(request.raw_post_data)
if not request_data:
result = dict(success=False, message=u"spots.views.add_spot_users: no request data")
return HttpResponse(dumps(result))
if "user_id" not in request_data:
result = dict(success=False, message=u"spots.views.add_spot_users: no user id")
return HttpResponse(dumps(result))
user_id = request_data["user_id"]
session = get_session()
spot = session.query(Spot).get(spot_id)
if not spot:
result = dict(success=False, message=u"spots.views.add_spot_users: no matching spot")
return HttpResponse(dumps(result))
can_snap = False
if spot.is_private:
if "can_snap" in request_data:
can_snap = request_data["can_snap"]
else:
session.close()
result = dict(
success=False, message=u"spots.views.add_spot_users: it's a private spot need 'can_snap' info"
)
return HttpResponse(dumps(result))
else:
can_snap = True
assoc = SpotUserAssociation(spot_id=spot_id, user_id=user_id, can_snap=can_snap)
try:
session.merge(assoc)
session.commit()
session.close()
except:
session.rollback()
session.close()
result = dict(
success=True,
message=u"spots.views.add_spot_users: user {user_id} added on spot {spot_id}".format(
user_id=user_id, spot_id=spot_id
),
)
return HttpResponse(dumps(result))
def signup(request) :
request_data = loads(request.raw_post_data)
if 'user_id' not in request_data : # check for empty id and pw field
result = dict(success=False, message=u'users.views.signup: user id not sent')
return HttpResponse(dumps(result))
if 'user_password' not in request_data :
result = dict(success=False, message=u'users.views.signup: password not sent')
return HttpResponse(dumps(result))
session = get_session()
request_data['user_id'] = request_data['user_id'].strip()
user = session.query(User).filter_by(user_id=request_data['user_id']).first()
if user :
session.close()
result = dict(success=False, message=u'users.views.signup: user id duplicated')
return HttpResponse(dumps(result))
phone_number = request_data.get('phone_number', None)
if not phone_number or not phone_number.isdigit() :
session.close()
result = dict(success=False, message=u'users.views.signup: phone number must be digits')
return HttpResponse(dumps(result))
user_data = dict(request_data)
user_info_data = dict(request_data)
remove_keys(user_data, User)
remove_keys(user_info_data, UserInfo)
new_user = User(**user_data)
new_user_info = UserInfo(**user_info_data)
new_user.userinfo = new_user_info
try :
session.add(new_user)
session.commit()
session.close()
except:
session.rollback()
session.close()
result = dict(success=False, message=u'users.views.signup: failed to save user info')
return HttpResponse(dumps(result))
result = dict(success=True, message=u'signuped!')
return HttpResponse(dumps(result))
def signin(request):
request_data = loads(request.raw_post_data)
if not request_data :
result = dict(success=False, message=u'no request data')
return HttpResponse(dumps(result))
if 'user_id' not in request_data :
result = dict(success=False, message=u'no user id in request data')
return HttpResponse(dumps(result))
if 'user_password' not in request_data:
result = dict(success=False, message=u'no user password in request data')
return HttpResponse(dumps(result))
user_id = request_data['user_id']
user_password = str(md5.new(request_data['user_password']).hexdigest())
session = get_session()
user = session.query(User).filter_by(user_id=user_id).first()
if user == None :
session.close()
result = dict(success=False, message=u'no user match with that id')
return HttpResponse(dumps(result))
if user.user_password != user_password :
session.close()
result = dict(success=False, message=u'the password is wrong')
return HttpResponse(dumps(result))
if 'HTTP_DEVICE_ID' not in request.META :
session.close()
result = dict(success=False, message=u'no device id in request header')
return HttpResponse(dumps(result))
key_cache = get_cache('user_key')
uid = str(uuid.uuid4())
device_id = request.META['HTTP_DEVICE_ID']
key_cache.set(device_id, uid, DAY)
user_info = to_dict(user.userinfo)
user_session = get_cache('user_session')
user_session.set(uid, dumps(user_info), DAY)
session.close()
result = dict(success=True, user_id = user_info['user_id'], server_key=uid, message=u'logged in')
return HttpResponse(dumps(result))
def get_snap_comments(request, snap_id=None):
limit, offset = get_paginate_info(request.GET)
session = get_session()
snap = session.query(Snap).get(snap_id)
if not snap :
result = dict(success=False, message=u'snaps.views.get_snap_comments: no snap with snap id {snap_id}'.format(snap_id=snap_id))
return HttpResponse(dumps(result))
comments = session.query(SnapComment).filter_by(snap_id=snap_id).limit(limit).offset(offset).all()
data = dict(
comment_list = to_dict(comments),
)
session.close()
result = dict(success=True, message=u'snaps.views.get_snap_comments: comment of Snap {snap_id} from {start} to {end}'.format(snap_id=snap_id, start=offset, end=offset+limit), data=data)
return HttpResponse(dumps(result))
def get_spot_profile_image(request, spot_id=None):
size = dict(original=0, thumbnail=1)
image_to_send = size["original"]
if "size" in request.GET:
image_to_send = size[request.GET["size"]]
session = get_session()
image = session.query(SpotProfileImage).get(spot_id)
session.close()
if not image:
result = dict(success=False, message=u"spots.views.get_spot_profile_image: no image at spot %s" % spot_id)
return HttpResponse(dumps(result))
if image_to_send == size["original"]:
return HttpResponse(image.image, mimetype="image/jpeg")
elif image_to_send == size["thumbnail1"]:
return HttpResponse(image.thumbnail1_image, mimetype="image/jpeg")
else:
return HttpResponse(image.image, mimetype="image/jpeg")
def update_spot_info(request, spot_id=None):
request_data = loads(request.raw_post_data)
remove_keys(request_data, Spot)
session = get_session()
spot_info = session.query(Spot).get(spot_id)
for key, value in request_data.items():
setattr(spot_info, key, value)
try:
session.merge(spot_info)
session.commit()
except:
session.rollback()
session.close()
result = dict(success=False, message=u"spots.views.update_spot_info: failed to update spot info")
return HttpResponse(dumps(result))
session.close()
result = dict(
success=True, message=u"spots.views.update_spot_info: spot id {spot_id} updated".format(spot_id=spot_id)
)
return HttpResponse(dumps(result))
def create_snap(request) :
# 특별하게 얘만 복합데이터, 헤더 조작후에 json을 POST안에 'data'라는 키로 따로 가져오기로 함.
request_data = loads(request.POST['data'])
user_id = get_user_id(request.META)
if not user_id :
result = dict(success=False, message=u'snaps.views.create_snap: user id not found')
return HttpResponse(dumps(result))
if not request_data :
result = dict(success=False, message=u'snaps.views.create_snap: no request data')
return HttpResponse(dumps(result))
if 'spot_id' not in request_data :
result = dict(success=False, message=u'snaps.views.create_snap: no spot id found in request data')
return HttpResponse(dumps(result))
if 'model_id' not in request_data :
result = dict(success=False, message=u'snaps.views.create_snap: no model id found in request data')
return HttpResponse(dumps(result))
request_data['user_id'] = user_id
filename = None
for temp_filename in request.FILES :
filename = temp_filename
if not filename :
result = dict(success=False, message=u'snaps.views.create_snap: no image attatched in request data')
return HttpResponse(dumps(result))
image_id = save_image(request.FILES[filename])
if not image_id :
result = dict(success=False, message=u'snaps.views.create_snap: failed to save image')
return HttpResponse(dumps(result))
request_data['image_id'] = image_id
request_data['snaptime'] = datetime.datetime.now()
remove_keys(request_data, Snap)
new_snap = Snap(**request_data)
session = get_session()
spot = session.query(Spot).get(request_data['spot_id'])
user_info = session.query(UserInfo).get(request_data['user_id'])
model_info = session.query(UserInfo).get(request_data['model_id'])
if not spot :
result = dict(success=False, message=u'snaps.views.create_snap: no spot found')
return HttpResponse(dumps(result))
if not user_info :
result = dict(success=False, message=u'snaps.views.create_snap: no user info found')
return HttpResponse(dumps(result))
if not model_info :
result = dict(success=False, message=u'snaps.views.create_snap: no model info found')
return HttpResponse(dumps(result))
request_data['spot_name'] = spot.name
request_data['user_nickname'] = user_info.nickname
request_data['model_nickname'] = model_info.nickname
try:
session.add(new_snap)
session.commit()
except:
session.rollback()
session.query(Image).filter(Image.image_id==image_id).delete()
session.commit()
result = dict(success=False, message=u'snaps.views.create_snap: database error')
return HttpResponse(dumps(result))
session.close()
result = dict(success=True, message=u'snaps.views.create_snap: snaped!')
return HttpResponse(dumps(result))
def update_user_profile(request, user_id=None):
sessions_user_id = get_user_id(request.META)
if user_id != sessions_user_id :
result = dict(success=False, message=u'users.views.update_user_profile: you are not this user')
return HttpResponse(dumps(result))
request_data = loads(request.raw_post_data)
if not request_data :
result = dict(success=False, message=u'users.views.update_user_profile: no request data')
return HttpResponse(dumps(result))
remove_keys(request_data, UserInfo)
session = get_session()
user_info = session.query(UserInfo).get(user_id)
phone_number = request_data.get('phone_number', None)
if phone_number:
if not phone_number.isdigit() :
session.close()
result = dict(success=False, message=u'users.views.update_user_profile: phone_number must be digit')
return HttpResponse(dumps(result))
nickname = request_data.get('nickname', None)
if nickname :
existing_user_info = session.query(UserInfo).filter(UserInfo.nickname==request_data['nickname']).first()
if existing_user_info :
session.close()
result = dict(success=False, message=u'users.views.update_user_profile: user nickname duplicated')
return HttpResponse(dumps(result))
else :
snaps_by_me = session.query(Snap).filter_by(user_id=user_id).all()
for snap in snaps_by_me :
snap.user_nickname = nickname
session.merge(snap)
try :
session.commit()
except :
session.rollback()
session.close()
result = dict(success=False, message=u'users.views.update_user_profile: failed to update snaps (1)')
return HttpResponse(dumps(result))
snaps_by_others = session.query(Snap).filter_by(model_id=user_id).all()
for snap in snaps_by_others :
snap.model_nickname = request_data['nickname']
session.merge(snap)
try :
session.commit()
except :
session.rollback()
session.close()
result = dict(success=False, message=u'users.views.update_user_profile: failed to update snaps (2)')
return HttpResponse(dumps(result))
for key, value in request_data.items():
setattr(user_info, key, value)
try :
session.merge(user_info)
session.commit()
session.close()
except :
session.rollback()
session.close()
result = dict(success=False, message=u'users.views.update_user_profile: database error')
return HttpResponse(dumps(result))
result = dict(success=True, message=u'users.views.update_user_profile: user profile updated succesfully')
return HttpResponse(dumps(result))
