def delete_category(category_id): if 'username' not in login_session: return redirect('/login') delete_me = db_session.query( Category).filter_by(id=category_id).one() if delete_me.user_id != login_session['user_id']: return """<script>function myFunction() { alert('You are not authorized to edit this category. Please create your own category in order to edit.'); } </script><body onload='myFunction()''>""" if request.method == 'POST': with store_context(local_storage): db_session.delete(delete_me) flash('%s Successfully Deleted' % delete_me.name) db_session.commit() return redirect(url_for('show_categories', category_id=category_id, username=login_session["username"], categories=db_session. query(Category).order_by(asc(Category.name)))) else: return render_template('delete_category.html', category=delete_me, username=login_session["username"], categories=db_session. query(Category).order_by(asc(Category.name)))
def behavior_user(array): # "10002", dict['f'], dict['b'], dict['d'] user = None try: # user = User.query.filter(User.user_id == user_id).first() user = User.query.filter(User.user_id == "10002").first() try: for dict in array: timeStamp = dict['b'] # 秒转换为时间 timeArray = time.localtime(timeStamp) otherStyleTime = time.strftime("%Y-%m-%d %H:%M:%S", timeArray) behavior = table_behavior_log(user.id) behavior.func_id = dict['f'] behavior.begin_time = otherStyleTime behavior.duration = dict['d'] db_session.add(behavior) db_session.commit() print ('提交成功') except Exception, e: print ("异常 插入用户行为异常", e) except Exception,e: print ("异常 查询 user_id 失败", e)
def getAccessToken(cls): ''' 从数据库中取 有 直接返回 没有 调用wxapi接口从微信服务器获取,并保存到数据库 ''' # 获取当前时间戳 单位:秒 dt = int(time.time()) * 1000 - 110 * 60 * 1000 tokenTemp = db_session.query(TokenTemp).filter( TokenTemp.name == 'access_token', TokenTemp.update_time > str(dt)).first() if tokenTemp != None: access_token = tokenTemp.token else: accessTokenObj = WeixinHelper.getAccessToken() access_token = accessTokenObj['access_token'] # 更新到数据库 db_session.query(TokenTemp).filter( TokenTemp.name == 'access_token').update({ 'token': access_token, 'update_time': str(int(time.time()) * 1000) }) db_session.commit() return access_token
def create_account(): output = render_template("dashboard/register.html") if request.form.get("remail1"): output = redirect(url_for("index")) email = request.form.get("remail2") if request.form.get("rpw") != None: password = request.form.get("rpw") else: password = "******" user = User(nickname=request.form.get("username"), email=email, password=password, email_confirmed=0) # Now we'll send the email confirmation link subject = "Confirm your email" token = ts.dumps(user.email, salt='email-confirm-key') confirm_url = url_for('confirm_email', token=token, _external=True) html = render_template('dashboard/email/activate.html', confirm_url=confirm_url) db_session.add(user) db_session.commit() checkbox = request.form.get("remember") login_user(user, checkbox) drill(user.email, subject, html) output = redirect(url_for("dashboard")) return output
def create_notification(payment_id): """ Notify about payment status """ payment = db_session.query(Payment).get(payment_id) if not payment: abort(404) if not request.json or 'notification_url' not in request.json: logger.debug( 'Not enough data to create notification! Request data: {0}'.format( request.json)) abort(400) if payment.status in [ PaymentStatus.timeout, PaymentStatus.success, PaymentStatus.refused ]: logger.debug('Payment has already finished') return jsonify({'error': 'Payment has already finished'}), 400 user_data = request.json.get('user_data', {}) notification = Notification(payment.payment_id, request.json.get('notification_url'), user_data) payment.notifications.append(notification) db_session.add(payment) db_session.commit() return jsonify({'id': notification.notification_id}), 201
def join_program(bot, update): """ Add new user to program as referraler :param bot: bot :type bot: telegram.Bot :param update: update event :type update: relegram.Update """ _, channel_id, channel_name = update.callback_query.data.split(':') username = update.effective_user.username user_id = update.effective_user.id if not db_session.query(Inviter.inviter_id).filter_by( inviter_id=user_id).scalar(): logger.debug('Adding inviter <{0}> to DB'.format(user_id)) inviter = Inviter(user_id, username, update.effective_user.first_name, update.effective_user.last_name) db_session.add(inviter) q = db_session.query(ChannelInviter).filter_by(inviter_id=user_id, channel_id=channel_id) if not db_session.query(q.exists()).scalar(): logger.info('Adding assoc SI <{0}:{1}> to DB' .format(user_id, channel_id)) association = ChannelInviter(user_id, channel_id) db_session.add(association) db_session.commit() update.callback_query.answer()
def work(): ''' Fetch and process a job by running the McStas simulation ''' # fetch job run = SimRun.query.filter_by(status="waiting").order_by('created').first() if run is None: return run.status = "running" db_session.commit() print "Running job: ", run.id # create output folder, this works as a lock workdir = "%s/%%s" % (WORK_PATH % run.id) try: os.mkdir(workdir % "") except OSError: # Someone else beat us to it, bail out print "Skipping: already running." return # try to process job try: processJob(run, workdir) except: exc = traceback.format_exc() file(workdir % 'err.txt', 'a').write('\n' + STACKTRACE % exc) print exc # mark job as completed run.status = "done" db_session.commit() print "Done."
def page(): user = None content = None pages = Page.query.filter(Page.url.isnot(None)) if "user" in session: user = User.query.filter_by(email=session["user"]).first() if request.form.get("inputURL") != None: content = { "aid": user.id, "url": request.form.get("inputURL"), "gender": request.form.get("gender"), "countries": request.form.get("countries"), "ppc": request.form.get("points"), } page = Page( aid=user.id, url=request.form.get("inputURL"), type=request.form.get("type"), gender=request.form.get("gender"), countries=request.form.get("countries"), ppc=request.form.get("points"), ex=0, ) db_session.add(page) db_session.commit() return render_template("dashboard/page.html", pages=pages, user=user)
def _delete_profile_photo(current_user): s3_fs.rm(current_user.profile_photo_s3_key) current_user.profile_photo_s3_key = "" db_session.add(current_user) db_session.commit() resp = jsonify({}) return resp, 200
def create_account(): output = render_template("dashboard/register.html") if request.form.get("remail1"): output = redirect(url_for("index")) email = request.form.get("remail2") if request.form.get("rpw") != None: password = request.form.get("rpw") else: password = "******" user = User(nickname=request.form.get("username"), email=email, password=password, email_confirmed=0) # Now we'll send the email confirmation link subject = "Confirm your email" token = ts.dumps(user.email, salt='email-confirm-key') confirm_url = url_for( 'confirm_email', token=token, _external=True) html = render_template( 'dashboard/email/activate.html', confirm_url=confirm_url) db_session.add(user) db_session.commit() checkbox = request.form.get("remember") login_user(user, checkbox) drill(user.email, subject, html) output = redirect(url_for("dashboard")) return output
def new_item(category_id): if 'username' not in login_session: return redirect('/login') category = db_session.query(Category).filter_by(id=category_id).one() all_categories = db_session.query(Category).order_by(asc(Category.name)) if request.method == 'POST': try: photo = request.files.get('photo') new_item = CategoryItem(name=request.form['name'], description=request. form['description'], category_id=category_id) with store_context(local_storage): new_item.picture.from_file(photo) new_item.picture.generate_thumbnail(width=300) db_session.add(new_item) db_session.commit() except: flash("Item creation failed") return redirect(url_for('show_items', category_id=category_id, categories=all_categories)) flash('New %s Item Successfully Created' % (new_item.name)) return redirect(url_for('show_items', category_id=category_id, categories=all_categories)) else: return render_template('new_item.html', category_id=category_id, categories=all_categories)
def getAccessTokenByCode(cls): ''' 从数据库中取 有 直接返回 没有 调用wxapi接口从微信服务器获取 ,并保存到数据库 ''' dt = int(time.time()) * 1000 - 110 * 60 * 1000 tokenTemp = db_session.query(TokenTemp).filter( TokenTemp.name == 'flush_token', TokenTemp.update_time > str(dt)).first() flush_token = '' if tokenTemp != None: flush_token = tokenTemp.token else: access_token = cls.getAccessToken() flushTokenObj = WeixinHelper.getAccessTokenByCode(access_token) if 'access_token' in flushTokenObj: flush_token = flushTokenObj['access_token'] flushTokenObj = WeixinHelper.refreshAccessToken(flush_token) if 'access_token' in flushTokenObj: flush_token = flushTokenObj['access_token'] # 更新到数据库 db_session.query(TokenTemp).filter( TokenTemp.name == 'flush_token').update({ 'token': flush_token, 'update_time': str(int(time.time()) * 1000) }) db_session.commit() return flush_token
def get(self, id): #obj = self.main_model.query.get(id) obj = db_session.query(self.main_model).get(id) db_session.delete(obj) db_session.commit() flash(u'%s deleted' % self.main_model.__name__) return redirect(url_for(self.default_route))
def createUser(login_session): newUser = User(name=login_session['username'], email=login_session[ 'email'], picture=login_session['picture']) db_session.add(newUser) db_session.commit() user = db_session.query(User).filter_by(email=login_session['email']).one() return user.id
def save_bitcoin_data(data): """ Save to database using db_session. """ db_session.add(data) db_session.commit() return True
def transfer_amount_db(source_account: str, to_account: str, amount: float, description: str = None): balance = get_account_balance(source_account) if balance < amount: return False, "Transaction Failed! Insufficient funds." source_transaction_id = get_transaction_id(source_account) source_transaction = Transaction( transaction_id=source_transaction_id, transaction_time=datetime.now(), account_number=source_account, amount=amount, transaction_type=Transaction.get_debit_type(), details=description) receiver_transaction_id = get_transaction_id(to_account) receiver_transaction = Transaction( transaction_id=receiver_transaction_id, transaction_time=datetime.now(), account_number=to_account, amount=amount, transaction_type=Transaction.get_credit_type(), details=description) db_session.add(source_transaction) db_session.add(receiver_transaction) db_session.commit() return True, "Transaction Successful"
def getJsToken(cls): ''' 从数据库中取 有 直接返回 没有 调用wxapi接口从微信服务器获取 ,并保存到数据库 ''' dt = int(time.time()) * 1000 - 110 * 60 * 1000 tokenTemp = db_session.query(TokenTemp).filter( TokenTemp.name == 'js_token', TokenTemp.update_time > str(dt)).first() js_token = '' if tokenTemp != None: js_token = tokenTemp.token else: access_token = cls.getAccessToken() js_token = WeixinHelper.getJsapiTicket(access_token) # 更新到数据库 db_session.query(TokenTemp).filter( TokenTemp.name == 'js_token').update({ 'token': access_token, 'update_time': str(int(time.time()) * 1000) }) db_session.commit() return js_token
def page(): user = None content = None pages = Page.query.filter(Page.url.isnot(None)) if 'user' in session: user = User.query.filter_by(email=session['user']).first() if request.form.get("inputURL") != None: content = { "aid": user.id, "url": request.form.get("inputURL"), "gender": request.form.get("gender"), "countries": request.form.get("countries"), "ppc": request.form.get("points") } page = Page(aid=user.id, url=request.form.get("inputURL"), type=request.form.get("type"), gender=request.form.get("gender"), countries=request.form.get("countries"), ppc=request.form.get("points"), ex=0) db_session.add(page) db_session.commit() return render_template("dashboard/page.html", pages=pages, user=user)
def test1(): try: user = User.query.filter(User.user_id == 14929000454).first() user.points = user.points + 1 db_session.commit() return jsonify({"test1": user.points}) except: return jsonify({'test1': 1})
def add(object): try: db_session.add(object) db_session.commit() except: db_session.rollback() finally: closeDbSession()
def deleteById(object, item_id): try: db_session.query(type(object)).filter_by(id=item_id).delete() db_session.commit() except: db_session.rollback() finally: closeDbSession()
def recreate_db(): """ Recreates a local database. You probably should not use this on production. """ Base.metadata.drop_all(bind=engine) Base.metadata.create_all(bind=engine) db_session.commit()
def checkr(): if request.method == "POST": if (session['level'] == 2): ans = Answer.query.filter( Answer.answer == request.form['answer'].replace("_", " ", 10) and Answer.q_id == request.form['q_id']).first() if ans.is_correct: user = User.query.filter( User.username == session['username']).first() user.marks = user.marks + session['marks'] session.pop('marks') db_session.add(user) db_session.commit() return jsonify(color="green") else: session.pop('marks') return jsonify(color="red") elif (session['level'] == 1): ans = Answer.query.filter( Answer.answer == request.form['answer'] and Answer.q_id == request.form['q_id']).first() if ans.is_correct: user = User.query.filter( User.username == session['username']).first() user.marks = user.marks + session['marks'] if user.marks > 30: user.level = user.level + 1 session['level'] = user.level session.pop('marks') print "##############################" db_session.add(user) db_session.commit() return jsonify(color="green") else: session.pop('marks') return jsonify(color="red") # @app.route("/question",methods=['GET','POST']) # def question(): # if request.method == "POST": # q = Question(request.form['question'],request.form['marks'],request.form['level']) # db_session.add(q) # db_session.commit() # return q.q_id # @app.route("/user",methods=['GET','POST']) # def user(): # if request.method == "POST": # u = User(request.form['username']) # db_session.add(u) # db_session.commit() # @app.route("/answer",methods=['GET','POST']) # def answer(): # if request.method == "POST": # ans = Answer(request.form['answer'],request.form['q_id'],True if request.form['is_correct'] == "True" else False) # db_session.add(ans) # db_session.commit()
def post(self,serial_no): data = request.json args = self.parser.parse_args() Ser = Servers(serial_no, args["name"], args["vendor"], args["rackno"], args["runits"], args["mgmt_ip"], args["env"]) Ser_desc = Server_DESC(serial_no,args["type"], args["hostname"], args["role"], args["owner"],args["data_ip"], args["gateway"], args["netmask"], args["interface"]) db_session.add(Ser) db_session.add(Ser_desc) db_session.commit() return data
def post(self): form = self.get_form() if form.validate(): obj = self.create_object(form) db_session.add(obj) db_session.commit() flash(u'%s added' % self.main_model.__name__) return redirect(url_for(self.default_route)) return render_template(self.template_name, form=form)
def updatedata(data, model): try: db_session.query(model).filter(model.id == 1).update(data) db_session.commit() flash("information updated successfully", "success") except exc.SQLAlchemyError as e: print(e) db_session.rollback() flash('there was an error committing your data.', 'danger')
def update(object): try: objToUpdate = db_session.query(type(object)).filter_by(id=object.id) objToUpdate.update(object.toMappedValues()) db_session.commit() except: db_session.rollback() finally: closeDbSession()
def create_or_login(response): match = _steam_id_re.search(response.identity_url) g.user = User.get_or_create(match.group(1)) steamdata = get_steam_userinfo(g.user.steam_id) g.user.nickname = steamdata['personaname'] db_session.commit() session['user_id'] = g.user.user_id output = redirect(open_id.get_next_url()) return output
def create_items(): for item in ITEMS: new_item = CatalogItem(name=item['name'], description=item['description'], user_id=item['user_id'], catalog_id=item['catalog_id']) db_session.add(new_item) db_session.commit()
def create_or_login(response): match = _steam_id_re.search(response.identity_url) g.user = User.get_or_create(match.group(1)) steamdata = get_steam_userinfo(g.user.steam_id) g.user.nickname = steamdata['personaname'] g.user.flag = 1 db_session.commit() session['user_id'] = g.user.user_id output = redirect(open_id.get_next_url()) return output
def db(): from openpyxl import load_workbook wb = load_workbook('krp.xlsx') ws = wb['4'] for row in range(1, ws.max_row + 1): room = db_session.query(models.Room).filter( models.Room.hostel_id == 3, models.Room.room_number == ws['A%s' % row].value).update( {'note': 'ktp'}) db_session.commit()
def post(self, id): obj = db_session.query(self.main_model).get(id) form = self.get_form(obj) if form.validate(): form.populate_obj(obj) db_session.add(obj) db_session.commit() flash(u'%s updated' % self.main_model.__name__) return redirect(url_for(self.default_route)) return render_template(self.template_name, obj=obj, form=form)
def databaseOperations(subject): targetsearch = Pynionquery.query.filter_by(searchword = subject).first() if (targetsearch): print("found and updating") db_session.query(Pynionquery).filter(Pynionquery.searchword == subject).update({Pynionquery.count: Pynionquery.count+1}) else: print("db file initialised....") pynionquery = Pynionquery(subject) db_session.add(pynionquery) db_session.commit()
def book(isbn): user_id = session.get("user_id") if user_id: db_session() book = db_session.execute("SELECT * FROM books WHERE isbn=:isbn;", { "isbn": isbn }).fetchone() if book is None: abort(404) else: if request.method == "POST": db_session.execute( """ INSERT INTO reviews (message, rating, user_id, book_id) VALUES (:message, :rating, :user_id, :book_id); """, { "message": request.form.get('message'), "rating": request.form.get('rating'), "user_id": user_id, "book_id": book.id }) db_session.commit() return redirect(url_for("main.book", isbn=isbn)) else: reviews = db_session.execute( """ SELECT user_id, message, rating, username FROM reviews JOIN users ON users.id=reviews.user_id WHERE book_id=:book_id; """, { "book_id": book.id }).fetchall() goodreads = {} if current_app.config.get("GOODREADS_KEY"): res = requests.get( "https://www.goodreads.com/book/review_counts.json", params={ "key": current_app.config.get("GOODREADS_KEY"), "isbns": isbn }, timeout=5) if res.status_code != 200: raise Exception( "Request to goodreads was unsuccessful") goodreads = (res.json())["books"][0] return render_template("book.html", book=book, reviews=reviews, user_id=int(user_id), goodreads=goodreads) else: abort(403)
def mypage(): form = MypageForm(request.form) if request.method == 'POST' and form.validate(): if form.new_upw.data != "": current_user.set_password(form.new_upw.data) if form.msg.data != current_user.msg: current_user.msg = form.msg.data db_session.commit() flash("update success") return redirect(request.args.get('next') or url_for('account.index')) return render_template("mypage.html", form=form)
def post(self): args = self.reqparse.parse_args() o = UserRoles(args["role_name"]) try: db_session.add(o) db_session.commit() except IntegrityError as err: db_session.rollback() return {"DB Error: {0}".format(err)}, 500 return o.as_dict(),201
def post(self, serial_no): data = request.json args = self.parser.parse_args() Ser = Servers(serial_no, args["name"], args["vendor"], args["rackno"], args["runits"], args["mgmt_ip"]) Ser_desc = Server_DESC(serial_no, args["type"], args["hostname"], args["role"], args["owner"], args["data_ip"]) db_session.add(Ser) db_session.add(Ser_desc) db_session.commit() return data
def post(self): args = self.reqparse.parse_args() o = SubCategory(args["name"],args["description"],args["image_url"],args["category_id"]) try: db_session.add(o) db_session.commit() except IntegrityError as err: db_session.rollback() return {"DB Error: {0}".format(err)}, 500 return o.as_dict(),201
def create_or_login(response): form = xForm() match = _steam_id_re.search(response.identity_url) g.user = User.get_or_create(match.group(1)) steamdata = get_steam_userinfo(g.user.steam_id) g.user.nickname = steamdata['personaname'] db_session.commit() session['user_id'] = g.user.user_id session['admin'] = False return redirect(url_for("select"))
def update_social_media(data): try: for i, k in enumerate(data, start=1): db_session.query(SocialMedia).filter(SocialMedia.site_id == i). \ update({'site_link': data[k]}) db_session.commit() flash('Restaurant social media accounts committed successfully .', 'success') except exc.SQLAlchemyError: db_session.rollback() flash('there was an error committing your data.', 'danger')
def repair(): if request.method == 'GET': repairs = models.Repair.query.filter_by(person=current_user.person_id) return render_template('repair.html', current_user=current_user, repairs=repairs) elif request.method == 'POST': db_session.add( models.Repair(request.form['description'], request.form['tag'], current_user.person_id)) db_session.commit() return redirect(url_for('repair'))
def post(self): args = self.reqparse.parse_args() o = Orders(args["table_id"],args["waiter_id"],args["chef_id"],args["order_details"],args["order_status"],args["cost"]) try: db_session.add(o) db_session.commit() except IntegrityError as err: db_session.rollback() return {"DB Error: {0}".format(err)}, 500 #return o.as_dict(),201 return "Success"
def delete_user(current_user): """Delete a user's account.""" if current_user.is_admin(): return Response( "You cannot delete your own account. Please " "ask another administrator to do this.", 400) else: current_user.clean() db_session.delete(current_user) db_session.commit() resp = jsonify({}) jwt.unset_jwt_cookies(resp) return resp, 200
def create_user(jdic): group_user = db_session.query(Group).filter_by(name='user').one() time_expire = datetime.timedelta(10)+datetime.datetime.now() s = Session(time_expire, jdic['username'],jdic['password']) db_session.add(s) db_session.commit() u = User(jdic['username'],jdic['email'],jdic['password'],group_user) u.session = s db_session.add(u) db_session.commit() db_session.close() return s.token
def upload_profile_photo(self, file): db_session.add(self) s3_dir = PROFILE_PHOTOS_DIR.format(bucket=config['S3_BUCKET'], id=self.id) s3_key = f'{s3_dir}/{file.filename}' if s3_fs.exists(s3_dir): # Remove existing folder s3_fs.rm(s3_dir) with s3_fs.open(s3_key, 'wb') as s3_fp: s3_fp.write(file.read()) self.profile_photo_s3_key = s3_key db_session.add(self) db_session.commit() return s3_key
def confirm_email(token): try: email = ts.loads(token, salt="email-confirm-key", max_age=86400) except: return "404" user = User.query.filter_by(email=email).first() user.email_confirmed = True session["user"] = user.id db_session.commit() return redirect("/")
def confirm_email(token): try: email = ts.loads(token, salt="email-confirm-key", max_age=86400) except: return "404" user = User.query.filter_by(email=email).first() user.email_confirmed = True session['user'] = user.id db_session.commit() return redirect('/dashboard')
def oauth_callback(provider): if not current_user.is_anonymous(): return redirect(url_for("index")) oauth = OAuthSignIn.get_provider(provider) social_id, username, email = oauth.callback() if social_id is None: flash("Authentication failed.") return redirect(url_for("index")) user = User.query.filter_by(social_id=social_id).first() if not user: user = User(social_id=social_id, nickname=username, email=email) db_session.add(user) db_session.commit() login_user(user, True) return redirect(url_for("index"))
def delete_item(category_id, item_id): if 'username' not in login_session: return redirect('/login') db_session.query(Category).filter_by(id=category_id).one() delete_me = db_session.query(CategoryItem).filter_by(id=item_id).one() all_categories = db_session.query(Category).order_by(asc(Category.name)) if request.method == 'POST': with store_context(local_storage): db_session.delete(delete_me) db_session.commit() flash('item Item Successfully Deleted') return redirect(url_for('show_items', category_id=category_id, categories=all_categories)) else: return render_template('delete_item.html', item=delete_me)
def create_account(): output = render_template("dashboard/register.html") if request.form.get("email"): output = redirect(url_for("index")) email = request.form.get("email") if request.form.get("password") != None: password = request.form.get("password") else: password = "******" exists = User.query.filter_by(email=email).first() if current_user.is_authenticated(): user = User( nickname=request.form.get("username"), email=email, password=password, vpoints=0, email_confirmed=0, oauth_token=current_user.token, oath_secret=current_user.secret, ) else: user = User( nickname=request.form.get("username"), email=email, password=password, vpoints=0, email_confirmed=0 ) # Now we'll send the email confirmation link subject = "Confirm your email" token = ts.dumps(user.email, salt="email-confirm-key") confirm_url = url_for("confirm_email", token=token, _external=True) html = render_template("dashboard/email/activate.html", confirm_url=confirm_url) if exists == None: db_session.add(user) db_session.commit() login_user(user, True) drill(user.email, subject, html) else: print "x is %s" db_session.merge(user) db_session.commit() login_user(user, True) output = redirect(url_for("index")) return output
def oauth_authorized(resp): next_url = request.args.get("next") or url_for("index") if resp is None: return redirect(next_url) this_account = User.query.filter_by(nickname=resp["screen_name"]).first() if this_account is None: new_account = User( nickname=resp["screen_name"], oauth_token=resp["oauth_token"], oauth_secret=resp["oauth_token_secret"] ) db_session.add(new_account) db_session.commit() login_user(new_account, True) else: login_user(this_account, True) return redirect(url_for("social"))
def post(self): args = self.reqparse.parse_args() o = Category(args["name"],args["description"],args["image_url"]) try: db_session.add(o) db_session.commit() except IntegrityError as err: db_session.rollback() return {"DB Error: {0}".format(err)}, 500 file = args['image'] if file: extension = os.path.splitext(file.filename)[1] filename = "uploads/categories/category_img_" + str(o.id) + extension o.image_url = filename file.save(os.path.join(os.getcwd(), filename)) return o.as_dict(),201
def create_or_login(response): match = _steam_id_re.search(response.identity_url) g.user = User.get_or_create(match.group(1)) steamdata = get_steam_userinfo(g.user.steam_id) g.user.nickname = steamdata["personaname"] for user1 in User.query.filter_by(steam_id=g.user.steam_id): g.user.flag = [user1][0].flag g.user.admin = [user1][0].admin print "user1flag is %s user1admin is %s" % ([user1][0].flag, [user1][0].admin) # if g.user.steam_id == "76561197966341176" or "STEAM_0:0:3037724": # g.user.admin = 1 # g.user.flag = 4 print "%s is admin %s is flag" % (g.user.admin, g.user.flag) db_session.commit() session["user_id"] = g.user.user_id output = redirect(open_id.get_next_url()) return output
def simulatePOST(jobid, user): ''' Create simulation job for the worker ''' job = Job.query.get(jobid) sim = Simulation.query.get(job.sim_id) # treat seed and samples specially params = { "_seed": job.seed, "_samples": job.samples, "_npoints": job.npoints } # filter params by what the simulation expects (needed!) valid = set(pd.name for pd in sim.params) params.update(dict( (pv.param.name, pv.value) for pv in job.params if pv.param.name in valid)) # create simulation run (for the worker to compute) run = SimRun(user=user, job=job, sim=sim, params=params) db_session.add(run) db_session.commit() # send user to status page return redirect(url_for('status', runid=run.id))
def new_category(): if 'username' not in login_session: return redirect('/login') if request.method == 'POST': new = Category(name=request.form['name'], user_id=login_session['user_id']) db_session.add(new) user = getUserInfo(login_session['user_id']) flash('New Category %s Successfully Created by %s' % (new.name, user.name)) db_session.commit() categories = db_session.query(Category).order_by(asc(Category.name)) return redirect(url_for('show_categories', username=login_session["username"], categories=categories)) else: categories = db_session.query(Category).order_by(asc(Category.name)) return render_template('new_category.html', username=login_session["username"], categories=categories)
def index(): ## Begin code ## ## Set your 'server' table to empty g.server = None ## Here I mapped the server list manually the first time, this method should be updated to mysqldb ^^ #serverlist = {"69.30.232.146:25451","69.30.232.146:25449","69.30.232.146:25461","69.30.232.146:25461","69.30.232.146:25459","69.30.232.146:25457","69.30.232.146:25455","69.30.232.146:25453","69.30.232.146:25447"} #serverlist = {"64.182.125.141:27017","64.182.125.141:27015","64.182.125.141:27019","64.182.125.142:27022","64.182.125.142:27018","64.182.125.140:27015","64.182.210.44:27015","64.182.210.36:27015","64.182.125.140:27016","64.182.210.44:27017","64.182.210.36:27016","64.182.210.44:27018","64.182.125.140:27018","64.182.125.140:27017","64.182.210.36:27017","64.182.210.36:27018","64.182.125.140:27019","64.182.125.142:27015","64.182.210.38:27016","64.182.125.142:27016","64.182.210.46:27015","64.182.210.38:27015","64.182.210.45:27016","64.182.210.37:27016","64.182.125.141:27017","64.182.210.37:27017","64.182.210.37:27019","64.182.210.45:27019"} serverlist = [] ## Now we build a list of servers from the DB for x in sList(): serverlist += ["%s:%s"%(x.ip,x.port)] rl = [] ## run through every server in the list and query its data for x in serverlist: ## filtering the ip from the list into the required format ip, separator, port = x.rpartition(':') assert separator # separator (`:`) must be present port = int(port) # convert to integer sq = SourceQuery(ip,port) server = sq.getInfo() try: g.server = Server.get_or_create(server['Hostname']) g.server.ip = ip g.server.port = port g.server.type = server['GameDesc'] g.server.map = server['Map'] g.server.hostname = server['Hostname'] g.server.maxplayers = server['MaxPlayers'] g.server.curplayers = server['Players'] ##now that we set up our session and database, we commit it db_session.commit() except: print "server offline" rl = sList() output = render_template('index.html',username=g.user,datas=rl) return output
def stripe2(): g.user = None form = xForm() form2 = signForm() team = None emailz = None output = render_template("fail.html") if 'user_id' in session: g.user = User.query.get(session['user_id']) if g.user != None: team = g.user.ptype emailz = g.user.email stripe_token = request.form['stripeToken'] email = request.form['stripeEmail'] if team == 1: amnt = 5 print amnt else: amnt = 20 print amnt try: charge = Charge.create( amount=int(amnt * 100), currency='usd', card=stripe_token, description=email) g.user.paid = 1 db_session.commit() output = render_template('success.html') if team == 2: html = "<p>You will be receiving a friend request in steam from a user named xTcR | Tournament [IN]. You will need to accept this friend request to be verified on the date of the tournament.</p><p>The tournament will be on August 15th, 2015 at 1:00pm EST. You and your team will need to be in xTcR's teamspeak (ts3.xtcr.net > INS Tournament Waiting Room) 1 hour before the starting time in order to be verified.</p><p>*If you do not recieve a friend request from xTcR | Tournament [IN] please add the user here: http://steamcommunity.com/id/xtcr-tournament/ . You will not be able to be verified for the tournament if you skip this step.</p>" else: html = "<p>You will be receiving a friend request in steam from a user named xTcR | Tournament [IN]. You will need to accept this friend request to be verified on the date of the tournament.</p><p>The tournament will be on August 15th, 2015 at 1:00pm EST. You will need to be in teamspeak (ts3.xtcr.net > INS Tournament Waiting Room) 1 and a half hours before the starting time to allow time for teaming up.</p><p>*If you do not recieve a friend request from xTcR | Tournament [IN] please add the user here: http://steamcommunity.com/id/xtcr-tournament/ . You will not be able to be verified for the tournament if you skip this step.</p>" drill(g.user.email,html) except stripe.CardError, e: return render_template("fail.html")
def signup(): g.user = None form = signForm() form2 = xForm() if 'user_id' in session: g.user = User.query.get(session['user_id']) if form.validate_on_submit(): print form.email.data session['username'] = g.user.nickname session['email'] = form.email.data session['team'] = form.team.data session['website'] = form.website.data g.user.email = form.email.data g.user.team = form.team.data g.user.website = form.website.data g.user.member1 = form.member1.data g.user.member2 = form.member2.data g.user.member3 = form.member3.data g.user.member4 = form.member4.data db_session.commit() return redirect(url_for('terms')) if form2.validate_on_submit(): print form.email.data session['username'] = g.user.nickname session['email'] = form2.email.data g.user.email = form2.email.data db_session.commit() return redirect(url_for('terms')) output = render_template('form.html',username=g.user,form=form) return output
def edit_item(category_id, item_id): if 'username' not in login_session: return redirect('/login') edited_item = db_session.query(CategoryItem).filter_by(id=item_id).one() # confirm category exists db_session.query(Category).filter_by(id=category_id).one() print edited_item.category.name if request.method == 'POST': if request.form['name']: edited_item.name = request.form['name'] if request.form['description']: edited_item.description = request.form['description'] if request.form['category']: edited_item.category = db_session.query(Category).filter_by( id=request.form['category']).one() print edited_item.category.name photo = request.files.get('photo') if photo: with store_context(local_storage): edited_item.picture.from_file(photo) edited_item.picture.generate_thumbnail(width=300) db_session.add(edited_item) db_session.commit() else: db_session.add(edited_item) db_session.commit() flash('Item Successfully Edited') return redirect(url_for('show_items', category_id=category_id)) else: all_categories = db_session.query(Category).\ order_by(asc(Category.name)) return render_template('edit_item.html', category_id=category_id, item_id=item_id, item=edited_item, categories=all_categories)