path: root/controllers/default.py

import os
import pickle
from gluon.tools import Service
service=Service(globals())

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 index():
  sorts = ["newest", "views"]
  if "page" in request.vars.keys(): page = int(request.vars["page"]) - 1
  else: page = 0
  if "sort" in request.vars.keys(): sort = request.vars["sort"]
  else: sort = 'newest'
  if sort not in sorts:
      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 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(cmp=lambda x,y:cmp(float(x.views),float(y.views)))
      images.reverse()
  if sort == 'newest':
      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:
          if i == 4:
              table.append(row)
              row = []
              i = 0
          i += 1
          row.append(image)
      count += 1
  table.append(row)
  pages = count / 12
  if count%12 > 0: pages += 1
  page += 1
  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():
    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 login_remote(username,password):
   logged_in = auth.login_bare(username,password)
   if logged_in:
      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():
   images = db().select(db.image.ALL)
   image_id = int(request.vars["image"])
   for image in images:
       if image.id == image_id:
           real_image = image
   title=real_image.title
   if real_image == None:
       redirect(URL(r=request, f='index'))
   if auth.is_logged_in():
       if auth.user.username != real_image.creator:
           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)
       db(db.comment.id==form.vars.id).update(image_id = real_image.id)
   comments=db().select(db.comment.ALL)
   image_comments = []
   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,favorites = favorite_users,num_requests = get_requests())

  
def testimage():
	return db(db.image.title=="hellotest")


def user(): 
  return dict(form=auth())

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