def POST(self, arg):
        if session.userid != -1:
            raise web.seeother('/')
        i = web.input()
        username = i.get('Username', None)
        password = i.get('Password', None)
        repassword = i.get('RePassword', None)
        email = i.get('Email', None)
        if not password or not repassword or not password == repassword:
            return render.Register("Passwords don't match")
        if not username or not vname.match(username):
            return render.Register('UserName must be between 4 to 50 characters')
        if not vpwd.match(password):
            return render.Register('Password must be more than 4 characters')
        if not email or not vemail.match(email):
            return render.Register('Invaild Email address')

        email = email.lower()
        userid = db.Member.Add(username, password, email)
        if userid:
            session.userid = userid
            session.username = username
            session.gravatar = db.Utility.MD5(email)
            raise web.seeother('/')
        else:
            return render.Register('['+username+'] or ['+email+'] exists')

    def GET(self):
        global ftoken_db
        i = web.input(author_key=[], language=[], first_publish_year=[], publisher_facet=[], subject_facet=[], person_facet=[], place_facet=[], time_facet=[])
        if i.get('ftokens', None) and ',' not in i.ftokens:
            token = i.ftokens
            if ftoken_db is None:
                ftoken_db = dbm.open('/olsystem/ftokens', 'r')
            if ftoken_db.get(token, None):
                raise web.seeother('/subjects/' + ftoken_db[token].decode('utf-8').lower().replace(' ', '_'))

        self.redirect_if_needed(i)

        if 'isbn' in i and all(not v for k, v in i.items() if k != 'isbn'):
            self.isbn_redirect(i.isbn)

        q_list = []
        q = i.get('q', '').strip()
        if q:
            m = re_olid.match(q)
            if m:
                raise web.seeother('/%s/%s' % (olid_urls[m.group(1)], q))
            m = re_isbn_field.match(q)
            if m:
                self.isbn_redirect(m.group(1))
            q_list.append(q)
        for k in ('title', 'author', 'isbn', 'subject', 'place', 'person', 'publisher'):
            if k in i:
                q_list.append(k + ':' + i[k].replace(':', '\\:').strip())

        return render.work_search(i, ' '.join(q_list), do_search, get_doc)

	def GET(self):
		if not base.logged():
			raise web.seeother('/')
		if web.ctx.session.privilege == 0:
			return base.code("<script language='javascript'>alert('您没有足够的权限，拒绝访问 !');window.history.back(-1);</script>")
		history = models.getHistory()		
		history = list(history)		
		for h in history:
			ltime = time.localtime(int(h['deltime']))
			deltime = time.strftime("%Y-%m-%d %H:%M:%S",ltime)
			h['deltime'] = deltime
		
		input = web.input(action=None,hid=None)

		if not input.action:	
			return render.history(history)
		else:
			# Remove history
			if input.action == 'dh':
				models.delOneHistory(input.hid)
				raise web.seeother('/history')
			# Resotre history
			elif input.action == 'rh':
			 	if models.restoreHistory(input.hid):
					models.delOneHistory(input.hid)
					return base.code("<script language='javascript'>alert('恢复成功 !');window.location.href='/history'; </script>")
				else:
					return base.code("<script language='javascript'>alert('恢复失败，此记录可能已存在，请检查！');window.history.back(-1);</script>")
				
			else:
				return base.code("<script language='javascript'>alert('参数错误 !');window.history.back(-1);</script>")

    def POST(self):
        web.header('Content-Type', 'text/html')
        f = login_form()
        if not f.validates():
            raise web.seeother('/')

        authOptions = [am for am in web.config.auth.methods if am.can_handle_user(f.d.username)]
        if len(authOptions) == 0:
            raise web.internalerror("No appropriate login method available")

        for ao in authOptions:
            try:
                success, res = ao.login(f.d.username, f.d.password, web.config)
                if success == True:
                    web.config.session.loggedin = True
                    web.config.session.userid = res['userid']
                    web.config.session.userfullname = res['userfullname']
                    web.config.session.userrights = res['rights']
                    raise web.seeother("/")
            except RequireRegistrationException, info:
                web.config.session.showIdentifierRegistration = True
                web.config.session.userid = info.username
                web.config.session.userfullname = info.userfullname
                web.config.session.userrights = "none"
                raise web.seeother('/register')

def auth_user(global_config, desired_path='/home'):
    auth = web.ctx.env.get('HTTP_AUTHORIZATION')
    authreq = False
    
    if auth is None:
        authreq = True
    else:
        auth = re.sub('^Basic ','',auth)
        username,password = base64.decodestring(auth).split(':')
        
        if logged_out_users.has_key(username):
            del logged_out_users[username]
        else:
            session = DbSession.open_db_session(global_config['users_db_name'] + global_config['this_season'])
            user = UsersDataModel.getUser(session, username)
            session.remove()
            if user:
                if user.state == 'Disabled':
                    raise web.seeother('/accountdisabled')
                #if (username,password) in allowed:
                if user.check_password(password) == True:
                    raise web.seeother(desired_path)
        authreq = True
    if authreq:
        web.header('WWW-Authenticate','Basic realm="FRC1073 ScoutingAppCentral"')
        web.ctx.status = '401 Unauthorized'
        return

  def POST( self, get_string='' ):
    log.loggit( 'update.POST()' )

    # Must be a matching user or administrator to update
    wputil.must_match_username_or_admin( web.input()['username'] )

    # Catch the cancel button
    if  web.input().has_key('cancel'):
      if wputil.is_admin():
        raise web.seeother('../')
      else:
        raise web.seeother('../../')

    # Validate the form
    if wputil.is_admin():
      f = admin_account_form()
    else:
      f = account_form()
    if not f.validates():
      return { 'status' : 'error',
               'message' : 'Verify all information has been provided correctly.',
               'form' : f }

    # update the account in the database
    adb = accountdb.AccountDB()
    try:
      account = adb.update_account( f.d )
    except:
      return { 'status' : 'error',
               'message' : 'An error occurred updating the account.',
               'form' : f }

    raise web.seeother( '../review/%s' % (account['username']) )

	def GET(self):
		userid = web.ctx.session.userid
		if userid:
			raise web.seeother('/show')
			
		else:
			raise web.seeother('/login')

	def POST(self):
		form = web.input(action=None)
		
		if form.action and session.room:
			if '*' in session.room.paths:
				if form.action != session.room.num and form.action not in self.commands:
					session.room.guess -= 1
					session.room.output = "..." % session.room.guess
					if session.room.guess == 0:
						session.room = session.room.go('*')
				elif form.action == session.room.num:
					session.room = session.room.go('x')
			else:
				transition = session.room.go(form.action)
				if transition == None:
					session.room.output = "You cannot do that."
				elif transition != None:
					session.room = transition
				else:
					session.room.output = "Please enter a command."
					
		if form.action in self.commands:
			self.commands[form.action]()
			
		web.seeother('/game')

    def POST(self):
        form = login_form()
        if not form.validates():
            return render.login(form=form)
        data = web.input()
        errcode, user = authenticate(data.username, data.password)
        req = web.ctx.req
        if errcode != ERR_OK:
            if errcode == ERR_USER_NOTEXISTS:
                req.err(u'用户未注册')
            elif errcode == ERR_PASSWORD_NOTCORRECT:
                req.err(u'密码错误')

            if 'redirect_to' in data:
                redirect_url = data.redirect_to
            req.update({
                'form': form,
                'redirect_url': redirect_url,
                })
            return render.login(**req)
        auth_login(user)
        redirect_url = data.redirect_to
        if redirect_url:
            raise web.seeother(redirect_url)
        else:
            raise web.seeother('/', True)

    def GET(self):
        # 第一次登陆时如果没有管理员帐号，
        # 则增加一个管理员帐号admin，密码admin，后续可以修改密码
        tips = ""
        u = KeUser.all().filter("name = ", "admin").get()
        if not u:
            myfeeds = Book(title=MY_FEEDS_TITLE, description=MY_FEEDS_DESC, builtin=False, keep_image=True)
            myfeeds.put()
            au = KeUser(
                name="admin",
                passwd=hashlib.md5("admin").hexdigest(),
                kindle_email="",
                enable_send=False,
                send_time=8,
                timezone=TIMEZONE,
                book_type="mobi",
                expires=None,
                ownfeeds=myfeeds,
                oldest_article=7,
            )
            au.put()
            tips = _("Please use admin/admin to login at first time.")
        else:
            tips = _("Please input username and password.")

        if session.login == 1:
            web.seeother(r"/")
        else:
            return self.render("login.html", "Login", tips=tips)

    def POST(self, _n=None):
        self.login_required()
        name = web.input().get("u")
        if name and (session.username == "admin" or session.username == name):
            u = KeUser.all().filter("name = ", name).get()
            if not u:
                tips = _("The username '%s' not exist!") % name
            else:
                if u.ownfeeds:
                    u.ownfeeds.delete()
                u.delete()

                # 要删掉数据库中订阅记录
                for book in Book.all():
                    if book.users and name in book.users:
                        book.users.remove(name)
                        book.put()

                if session.username == name:
                    raise web.seeother("/logout")
                else:
                    raise web.seeother("/admin")
        else:
            tips = _("The username is empty or you dont have right to delete it!")
        return self.render("delaccount.html", "Delete account", tips=tips, username=name)

 def POST(self):
     try:
         args = web.input(xlsfile={}) 
     except ValueError:
         return "File too large. Maximum file size is 50MB"
         
     if 'xlsfile' not in args:
         web.seeother('/')
     
     #Cleanup the file path  
     filepath = args.xlsfile.filename.replace('\\','/')
     filename = filepath.split('/')[-1]
     
     if not filename.lower().endswith('xls'):
         raise web.seeother('/?e=Only xls files are accepted')
     
     #Generate a unique folder to store the uploaded file in    
     ID = str(int(random.random()*1000000000000))
     os.mkdir(upload_dir+ID)  
     
     #Store the uploaded xls 
     fout = open(upload_dir+ID+'/'+filename,'w') 
     fout.write(args.xlsfile.file.read())
     fout.close()
     
     #Remove any expired uploads
     self.cleanup_files(upload_dir)
     
     #Convert the file. Report any errors, or offer the id of the
     #folder to download from
     try:
         download_ID = convert.convert(upload_dir +'/'+ID+'/'+filename)
     except:
         raise web.seeother('/?e='+ str(sys.exc_info()[1]))
     raise web.seeother('/?id=' + download_ID)

    def _store(self, uri, i):
        """
        Store a record
        """
        status = required(i, 'status')
        if status is None:
            return False

        if not self.validstatus.match(status):
            return self._badrequest("Bad value for status: '%s'" % status)

        tags = unpack_tags(getattr(i, 'tags', []))
        pairs = unpack_pairs(getattr(i, 'pairs', {}))
        location = getattr(i, 'location', None)
        known = get_known()
        unknown = get_unknown()

        try:
            u = get_manager().register(
                uri,
                int(status),
                tags = tags,
                pairs = pairs,
                location = location
                )

            known[u.id] = u
            if u.id in unknown:
                del unknown[u.id]

            web.seeother("%s/%s" % (web.ctx.home, u.id))
            return

        except URIError, e:
            return self._badrequest(e)

 def GET(self):
     qdict = web.input()
     approve_pwd(qdict)
     if qdict.has_key("rsn") and qdict["rsn"] == "1":
         stop_stations()
         raise web.seeother("/")
         return
     if qdict.has_key("en") and qdict["en"] == "":
         qdict["en"] = "1"  # default
     elif qdict.has_key("en") and qdict["en"] == "0":
         gv.srvals = [0] * (gv.sd["nst"])  # turn off all stations
         set_output()
     if qdict.has_key("mm") and qdict["mm"] == "0":
         clear_mm()
     if qdict.has_key("rd") and qdict["rd"] != "0" and qdict["rd"] != "":
         gv.sd["rdst"] = gv.now + (int(qdict["rd"]) * 3600)
         stop_onrain()
     elif qdict.has_key("rd") and qdict["rd"] == "0":
         gv.sd["rdst"] = 0
     if qdict.has_key("rbt") and qdict["rbt"] == "1":
         jsave(gv.sd, "sd")
         gv.srvals = [0] * (gv.sd["nst"])
         set_output()
         os.system("reboot")
         raise web.seeother("/")
     for key in qdict.keys():
         try:
             gv.sd[key] = int(qdict[key])
         except:
             pass
     jsave(gv.sd, "sd")
     raise web.seeother("/")  # Send browser back to home page
     return

    def profile(self, domain, mail, accountType='user'):
        self.mail = web.safestr(mail)
        self.domain = self.mail.split('@', 1)[-1]

        if self.domain != domain:
            return web.seeother('/domains?msg=PERMISSION_DENIED')

        self.filter = '(&(objectClass=mailUser)(mail=%s))' % (self.mail,)
        if accountType == 'catchall':
            self.filter = '(&(objectClass=mailUser)([email protected]%s))' % (self.mail,)
        else:
            if not self.mail.endswith('@' + self.domain):
                return web.seeother('/domains?msg=PERMISSION_DENIED')

        if attrs.RDN_USER == 'mail':
            self.searchdn = ldaputils.convKeywordToDN(self.mail, accountType=accountType)
            self.scope = ldap.SCOPE_BASE
        else:
            self.searchdn = attrs.DN_BETWEEN_USER_AND_DOMAIN + ldaputils.convKeywordToDN(self.domain, accountType='domain')
            self.scope = ldap.SCOPE_SUBTREE

        try:
            self.user_profile = self.conn.search_s(
                self.searchdn,
                self.scope,
                self.filter,
                attrs.USER_ATTRS_ALL,
            )
            return (True, self.user_profile)
        except Exception, e:
            return (False, ldaputils.getExceptionDesc(e))

 def GET(self):
     # 第一次登陆时如果没有管理员帐号，
     # 则增加一个管理员帐号admin，密码admin，后续可以修改密码
     tips = ''
     u = KeUser.all().filter("name = ", 'admin').get()
     if not u:
         myfeeds = Book(title=MY_FEEDS_TITLE,description=MY_FEEDS_DESC,
                 builtin=False,keep_image=True)
         myfeeds.put()
         au = KeUser(name='admin',passwd=hashlib.md5('admin').hexdigest())
         au.kindle_email = ''
         au.enable_send = False
         au.send_time = 8
         au.timezone = TIMEZONE
         au.book_type = "mobi"
         au.expires = None
         au.ownfeeds = myfeeds
         au.put()
         tips = u"初次登陆请使用用户名'admin'/密码'admin'登陆。 "
     else:
         tips = u"请输入正确的用户名和密码登陆进入系统。 "
     
     if session.login == 1:
         web.seeother(r'/')
     else:
         return jjenv.get_template("login.html").render(nickname='',title='Login',tips=tips)

  def POST( self, get_string='' ):
    log.loggit( 'delete.POST()' )

    # Catch the cancel button
    if  web.input().has_key('cancel'):
      raise web.seeother('../')

    # Validate the form
    f = delete_confirmation_form()
    if not f.validates():
      return { 'status' : 'error',
               'message' : 'Verify all information has been provided correctly.',
               'form' : f }

    if f.d['username'] == 'admin':
      return { 'status' : 'error',
               'message' : 'You cannot delete the administration account.' }

    # update the account in the database
    adb = accountdb.AccountDB();
    try:
      row = adb.delete_account( f.d['username'] )
    except:
      return { 'status' : 'error',
               'message' : 'An error occurred deleting the account.' }

    raise web.seeother('../')

def results_post(session):
    form = web.input().group
    if form is not None:
        session.studid = form
        raise web.seeother('/studedit/' + session.studid)
        #raise web.seeother('/cart')
    raise web.seeother('/search')

	def GET(self):
		data = web.input()
		contype = data['type']
		content = data['content']
		if contype=="tvshow":
			tvopen = open(tvfile,"a")
			tvread = tvopen.write(content+"\n")
			tvopen.close()
			tvShowSearchWeb()
			raise web.seeother('/')
		elif contype=="movie":
			movieopen = open(moviefile,"a")
			movieread = movieopen.write(content+"\n")
			movieopen.close()
			movieSearchWeb()
			raise web.seeother('/')
		elif contype=="music":
			musicopen = open(musicfile,"a")
			musicread = musicopen.write(content+"\n")
			musicopen.close()
			musicSearchWeb()
			raise web.seeother('/')
		elif contype=="picture":
			pictureopen = open(picturefile,"a")
			pictureread = pictureopen.write(content+"\n")
			pictureopen.close()
			photoSearchWeb()
			raise web.seeother('/')

 def POST(self, chid):
     userid = web.config.db.select(
         'channels', what='user', where='id = $ch',
         vars={'ch': int(chid)})[0]['user']
     web.config.db.delete(
         'readed', where='channel = $ch', vars={'ch': int(chid)})
     web.seeother('/user/%d' % userid)