made a lot of major changes because it has been a long time since I commited last. There are many new features. Also added app.yaml file which should be placed in the web2py directly in order for the URL to work properly.

1 files changed, 364 insertions, 33 deletions

diff --git a/controllers/default.py b/controllers/default.py
index d9f9a6d..21cf579 100644
--- a/controllers/default.py
+++ b/controllers/default.py
@@ -1,12 +1,69 @@
 import os
+import pickle
+from gluon.tools import Service
+service=Service(globals())
 
-def sort_by_views(L):
-    if len(L) <= 1: return L
-    return sort_by_views( [ lt for lt in L[1:] if lt.views < L[0].views ] )  +  [ L[0] ]  +  sort_by_views( [ ge for ge in L[1:] if ge.views >= L[0].views ] )
+def get_requests():
+  if auth.is_logged_in():
+      users = db().select(db.auth_user.ALL)
+      for user in users:
+          if auth.user.username == user.username:
+               return len(pickle.loads(user.requests))
+  else: return None
+
+@auth.requires_membership('admin')
+def admin():
+  if "page" in request.vars.keys(): page = int(request.vars["page"])-1
+  else: page = 0
+  users = db().select(db.auth_user.ALL)
+  users_list=[]
+  for user in users:
+      users_list.append(user)
+  users_list.sort(cmp=lambda x,y:cmp(x.username.lower(),y.username.lower()))
+  users_on_page = users_list[page*10:(page+1)*10]
+  pages = len(users_list) / 10
+  if len(users_list)%10 > 0: pages += 1
+  return dict(users = users_on_page, page=page+1,pages=pages, num_requests = get_requests())
+
+@auth.requires_membership('admin')
+def make_admin():
+  if "page" in request.vars.keys(): page = int(request.vars["page"])
+  else: page = 1
+  if "user" in request.vars.keys(): user = request.vars["user"]
+  else: redirect(URL(r=request, f="admin?page="+str(page)))
+  auth.add_membership('admin',user)
+  redirect(URL(r=request, f="admin?page="+str(page)))
+
+@auth.requires_membership('admin')
+def remove_admin():
+  if "page" in request.vars.keys(): page = int(request.vars["page"])
+  else: page = 1
+  if "user" in request.vars.keys(): user = request.vars["user"]
+  else: redirect(URL(r=request, f="admin?page="+str(page)))
+  auth.del_membership(auth.id_group('admin'),user)
+  redirect(URL(r=request, f="admin?page="+str(page)))
+
+@auth.requires_membership('admin')
+def delete_user():
+  if "page" in request.vars.keys(): page = int(request.vars["page"])
+  else: page = 1
+  if "user" in request.vars.keys(): user_to_delete = request.vars["user"]
+  else: redirect(URL(r=request, f="admin?page="+str(page)))
+  query=(db.auth_user.username==user_to_delete)
+  db(query).delete()
+  images = db().select(db.image.ALL)
+  for image in images:
+      if image.creator == user_to_delete:
+          query=(db.image.id==image.id)
+          db(query).delete()
+  comments = db().select(db.comment.ALL)
+  for comment in comments:
+      if comment.author == user_to_delete:
+          query=(db.comment.id==comment.id)
+          db(query).delete()
+  redirect(URL(r=request, f="admin?page="+str(page))) 
+  
 
-def sort_by_id(L):
-    if len(L) <= 1: return L
-    return sort_by_id( [ lt for lt in L[1:] if lt.id < L[0].id ] )  +  [ L[0] ]  +  sort_by_id( [ ge for ge in L[1:] if ge.id >= L[0].id ] )
 
 def index():
   sorts = ["newest", "views"]
@@ -18,22 +75,37 @@ def index():
       sort = "newest"
   if "profile" in request.vars.keys(): profile = request.vars["profile"]
   else: profile = None
+  if "favorites" in request.vars.keys(): show_favorites = bool(request.vars["favorites"])
+  else: show_favorites = False
+  profile_user = None
+  favorites = None
+  if profile != None:
+     users = db().select(db.auth_user.ALL)
+     for user in users:
+         if user.username == profile:
+             profile_user = user
+             favorites = pickle.loads(profile_user.favorites)
   table = []
   raw_images = db().select(db.image.ALL)
   i = 0
   row = []
   count = 0
   images = []
+  c = 1
   for image in raw_images:
       if profile != None:
-          if image.creator == profile:
-              images.append(image)
+          if show_favorites:
+              if image.id in favorites:
+                  images.append(image)
+          if not show_favorites:
+              if image.creator == profile:
+                  images.append(image)
       else: images.append(image)
   if sort == 'views':
-      #images = sort_by_views(images)
+      images.sort(cmp=lambda x,y:cmp(float(x.views),float(y.views)))
       images.reverse()
   if sort == 'newest':
-      images.sort(cmp=lambda x,y:cmp(x.id,y.id))
+      images.sort(cmp=lambda x,y:cmp(float(x.Submit_Time),float(y.Submit_Time)))
       images.reverse()
   for image in images:
       if count >= page * 12 and page*12+12 > count:
@@ -48,28 +120,253 @@ def index():
   pages = count / 12
   if count%12 > 0: pages += 1
   page += 1
-  return dict(images=table, pages=pages, page=page, sort=sort, profile=profile)
+  return dict(images=table, pages=pages, page=page, sort=sort, profile=profile_user, show_favorites=show_favorites,num_requests = get_requests())
+
+
+def profile():
+    if "profile" in request.vars.keys(): profile = request.vars["profile"]
+    else: redirect(URL(r=request,f='index'))
+    users = db().select(db.auth_user.ALL)
+    for user in users:
+        if user.username == profile:
+            profile_user = user
+            favorite_ids = pickle.loads(profile_user.favorites)
+            friends = pickle.loads(profile_user.friends)
+    requests = pickle.loads(profile_user.requests)
+    raw_images = db().select(db.image.ALL)
+    images = []
+    favorites = []
+    avatar = None
+    for image in raw_images:
+        #if image.id == int(profile_user.avatar):
+        #    avatar = image
+        if image.creator == profile:
+            images.append(image)
+        if image.id in favorite_ids:
+            favorites.append(image)
+    images.sort(cmp=lambda x,y:cmp(float(x.Submit_Time),float(y.Submit_Time)))
+    images.reverse()
+    favorite_ids.reverse()
+    favorites_table = []
+    favs_sorted = []
+    i = 0
+    row = []
+    for f_id in favorite_ids:
+        if i < 8:
+             for fav in favorites:
+                  if fav.id == f_id:
+                      favs_sorted.append(fav)
+    if len(favs_sorted) < 4:
+        favorites_table.append(favs_sorted)
+    if len(favs_sorted) == 4 or len(favs_sorted)>4:
+        favorites_table.append(favs_sorted[:4])
+    if len(favs_sorted) > 4 and len(favs_sorted) < 8:
+        favorites_table.append(favs_sorted[4:])
+    if len(favs_sorted) > 4 and len(favs_sorted) >= 8:
+        favorites_table.append(favs_sorted[4:8])
+                      
+    images_table = []
+    row = []
+    c = 0
+    i = 0
+    for image in images:
+        if c < 2:
+            row.append(image)
+            i += 1
+            if i == 4:
+                images_table.append(row)
+                c += 1
+                i = 0
+                row = []
+    if len(images) < 8 and len(images)%4 != 0:
+        images_table.append(row)
+    return dict(profile = profile_user, images = images_table, favorites = favorites_table,requests = requests,friends=friends,avatar=avatar, num_requests = get_requests())
+
+def friends():
+   if "page" in request.vars.keys(): page = int(request.vars["page"]) - 1
+   else: page = 0
+   if "user" in request.vars.keys(): username = request.vars["user"]
+   else: redirect(URL(r=request,f='index'))
+   users = db().select(db.auth_user.ALL)
+   for user in users:
+       if user.username == username:
+            friends = pickle.loads(user.friends)
+   friends_list=[]
+   for user in users:
+       if user.username in friends:
+           friends_list.append(user)
+   friends_list.sort(cmp=lambda x,y:cmp(x.username.lower(),y.username.lower()))
+   friends_on_page = friends_list[page*10:(page+1)*10]
+   pages = len(friends_list) / 10
+   if len(friends_list)%10 > 0: pages += 1
+   return dict(username = username, friends = friends_on_page,page=page+1,pages=pages, num_requests = get_requests())
+
+def respond_to_request():
+   if "user" in request.vars.keys() and auth.is_logged_in(): username = request.vars["user"]
+   else: redirect(URL(r=request,f='index'))
+   if "response" in request.vars.keys(): response = bool(request.vars["user"])
+   else: redirect(URL(r=request,f='index'))
+   users = db().select(db.auth_user.ALL)
+   current_user = None
+   user_to_add = None
+   for user in users:
+       if user.username == auth.user.username:
+            current_user = user
+       if user.username == username:
+            user_to_add = user
+   if user_to_add == None or current_user == None:
+       redirect(URL(r=request,f='index'))
+   requests = pickle.loads(current_user.requests)
+   real_request = None
+   for r in requests:
+       if r[1] == user_to_add.username:
+           real_request = r
+   if real_request == None:redirect(URL(r=request,f='index'))
+   requests.remove(real_request)
+   db(db.auth_user.username==current_user.username).update(requests = pickle.dumps(requests))
+   if response:
+        friends = pickle.loads(current_user.friends)
+        friends.append(user_to_add.username)
+        db(db.auth_user.username==current_user.username).update(friends = pickle.dumps(friends))
+        friends = pickle.loads(user_to_add.friends)
+        friends.append(current_user.username)
+        db(db.auth_user.username==user_to_add.username).update(friends = pickle.dumps(friends))
+   redirect(URL(r=request,f='requests'))
+        
+def remove_friends():
+   if "user" in request.vars.keys() and auth.is_logged_in(): username = request.vars["user"]
+   else: redirect(URL(r=request,f='index'))      
+   users = db().select(db.auth_user.ALL)
+   current_user = None
+   user_to_remove = None
+   for user in users:
+       if user.username == auth.user.username:
+            current_user = user
+       if user.username == username:
+            user_to_remove = user  
+   if user_to_remove == None or current_user == None:
+       redirect(URL(r=request,f='index'))
+   friends = pickle.loads(current_user.friends)
+   if user_to_remove.username in friends:
+       friends.remove(user_to_remove.username)
+   db(db.auth_user.username==current_user.username).update(friends = pickle.dumps(friends))
+   friends = pickle.loads(user_to_remove.friends)
+   if current_user.username in friends:
+       friends.remove(current_user.username)
+   db(db.auth_user.username==user_to_remove.username).update(friends = pickle.dumps(friends))
+   redirect(URL(r=request,f='friends?user='+current_user.username))
+
+def add_as_friend():
+   if "user" in request.vars.keys() and auth.is_logged_in(): username = request.vars["user"]
+   else: redirect(URL(r=request,f='index'))
+   users = db().select(db.auth_user.ALL)
+   for user in users:
+       if user.username == username:
+           user_to_add = user
+   requests = pickle.loads(user_to_add.requests)
+   requests.append(('friend', auth.user.username))
+   db(db.auth_user.username==user_to_add.username).update(requests = pickle.dumps(requests))
+   redirect(URL(r=request,f='profile?profile='+username))
+
+
+def requests():
+    if not auth.is_logged_in(): redirect(URL(r=request,f='index'))
+    users = db().select(db.auth_user.ALL)
+    for user in users:
+        if user.username == auth.user.username:
+             current_user = user
+    requests = pickle.loads(current_user.requests)
+    return dict(requests = requests, num_requests = get_requests())
+
 
 def upload():
-    form = SQLFORM(db.image, fields = ['title', 'file', 'newimage', 'description'])
-    if form.accepts(request.vars, session):
-      session.new_image_title = form.vars.title
-      db(db.image.title==session.new_image_title).update(creator = auth.user.username)
-      db(db.image.title==session.new_image_title).update(views = 0)
-      redirect(URL(r=request, f='index')) 
+    upload_key = request.vars["upload_key"]
+    title = request.vars["title"]
+    form = SQLFORM(db.image, fields = ['title', 'file', 'newimage','small_image', 'description','upload_key'])
+    if form.accepts(request.vars):
+      keys = db().select(db.upload_key.ALL)
+      for key in keys:
+          if key.upload_key == upload_key:
+              user = key.user
+      db(db.image.upload_key==upload_key).update(creator = user)
+      query=(db.upload_key.upload_key==upload_key)
+      db(query).delete()
+      images = db().select(db.image.ALL)
+      for image in images:
+         if image.id == form.vars.id:
+            real_image = image
+      images = db().select(db.image.ALL)
+      for image in images:
+          if image.creator == user and image.title.lower() == form.vars.title.lower() and image.upload_key != upload_key:
+              db(db.image.upload_key==upload_key).update(views = image.views)
+              query=(db.image.id==image.id)
+              db(query).delete()
+    else:
+      import logging
+      logging.error("form not accepted")
+      raise HTTP(400,"failed to upload")
     return dict(form=form)
 
-"""@service.xmlrpc
-def upload_remote(username,password,image,ta_file,title,description):
+
+@service.xmlrpc
+def login_remote(username,password):
    logged_in = auth.login_bare(username,password)
    if logged_in:
-      db.image.insert(file=ta_file,
-                      image=image,
-                      title=title,
-                      description=description,
-                      creator=auth.user.username,
-                      views=0)"""
-   
+      db.upload_key.insert(user=username)
+      keys = db().select(db.upload_key.ALL)
+      for key in keys:
+          if key.user == username:
+               return str(key.upload_key)
+      return False
+   else: return False
+
+
+def remove_as_favorite():
+   if "id" in request.vars.keys(): image_id = int(request.vars["id"])
+   else: redirect(URL(r=request,f='index'))
+   if auth.is_logged_in():
+       images = db().select(db.image.ALL)
+       for image in images:
+           if image.id == image_id:
+               favorite_users = pickle.loads(image.favorite_users)
+       if auth.user.username in favorite_users:
+           favorite_users.remove(auth.user.username)
+       db(db.image.id==image_id).update(favorite_users = pickle.dumps(favorite_users))
+       users = db().select(db.auth_user.ALL)
+       for user in users:
+          if user.username == auth.user.username:
+             favorites = pickle.loads(user.favorites)
+       if image_id in favorites:
+          favorites.remove(image_id)
+       db(db.auth_user.username==auth.user.username).update(favorites = pickle.dumps(favorites))
+   redirect(URL(r=request, f='image?image='+str(image_id)))
+
+def make_avatar():
+   if "image" in request.vars.keys() and auth.is_logged_in(): image_id = int(request.vars["image"])
+   else: redirect(URL(r=request,f='index'))
+   db(db.auth_user.username==auth.user.username).update(avatar = image_id)
+   redirect(URL(r=request,f='image?image='+str(image_id)))
+
+
+def add_as_favorite():
+   if "id" in request.vars.keys(): image_id = int(request.vars["id"])
+   else: redirect(URL(r=request,f='index'))
+   if auth.is_logged_in():
+       images = db().select(db.image.ALL)
+       for image in images:
+           if image.id == image_id:
+               favorite_users = pickle.loads(image.favorite_users)
+       if auth.user.username not in favorite_users:
+           favorite_users.append(auth.user.username)
+       db(db.image.id==image_id).update(favorite_users = pickle.dumps(favorite_users))
+       users = db().select(db.auth_user.ALL)
+       for user in users:
+          if user.username == auth.user.username:
+             favorites = pickle.loads(user.favorites)
+       if image_id not in favorites:
+          favorites.append(image_id)
+       db(db.auth_user.username==auth.user.username).update(favorites = pickle.dumps(favorites))
+   redirect(URL(r=request, f='image?image='+str(image_id)))
 
 
 def image():
@@ -83,8 +380,12 @@ def image():
        redirect(URL(r=request, f='index'))
    if auth.is_logged_in():
        if auth.user.username != real_image.creator:
-           views = int(real_image.views) + 1
+           try:
+               views = int(real_image.views) + 1
+           except: views = 1
            db(db.image.title==real_image.title).update(views = views)
+       users = db().select(db.auth_user.ALL)
+   favorite_users = pickle.loads(real_image.favorite_users)
    form = SQLFORM(db.comment, fields = ['body'])
    if form.accepts(request.vars, session):
        db(db.comment.id==form.vars.id).update(author = auth.user.username)
@@ -94,27 +395,57 @@ def image():
    for comment in comments:
        if comment.image_id == real_image.id:
             image_comments.append(comment)
-   return dict(image = real_image, form= form,comments=image_comments)
-   
+   return dict(image = real_image, form= form,comments=image_comments,favorites = favorite_users,num_requests = get_requests())
+
   
 def testimage():
 	return db(db.image.title=="hellotest")
 
+
 def user(): 
   return dict(form=auth())
 
-def delete():
+@auth.requires_membership('admin')
+def delete_comment():
+   comment_id = int(request.vars["id"])
+   if "image" in request.vars.keys():
+       image_id = request.vars["image"]
+   else:image_id = None
+   if auth.is_logged_in():
+       if auth.has_membership('admin'):
+           query=(db.comment.id==comment_id)
+           db(query).delete()
+   if image_id != None:
+       redirect(URL(r=request, f='image?image='+image_id))
+   else:
+       redirect(URL(r=request, f='index'))
+
+def delete_image_confirmation():
    images = db().select(db.image.ALL)
    image_id = int(request.vars["id"])
    for image in images:
        if image.id == image_id:
            real_image = image
    if auth.is_logged_in():
-       if auth.user.username == real_image.creator:
+       if auth.user.username == real_image.creator or auth.has_membership('admin'):
+            return dict(image = real_image,num_requests = get_requests())
+   else: redirect(URL(r=request, f='index')) 
+
+def delete_image():
+   images = db().select(db.image.ALL)
+   image_id = int(request.vars["id"])
+   for image in images:
+       if image.id == image_id:
+           real_image = image
+   if auth.is_logged_in():
+       if auth.user.username == real_image.creator or auth.has_membership('admin'):
            query=(db.image.id==real_image.id)
            db(query).delete()
    redirect(URL(r=request, f='index')) 
-  
-  
+
+
 def download():
   return response.download(request, db)
+
+
+def call(): return service()