def login_post():
name = request.form.get("name")
email = request.form.get("email")
password = hashlib.sha512(
request.form.get("password").encode()).hexdigest()
print(password)
number = randint(0, 10)
print(number)
user = db.query(User).filter_by(email=email).first()
if user is not None:
if user.password != password:
return "<h1> Wrong Username or Password! </h1>"
else:
user = User(name=name,
email=email,
secret_number=number,
password=password,
token=str(uuid.uuid4()))
db.add(user)
db.commit()
response = make_response(redirect(url_for("index")))
response.set_cookie("token", user.token)
return response
def profile_edit():
session_token = request.cookies.get("session_token")
# get user from the database based on his / her session token from cookie "session_token"
user = db.query(User).filter_by(session_token=session_token).first()
if request.method == "GET":
if user: # if user is found
return render_template("profile_edit.html", user=user)
else:
return render_template("index.html", user=user)
elif request.method == "POST":
name = request.form.get("profile-name")
email = request.form.get("profile-email")
password = request.form.get("profile-password")
# hash the password
hashed_password = hashlib.sha256(password.encode()).hexdigest()
# update the user object
user.name = name
user.email = email
user.password = hashed_password
# store changes into the database
db.add(user)
db.commit()
return redirect(url_for("profile"))
def login():
name = request.form.get("user-name")
email = request.form.get("user-email")
password = request.form.get("user-password")
hashed_password = hashlib.sha256(password.encode()).hexdigest()
secret_number = random.randint(1, 30)
user = db.query(User).filter_by(email=email).first()
# user = User.fetch_one(query=["email", "==", email])
if not user:
user = User(name=name,
email=email,
secret_number=secret_number,
password=hashed_password)
db.add(user)
db.commit()
if hashed_password != user.password:
return "WRONG PASSWORD! Go back and try again"
elif hashed_password == user.password:
# generate random session number
session_token = str(uuid.uuid4())
user.session_token = session_token
db.add(user)
db.commit()
response = make_response(redirect(url_for('index')))
response.set_cookie("session_token",
session_token,
httponly=True,
samesite='Strict')
return response
def login():
name = request.form.get("user-name")
email = request.form.get("user-email")
password = request.form.get("user-password")
# create a secret number
secret_number = random.randint(1, 30)
# see if user already exists
user = db.query(User).filter_by(email=email).first()
if not user:
# create a User object
user = User(name=name, email=email, password=generate_password_hash(password), secret_number=secret_number)
# save the user object into a database
db.add(user)
db.commit()
if not check_password_hash(user.password, password):
return "Sorry, your password is not correct."
session_token = str(uuid.uuid4())
user.session_token = session_token
db.add(user)
db.commit()
# save user's token into a cookie
response = make_response(redirect(url_for('index')))
response.set_cookie("session_token", session_token, httponly=True, samesite="Strict")
return response
def setUp(self):
super(TestCheckIn, self).setUp()
db.add(Patient(nhi="123ABC"))
db.add(CheckIn(patient_nhi="123ABC", checkin_time=self.now))
db.commit()
def get():
"""
参数
content: 反馈内容
user_id: 登录用户id
"""
parser = reqparse.RequestParser()
parser.add_argument('content', type=str, required=True, help=u'content必须。')
parser.add_argument('user_id', type=str, required=True, help=u'user_id必须。')
args = parser.parse_args()
resp_suc = success_dic().dic
resp_fail = fail_dic().dic
content = args['content']
user_id = args['user_id']
feed_back = FeedBack(content=content, user_id=user_id)
try:
db.add(feed_back)
db.commit()
except:
return resp_fail
return resp_suc
def add_dia():
t_hora_cita = request.form.get("hora_cita")
titulo_cita = request.form.get("titulo_cita")
notas_cita = request.form.get("notas_cita")
year = request.form.get("cita_year")
month = request.form.get("cita_month")
day = request.form.get("cita_day")
hora, minutos = convierte_hora(t_hora_cita)
t_cita = year + "-" + month + "-" + day + "-" + hora + "-" + minutos
hora_cita = datetime.strptime(
t_cita, "%Y-%m-%d-%H-%M") # convierto del formato texto al datetime
user = db.query(User).filter_by(username=session["username"]).first()
cita = Cita(fecha=hora_cita,
titulo=titulo_cita,
notas=notas_cita,
user_id=user.id)
db.add(cita)
db.commit()
return redirect(url_for('dia', month=month, year=year, day=day))
def result():
guess = int(request.form.get("guess"))
session_token = request.cookies.get("session_token")
# get user from the database based on her/his email address
user = db.query(User).filter_by(session_token=session_token).first()
if guess == user.secret_number:
message = "Correct! The secret number is {0}".format(str(guess))
# create a new random secret number
new_secret = random.randint(1, 30)
# update the user's secret number
user.secret_number = new_secret
# update the user object in a database
db.add(user)
db.commit()
elif guess > user.secret_number:
message = "Your guess is not correct... try something smaller."
elif guess < user.secret_number:
message = "Your guess is not correct... try something bigger."
return render_template("result.html", message=message)
def get():
"""
所需参数
user_id: 必传，登录用户的id
pub_id: 必传，用户点击收藏的当前酒吧的id
"""
parser = reqparse.RequestParser()
parser.add_argument('user_id', type=str, required=True, help=u'用户登录user_id必须。')
parser.add_argument('pub_id', type=str, required=True, help=u'当前酒吧pub_id必须。')
args = parser.parse_args()
user_id = int(args['user_id'])
pub_id = int(args['pub_id'])
resp_suc = {}
# 先判断用户是否已经收藏此酒吧
check_collect = Collect.query.filter(Collect.user_id == user_id, Collect.pub_id == pub_id).count()
if check_collect >= 1:
resp_suc['message'] = 'again'
resp_suc['status'] = 2
else:
collect = Collect(user_id, pub_id)
db.add(collect)
db.commit()
resp_suc['message'] = 'success'
resp_suc['status'] = 0
return resp_suc
def login():
if request.method == "GET":
return render_template("login.html")
elif request.method== "POST":
username = request.form.get("username")
password = request.form.get("password")
hashed_pw = hashlib.sha256(password.encode()).hexdigest()
# pregled ali user obstaja
user = db.query(User).filter_by(username=username).first()
if user:
if hashed_pw == user.password:
#Creating session token
session_token = str(uuid.uuid4())
user.session_token = session_token
# db update with token
db.add(user)
db.commit()
# cookie response
response = make_response(redirect(url_for("index")))
response.set_cookie("session_token", session_token, httponly=True, samesite="Strict")
return response
else:
return render_template("failedlogin.html")
else:
return render_template("failedlogin.html")
def edit_profile():
session_token = request.cookies.get("session_token")
user = db.query(User).filter_by(session_token=session_token, deleted=False).first()
if request.method == "GET":
if user:
return render_template("profile_edit.html", user=user)
else:
return redirect(url_for("index"))
elif request.method == "POST":
name = request.form.get("profile-name")
email = request.form.get("profile-email")
prev_password = request.form.get("previous-password")
new_password = request.form.get("new-password")
if check_password_hash(user.password, prev_password):
hashed_new_password = generate_password_hash(new_password)
user.password = hashed_new_password
else:
return "Wrong (old) password! Go back and try again."
user.name = name
user.email = email
db.add(user)
db.commit()
return redirect(url_for("show_profile"))
def signup_post():
email = request.form.get('email')
name = request.form.get('name')
password = request.form.get('password')
gender = request.form.get('gender')
address = request.form.get('address')
contact = request.form.get('contact')
user = db.query(User).filter_by(email=email).first(
) # if this returns a user, then the email already exists in database
if user: # if a user is found, we want to redirect back to signup page so user can try again
flash('Email address already exists')
return redirect(url_for('auth.signup'))
# create new user with the form data. Hash the password so plaintext version isn't saved.
new_user = User(email=email,
name=name,
password=generate_password_hash(password, method='sha256'),
gender=gender,
address=address,
contact=contact)
# add the new user to the database
db.add(new_user)
db.commit()
# code to validate and add user to database goes here
return redirect(url_for('auth.login'))
def login():
name = request.form.get("user-name")
email = request.form.get("user-email")
password = request.form.get("user-password")
# hash the password
hashed_password = hashlib.sha256(password.encode()).hexdigest()
secret_number = random.randint(1, 30)
# create a User object
user = db.query(User).filter_by(email=email).first()
if not user: # create a user
user = User(name=name, email=email, secret_number=secret_number, password=hashed_password)
# save the user object into a database
db.add(user)
db.commit()
if hashed_password != user.password:
return "WRONG PASSWORD! Go back and try again."
elif hashed_password == user.password:
# create a random session token for this user
session_token = str(uuid.uuid4())
# save the session token in a database
user.session_token = session_token
db.add(user)
db.commit()
# save user's session token into a cookie
response = make_response(redirect(url_for('index')))
response.set_cookie("session_token", session_token)
return response
def profile_edit():
token_session = request.cookies.get("token_session")
user = db.query(User).filter_by(token_session=token_session,
delete=False).first()
if request.method == "GET":
if user:
return render_template("profile_edit.html", user=user)
else:
return redirect(url_for("index"))
elif request.method == "POST":
name = request.form.get("profile-name")
email = request.form.get("profile-email")
old_password = request.form.get("old-password")
new_password = request.form.get("new-password")
if old_password and new_password:
h_old_password = hashlib.sha256(old_password.encode()).hexdigest()
h_new_password = hashlib.sha256(new_password.encode()).hexdigest()
if h_old_password == user.password:
user.password = h_new_password
else:
return "Operacion incorrecta! Su antigua contraseña no es correcta"
user.name = name
user.email = email
db.add(user)
db.commit()
return redirect(url_for("profile"))
def login():
name = request.form.get("user-name")
email = request.form.get("user-email")
password = request.form.get("user-password")
hash_pass = hashlib.sha256(password.encode()).hexdigest()
user = db.query(User).filter_by(email=email).first()
if not user:
user = User(name=name, email=email, password=hash_pass)
db.add(user)
db.commit()
if hash_pass != user.password:
return "Contraseña incorrecta! Introduzca la contraseña correcta!"
elif hash_pass == user.password:
token_session = str(uuid.uuid4())
user.token_session = token_session
db.add(user)
db.commit()
response = make_response(redirect(url_for('index')))
response.set_cookie("token_session",
token_session,
httponly=True,
samesite='Strict')
return response
def login():
name = request.form.get("name")
password = request.form.get("password")
hashed_pwd = hashlib.sha256(password.encode()).hexdigest()
user = db.query(User).filter_by(name=name).first()
if not user:
flash(f"User doesn't exists. Please register.")
return redirect(url_for("reg"))
if hashed_pwd != user.password:
flash(f"Wrong user name, email or password. Try again please.")
return redirect(url_for("home"))
else:
session_token = str(uuid4())
user.session_token = session_token
user = User(online=True, offline=False)
db.add(user)
db.commit()
response = make_response(redirect(url_for("home")))
response.set_cookie("session_token", session_token)
return response
def index():
if request.method == "GET":
email_address = request.cookies.get("email")
if email_address:
user = db.query(User).filter_by(email=email_address).first()
else:
user = None
return render_template("index.html", user=user)
elif request.method == "POST":
nombre = request.form.get("nombre")
email = request.form.get("email")
password = request.form.get("password")
print(nombre)
print(email)
user = User(name=nombre, email=email, password=password)
db.add(user)
db.commit()
response = make_response(redirect(url_for("index")))
response.set_cookie("email", email)
return response
def index():
if request.method == "GET":
data = {}
session_token = request.cookies.get("session_token") #guardamos el valor de la cookie session token en la variable session_token
if session_token:
user = db.query(User).filter_by(session_token=session_token).first() #si tenemos una session token, miramos y comparamos en la base de datos
else: #si no creamos una instancia user vacia
user = None
data.update({'user': user})
return render_template("index.html", data=data)
elif request.method == "POST":
guess = request.form.get('guess', False)
email_address = request.cookies.get("email")
user = db.query(User).filter_by(email=email_address).first()
try: # compara si el valor introducido es un entero y si no lo es devuelve un error
guess = int(guess)
except Exception:
data = {'result': False,
"user": user,
"error": 2}
response = make_response(render_template("index.html", data=data))
return response
if guess > 30 or guess < 1: #comprueba que ademas de ser un entero sea un valor comprendido entre 1 y 30, si no devuelve un error
data = {'result': False,
"user": user,
"error": 1}
response = make_response(render_template("index.html", data=data))
return response
if guess == int(user.secret_number): # Si ha acertado:
new_secret = random.randint(1, 30)
user.secret_number = new_secret
db.add(user)
db.commit()
new_wrong = wrong_guess.copy()
data = {'result': True,
"wrong_guess": new_wrong,
"user": user}
wrong_guess.clear()
response = make_response(render_template("index.html", data=data))
return response
else: # Si no hemos acertado damos una pista para que pueda acertar
if int(user.secret_number) < guess:
data = {'result': False, # Diferentes lineas para mas orden y solo un diccionario con datos
'hint': "Demasiado grande, prueba algo mas pequeño",
'user': user}
else:
data = {'result': False,
'hint': "Demasiado pequeño, prueba algo mas grande",
'user': user}
response = make_response(render_template("index.html", data=data))
wrong_guess.append(guess)
return response # Devolvemos un response por pantalla,mostrando un mensaje segun si ha acertado o si ha puesto un numero mayor o menor
return render_template("index.html")
def give_up():
session_token = request.cookies.get("session_token")
user = db.query(User).filter_by(session_token=session_token).first()
user.games += 1
user.losses += 1
user.score -= 1
db.add(user)
db.commit()
location = request.args.get("location", "Maribor")
r = requests.get(f"{OWA}?q={location}&units=metric&appid={API_KEY}")
tempwat = r.json()
temperature = tempwat["main"]["temp"]
weather = tempwat["weather"][0]["main"]
return render_template(
"home.html",
user=user,
location=location.title(),
temperature=temperature,
weather=weather,
)
def login():
name = request.form.get("user-name") #cogemos del formulario el nombre y el email y los guardamos en las variables name y email
email = request.form.get("user-email")
secret_number = random.randint(1, 30) #generamos un numero aleatorio y lo guardamos en secret_number
password = request.form.get("user-password")
hashed_password = hashlib.sha256(password.encode()).hexdigest() #encriptamos el password
user = db.query(User).filter_by(email=email).first() #comprobamos si ese usuario existe en nuestra base de datos, filtrando por el email
if not user: #si no hay un usuario registrado, creamos una instancia nueva para ese usuario y la guardamos en la bsae de datos
user = User(name=name, email=email, secret_number=secret_number, password=hashed_password,)
db.add(user)
db.commit()
if hashed_password != user.password:
return "WRONG PASSWORD! Go back and try again."
elif hashed_password == user.password: #si el password introducido es igual al de la base de datos generamos un numero de sesion y lo guardamos en la BD
session_token = str(uuid.uuid4())
user.session_token = session_token
db.add(user)
db.commit()
response = make_response(redirect(url_for('index')))
response.set_cookie("session_token", session_token, httponly=True, samesite='Strict') #guardamos el token de sesions en una cookie llamada session_token
return response
def search_tag(self, instance):
tag = instance.text
search = Search(searchterm=tag)
db.add(search)
db.commit()
App.get_running_app().root.next_screen("front_screen")
def login():
name = request.form.get("user-name")
email = request.form.get("user-email")
password = request.form.get("user-password")
hashed_password = hashlib.sha256(password.encode()).hexdigest()
secret_number = random.randint(1, 30)
user = db.query(User).filter_by(email=email).first()
if not user:
user = User(name=name,
email=email,
secret_number=secret_number,
password=hashed_password)
db.add(user)
db.commit()
if hashed_password != user.password:
return "Wrong password! Please try again"
elif hashed_password == user.password:
session_token = str(uuid.uuid4())
user.session_token = session_token
db.add(user)
db.commit()
response = make_response(redirect(url_for('index')))
response.set_cookie("session_token",
session_token,
httponly=True,
samesite="Strict")
return response
def receipts(user_id):
user = User.query.filter_by(id=user_id).first()
if not user:
return make_response("User " + str(user_id) + " doesn't exist", 404)
if request.method == "POST":
if validate_request_receipt():
receipt_date = date_string_to_datetime(request.json["date_time"])
receipt = Receipt(request.json["store_name"],
request.json["category"],
request.json["total_transaction"],
receipt_date)
user.receipts.append(receipt)
for item in request.json["items"]:
if validate_item(item):
item = PurchasedItem(item["name"],
request.json["category"],
item["price_per_item"],
item["quantity"])
receipt.purchased_items.append(item)
db.add(user)
db.commit()
return json.dumps({"receipt": receipt.serialize()})
else: #request is a get and return the receipts of the user
return get_user_receipts(user)
def bathymetry_coordinates(id):
"""
API endpoint to overwrite X,Y,Z coordinates for a specific bathymetry.
:param id: bathymetry identifier
:return:
"""
content = request.get_json(silent=True)
print(f"Content = {content}")
validate(instance=content, schema=schema)
bathymetry = Bathymetry.query.get(id)
if not bathymetry:
raise ValueError("Invalid bathymetry with identifier %s" % id)
if len(content["coordinates"]) < 6:
raise ValidationError(f"Coordinates Must be a minimum of 6")
BathymetryCoordinate.query.filter(
BathymetryCoordinate.bathymetry_id == bathymetry.id).delete()
for coordinate in content["coordinates"]:
db.add(
BathymetryCoordinate(x=coordinate['x'],
y=coordinate['y'],
z=coordinate['z'],
bathymetry_id=bathymetry.id))
db.commit()
return jsonify(bathymetry.to_dict())
def login_exhentai(self, username, password):
self.username = username.text
self.password = password.text
payload = {
"UserName": username.text,
"PassWord": password.text,
"returntype": "8",
"CookieDate": "1",
"b": "d",
"bt": "pone"
}
headers = {'User-Agent': 'Mozilla/5.0'}
r = requests.post(
"https://forums.e-hentai.org/index.php?act=Login&CODE=01",
data=payload,
headers=headers)
if len(r.cookies) <= 1:
captchapopup = CaptchaPopup()
captchapopup.bind(on_dismiss=self.login_captcha)
captchapopup.open()
else:
self.cookies = r.cookies
cookies = User(cookies=str(self.cookies))
db.add(cookies)
db.commit()
self.baseurl = "exhentai"
self.next_screen("front_screen")
def dashboard():
form = Messageform()
form.receiver_email.choices = get_choices(current_user)
if request.method == "GET":
messages = db.query(Mensaje).filter_by(receiver=current_user.email,
read=False).all()
users = db.query(User).all()
return render_template("dashboard.html",
messages=messages,
form=form,
current_user=current_user,
users=users)
else:
if form.validate_on_submit():
msg = Mensaje(subject=form.subject.data,
message=form.message.data,
receiver=form.receiver_email.data,
sender=current_user.email,
read=False)
db.add(msg)
db.commit()
data = "Your message has been sent"
return render_template("dashboard.html",
data=data,
form=form,
current_user=current_user,
msg=msg)
else:
data = "Error, review the entered data"
return render_template("dashboard.html",
data=data,
form=form,
current_user=current_user)
def login_exhentai(self, username, password):
self.username = username.text
self.password = password.text
payload = {
"UserName": username.text,
"PassWord": password.text,
"returntype": "8",
"CookieDate": "1",
"b": "d",
"bt": "pone"
}
headers = {'User-Agent': 'Mozilla/5.0'}
r = requests.post(
"https://forums.e-hentai.org/index.php?act=Login&CODE=01",
data=payload,
headers=headers)
if len(r.cookies) <= 1:
captchapopup = CaptchaPopup()
captchapopup.bind(on_dismiss=self.login_captcha)
captchapopup.open()
else:
self.cookies = r.cookies
cookies = User(cookies=str(self.cookies))
db.add(cookies)
db.commit()
self.baseurl = "exhentai"
self.next_screen("front_screen")
def edit():
# find user
session_token = request.cookies.get("session_token")
user = db.query(User).filter_by(session_token=session_token).first()
if request.method == "GET":
return render_template("edit.html", user=user)
elif request.method == "POST":
#username change
username = request.form.get("username")
if len(username) > 0:
user.username = username
#email change
email = request.form.get("user-email")
if len(email) > 0:
user.email = email
#password change
password = request.form.get("password")
passwordtest = request.form.get("password-repeat")
if (len(password) > 0) and (password == passwordtest):
hashed_pw = hashlib.sha256(password.encode()).hexdigest()
user.password = hashed_pw
db.add(user)
db.commit()
return redirect((url_for("edit")))
def edit_profile():
session_token = request.cookies.get("session_token")
user = db.query(User).filter_by(session_token=session_token).first()
if request.method == "GET":
return render_template("edit_profile.html", user=user)
elif request.method == "POST":
name = request.form.get("profile-name") #cogemos el nombre y el email del formulario y lo guardamos en estas variables
email = request.form.get("profile-email")
new_password = request.form.get("new_password")
if len(new_password) > 6:
hashed_new_password = hashlib.sha256(new_password.encode()).hexdigest()
if hashed_new_password != user.password:
user.password = hashed_new_password
else:
message1 = "This password is the same than the old one, please set a different one"
return render_template("edit_profile.html", message1=message1, user=user)
else:
message2 = "Your password must be at least 6 characters long"
return render_template("edit_profile.html", message2=message2, user=user)
user.name = name #asignamos el valor de la variable name y email a la propiedad user.name y user.email del objeto
user.email = email
db.add(user) #guardamos los cambios en la base de datos
db.commit()
return redirect(url_for("bp_profile.profile"))
def login():
if request.method == "GET":
return render_template("login.html")
elif request.method == "POST":
email = request.form.get("email")
password = hashlib.sha256(request.form.get("password").encode("utf-8")).hexdigest()
user = db.query(User).filter_by(email=email).first()
if not user:
user = User(password=password, email=email)
db.add(user)
db.commit()
if password == user.password:
# create a random session token for this user
session_cookie = str(uuid.uuid4())
# save the session token in a database
user.session_token = session_cookie
db.add(user)
db.commit()
response: Response = make_response(redirect(url_for('messenger', session_cookie=session_cookie)))
# render template --> show html now on this url where you are; redirect move to new ur, make get request
# there
response.set_cookie("session_cookie", session_cookie, httponly=True, samesite='Strict')
return response
return redirect(url_for('login'))
def add_receipt(num_receipts=1):
user = User.query.first()
days_ago_to_start = num_receipts/2
date = datetime.now() - timedelta(days=days_ago_to_start)
even_receipt = True
for x in range(num_receipts):
SHOP_NAME = "Countdown Birkenhead"
SHOP_CATEGORY = "Groceries"
TOTAL = 123.81
r = Receipt(SHOP_NAME, SHOP_CATEGORY, TOTAL, date)
r.purchased_items = [
PurchasedItem("Chocolate Milk", SHOP_CATEGORY, 3.99, 2),
PurchasedItem("Garlic Pita Breads", SHOP_CATEGORY, 4.50, 1),
PurchasedItem("Old Spice Deoderant", SHOP_CATEGORY, 6.21, 4),
PurchasedItem("Eye Fillet Steak", SHOP_CATEGORY, 21.4, 1),
PurchasedItem("Obikwa Wine 750mL", SHOP_CATEGORY, 6.99, 4),
PurchasedItem("North Shore Rubbish Sack", SHOP_CATEGORY, 4.99, 5),
PurchasedItem("Nutri-Grain 700g", SHOP_CATEGORY, 6.23, 1),
PurchasedItem("Olivio Butter", SHOP_CATEGORY, 5.95, 1)
]
user.receipts.append(r)
even_receipt = not even_receipt
if even_receipt:
date = date + timedelta(days=1)
print len(user.receipts)
db.add(user)
db.commit()
def enter_gallery(self, instance):
galleryinfo = [instance.gallery_id, instance.gallery_token,
instance.pagecount, instance.gallery_name,
instance.gallery_tags, instance.gallery_thumb, instance.filesize]
existgallery = db.query(Gallery).filter_by(
gallery_id=instance.gallery_id).first()
if existgallery:
pass
else:
gallery = Gallery(gallery_id=instance.gallery_id,
gallery_token=instance.gallery_token,
pagecount=instance.pagecount,
gallery_name=instance.gallery_name,
gallery_thumb=instance.gallery_thumb,
filesize=instance.filesize)
db.add(gallery)
db.commit()
for tag in instance.gallery_tags:
gallerytag = GalleryTags(galleryid=gallery.id, tag=tag)
db.add(gallerytag)
db.commit()
preview_screen = App.get_running_app(
).root.ids.sadpanda_screen_manager.get_screen("gallery_preview_screen")
preview_screen.gallery_id = instance.gallery_id
App.get_running_app().root.next_screen("gallery_preview_screen")
def message_details(msg_id=None):
if msg_id:
msg = db.query(Mensaje).get(int(msg_id))
if msg and msg.receiver == current_user.email:
msg.read = True
db.add(msg)
db.commit()
return render_template("messages.html",
current_msg=msg,
current_user=current_user)
else:
return "Message ID not valid!"
else:
messages = list(
db.query(Mensaje).filter_by(receiver=current_user.email))
messages.sort(key=lambda s: s.date)
read = list(filter(lambda s: s.read, messages))
non_read = list(filter(lambda s: not s.read, messages))
for msg in non_read:
msg.read = True
db.add(msg)
db.commit()
return render_template("messages.html",
msg_read=read,
msg_non_read=non_read,
current_user=current_user)
return render_template("messages.html", no_msg=True)
def setUp(self):
super(TestVitalInfo, self).setUp()
db.add(Patient(nhi="123ABC"))
db.add(VitalInfo(patient_nhi="123ABC", check_in_time=self.now))
db.commit()
def profile_edit():
session_token = request.cookies.get("session_token")
# get user from the database based on her/his email address
user = db.query(User).filter_by(session_token=session_token).first()
if request.method == "GET":
if user: # if user is found
return render_template("profile_edit.html", user=user)
else:
return redirect(url_for("index"))
elif request.method == "POST":
name = request.form.get("profile-name")
email = request.form.get("profile-email")
# update the user object
user.name = name
user.email = email
# store changes into the database
db.add(user)
db.commit()
return redirect(url_for("profile"))
def search_tag(self, instance):
tag = instance.text
search = Search(searchterm=tag)
db.add(search)
db.commit()
App.get_running_app().root.next_screen("front_screen")
def result():
guess = int(request.form.get("guess"))
email_address = request.cookies.get("email")
# Vadim Usera iz databaze po mailu
user = db.query(User).filter_by(email=email_address).first()
if guess == user.secret_number:
message = "Correct! The secret number is {0}".format(str(guess))
# Stvaram novi broj
new_secret = random.randint(1, 30)
# Updejtam Userov broj
user.secret_number = new_secret
# Updejtam objekt u databazi
db.add(User)
db.commit()
elif guess > user.secret_number:
message = "Your guess is not correct... try something smaller."
elif guess < user.secret_number:
message = "Your guess is not correct... try something bigger."
return render_template("result.html", message=message)
def bathymetry_coordinates_txt(id):
"""
API endpoint to transform and store the posted X,Y,Z coordinates text blob in the specified bathymetry.
:param id: bathymetry identifier
:rtype: object
"""
content = request.get_json(silent=True)
print(content)
# parse content
f = StringIO(content.replace(' ', ''))
result = read_coords(f)
validate(instance=result, schema=schema)
bathymetry = Bathymetry.query.get(id)
if not bathymetry:
raise ValueError("Invalid bathymetry with identifier %s" % id)
BathymetryCoordinate.query.filter(
BathymetryCoordinate.bathymetry_id == bathymetry.id).delete()
for coordinate in result["coordinates"]:
db.add(
BathymetryCoordinate(x=coordinate["x"],
y=coordinate["y"],
z=coordinate["z"],
bathymetry_id=bathymetry.id))
db.commit()
return jsonify(bathymetry.to_dict())
def register():
user = check_login()
if user:
return redirect(url_for('index'))
if request.method == "GET":
return render_template("register.html", title="Register")
elif request.method == "POST":
name = request.form.get("username")
email = request.form.get("email")
raw_password = request.form.get("password")
raw_password2 = request.form.get("passwordConf")
if raw_password != raw_password2:
return render_template("register.html",
title="Register",
diffPass=True)
password = hashlib.sha3_256(raw_password.encode()).hexdigest()
user = User(name=name, email=email, password=password)
try:
db.add(user)
db.commit()
except exc.IntegrityError:
return render_template("register.html",
title="Register",
message=True)
return log_in(user)
else:
return "Something is wrong."
def save_pub_type(pub_id, types):
"""保存酒吧类型"""
type_list = [int(i) for i in types.split(",")]
for pub_type in type_list:
db.add(PubTypeMid(pub_id, pub_type))
db.commit()
def update_smartcard_status(smartcard):
if not "enabled" in request.json:
return make_response("Incorrect data in json", 400)
smartcard.enabled = request.json["enabled"]
db.add(smartcard)
db.commit()
return json.dumps(smartcard.serialize())
def new_smartcard(user):
if validate_smartcard():
user.smartcard = Smartcard(request.json["smartcard_number"], request.json["enabled"])
db.add(user)
db.commit()
return json.dumps(user.smartcard.serialize())
else:
return make_response("Incorrect data in JSON", 400)
def process_item(self, item, spider):
# create a new SQL Alchemy object and add to the db session
record = AllData(title=item['title'][0].decode('unicode_escape'),
url=item['url'][0],
desc=item['desc'])
db.add(record)
db.commit()
return item
def populate_gallery(self):
# change placehold.it with
gallerypages = float(self.pagecount) / float(40)
pageregex = re.compile('http://' + App.get_running_app().root.baseurl +
'.org/s/\S{10}/\d{6}-\d+')
if gallerypages.is_integer():
pass
else:
gallerypages += 1
headers = {'User-agent': 'Mozilla/5.0'}
cookies = App.get_running_app().root.cookies
for i in range(int(gallerypages)):
galleryrequest = requests.get(
"http://" + App.get_running_app().root.baseurl +
".org/g/{}/{}/?p={}\
"
.format(self.gallery_id, self.gallery_token, i),
headers=headers,
cookies=cookies)
soup = BS(galleryrequest.text)
for a in soup.findAll(name="a", attrs={"href": pageregex}):
self.pagelinks.append(a["href"])
existpageurl = db.query(Pagelink).filter_by(
pagelink=a["href"]).first()
if existpageurl:
pass
else:
pageurl = Pagelink(galleryid=self.db_id,
pagelink=a["href"])
db.add(pageurl)
db.commit()
# pagetimer = 0
# for page in self.pagelinks:
# Clock.schedule_once(partial(self.grab_image, page), 2*pagetimer)
# pagetimer += 1
self.next_page = 1
currentexist = db.query(Pagelink).filter_by(galleryid=self.db_id,
current=1).first()
if currentexist:
first_screen = self.construct_image(currentexist.pagelink)
self.ids.gallery_manager.switch_to(first_screen)
else:
first_screen = self.construct_image(self.pagelinks[0])
self.ids.gallery_manager.switch_to(first_screen)
# consider adding this in its own thread
firstimage = db.query(Pagelink).filter_by(
pagelink=self.pagelinks[0]).first()
firstimage.current = 1
db.commit()
def add_checkin(nhi, data):
c = CheckIn(**data)
c.patient_nhi = nhi
db.add(c)
db.commit()
if c.patient.latest_checkin_time is None or c.checkin_time > c.patient.latest_checkin_time:
c.patient.latest_checkin_time = c.checkin_time
db.commit()
return c
def add_vital_info(nhi, data):
v = VitalInfo(**data)
v.patient_nhi = nhi
db.add(v)
db.commit()
if v.patient.latest_check_in is None or v.check_in_time > v.patient.latest_check_in:
v.patient.latest_check_in = v.check_in_time
db.commit()
return v
def user_put(user):
for key in request.json.keys():
if key == "id":
pass
elif hasattr(user, key):
setattr(user, key, request.json[key])
user.generate_gravatar_url()
db.add(user)
db.commit()
return json.dumps({"user": user.serialize()})
def spending_category_put(sc):
print request.json
if "category_name" in request.json:
sc.category_name = request.json["category_name"]
if "monthly_allowance" in request.json:
sc.monthly_allowance = request.json["monthly_allowance"]
db.add(sc)
db.commit()
return json.dumps(sc.serialize())
def register_view():
register_form = RegisterForm(request.form)
if helpers.validate_form_on_submit(register_form):
user = User(login_name=register_form.email.data, password=register_form.password.data,
login_type=0, nick_name=register_form.login.data)
db.add(user)
db.commit()
login_user_with_remember(user)
if user.admin:
return redirect('/admin')
return redirect('/admin')
return render_template('admin_pub/auth.html', form=register_form)
def add_favourite(self, *args):
existfavourite = db.query(Favourites).filter_by(gallery_id=self.gallery_id).first()
if existfavourite:
return
else:
newfav = Favourites()
newfav.gallery_id = self.gallery_id
newfav.gallery_token = self.gallery_token
newfav.pagecount = self.pagecount
newfav.gallery_name = self.gallery_name
newfav.gallery_thumb = self.gallery_thumb
newfav.filesize = self.filesize
db.add(newfav)
db.commit()
Snackbar.make("Added to favourites!")
def save_activity_pictures(activity_id, pictures):
"""保存酒吧图片"""
for picture in pictures:
if not allowed_file_extension(picture.filename, ACTIVITY_PICTURE_ALLOWED_EXTENSION):
continue
else:
upload_name = picture.filename
base_path = ACTIVITY_PICTURE_BASE_PATH
rel_path = ACTIVITY_PICTURE_UPLOAD_FOLDER
pic_name = time_file_name(secure_filename(upload_name), sign=activity_id)
activity_picture = ActivityPicture(activity_id, base_path, rel_path, pic_name, upload_name, cover=0)
db.add(activity_picture)
picture.save(os.path.join(base_path+rel_path+'/', pic_name))
db.commit()
save_thumbnail(activity_picture.id)
def save_pub_pictures(pub_id, pictures):
"""保存酒吧图片"""
for picture in pictures:
if not allowed_file_extension(picture.filename, PUB_PICTURE_ALLOWED_EXTENSION):
continue
else:
upload_name = picture.filename
base_path = PUB_PICTURE_BASE_PATH
rel_path = PUB_PICTURE_UPLOAD_FOLDER
pic_name = time_file_name(secure_filename(upload_name), sign=pub_id)
pub_picture = PubPicture(pub_id, base_path, rel_path, pic_name, upload_name, cover=0)
db.add(pub_picture)
picture.save(os.path.join(base_path + rel_path + "/", pic_name))
db.commit()
save_thumbnail(pub_picture.id)
def signup():
user_query = User.query.filter_by(email_address=request.json["email_address"]).all()
if user_query:
return json.dumps({"error": "Email address taken"})
else:
user = User(request.json['email_address'],
request.json['password'],
request.json['first_name'],
request.json['last_name'])
db.add(user)
db.commit()
session['user_id'] = user.id
return json.dumps({"user": user.serialize()})
def sender_invitation(sender_id, receiver_id):
"""
发送一个邀约
"""
invitation = Invitation(sender_id=sender_id, receiver_id=receiver_id)
try:
db.add(invitation)
db.commit()
user_info = ModelUserInfo.query.filter(ModelUserInfo.user_id == receiver_id).first()
user_info.add_credit('invite') # 增加接受者积分
db.commit()
sender_user = ModelUserInfo.query.filter(ModelUserInfo.user_id == sender_id).first()
sender_user.add_reputation('invite') # 增加发送者经验值
db.commit()
except:
return False
return True
def set_filters(self, instance):
filters = {
"doujinshi": 0,
"manga": 0,
"artistcg": 0,
"gamecg": 0,
"western": 0,
"nonh": 0,
"imageset": 0,
"cosplay": 0,
"asianporn": 0,
"misc": 0
}
if instance.ids.doujinshi.active == True:
filters["doujinshi"] = 1
if instance.ids.manga.active == True:
filters["manga"] = 1
if instance.ids.artistcg.active == True:
filters["artistcg"] = 1
if instance.ids.gamecg.active == True:
filters["gamecg"] = 1
if instance.ids.western.active == True:
filters["western"] = 1
if instance.ids.nonh.active == True:
filters["nonh"] = 1
if instance.ids.imageset.active == True:
filters["imageset"] = 1
if instance.ids.cosplay.active == True:
filters["cosplay"] = 1
if instance.ids.asianporn.active == True:
filters["asianporn"] = 1
if instance.ids.misc.active == True:
filters["misc"] = 1
newfilter = Filters(doujinshi=filters["doujinshi"],
manga=filters["manga"],
artistcg=filters["artistcg"],
gamecg=filters["gamecg"],
western=filters["western"],
nonh=filters["nonh"],
imageset=filters["imageset"],
cosplay=filters["cosplay"],
asianporn=filters["asianporn"],
misc=filters["misc"])
db.add(newfilter)
db.commit()
def sender_gift(sender_id, receiver_id, gift_id):
"""
发送礼物
"""
gift = UserGift(sender_id=sender_id, receiver_id=receiver_id, gift_id=gift_id)
try:
db.add(gift)
db.commit()
user_info = ModelUserInfo.query.filter(ModelUserInfo.user_id == receiver_id).first()
user_info.add_credit('gift') # 增加接受者积分
db.commit()
sender_user = ModelUserInfo.query.filter(ModelUserInfo.user_id == sender_id).first()
sender_user.add_reputation('gift') # 增加发送者经验值
db.commit()
except:
return False
return True
def upload(self, path=None):
"""
Upload view method
:param path:
Optional directory path. If not provided, will use the base directory
"""
# Get path and verify if it is valid
base_path, directory, path = self._normalize_path(path)
if not self.can_upload:
flash(gettext('File uploading is disabled.'), 'error')
return redirect(self._get_dir_url('.index', path))
if not self.is_accessible_path(path):
flash(gettext(gettext('Permission denied.')))
return redirect(self._get_dir_url('.index'))
form = UploadForm(self)
if helpers.validate_form_on_submit(form):
activity_id = request.args.get('activity_id')
if not activity_id:
flash(gettext('这里无法上传图片，修改酒吧即可看到图片管理按钮。'), 'error')
return redirect("/admin/activitypicturefile") # todo-lyw ugly
upload_name = secure_filename(form.upload.data.filename)
pic_name = time_file_name(upload_name, sign=activity_id)
save_path_name = op.join(directory, pic_name)
if not allowed_file_extension(upload_name, ACTIVITY_PICTURE_ALLOWED_EXTENSION):
flash(gettext('File "%(name)s" must be a picture!', name=pic_name),
'error')
else:
try:
self.save_file(save_path_name, form.upload.data)
picture = ActivityPicture(activity_id, ACTIVITY_PICTURE_BASE_PATH, ACTIVITY_PICTURE_UPLOAD_FOLDER,
pic_name, upload_name, cover=0)
db.add(picture)
db.commit()
save_activity_thumbnail(picture.id) # 生产略缩图文件，保存到本地，然后数据库添加数据
self.on_file_upload(directory, path, pic_name)
return redirect('/admin/activitypicturefile/?activity_id=' + str(request.args.get('activity_id')))
except Exception as ex:
flash(gettext('Failed to save file: %(error)s', error=ex))
return self.render(self.upload_template, form=form)
def start(bot, update):
user_id = update.message.from_user.id
user_name = update.message.from_user.username
user = User(user_id=user_id).get()
# Creating menu keyboard
reply_markup = ReplyKeyboardMarkup(default_keyboard)
if user:
msg = 'С возвращением, %s\nПомощь - /help' % user_name
else:
db.add(User(user_id, user_name))
db.commit()
logger.info('User {}({}) added bot'.format(user_name, user_id))
msg = 'Добро пожаловать в ChatRoo!\nПомощь - /help'
bot.sendMessage(chat_id=update.message.chat_id, text=msg, reply_markup=reply_markup)
def get():
"""
参数:
sender_id:发送的id
receiver_id:接收的id
content: 发送内容
"""
parser = reqparse.RequestParser()
parser.add_argument('sender_id', type=str, required=True, help=u'sender_id必须。')
parser.add_argument('receiver_id', type=str, required=True, help=u'receiver_id必须。')
parser.add_argument('content', type=str, required=True, help=u'content必须。')
# parser.add_argument('date', type=str, required=True, help=u'date必须.')
args = parser.parse_args()
sender_id = args['sender_id']
receiver_id = args['receiver_id']
content = args['content']
resp_suc = success_dic().dic
resp_fail = fail_dic().dic
resp_suc['sender_list'] = []
if sender_id == receiver_id:
resp_fail['message'] = '您不能发给自己！'
return resp_fail
message = Message(sender_id=sender_id, receiver_id=receiver_id, content=content, view=0)
db.add(message)
try:
db.commit()
result = db.query(Message).\
filter(Message.sender_id == sender_id).\
group_by(Message.sender_id).count()
if result == 0:
user_info = UserInfo.query.filter(UserInfo.user_id == receiver_id).first()
user_info.add_credit('message')
db.commit()
sender_info = UserInfo.query.filter(UserInfo.user_id == sender_id).first()
sender_info.add_reputation('message')
db.commit()
except:
return resp_fail
message = Message.query.filter(Message.id == message.id).first()
traverse_message_sender(message, resp_suc)
return resp_suc
def _process_fullcopy(key):
# Set the content-type correctly
bucket = helper.get_bucket()
k = bucket.lookup(key)
k.copy(k.bucket, k.name, preserve_acl=True, metadata={'Content-Type': helper.get_mimetype(k.name)})
orig_video = Video(key=key, status='downloading')
db.add(orig_video)
db.commit()
url = helper.get_s3url(key)
orig_path = download_url(url)
orig_video.update(get_video_attrs(orig_path))
orig_video.status = 'done'
for preset in FFMPEG_PRESETS.iterkeys():
# Transcode/Upload based on ffmpeg preset
iphone_path = os.path.splitext(orig_path)[0] + preset
iphone_video = Video(key=os.path.basename(iphone_path), status='transcoding')
db.add(iphone_video)
db.commit()
try:
make_iphone(orig_path, iphone_path, preset)
iphone_video.update(get_video_attrs(iphone_path))
except:
iphone_video.status = 'transcoding error'
else:
iphone_video.status = 'uploading'
db.commit()
if iphone_video.status == 'uploading':
upload_to_s3(iphone_path)
iphone_video.status = 'done'
db.commit()
os.remove(iphone_path)
os.remove(orig_path)
