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