Example #1
0
def content(subject, title, username):
    res = studhelp_dbsql.get_post_contents(subject, title)
    content = res
    if content == -3:
        return error("")
    if content == ['This post does not exist']:
        return error("Script tags disabled temporarily")
    responses = studhelp_dbsql.get_post_responses(subject, title)
    if responses == -3:
        return error
    #if responses == ['Response does not exist']:
    #    return [["",""]]
    print(responses)
    val = None
    for i in title:
        mod_i = ''.join(e for e in i if e.isalnum())
        for char in mod_i.lower():
            val = ord(char) - 96

    return template("topic.tpl",
                    title=title,
                    unit=subject,
                    content=content,
                    responses=responses,
                    server=conf.complete_server_conf(),
                    username=username,
                    value=val)
Example #2
0
def new_comment(subject, title, comment, username):
    if len(comment) == 0:
        return error("Comment not written")
    ret = studhelp_dbsql.add_post_response(subject, title, comment, username)
    if ret == -3:
        return error("")
    return content(subject, title, username)
Example #3
0
def new_message(sender, reciever, message):
    if len(message) == 0:
        return error("message not written")
    ret = studhelp_dbsql.add_message(sender, reciever, message)
    if ret == -3:
        return error()
    return get_messages(sender, reciever)
Example #4
0
def new_post(subject, title, content, username):
    if len(title) == 0 or len(content) == 0:
        return error("Title and/or content not written")
    ret = studhelp_dbsql.add_new_post(username, subject, title, content)
    if ret == -3:
        return error("")
    url = conf.complete_server_conf() + '/homepage/' + subject
    redirect(url)
Example #5
0
def reset_pass(email):
    if len(email) == 0:
        return error("No email mentioned")
    ret = studhelp_dbsql.send_password(email)
    url = conf.complete_server_conf() + "/"
    if ret == -3 or ret == -1:
        return error()
    return redirect(url)
Example #6
0
def import_routes(route_location):
    # import route
    module_obj = None
    __import__(route_location, globals(), locals())
    module_obj = sys.modules[route_location]
    url_properties = {
            'urls' : ['GET', 'POST', 'PUT', 'DELETE'],
            'gets' : ['GET'],
            'posts': ['POST'],
            'puts' : ['PUT'],
            'deletes': ['DELETE']
        }
    # urls
    for url_property in url_properties:
        methods = url_properties[url_property]
        if hasattr(module_obj, url_property):
            for url_pair in getattr(module_obj, url_property):
                # address               
                route_address = url_pair[0]
                slashed_url = add_begining_slash(add_trailing_slash(route_address))
                unslashed_url = add_begining_slash(remove_trailing_slash(route_address))
                # callback
                if len(url_pair)==1:
                    route_callback = 'Undefined callback'
                else:
                    route_callback = url_pair[1]
                if isinstance(route_callback, str):
                    content = route_callback
                    def wrapper():
                        return content
                    route_callback = wrapper
                # default values
                name, apply_, skip, configs = None, None, None, {}
                # name
                if len(url_pair)>2:
                    name = url_pair[2]
                    # apply
                    if len(url_pair)>3:
                        apply_ = url_pair[3]
                        # skip
                        if len(url_pair)>4:
                            skip = url_pair[4]
                            # configs
                            if len(url_pair)>5:
                                configs = url_pair[5]
                # call the routes
                route(slashed_url, methods, route_callback, name, apply_, skip, **configs)
                route(unslashed_url, methods, route_callback, name, apply_, skip, **configs)
    # hooks
    if hasattr(module_obj, 'hooks'):
        for hook_pair in module_obj.hooks:
            hook(hook_pair[0])(hook_pair[1])
    # errors
    if hasattr(module_obj, 'errors'):
        for error_pair in module_obj.errors:
            error(error_pair[0])(error_pair[1])
Example #7
0
def homepage(username):
    if len(username) == 0:
        return error()
    subject = studhelp_dbsql.get_user_subject(username)
    if subject == -3:
        return error()
    return template("homepage.tpl",
                    name=username,
                    subject=subject,
                    server=conf.complete_server_conf())
Example #8
0
def routeapp(obj):
    for kw in dir(obj):
        attr = getattr(obj, kw)
        if hasattr(attr, 'error'):
            bottle.error(attr.error)(attr)
        if hasattr(attr, 'delete'):
            bottle.delete(attr.delete)(attr)
        if hasattr(attr, 'put'):
            bottle.put(attr.put)(attr)
        if hasattr(attr, 'post'):
            bottle.post(attr.post)(attr)
        if hasattr(attr, 'route'):
            bottle.route(attr.route)(attr)
Example #9
0
	def wrapper(*args,**kwargs):
		try:
			try:
				uhmac = request.cookies.get('uhmac')
				token = request.cookies.get('token')
				uname = request.cookies.get('uname')
				hm = hmac.new(str(RSAKEY['passwd_store']),"UNHMAC_"+uname, hashlib.sha1)
				uhmac2 = hm.digest().encode('base64').strip()
				if not uhmac == uhmac2:
					raise AuthStatus.NotLoggedIn
				kn = redis_conf['prefix']+'#uSession'
				rtk = redis.hget(kn,uhmac)
				if rtk == None or rtk == "":
					raise AuthStatus.NotLoggedIn
				if not rtk == token:
					raise AuthStatus.NotLoggedIn
			except:
				SelfFailureLoggerModel.addlog(logging.DEBUG,'text/plain',"<DEBUG>[LoginError]%s"%traceback.format_exc())
				raise AuthStatus.NotLoggedIn
			authobj = AuthObj()
			authobj.username = uname
			authobj.uhmac = uhmac
			kwargs ["auth"] = authobj
			try:
				result = func(*args,**kwargs)
				return result
			except:
				SelfFailureLoggerModel.addlog(logging.ERROR,'text/plain',traceback.format_exc())
				return error(500)
		except AuthStatus.NotLoggedIn:
			SelfFailureLoggerModel.addlog(logging.DEBUG,'text/plain',"<DEBUG>[LoginFailure]%s"%traceback.format_exc())
			return redirect("/login/",code=302)
Example #10
0
def api_payssion_notify_url():
    import hashlib
    p = ParamWarper(request)
    TRACE("REQ:", str(request.body))
    pm_id, amount, currency, order_id, state = p.__pm_id, p.__amount, p.__currency, p.__order_id, p.__state
    # api_key|pm_id|amount|currency|order_id|state|sercret_key
    verify = '|'.join([
        str(x) for x in [
            PSS_APP_KEY, pm_id, amount, currency, order_id, state,
            PSS_SECRET_KEY
        ]
    ])
    TRACE("BEFORE:", verify)
    verify = hashlib.md5(verify).hexdigest()
    TRACE("VERIFY:", verify)
    TRACE("SIGN:", p.__notify_sig)
    out_trade_no, transaction_id = order_id, p.__transaction_id
    if str(verify).lower() != str(p.__notify_sig).lower():
        TRACE("PARAM", pm_id, amount, currency, order_id)
        return error(404)
    if p.__state == 'completed':
        with DB() as db:
            db.sql_exec(
                """
                INSERT INTO poker.paycallback
                (TRANID, PAYID) 
                VALUES ('%s', '%s');
            """, transaction_id, out_trade_no)
            db.commit()
    return HTTPResponse("success", content_type="text/xml")
Example #11
0
def getQuestion(questionTitle):
	try:
		questionData = db.getQuestion(questionTitle)
	except askExceptions.NotExist as e:
		return error(e)

	return template('question.tpl',questionData=questionData)
Example #12
0
def parse_url(url):

    if get_status_code(url)==404: # page is not found
        return error(PageNotFoundError())

    output = {}
    crawler = LinkedinCrawler()

    try:
        items = crawler.start(url) # launching crawler
    except BadFormatError:
        return error(BadFormatError())

    output["tags"]= [elem.get('label') for elem in items if 'label' in elem.keys()]# formatting output
    output["educations"] = [elem for elem in items if 'school' in elem.keys()]    
    return json.dumps(output)
Example #13
0
def deleteAnswer(questionTitle):
	answerID = request.forms.get('answerID')
	try:
		db.delAnswer(questionTitle,answerID)
	except askExceptions.NotExist as e:
		return error(e)
	redirect("/question/"+questionTitle) 
Example #14
0
def parse():
    url = request.GET.get('url')
    print "Request parameters: url=",url
    if not url:
        return error(PageNotFoundError())

    return parse_url(url)
Example #15
0
def api_wxpay_notify_url():
    """微信回调"""
    wx = H5WXPlay()
    if not wx.verify_notify(request.body):
        return error(404)

    def to_xml(raw):
        s = ""
        for k, v in raw.items():
            s += "<{0}>{1}</{0}>".format(k, v)
        s = "<xml>{0}</xml>".format(s)
        return s.encode("utf-8")

    r = wx.notify_xml_string_to_dict(request.body)

    out_trade_no = r['out_trade_no']
    return_code = r['return_code']
    transaction_id = r['transaction_id']
    if return_code == 'SUCCESS':
        with DB() as db:
            db.sql_proc("sp_pay_notify", out_trade_no, transaction_id)
            db.commit()

    return HTTPResponse(to_xml(
        dict(return_code=r['return_code'], return_msg="OK")),
                        content_type="text/xml")
Example #16
0
def voteDown(questionTitle):
	answerID = request.forms.get("answerID")
	try:
		votes = db.voteDown(questionTitle, answerID)
	except askExceptions.NotExist as e:
		return error(e)
	redirect("/question/"+questionTitle) 
Example #17
0
def deleteComment(questionTitle):
	commentID = request.forms.get("commentID")
	answerID = request.forms.get('answerID')
	try:
		db.deleteComment(questionTitle,answerID,commentID)
	except askExceptions.NotExist as e:
		return error(e)
	redirect("/question/"+questionTitle) 
Example #18
0
def get_messages(username, chat_with):
    ret = studhelp_dbsql.view_chat_history(username, chat_with)
    if ret == -3:
        return error("")
    return template("chat.tpl",
                    chat=ret,
                    reciever=chat_with,
                    server=conf.complete_server_conf())
Example #19
0
def postAnswer(questionTitle):
	author = ""
	text = request.forms.get('text')
	try:
		db.addAnswer(questionTitle,text,author)
	except askExceptions.NotExist as e:
		return error(e)
	redirect("/question/"+questionTitle) 
Example #20
0
def show(item):
    dbname.execute(
        'SELECT * from angelo.temperatura')  # where sensorid="%s"', (item,))
    row = dbname.fetchone()
    return row
    if row:
        return template('showitem', page=row)
    return error(404, "Page not found")
Example #21
0
def updateAnswer(questionTitle):
	answerId = request.forms.get('answerID')
	text = request.forms.get('text')
	print "update"+str(text)
	try:
		db.updateAnswer(questionTitle,answerId,text)
	except askExceptions.NotExist as e:
		return error(e)
	redirect("/question/"+questionTitle) 
Example #22
0
def display_episode(showname, episodenum):
    sectionTemplate = "./templates/episode.tpl"
    sectionData = utils.displayEp(showname, episodenum)
    if sectionData == 'error':
        return error(error)
    return template("./pages/index.html",
                    version=utils.getVersion(),
                    sectionTemplate=sectionTemplate,
                    sectionData={sectionData})
Example #23
0
def updateComment(questionTitle):
	answerID = request.forms.get('answerID')
	commentID = request.forms.get("commentID")
	text = request.forms.get('text')
	try:
		db.updateComment(questionTitle,answerID,commentID,text)
	except askExceptions.NotExist as e:
		return error(e)
	redirect("/question/"+questionTitle) 
Example #24
0
def addUnit(unit, username):
    #ADD unit to DB with the username and return homepage
    subject = studhelp_dbsql.unit_add(username, unit)
    if subject == -3:
        return error()
    return template("homepage.tpl",
                    name=username,
                    subject=subject,
                    server=conf.complete_server_conf())
Example #25
0
def postComment(questionTitle):
	author = ""
	answerID = request.forms.get('answerID')
	text = request.forms.get('text')
	try:
		db.addComment(questionTitle,answerID,text,author)
	except askExceptions.NotExist as e:
		return error(e)
	redirect("/question/"+questionTitle) 
Example #26
0
def display_show(showname):
    sectionTemplate = "./templates/show.tpl"
    sectionData = utils.displayShow(showname)
    if sectionData == 'error':
        return error(error)
    return template("./pages/index.html",
                    version=utils.getVersion(),
                    sectionTemplate=sectionTemplate,
                    sectionData=sectionData)
Example #27
0
def add_twitter():
    user = users.get_current_user()
    if user is None:
        redirect("/login?{0}".format(
            urllib.urlencode(dict(continue_url=request.url))))
    else:
        session = request.environ.get('beaker.session')
        auth = session.get("twitter_auth")
        verifier = request.GET.get('oauth_verifier')

        if auth is not None and auth.request_token is None:
            auth = None

        twi = TwitterUser.get_by_key_name(user.email())

        auth_url = ''
        if twi is None:

            #first
            if auth is None or verifier is None:
                auth = tweepy.OAuthHandler(consumer_key, consumer_secret,
                                           request.url)
                auth_url = auth.get_authorization_url()
                session["twitter_auth"] = auth
                session.save()
                redirect(auth_url)
            else:
                try:
                    auth.get_access_token(verifier)
                except tweepy.TweepError:
                    error('Error! Failed to get access token.')

                twi = TwitterUser.get_or_insert(
                    user.email(),
                    user=user,
                    last_retweeted_id=0,
                    twitter_access_token=auth.access_token.key,
                    twitter_access_token_secret=auth.access_token.secret,
                    twitter_id=auth.get_username())

                session["twitter_auth"] = None
                session.save()

        redirect("/twitter")
Example #28
0
def overview_messages(username):
    ret = studhelp_dbsql.view_messages(username)
    if ret == -3:
        return error("")
    users = []
    users = get_users(ret, username)
    return template("view_all_messages.tpl",
                    username=username,
                    users=users,
                    server=conf.complete_server_conf())
Example #29
0
def import_routes(route_location):
    # import route
    module_obj = None
    __import__(route_location, globals(), locals())
    module_obj = sys.modules[route_location]
    # urls
    if hasattr(module_obj, 'urls'):
        for url_pair in module_obj.urls:
            slashed_url = add_trailing_slash(url_pair[0])
            unslashed_url = remove_trailing_slash(url_pair[0])
            route(slashed_url)(url_pair[1])
            route(unslashed_url)(url_pair[1])
    # hooks
    if hasattr(module_obj, 'hooks'):
        for hook_pair in module_obj.hooks:
            hook(hook_pair[0])(hook_pair[1])
    # errors
    if hasattr(module_obj, 'errors'):
        for error_pair in module_obj.errors:
            error(error_pair[0])(error_pair[1])
Example #30
0
def listTopics(unit, username):
    title = studhelp_dbsql.get_all_post_title(unit)
    if title == -1:
        return error()
    url = 'homepage/' + unit
    return template("UnitDiscussion.tpl",
                    title=title,
                    url=url,
                    unit=unit,
                    server=conf.complete_server_conf(),
                    username=username)
Example #31
0
def login_check(username, password):
    if len(username) == 0:
        return error("No username written")
    if len(password) == 0:
        return error("No password written")
    result = studhelp_dbsql.check_login(username, password)

    if result == 0:
        #checking the units that the user chose and only showing them in the homepage
        subject = studhelp_dbsql.get_user_subject(username)
        if subject == -3:
            return error()
        response.set_cookie("username", username, secret='houdini+stockfish')
        return template("homepage.tpl",
                        name=username,
                        subject=subject,
                        server=conf.complete_server_conf())
    else:
        return template("LoginError.tpl",
                        reason="check credentials",
                        server=conf.complete_server_conf())
Example #32
0
def signup_check(username, password, email):
    u_l = len(username)
    p_l = len(password)
    e_l = len(email)
    if u_l == 0 or p_l == 0 or e_l == 0:
        return error("One of the fields in the previous form was blank")
    result = studhelp_dbsql.check_signup(username, password)

    if (result == 0):
        studhelp_dbsql.add_user(username, password, email)
        return template("Login.tpl", server=conf.complete_server_conf())
    else:
        return template("SignupError.tpl", server=conf.complete_server_conf())
Example #33
0
def postNewQuestion():
	print "body"+str(request.body)
	print "length:"+str(request.content_length)


	author = ""
	questionTitle = request.forms.get('title')
	text = request.forms.get('text')
	tags = request.forms.getlist('tags')
	print "questionTitle"+str(questionTitle)
	try:
		question = db.addNewQuestion(questionTitle,text,tags,author)
		redirect("/question/"+question.title)
	except askExceptions.NotExist as e:
		return error(e)
Example #34
0
def api_aplipay_notify_url():
    """支付宝回调"""
    TRACE("ALIPAYNOTIFY:=======")
    data = dict(request.POST)
    success = AliPay.verify_notify(data)
    if success:
        out_trade_no = data['out_trade_no']
        trade_status = data["trade_status"]
        trade_no = data['trade_no']
        if trade_status == 'TRADE_SUCCESS':
            with DB() as db:
                db.sql_proc("sp_pay_notify", out_trade_no, trade_no)
                db.commit()
        return HTTPResponse("success", content_type="text/xml")
    return error(404)
Example #35
0
    def test_error_routing(self):

        @bottle.route("/<code:int>")
        def throw_error(code):
            bottle.abort(code)

        # Decorator syntax
        @bottle.error(500)
        def catch_500(err):
            return err.status_line

        # Decorator syntax (unusual/custom error codes)
        @bottle.error(999)
        def catch_999(err):
            return err.status_line

        # Callback argument syntax
        def catch_404(err):
            return err.status_line
        bottle.error(404, callback=catch_404)

        self.assertBody("404 Not Found", '/not_found')
        self.assertBody("500 Internal Server Error", '/500')
        self.assertBody("999 Unknown", '/999')
Example #36
0
def view(paper_name):
    paper_name = paper_name.strip('/')
    if paper_name not in paper_metadata:
        return bottle.error(404)

    template = jinja_env.get_template("view_paper.jinja2")

    render_cmd = "%s %s" % (notes_renderer, os.path.join(
            root_folder, paper_name, "notes." + notes_extension))

    render_subproc = subprocess.Popen(render_cmd, shell=True,
                                      stdout=subprocess.PIPE)
    rendered_notes = render_subproc.communicate()[0].strip()

    return template.render(paper_info = paper_metadata[paper_name],
                           paper_name = paper_name,
                           rendered_notes = rendered_notes)
Example #37
0
def mycard_notify_url():
    p = ParamWarper(request)
    TRACE("MYCARDPARAM:", str(p.params))
    data = p.__DATA
    TRACE(data)
    try:
        data = json.loads(data)
        ReturnCode = data['ReturnCode']
        FacTradeSeq = data['FacTradeSeq']
        TRACE("PARAM:", str(data))
        if str(ReturnCode) == '1':
            for seq in FacTradeSeq:
                mycard_pay(seq)
        return HTTPResponse("success", content_type="text/xml")
    except Exception, e:
        TRACE_ERROR(e)
        return error(404)
Example #38
0
def process_routes(routes):
    for config in routes:
        route(config["url"], method=config["method"])(config["controller"])
    if production:
        error(404)(not_found)
        error(405)(not_allowed)
Example #39
0
def deleteQuestion(questionTitle):
	try:
		db.deleteQuestion(questionTitle)
	except askExceptions.NotExist as e:
		return error(e)
	redirect("/")
Example #40
0
def error404(error):
    return error(PageNotFoundError())
Example #41
0
def icon_png(icon):
    response.set_header('Content-Type', 'image/png')
    try:
        return pkgutil.get_data('ejui', icon + '.png')
    except OSError:
        error(404)
Example #42
0
def process_routes(routes):
    for config in routes:
        route(config["url"], method=config["method"])(config["controller"])
    if production:
        error(404)(not_found)
        error(405)(not_allowed)
Example #43
0
def process_routes(routes):
    for config in routes:
        route(config["url"], method=config["method"])(config["controller"])
    #comment the following two lines for debugging
    error(404)(not_found)
    error(405)(not_allowed)
Example #44
0
def give_blob(job_id):
    return get_db()['jobs'][job_id]['blob']

@error(404)
Example #45
0
def main():
    error_codes = [404, 405, 503]
    for error_code in error_codes:
        bottle.error(error_code)(lambda error: _default_handler())
    bottle.run(quiet=True)
Example #46
0
    #     'sub_title': data[0]['sub_title'],
    #     'thumbnail': data[0]['thumbnail']
    # }
    # if data:
    #     return json.dumps([
    #         'meta': meta,
    #         'topic': data
    #     ])
    # else:
    #     return json.dumps([
    #         'topic': [],
    #         'meta': []
    #     ])


bottle.error(404)
def error404(error):
    return json.dumps({
        'statusCode': 404,
        'status': 'error',
        'message': 'Not Found'
    })

bottle.error(500)
def error500(error):
    return json.dumps({
        'statusCode': 500,
        'status': 'error',
        'message': 'Internal Server Error, our fat cat did something wrong'
    })
Example #47
0
def display_episode(showname, episodenum):
    sectionData = utils.displayEp(showname, episodenum)
    if sectionData == 'error':
        return error(error)
    return template("./templates/episode.tpl", result=sectionData)
Example #48
0
def display_show(showname):
    sectionData = utils.displayShow(showname)
    if sectionData == 'error':
        return error(error)
    return template("./templates/show.tpl", result=sectionData)