def edit(request, user_id, photo_id):
# 只有登录用户，且是自己的照片，才可以操作，
if not request.user.is_authenticated() or str(request.user.id) != user_id:
return error_404(request)
try:
photo = Photo.objects.get(owner=request.user, id=photo_id)
except:
return error_404(request)
if request.method == "POST":
if request.POST.get("update") == u"更新":
title = (request.POST.get("title", "")).strip() # 去掉两端的空格
caption = (request.POST.get("caption", "")).strip() # 去掉两端的空格
tags = request.POST.get("tags", "").strip() # 去掉两端的空格
tags = tags.replace(u"，", ",") # 把中文的逗号'，'替换成英文的','
tag_list = tags.split(",")
photo.update_photo_info(title, caption, tag_list)
elif request.POST.get("cancel") == u"撤销":
pass
return HttpResponseRedirect(
settings.HOME_PAGE_URL + "photos/" + str(user_id) + "/" + str(photo_id) + "/"
) # 跳转到该照片的页面
else:
tag_list = []
for tag in photo.tags.all():
tag_list.append(tag.name)
photo.tagStr = u"，".join(tag_list)
return render_to_response("photos/edit.html", {"request": request, "photo": photo})
def default(request):
if 'q' in request.GET:
q = request.GET['q']
if not q:
return error_404(request)
else:
# contains是严格区分大小写的，icontains（Case-insensitive contains）是不严格区分大小写的
inner_qs_tag = Tag.objects.filter(name__icontains=q)
inner_qs_user = User.objects.filter(name__icontains=q)
photo_by_tag = Photo.objects.filter(tags__in=inner_qs_tag).order_by('id')
photo_by_user_name = Photo.objects.filter(owner__in=inner_qs_user).order_by('id')
photos_by_caption = Photo.objects.filter(caption__icontains=q).order_by('id')
# 将根据用户名，标签，描述，搜索到的图片列表合并成不包含重复的图片列表
photos = util.merge_photos(photo_by_tag, photo_by_user_name, photos_by_caption)
for p in photos:
p.tag_list = p.tags.all()[0:4] # 只取前4个标签
p_len = len(photos)
p_items = []
for i in range(0, p_len, 3):
p_items.extend([photos[i:i + 3]]) # 在末端添加列表元素
return render_to_response('search/default.html', {'request': request, 'query': q, 'p_items': p_items})
else:
return error_404(request)
def edit(request, user_id, photo_id):
# 只有登录用户，且是自己的照片，才可以操作，
if not request.user.is_authenticated() or str(request.user.id) != user_id:
return error_404(request)
try:
photo = Photo.objects.get(owner=request.user, id=photo_id)
except:
return error_404(request)
if request.method == 'POST':
if request.POST.get('update') == u'更新':
title = (request.POST.get('title', '')).strip() # 去掉两端的空格
caption = (request.POST.get('caption', '')).strip() # 去掉两端的空格
tags = request.POST.get('tags', '').strip() # 去掉两端的空格
tags = tags.replace(u'，', ',') # 把中文的逗号'，'替换成英文的','
tag_list = tags.split(',')
photo.update_photo_info(title, caption, tag_list)
elif request.POST.get('cancel') == u'撤销':
pass
return HttpResponseRedirect(settings.HOME_PAGE_URL + 'photos/' +
str(user_id) + '/' + str(photo_id) +
'/') # 跳转到该照片的页面
else:
tag_list = []
for tag in photo.tags.all():
tag_list.append(tag.name)
photo.tagStr = u'，'.join(tag_list)
return render_to_response('photos/edit.html', {
'request': request,
'photo': photo
})
def default(request):
if 'q' in request.GET:
q = request.GET['q']
if not q:
return error_404(request)
else:
# contains是严格区分大小写的，icontains（Case-insensitive contains）是不严格区分大小写的
inner_qs_tag = Tag.objects.filter(name__icontains=q)
inner_qs_user = User.objects.filter(name__icontains=q)
photo_by_tag = Photo.objects.filter(
tags__in=inner_qs_tag).order_by('id')
photo_by_user_name = Photo.objects.filter(
owner__in=inner_qs_user).order_by('id')
photos_by_caption = Photo.objects.filter(
caption__icontains=q).order_by('id')
# 将根据用户名，标签，描述，搜索到的图片列表合并成不包含重复的图片列表
photos = util.merge_photos(photo_by_tag, photo_by_user_name,
photos_by_caption)
for p in photos:
p.tag_list = p.tags.all()[0:4] # 只取前4个标签
p_len = len(photos)
p_items = []
for i in range(0, p_len, 3):
p_items.extend([photos[i:i + 3]]) # 在末端添加列表元素
return render_to_response('search/default.html', {
'request': request,
'query': q,
'p_items': p_items
})
else:
return error_404(request)
def edit(request, user_id, album_id):
if not request.user.is_authenticated() or user_id != str(request.user.id):
return error_404(request)
try:
people = User.objects.get(id=user_id)
album = Album.objects.get(owner=people, id=album_id)
except User.DoesNotExist, Album.DoesNotExist:
return error_404(request)
def edit(request, user_id, album_id):
if not request.user.is_authenticated() or user_id != str(request.user.id):
return error_404(request)
try:
people = User.objects.get(id=user_id)
album = Album.objects.get(owner=people, id=album_id)
except User.DoesNotExist, Album.DoesNotExist:
return error_404(request)
def upload_done(request):
# 只有登录用户才可以操作
if not request.user.is_authenticated():
return error_404(request)
if UPLOAD_STEP2_SESSION_KEY in request.session and request.session[UPLOAD_STEP2_SESSION_KEY]: # 通过第二步
# request.session[UPLOAD_STEP1_SESSION_KEY] = False
request.session[UPLOAD_STEP2_SESSION_KEY] = False
return render_to_response("photos/upload_done.html", {"request": request})
else:
return error_404(request)
def upload_done(request):
# 只有登录用户才可以操作
if not request.user.is_authenticated():
return error_404(request)
if UPLOAD_STEP2_SESSION_KEY in request.session and request.session[
UPLOAD_STEP2_SESSION_KEY]: # 通过第二步
# request.session[UPLOAD_STEP1_SESSION_KEY] = False
request.session[UPLOAD_STEP2_SESSION_KEY] = False
return render_to_response('photos/upload_done.html',
{'request': request})
else:
return error_404(request)
def photo(request, user_id, photo_id):
try:
people = User.objects.get(id=user_id)
photo = Photo.objects.get(owner=people, id=photo_id)
except User.DoesNotExist, Photo.DoesNotExist:
return error_404(request)
def album(request, user_id, album_id):
try:
people = User.objects.get(id=user_id)
album = Album.objects.get(owner=people, id=album_id)
except:
return error_404(request)
photos = Photo.objects.filter(owner=people, album=album).order_by(
'-date_posted') # 按上传时间倒序，最近的排在前面
album.cover_loc = album.getCoverLoc()
for p in photos:
p.tag_list = p.tags.all()[0:4] # 只取前4个标签
p_len = len(photos)
p_items = []
for i in range(0, p_len, 3):
p_items.extend([photos[i:i + 3]]) # 在末端添加列表元素
# 注意user_id是unicode字符串，比较时要先转成字符串
if request.user.is_authenticated() and str(request.user.id) == user_id:
is_myPage = True # 用户查看自己的相册页面，可以进行编辑操作
else:
is_myPage = False
return render_to_response(
'albums/album.html', {
'request': request,
'people': people,
'p_items': p_items,
'is_myPage': is_myPage,
'album': album
})
def profile(request):
if not request.user.is_authenticated():
return error_404(request)
if request.method == 'POST':
user = request.user
name = request.POST.get('name', '')
if name != user.name:
form = UserInfoEditForm(user, request.POST)
if form.is_valid():
user = form.save()
return render_to_response("accounts/profile.html",
{'user': user, 'name_edited': False, 'edit_success': True,
'request': request})
else:
return render_to_response("accounts/profile.html",
{'user': user, 'name_edited': True, 'name_hasExist': form.name_hasExist,
'request': request})
else:
return render_to_response("accounts/profile.html",
{'user': user, 'name_edited': False, 'request': request})
else:
user = request.user
return render_to_response("accounts/profile.html",
{'user': user, 'name_edited': False, 'request': request})
def upload(request):
# 只有登录用户才可以上传
if not request.user.is_authenticated():
return error_404(request)
if request.method == "POST":
photo_id_list = []
for i in request.FILES:
photo = Photo()
photo.save_photo_brief(request.user, request.FILES[i], request.POST["album_id"])
photo_id_list.append(photo.id)
album_id = string.atoi(request.POST["album_id"])
try:
album = Album.objects.get(owner=request.user, id=album_id)
except:
pass
else:
album.photo_count += len(photo_id_list) # 增加相册照片数
request.user.photo_count += len(photo_id_list) # 增加用户照片数
album.last_post = datetime.datetime.now()
album.save()
request.user.save()
request.session[UPLOAD_PHOTOS_SESSION_KEY] = tuple(photo_id_list) # 转换成元组
request.session[UPLOAD_STEP1_SESSION_KEY] = True # 通过第一步
request.session[UPLOAD_ALBUM_SESSION_KEY] = request.POST.get("album_id")
return HttpResponseRedirect("complete/") # 跳转到照片信息编辑页
else:
album_list = Album.objects.filter(owner=request.user) # 获取该用户的所有相册
return render_to_response("photos/upload.html", {"request": request, "album_list": album_list})
def album(request, user_id, album_id):
try:
people = User.objects.get(id=user_id)
album = Album.objects.get(owner=people, id=album_id)
except:
return error_404(request)
photos = Photo.objects.filter(owner=people, album=album).order_by('-date_posted') # 按上传时间倒序，最近的排在前面
album.cover_loc = album.getCoverLoc()
for p in photos:
p.tag_list = p.tags.all()[0:4] # 只取前4个标签
p_len = len(photos)
p_items = []
for i in range(0, p_len, 3):
p_items.extend([photos[i:i + 3]]) # 在末端添加列表元素
# 注意user_id是unicode字符串，比较时要先转成字符串
if request.user.is_authenticated() and str(request.user.id) == user_id:
is_myPage = True # 用户查看自己的相册页面，可以进行编辑操作
else:
is_myPage = False
return render_to_response('albums/album.html', {'request': request, 'people': people,
'p_items': p_items, 'is_myPage': is_myPage, 'album': album})
def profile(request, user_id):
try:
people = User.objects.get(id=user_id)
except:
return error_404(request)
is_myPage = False # 用来标记该页面是不是登录用户的个人页面
if request.user.is_authenticated():
if str(request.user.id) == user_id: # 注意user_id是unicode字符串，比较时要先转成字符串
is_myPage = True
else:
try:
Follow.objects.get(be_followed_user=people,
follower=request.user)
except Follow.DoesNotExist:
people.i_follow = False
else:
people.i_follow = True
request.pageTitle = people.name + u"的个人资料"
return render_to_response('people/profile.html', {
'request': request,
'people': people,
'is_myPage': is_myPage
})
def tags(request, user_id):
try:
people = User.objects.get(id=user_id)
except:
return error_404(request)
tag_list = UserTag.objects.filter(user=people)
for t in tag_list:
if t.used_count == 1:
t.fontsize = 14
elif t.used_count < 5:
t.fontsize = 16
elif t.used_count < 10:
t.fontsize = 20
elif t.used_count < 17:
t.fontsize = 24
else:
t.fontsize = 28
is_myPage = False # 用来标记该页面是不是登录用户的个人页面
if request.user.is_authenticated():
if str(request.user.id) == user_id: # 注意user_id是unicode字符串，比较时要先转成字符串
is_myPage = True # 用户查看自己的页面，可以进行编辑操作
else:
try:
Follow.objects.get(be_followed_user=people, follower=request.user)
except Follow.DoesNotExist:
people.i_follow = False
else:
people.i_follow = True
request.pageTitle = people.name + u"的标签"
return render_to_response('people/tags.html', {'request': request,
'people': people, 'tag_list': tag_list, 'is_myPage': is_myPage})
def photo(request, user_id, photo_id):
try:
people = User.objects.get(id=user_id)
photo = Photo.objects.get(owner=people, id=photo_id)
except User.DoesNotExist, Photo.DoesNotExist:
return error_404(request)
def albums(request, user_id):
try:
people = User.objects.get(id=user_id)
except:
return error_404(request)
album_list = Album.objects.filter(owner=people).order_by(
'-date_created') # 按创建时间倒序，最近的排在前面
# 添加相册封面图片的地址
for album in album_list:
album.cover_loc = album.getCoverLoc()
is_myPage = False # 用来标记该页面是不是登录用户的个人页面
if request.user.is_authenticated():
if str(request.user.id) == user_id: # 注意user_id是unicode字符串，比较时要先转成字符串
is_myPage = True
else:
try:
Follow.objects.get(be_followed_user=people,
follower=request.user)
except Follow.DoesNotExist:
people.i_follow = False
else:
people.i_follow = True
request.pageTitle = people.name + u"的相册"
return render_to_response(
'people/albums.html', {
'request': request,
'people': people,
'album_list': album_list,
'is_myPage': is_myPage
})
def comments(request, user_id, is_myComments=False):
# 只有登录用户，且是自己的页面，才可以操作
if not request.user.is_authenticated() or str(request.user.id) != user_id:
return error_404(request)
comment_list = []
if is_myComments:
comment_list = Comment.objects.filter(
author=request.user).order_by('-date_posted')
else:
comment_list = Comment.objects.filter(
photo_owner=request.user,
deleted_by_photo_owner=False).order_by('-date_posted')
for c in comment_list:
c.photo = Photo.objects.get(id=c.photo_id)
request.pageTitle = request.user.name + u"的评论"
return render_to_response(
'people/comments.html', {
'request': request,
'is_myPage': True,
'people': request.user,
'comment_list': comment_list,
'is_myComments': is_myComments
})
def editpassword(request):
if not request.user.is_authenticated():
return error_404(request)
if request.method == 'POST':
user = request.user
form = PasswordChangeForm(user, request.POST)
if form.is_valid():
user = form.save() # 将数据保存到数据库中
return render_to_response("accounts/editpassword.html", {
'editpassword_success': True,
'request': request
}) # 修改成功
else:
return render_to_response(
"accounts/editpassword.html", {
'editpassword_success': False,
'password_notMatch': form.password_notMatch,
'old_password_correct': form.old_password_correct,
'request': request
})
else:
return render_to_response(
"accounts/editpassword.html", {
'editpassword_success': False,
'request': request,
'old_password_correct': True
})
def albums(request, user_id):
try:
people = User.objects.get(id=user_id)
except:
return error_404(request)
album_list = Album.objects.filter(owner=people).order_by('-date_created') # 按创建时间倒序，最近的排在前面
# 添加相册封面图片的地址
for album in album_list:
album.cover_loc = album.getCoverLoc()
is_myPage = False # 用来标记该页面是不是登录用户的个人页面
if request.user.is_authenticated():
if str(request.user.id) == user_id: # 注意user_id是unicode字符串，比较时要先转成字符串
is_myPage = True
else:
try:
Follow.objects.get(be_followed_user=people, follower=request.user)
except Follow.DoesNotExist:
people.i_follow = False
else:
people.i_follow = True
request.pageTitle = people.name + u"的相册"
return render_to_response('people/albums.html', {'request': request,
'people': people, 'album_list': album_list,
'is_myPage': is_myPage})
def follow(request, user_id, is_myFollow=True):
try:
people = User.objects.get(id=user_id)
except:
return error_404(request)
follow_list = []
if is_myFollow:
follow_list = Follow.objects.filter(follower=people).order_by('-date_followed')
else:
follow_list = Follow.objects.filter(be_followed_user=people).order_by('-date_followed')
is_myPage = False # 用来标记该页面是不是登录用户的个人页面
if request.user.is_authenticated():
if str(request.user.id) == user_id: # 注意user_id是unicode字符串，比较时要先转成字符串
is_myPage = True
else:
try:
Follow.objects.get(be_followed_user=people, follower=request.user)
except Follow.DoesNotExist:
people.i_follow = False
else:
people.i_follow = True
request.pageTitle = people.name + u"的关注"
return render_to_response('people/follow.html', {'request': request, 'is_myPage': is_myPage,
'people': request.user, 'follow_list': follow_list,
'is_myFollow': is_myFollow, 'people': people})
def prev_photo(request, user_id, photo_id):
try:
people = User.objects.get(id=user_id)
photo = Photo.objects.get(owner=people, id=photo_id)
try:
# id__lt表示id小于
prev_photo = Photo.objects.filter(id__lt=photo_id, owner=photo.owner, album=photo.album).order_by("-id")[0]
prev_photo_id = prev_photo.id
except: # 不存在上一张照片，就用当前这张
prev_photo_id = photo_id
except User.DoesNotExist, Photo.DoesNotExist:
return error_404(request)
def home(request, user_id):
try:
people = User.objects.get(id=user_id)
except:
return error_404(request)
recent_photos = Photo.objects.filter(
owner=people).order_by('-date_posted')[0:12] # 按上传时间倒序，最近的排在前面
album_list = Album.objects.filter(
owner=people).order_by('-date_created')[0:10] # 按创建时间倒序，最近的排在前面
# 统计相册数目是否大于10，若大于则显示，“查看更多”
if Album.objects.filter(owner=people).count() > 10:
album_too_more = True
else:
album_too_more = False
# 添加相册封面图片的地址
for album in album_list:
album.cover_loc = album.getCoverLoc()
# 取标签
for p in recent_photos:
p.tag_list = p.tags.all()[0:4] # 只取前4个标签
p_len = len(recent_photos)
p_items = []
for i in range(0, p_len, 2):
p_items.extend([recent_photos[i:i + 2]]) # 在末端添加列表元素
is_myPage = False # 用来标记该页面是不是登录用户的个人页面
if request.user.is_authenticated():
if str(request.user.id) == user_id: # 注意user_id是unicode字符串，比较时要先转成字符串
is_myPage = True # 用户查看自己的页面，可以进行编辑操作
else:
try:
Follow.objects.get(be_followed_user=people,
follower=request.user)
except Follow.DoesNotExist:
people.i_follow = False
else:
people.i_follow = True
request.pageTitle = people.name + u'的照片' # django模板使用unicode编码
return render_to_response(
'people/home.html', {
'request': request,
'people': people,
'album_list': album_list,
'p_items': p_items,
'album_too_more': album_too_more,
'is_myPage': is_myPage
})
def prev_photo(request, user_id, photo_id):
try:
people = User.objects.get(id=user_id)
photo = Photo.objects.get(owner=people, id=photo_id)
try:
# id__lt表示id小于
prev_photo = Photo.objects.filter(
id__lt=photo_id, owner=photo.owner,
album=photo.album).order_by('-id')[0]
prev_photo_id = prev_photo.id
except: # 不存在上一张照片，就用当前这张
prev_photo_id = photo_id
except User.DoesNotExist, Photo.DoesNotExist:
return error_404(request)
def create(request, user_id):
if not request.user.is_authenticated() or user_id != str(request.user.id):
return error_404(request)
if request.method == 'POST':
if request.POST.get('create') == u'创建相册':
form = AlbumCreationForm(request.user, request.POST)
if form.is_valid():
form.save()
return render_to_response('albums/create_done.html', {'request': request})
else:
return render_to_response('albums/create.html', {'request': request, 'form': form})
elif request.POST.get('cancel') == u'取消':
return HttpResponseRedirect(settings.HOME_PAGE_URL
+ "people/" + str(request.user.id) + "/albums/") # 跳转到用户的相册
else:
return render_to_response('albums/create.html', {'request': request})
def likes(request, user_id):
try:
people = User.objects.get(id=user_id)
except:
return error_404(request)
likes = Like.objects.filter(user=people).order_by(
'-date_liked') # 按喜欢时间倒序，最近的排在前面
photos = []
for l in likes:
p = Photo.objects.get(id=l.photo_id)
photos.append(p) # 在末端添加元素
p_len = len(photos)
# 把[1,2,3,...,10,11,12]转换成[[1,2,3,...,10],[11,12]]
p_items = []
for i in range(0, p_len, 10):
p_items.extend([photos[i:i + 10]]) # 在末端添加列表元素
is_myPage = False # 用来标记该页面是不是登录用户的个人页面
if request.user.is_authenticated():
if str(request.user.id) == user_id: # 注意user_id是unicode字符串，比较时要先转成字符串
is_myPage = True # 用户查看自己的页面，可以进行编辑操作
else:
try:
Follow.objects.get(be_followed_user=people,
follower=request.user)
except Follow.DoesNotExist:
people.i_follow = False
else:
people.i_follow = True
request.pageTitle = people.name + u"喜欢的照片"
return render_to_response(
'people/likes.html', {
'request': request,
'people': people,
'p_items': p_items,
'is_myPage': is_myPage
})
def editpassword(request):
if not request.user.is_authenticated():
return error_404(request)
if request.method == 'POST':
user = request.user
form = PasswordChangeForm(user, request.POST)
if form.is_valid():
user = form.save() # 将数据保存到数据库中
return render_to_response("accounts/editpassword.html",
{'editpassword_success': True, 'request': request}) # 修改成功
else:
return render_to_response("accounts/editpassword.html", {'editpassword_success': False,
'password_notMatch': form.password_notMatch,
'old_password_correct': form.old_password_correct,
'request': request})
else:
return render_to_response("accounts/editpassword.html",
{'editpassword_success': False, 'request': request, 'old_password_correct': True})
def home(request, user_id):
try:
people = User.objects.get(id=user_id)
except:
return error_404(request)
recent_photos = Photo.objects.filter(owner=people).order_by('-date_posted')[0:12] # 按上传时间倒序，最近的排在前面
album_list = Album.objects.filter(owner=people).order_by('-date_created')[0:10] # 按创建时间倒序，最近的排在前面
# 统计相册数目是否大于10，若大于则显示，“查看更多”
if Album.objects.filter(owner=people).count() > 10:
album_too_more = True
else:
album_too_more = False
# 添加相册封面图片的地址
for album in album_list:
album.cover_loc = album.getCoverLoc()
# 取标签
for p in recent_photos:
p.tag_list = p.tags.all()[0:4] # 只取前4个标签
p_len = len(recent_photos)
p_items = []
for i in range(0, p_len, 2):
p_items.extend([recent_photos[i:i + 2]]) # 在末端添加列表元素
is_myPage = False # 用来标记该页面是不是登录用户的个人页面
if request.user.is_authenticated():
if str(request.user.id) == user_id: # 注意user_id是unicode字符串，比较时要先转成字符串
is_myPage = True # 用户查看自己的页面，可以进行编辑操作
else:
try:
Follow.objects.get(be_followed_user=people, follower=request.user)
except Follow.DoesNotExist:
people.i_follow = False
else:
people.i_follow = True
request.pageTitle = people.name + u'的照片' # django模板使用unicode编码
return render_to_response('people/home.html', {'request': request, 'people': people,
'album_list': album_list, 'p_items': p_items,
'album_too_more': album_too_more, 'is_myPage': is_myPage})
def upload_complete(request):
# 只有登录用户，已通过第一步的前提下，才可以操作，
if (not request.user.is_authenticated()) or \
(UPLOAD_PHOTOS_SESSION_KEY not in request.session) or \
(UPLOAD_STEP1_SESSION_KEY not in request.session) or \
(not request.session[UPLOAD_STEP1_SESSION_KEY]):
return error_404(request)
if request.method == 'POST':
photo_id_list = request.session[UPLOAD_PHOTOS_SESSION_KEY]
for p_id in photo_id_list:
try:
photo = Photo.objects.get(id=p_id)
except:
pass
else:
title = (request.POST.get(str(p_id) + '_title',
'')).strip() # 去掉两端的空格
caption = (request.POST.get(str(p_id) + '_caption',
'')).strip() # 去掉两端的空格
tags = (request.POST.get(str(p_id) + '_tags', '')).strip()
tags = tags.replace(u'，', ',') # 把中文的逗号'，'替换成英文的','
tag_list = tags.split(',')
photo.save_photo_description(request.user, title, caption,
tag_list)
request.session[UPLOAD_STEP1_SESSION_KEY] = False
request.session[UPLOAD_STEP2_SESSION_KEY] = True # 通过第二步
return HttpResponseRedirect('done/') # 跳转到照片上传完成页
else:
photo_id_list = request.session[UPLOAD_PHOTOS_SESSION_KEY]
photo_list = []
for p_id in photo_id_list:
photo = Photo.objects.get(id=p_id)
photo.input_title_name = str(photo.id) + '_title'
photo.input_caption_name = str(photo.id) + '_caption'
photo.input_tags_name = str(photo.id) + '_tags'
photo_list.append(photo)
return render_to_response('photos/upload_complete.html', {
'request': request,
'photo_list': photo_list
})
def profile(request, user_id):
try:
people = User.objects.get(id=user_id)
except:
return error_404(request)
is_myPage = False # 用来标记该页面是不是登录用户的个人页面
if request.user.is_authenticated():
if str(request.user.id) == user_id: # 注意user_id是unicode字符串，比较时要先转成字符串
is_myPage = True
else:
try:
Follow.objects.get(be_followed_user=people, follower=request.user)
except Follow.DoesNotExist:
people.i_follow = False
else:
people.i_follow = True
request.pageTitle = people.name + u"的个人资料"
return render_to_response('people/profile.html', {'request': request, 'people': people, 'is_myPage': is_myPage})
def comments(request, user_id, is_myComments=False):
# 只有登录用户，且是自己的页面，才可以操作
if not request.user.is_authenticated() or str(request.user.id) != user_id:
return error_404(request)
comment_list = []
if is_myComments:
comment_list = Comment.objects.filter(author=request.user).order_by('-date_posted')
else:
comment_list = Comment.objects.filter(photo_owner=request.user, deleted_by_photo_owner=False).order_by(
'-date_posted')
for c in comment_list:
c.photo = Photo.objects.get(id=c.photo_id)
request.pageTitle = request.user.name + u"的评论"
return render_to_response('people/comments.html', {'request': request, 'is_myPage': True,
'people': request.user, 'comment_list': comment_list,
'is_myComments': is_myComments})
def tags(request, user_id):
try:
people = User.objects.get(id=user_id)
except:
return error_404(request)
tag_list = UserTag.objects.filter(user=people)
for t in tag_list:
if t.used_count == 1:
t.fontsize = 14
elif t.used_count < 5:
t.fontsize = 16
elif t.used_count < 10:
t.fontsize = 20
elif t.used_count < 17:
t.fontsize = 24
else:
t.fontsize = 28
is_myPage = False # 用来标记该页面是不是登录用户的个人页面
if request.user.is_authenticated():
if str(request.user.id) == user_id: # 注意user_id是unicode字符串，比较时要先转成字符串
is_myPage = True # 用户查看自己的页面，可以进行编辑操作
else:
try:
Follow.objects.get(be_followed_user=people,
follower=request.user)
except Follow.DoesNotExist:
people.i_follow = False
else:
people.i_follow = True
request.pageTitle = people.name + u"的标签"
return render_to_response(
'people/tags.html', {
'request': request,
'people': people,
'tag_list': tag_list,
'is_myPage': is_myPage
})
def profile(request):
if not request.user.is_authenticated():
return error_404(request)
if request.method == 'POST':
user = request.user
name = request.POST.get('name', '')
if name != user.name:
form = UserInfoEditForm(user, request.POST)
if form.is_valid():
user = form.save()
return render_to_response(
"accounts/profile.html", {
'user': user,
'name_edited': False,
'edit_success': True,
'request': request
})
else:
return render_to_response(
"accounts/profile.html", {
'user': user,
'name_edited': True,
'name_hasExist': form.name_hasExist,
'request': request
})
else:
return render_to_response("accounts/profile.html", {
'user': user,
'name_edited': False,
'request': request
})
else:
user = request.user
return render_to_response("accounts/profile.html", {
'user': user,
'name_edited': False,
'request': request
})
def create(request, user_id):
if not request.user.is_authenticated() or user_id != str(request.user.id):
return error_404(request)
if request.method == 'POST':
if request.POST.get('create') == u'创建相册':
form = AlbumCreationForm(request.user, request.POST)
if form.is_valid():
form.save()
return render_to_response('albums/create_done.html',
{'request': request})
else:
return render_to_response('albums/create.html', {
'request': request,
'form': form
})
elif request.POST.get('cancel') == u'取消':
return HttpResponseRedirect(settings.HOME_PAGE_URL + "people/" +
str(request.user.id) +
"/albums/") # 跳转到用户的相册
else:
return render_to_response('albums/create.html', {'request': request})
def upload_complete(request):
# 只有登录用户，已通过第一步的前提下，才可以操作，
if (
(not request.user.is_authenticated())
or (UPLOAD_PHOTOS_SESSION_KEY not in request.session)
or (UPLOAD_STEP1_SESSION_KEY not in request.session)
or (not request.session[UPLOAD_STEP1_SESSION_KEY])
):
return error_404(request)
if request.method == "POST":
photo_id_list = request.session[UPLOAD_PHOTOS_SESSION_KEY]
for p_id in photo_id_list:
try:
photo = Photo.objects.get(id=p_id)
except:
pass
else:
title = (request.POST.get(str(p_id) + "_title", "")).strip() # 去掉两端的空格
caption = (request.POST.get(str(p_id) + "_caption", "")).strip() # 去掉两端的空格
tags = (request.POST.get(str(p_id) + "_tags", "")).strip()
tags = tags.replace(u"，", ",") # 把中文的逗号'，'替换成英文的','
tag_list = tags.split(",")
photo.save_photo_description(request.user, title, caption, tag_list)
request.session[UPLOAD_STEP1_SESSION_KEY] = False
request.session[UPLOAD_STEP2_SESSION_KEY] = True # 通过第二步
return HttpResponseRedirect("done/") # 跳转到照片上传完成页
else:
photo_id_list = request.session[UPLOAD_PHOTOS_SESSION_KEY]
photo_list = []
for p_id in photo_id_list:
photo = Photo.objects.get(id=p_id)
photo.input_title_name = str(photo.id) + "_title"
photo.input_caption_name = str(photo.id) + "_caption"
photo.input_tags_name = str(photo.id) + "_tags"
photo_list.append(photo)
return render_to_response("photos/upload_complete.html", {"request": request, "photo_list": photo_list})
def follow(request, user_id, is_myFollow=True):
try:
people = User.objects.get(id=user_id)
except:
return error_404(request)
follow_list = []
if is_myFollow:
follow_list = Follow.objects.filter(
follower=people).order_by('-date_followed')
else:
follow_list = Follow.objects.filter(
be_followed_user=people).order_by('-date_followed')
is_myPage = False # 用来标记该页面是不是登录用户的个人页面
if request.user.is_authenticated():
if str(request.user.id) == user_id: # 注意user_id是unicode字符串，比较时要先转成字符串
is_myPage = True
else:
try:
Follow.objects.get(be_followed_user=people,
follower=request.user)
except Follow.DoesNotExist:
people.i_follow = False
else:
people.i_follow = True
request.pageTitle = people.name + u"的关注"
return render_to_response(
'people/follow.html', {
'request': request,
'is_myPage': is_myPage,
'people': request.user,
'follow_list': follow_list,
'is_myFollow': is_myFollow,
'people': people
})
def upload(request):
# 只有登录用户才可以上传
if not request.user.is_authenticated():
return error_404(request)
if request.method == 'POST':
photo_id_list = []
for i in request.FILES:
photo = Photo()
photo.save_photo_brief(request.user, request.FILES[i],
request.POST['album_id'])
photo_id_list.append(photo.id)
album_id = string.atoi(request.POST['album_id'])
try:
album = Album.objects.get(owner=request.user, id=album_id)
except:
pass
else:
album.photo_count += len(photo_id_list) # 增加相册照片数
request.user.photo_count += len(photo_id_list) # 增加用户照片数
album.last_post = datetime.datetime.now()
album.save()
request.user.save()
request.session[UPLOAD_PHOTOS_SESSION_KEY] = tuple(
photo_id_list) # 转换成元组
request.session[UPLOAD_STEP1_SESSION_KEY] = True # 通过第一步
request.session[UPLOAD_ALBUM_SESSION_KEY] = request.POST.get(
'album_id')
return HttpResponseRedirect('complete/') # 跳转到照片信息编辑页
else:
album_list = Album.objects.filter(owner=request.user) # 获取该用户的所有相册
return render_to_response('photos/upload.html', {
'request': request,
'album_list': album_list
})
def likes(request, user_id):
try:
people = User.objects.get(id=user_id)
except:
return error_404(request)
likes = Like.objects.filter(user=people).order_by('-date_liked') # 按喜欢时间倒序，最近的排在前面
photos = []
for l in likes:
p = Photo.objects.get(id=l.photo_id)
photos.append(p) # 在末端添加元素
p_len = len(photos)
# 把[1,2,3,...,10,11,12]转换成[[1,2,3,...,10],[11,12]]
p_items = []
for i in range(0, p_len, 10):
p_items.extend([photos[i:i + 10]]) # 在末端添加列表元素
is_myPage = False # 用来标记该页面是不是登录用户的个人页面
if request.user.is_authenticated():
if str(request.user.id) == user_id: # 注意user_id是unicode字符串，比较时要先转成字符串
is_myPage = True # 用户查看自己的页面，可以进行编辑操作
else:
try:
Follow.objects.get(be_followed_user=people, follower=request.user)
except Follow.DoesNotExist:
people.i_follow = False
else:
people.i_follow = True
request.pageTitle = people.name + u"喜欢的照片"
return render_to_response('people/likes.html',
{'request': request, 'people': people, 'p_items': p_items, 'is_myPage': is_myPage})
def editavatar(request):
if not request.user.is_authenticated():
return error_404(request)
if request.method == 'POST':
policy = qiniu.rs.PutPolicy('oxygen')
uptoken = policy.token()
extra = qiniu.io.PutExtra()
extra.mime_type = "image/jpeg"
bucket_name = 'oxygen'
user = request.user
file_name = 'a_' + str(user.id) + '_temp.jpg' # 临时头像文件
temp_avatar_loc = settings.AVATAR_RELATIVE_PATH + file_name # 头像图片相对于站点的存放位置
temp_abs_path = settings.UPLOAD_AVATAR_PATH + file_name
# 多个submit的判断，第一个name，第二个是value
if request.POST.get('pic_submit') == u'上传图片': # 中文使用unicode，要加u
img_file = request.FILES.get('pic_avatar')
if img_file == None: # 没有选择图片
if os.path.isfile(temp_abs_path): # 如果已存在上次上传的临时头像图片，则显示上传上传的图片
avatar_loc = temp_avatar_loc
else:
avatar_loc = user.avatar_loc
return render_to_response("accounts/editavatar.html",
{'avatar_loc': avatar_loc, 'request': request})
else:
image = Image.open(img_file)
image = util.makeSquareImg(image, 160)
# image.thumbnail((160,160), Image.ANTIALIAS)
if os.path.isfile(temp_abs_path): # 如果已存在上次上传的临时头像图片，先删除
os.remove(temp_abs_path)
image.save(temp_abs_path, "jpeg", quality=90) # 将该头像图片临时保存起来，不设置quality，默认是75
output = StringIO()
image.save(output, "jpeg", quality=90) # 不设置quality，默认是75
img_data = output.getvalue()
output.close()
ret, err = qiniu.io.put(uptoken, file_name, img_data, extra)
return render_to_response("accounts/editavatar.html",
{'avatar_loc': file_name, 'request': request})
elif request.POST.get('save') == u'保存':
if os.path.isfile(temp_abs_path): # 如果存在上传的临时头像图片，更新头像
nowTime = time.localtime()
# 头像地址加上时间，和之前的头像予以区分，可以避免使用相同路径，导致浏览器缓存图片而使得在返回个人资料页时，头像还是之前的
user.avatar_loc = '%s_a_%s_%s_l.jpg' % (settings.QINIU_FILE_PREFIX, str(user.id),
time.strftime('%Y%m%d%H%M%S', nowTime))
user.avatar_square_loc = '%s_a_%s_%s_s.jpg' % (settings.QINIU_FILE_PREFIX, str(user.id),
time.strftime('%Y%m%d%H%M%S', nowTime))
user.save() # 保存数据到数据库
if user.avatar_loc != settings.DEFAULT_AVATAR_LOC: # 如果用户不是使用缺省头像的话，删掉原先的图片
key = user.avatar_loc
ret, err = qiniu.rs.Client().delete(bucket_name, key)
ret, err = qiniu.rs.Client().stat(bucket_name, key)
key = user.avatar_square_loc
ret, err = qiniu.rs.Client().delete(bucket_name, key)
ret, err = qiniu.rs.Client().stat(bucket_name, key)
image = Image.open(temp_abs_path)
output = StringIO()
image.save(output, "jpeg", quality=90) # 不设置quality，默认是75
img_data = output.getvalue()
output.close()
ret, err = qiniu.io.put(uptoken, user.avatar_loc, img_data, extra)
image = util.makeSquareImg(image, 48)
output = StringIO()
image.save(output, "jpeg", quality=90) # 不设置quality，默认是75
img_data = output.getvalue()
output.close()
ret, err = qiniu.io.put(uptoken, user.avatar_square_loc, img_data, extra)
key = file_name # 删除临时头像图片
ret, err = qiniu.rs.Client().delete(bucket_name, key)
ret, err = qiniu.rs.Client().stat(bucket_name, key)
os.remove(temp_abs_path) # 删除临时头像图片
return HttpResponseRedirect(settings.HOME_PAGE_URL + 'accounts/profile/')
elif request.POST.get('cancel') == u'撤销':
if os.path.isfile(temp_abs_path): # 如果存在上传的临时头像图片，删除该图片
os.remove(temp_abs_path)
return HttpResponseRedirect(settings.HOME_PAGE_URL + 'accounts/profile/')
else:
user = request.user
return render_to_response("accounts/editavatar.html",
{'avatar_loc': user.avatar_loc, 'request': request})
def editavatar(request):
if not request.user.is_authenticated():
return error_404(request)
if request.method == 'POST':
policy = qiniu.rs.PutPolicy('oxygen')
uptoken = policy.token()
extra = qiniu.io.PutExtra()
extra.mime_type = "image/jpeg"
bucket_name = 'oxygen'
user = request.user
file_name = 'a_' + str(user.id) + '_temp.jpg' # 临时头像文件
temp_avatar_loc = settings.AVATAR_RELATIVE_PATH + file_name # 头像图片相对于站点的存放位置
temp_abs_path = settings.UPLOAD_AVATAR_PATH + file_name
# 多个submit的判断，第一个name，第二个是value
if request.POST.get('pic_submit') == u'上传图片': # 中文使用unicode，要加u
img_file = request.FILES.get('pic_avatar')
if img_file == None: # 没有选择图片
if os.path.isfile(
temp_abs_path): # 如果已存在上次上传的临时头像图片，则显示上传上传的图片
avatar_loc = temp_avatar_loc
else:
avatar_loc = user.avatar_loc
return render_to_response("accounts/editavatar.html", {
'avatar_loc': avatar_loc,
'request': request
})
else:
image = Image.open(img_file)
image = util.makeSquareImg(image, 160)
# image.thumbnail((160,160), Image.ANTIALIAS)
if os.path.isfile(temp_abs_path): # 如果已存在上次上传的临时头像图片，先删除
os.remove(temp_abs_path)
image.save(temp_abs_path, "jpeg",
quality=90) # 将该头像图片临时保存起来，不设置quality，默认是75
output = StringIO()
image.save(output, "jpeg", quality=90) # 不设置quality，默认是75
img_data = output.getvalue()
output.close()
ret, err = qiniu.io.put(uptoken, file_name, img_data, extra)
return render_to_response("accounts/editavatar.html", {
'avatar_loc': file_name,
'request': request
})
elif request.POST.get('save') == u'保存':
if os.path.isfile(temp_abs_path): # 如果存在上传的临时头像图片，更新头像
nowTime = time.localtime()
# 头像地址加上时间，和之前的头像予以区分，可以避免使用相同路径，导致浏览器缓存图片而使得在返回个人资料页时，头像还是之前的
user.avatar_loc = '%s_a_%s_%s_l.jpg' % (
settings.QINIU_FILE_PREFIX, str(
user.id), time.strftime('%Y%m%d%H%M%S', nowTime))
user.avatar_square_loc = '%s_a_%s_%s_s.jpg' % (
settings.QINIU_FILE_PREFIX, str(
user.id), time.strftime('%Y%m%d%H%M%S', nowTime))
user.save() # 保存数据到数据库
if user.avatar_loc != settings.DEFAULT_AVATAR_LOC: # 如果用户不是使用缺省头像的话，删掉原先的图片
key = user.avatar_loc
ret, err = qiniu.rs.Client().delete(bucket_name, key)
ret, err = qiniu.rs.Client().stat(bucket_name, key)
key = user.avatar_square_loc
ret, err = qiniu.rs.Client().delete(bucket_name, key)
ret, err = qiniu.rs.Client().stat(bucket_name, key)
image = Image.open(temp_abs_path)
output = StringIO()
image.save(output, "jpeg", quality=90) # 不设置quality，默认是75
img_data = output.getvalue()
output.close()
ret, err = qiniu.io.put(uptoken, user.avatar_loc, img_data,
extra)
image = util.makeSquareImg(image, 48)
output = StringIO()
image.save(output, "jpeg", quality=90) # 不设置quality，默认是75
img_data = output.getvalue()
output.close()
ret, err = qiniu.io.put(uptoken, user.avatar_square_loc,
img_data, extra)
key = file_name # 删除临时头像图片
ret, err = qiniu.rs.Client().delete(bucket_name, key)
ret, err = qiniu.rs.Client().stat(bucket_name, key)
os.remove(temp_abs_path) # 删除临时头像图片
return HttpResponseRedirect(settings.HOME_PAGE_URL +
'accounts/profile/')
elif request.POST.get('cancel') == u'撤销':
if os.path.isfile(temp_abs_path): # 如果存在上传的临时头像图片，删除该图片
os.remove(temp_abs_path)
return HttpResponseRedirect(settings.HOME_PAGE_URL +
'accounts/profile/')
else:
user = request.user
return render_to_response("accounts/editavatar.html", {
'avatar_loc': user.avatar_loc,
'request': request
})
