def login():
"""
Login Endpunkt
Returns:
Rendert das Login Template oder leitet an das Dashboard weiter nach erfolgreichem Login
"""
form = LoginForm()
ip_address = get_real_ip()
if request.method == "POST":
if form.validate_on_submit():
be_user = BeUser()
be_user.set("username", escape(request.form["username"]))
be_user.temp_password = escape(request.form["password"])
if be_user.validate_login():
be_user.load()
session = Session()
session.set_user_id(be_user.get_id())
if session.session_exists():
session.delete()
session = Session()
session.set_user_id(be_user.get_id())
ip_address = escape(ip_address)
user_agent = escape(request.user_agent)
token = session.encryption.create_random_token(32)
session.set_ip_address(ip_address)
session.set_user_agent(user_agent)
session.set_token(token)
time = datetime.now()
session.set_timestamp(time)
if session.save() is not False:
session_user = be_user.create_session_user()
if login_user(session_user):
debug_logger.log(
10, "User mit der ID {0} eingeloggt".format(
session_user.get_id()))
return redirect(url_for("backend.dashboard"))
else:
failed_login_record = FailedLoginRecord()
failed_login_record.set_user_id(be_user.get_id())
failed_login_record.set_username(be_user.get_username())
failed_login_record.set_ip_address(request.remote_addr)
failed_login_record.set_user_agent(str(request.user_agent))
failed_login_record.save()
else:
flash(form.errors)
return render_template("login.html", form=form)
def login():
if request.method == 'POST':
if current_user.is_active:
print('Error, user is active!')
return json.dumps({'errmsg': '用户已登陆'})
#获取post来的数据
json_data = json.loads(request.data)
user = User.query.filter_by(id=json_data['id']).first()
if user is None or not user.check_password(json_data['password']):
print('username or password isn\'t correct!')
return json.dumps({'errmsg': '用户名或密码错误'})
login_user(user)
#建立session数据库
se = Session.query.filter_by(uid=user.id).first()
if se == None:
se = Session(uid=user.id)
db.session.add(se)
db.session.commit()
print('Create a new session {}'.format(se.sid))
else:
print('Resume Session {}'.format(se.sid))
print('login user {}!'.format(user))
data = json.dumps(user, default=UserToJson, sort_keys=False)
#生成返回的resp，增加session的选项
resp = make_response()
resp.headers['session_id'] = str(se.sid)
resp.data = data
return resp
return json.dumps({'errmsg': '没有使用POST请求'})
def load_user(user_id):
"""
user loader
hier wird beim aufruf von login.required dekorierten punkten
der in der session gespeicherte benutzer geladen wenn vorhanden
Args:
user_id:
Returns:
"""
if user_id > 0:
user = BeUser()
user.set("id", user_id)
user.load()
session = Session()
session.set_user_id(user.get_id())
if session.load():
session_user = user.create_session_user()
ip_address = get_real_ip()
session_user.ip_address = ip_address
session_user.user_agent = request.user_agent
session_user.token = session.get_token()
session_user.timestamp = session.get_timestamp()
hash = session.get_user_hash_string(session_user)
if session.is_valid(session.encryption.get_generic_hash(hash)):
return session_user
else:
debug_logger.debug("session nicht valid")
session.delete()
return SessionUser()
def create_session():
"""Create a new Session"""
app = Application.query.filter_by(id=request.json['app']).first()
questionnaire = Questionnaire.query.filter_by(
id=request.json['questionnaire']).first()
expected_emotions = request.json['expected_emotions']
# validate application type
if not app:
return {'status': 'error', 'message': 'Invalid application.'}, 400
new_session = Session(app=app,
expected_emotions=expected_emotions,
questionnaire=questionnaire)
db.session.add(new_session)
db.session.commit()
result = session_schema.dump(new_session).data
return jsonify({
'status':
'success',
'message':
'Created new session for application with id of {}.'.format(
request.json['app']),
'data':
result
}), 201
def loaddb_sessions(filename):
""" Populates the database with sessions and session-related relationships from a yml file. Requires loaddb_games and loaddb_users """
sessions = yaml.safe_load(open(filename))
# premier tour de boucle, creation des sessions et des timeslots
dico_timeslots = dict() # k=session_yml_id, v=timeslot_object
dico_sessions = dict() # k=session_yml_id, v=session_object
for id, s in sessions.items():
session_object = Session(nb_players_required=s["nb_players_required"],
notifactions_sent=s["notifactions_sent"],
confirmed=s["confirmed"],
timeout=s["timeout"],
archived=s["archived"])
db.session.add(session_object)
dico_sessions[id] = session_object
timeslot = s["timeslot"]
timeslot_object = TimeSlot(beginning=timeslot["beginning"],
end=timeslot["end"],
day=timeslot["day"])
db.session.add(timeslot_object)
dico_timeslots[id] = timeslot_object
db.session.commit()
# deuxieme tour de boucle, ajout des relations SessionXTimeslot, SessionXGame et SessionXUser
for id, s in sessions.items():
session_object = dico_sessions[id]
session_object.timeslot_id = dico_timeslots[id].id
load_relationship(s, 'session_id', session_object.id, 'games', Use,
Game.from_title, 'game_id', ['expected_time'],
'title')
load_relationship(s, 'session_id', session_object.id, 'players', Play,
User.from_username, 'user_id', ['confirmed', 'won'],
'username')
db.session.commit()
def v1_fblogin():
try:
check_params(request, ['token'])
except StandardError as e:
return respond(str(e), code=400), 400
token = str(request.form['token'])
# Create the username
fb_url = "https://graph.facebook.com/v2.8/me?fields=id&access_token={}"
r = requests.get(fb_url.format(token))
data = r.json()
if r.status_code != 200:
return respond("Server failure", code=r.status_code), 500
fb_username = "******".format(r.json()['id'])
user = User.query.filter(User.username == fb_username).first()
## Create if does not exist
if user == None:
user = User(fb_username, "")
db.session.add(user)
db.session.commit()
# Create a session
session = Session(hexlify(urandom(50)), user)
try:
db.session.add(session)
db.session.commit()
except:
db.session.rollback()
return respond("Internal server error has occured", code=101), 500
return respond("SUCCESS", data={'session': session.session})
def get_user_id(uuid):
session = db.session.query(Session).filter_by(uuid=uuid).first()
if session:
user_id = session.email
if user_id:
return user_id
else:
return None
else:
user_id = get_user_id_ext(uuid=uuid)
if user_id:
try:
session = db.session.query(Session).filter_by(
email=str(user_id)).first()
except Exception as ex:
print('ex: ' + ex)
if session:
session.uuid = uuid
session = session.update_session()
else:
session = Session(username=user_id, uuid=uuid)
session = session.save()
return session.email
else:
return None
def create_with_campaign(id):
form = SessionForm()
form.submit.label.text = "Create Session"
form.participants.choices = gen_participant_choices()
campaign = Campaign.query.filter_by(id=id).first_or_404()
if not current_user.is_dm_of(campaign):
del form.dm_notes
if form.validate_on_submit():
participants = Character.query.filter(Character.id.in_(form.participants.data)).all()
dm_notes = None
if current_user.is_dm_of(campaign):
dm_notes = form.dm_notes.data
new_session = Session(title=form.title.data, campaign_id=form.campaign.data, summary=form.summary.data, dm_notes=dm_notes, date=form.date.data, participants=participants)
db.session.add(new_session)
db.session.commit()
flash("Session was created.", "success")
return redirect(url_for("session.view", id=new_session.id))
elif request.method == "GET":
participants = []
for p in campaign.default_participants:
participants.append(p.id)
form.participants.data = participants
form.campaign.data = id
return render_template("session/create.html", form=form, campaign=campaign, title=page_title("Add Session"))
def user_register(data):
try:
username = data.get('username')
password = data.get('password')
language = data.get('language')
status = data.get('status')
if is_user_exist(username):
return generate_username_taken_response(username)
salt = generate_uuid()
hash_pwd = get_hash_password(salt, password)
user = User(username=username,
hash_pwd=hash_pwd,
salt=salt,
language=language,
status=status)
if user:
temp_uuid = generate_uuid()
session = Session(username=user.username, uuid=temp_uuid)
user.save(session)
return generate_registration_success_response(temp_uuid)
else:
raise Exception('Failed to create user')
except Exception as exe:
print('user user registration failed')
if hasattr(exe, 'message'):
print(exe.message)
else:
print(exe)
return generate_registration_failed_response(exe)
def login():
form = LoginForm()
if form.validate_on_submit():
child_id = form.child_id.data
proctor_id = form.proctor_id.data
# Check if the child is in the database - if they are not, then add
# them. We might want to change this behavior later so that if they are
# not in the database, we do not allow them to log in.
if Child.query.filter_by(id=child_id).first() is None:
child = Child(id=child_id)
db.session.add(child)
db.session.commit()
# Check if the proctor is in the database - if they are not, then add
# them. We might want to change this behavior later so that if they are
# not in the database, we do not allow them to log in.
if Proctor.query.filter_by(id=proctor_id).first() is None:
proctor = Proctor(id=proctor_id)
db.session.add(proctor)
db.session.commit()
session_db_entry = Session(child_id=child_id, proctor_id=proctor_id)
db.session.add(session_db_entry)
db.session.commit()
child = Child.query.filter_by(id=form.child_id.data).first()
if child is None:
print("Invalid child_id or password")
return redirect(url_for("routes.login"))
login_user(child)
return redirect(url_for("routes.index"))
return render_template("login.html", title="Sign In", form=form)
def update(self, **data):
"""
update
:param data:
:return:
"""
# 基于 id 的更新
cid = data.pop('id', -1)
with Session() as ss:
if cid > 0:
query = ss.query(
self.table).filter(self.table.id == cid).first()
if query:
self.modify_raw(query, data)
ss.add(query)
ss.commit()
return 200, query.id
return 404, u'id无法关联信息'
# 基于其他唯一且不为空的key更新
keys = self.get_unique_key()
for key in keys:
name = data.pop(key, None)
if name:
query = ss.query(self.table).filter(
self.table.__dict__[key] == name).first()
if query:
self.modify_raw(query, data)
ss.add(query)
ss.commit()
return 200, query.id
return 404, u'没有匹配到任何行'
def post(self):
session = Session(status='Started',
startDate=datetime.datetime.now(),
company_id=api.payload['companyId'],
user_id=api.payload['userId'])
db.session.add(session)
db.session.commit()
return session_schema.jsonify(session)
def registerHouse():
get_lang(request)
#generate form data
form = RegisterForm(request.form)
if request.method == 'POST':
#store form data
address = form.address.data
city = form.city.data
state = form.state.data
zip = form.zip.data
#generate lat/long from address
results = Geocoder.geocode(address)
result = results[0].coordinates
lat = result[0]
long = result[1]
#create new db session
sess = Session()
#get user id for database relations
account_id = session['id']
#create new home: A new home is identified by street. city, zip, state, lat/long
new_home = Home(account_id=account_id,
street_address=address,
city=city,
state=state,
zip_code=zip,
latitude=lat,
longitude=long)
#Does the address already exist
match = sess.query(Home.street_address)\
.filter(Home.street_address==address)\
.all()
#If the address is unique the home is added
if not match:
print(f'Added: {new_home}')
#add entry to database for home
sess.add(new_home)
#save changes
sess.commit()
#the address is not unique
else:
#error message
flash("Address already registered")
#return to registration page
return render_template('registerHouse.html', form=form)
#close connection
sess.close()
return redirect(url_for('dashboard'))
return render_template('registerHouse.html', form=form)
def __setitem__(self, key, value):
pickled = self.encode(value)
now = datetime.datetime.now()
s = Session.get(key)
if s:
s.data = pickled
else:
s = Session(key, now, pickled)
config.orm.add(s)
def wrapper(bot, update, *args, **kwargs):
s = Session()
if not Chat.q.get(update.message.chat.id):
chat = Chat(id=update.message.chat.id,
is_private=update.message.chat.type == 'private')
s.add(chat)
s.commit()
chat = Chat.q.get(update.message.chat.id) # type: Chat
return fn(bot, update, *args, chat, **kwargs)
def get_users():
try:
result = []
sess = Session()
user = sess.query(User).order_by(User.name).all()
result = [a.to_dict() for a in user]
except Exception as e:
result = []
return result
def get_books():
try:
result = []
sess = Session()
book = sess.query(Book).order_by(Book.name).all()
result = [a.to_dict() for a in book]
except Exception as e:
result = []
return result
def createsession():
form= CreateSessionForm()
if form.validate_on_submit():
session=Session(session_number=form.session_number.data,gametype=form.gametype.data,
patient_id=form.patient_id.data,therapist_id=form.therapist_id.data,intervention_id=form.intervention_id.data,
date_started=form.date_started.data)
db.session.add(session)
db.session.commit()
flash('CONFIRMATION: Session has been created')
return render_template('createsession.html',title='Create Session',form=form)
def get_session_draft(user_id):
session_draft = Session.query.filter(Session.user_id == user_id, Session.is_draft.is_(True)).first()
debug_flash("session_draft", session_draft)
if session_draft:
return session_draft
else:
session = Session(user_id=user_id, is_draft=True)
db.session.add(session)
db.session.commit()
return session
def wrapper(*args, **kwargs):
s = Session()
try:
r = fn(*args, s, **kwargs)
s.commit()
return r
except Exception:
s.rollback()
raise
finally:
s.close()
def generate_session(user_id, **kwargs):
random_int = lambda: random.randint(10, 300)
session = Session(user_id=user_id,
words=kwargs.get('words', random_int()),
chars=kwargs.get('chars', random_int()),
accuracy=kwargs.get('accuracy', random_int()),
created_date=kwargs.get('created_date',
datetime.datetime.now()))
db.session.add(session)
db.session.commit()
return session
def get_user(user_id):
try:
sess = Session()
user = sess.query(User).get(user_id)
if not user:
result = []
else:
result = [user.to_dict()]
except Exception as e:
result = []
return result
def publish_one(self, a_news):
message = self._compose_message(a_news)
r = self._compose_request(message)
resp = requests.post(r)
if resp.status_code == 200:
print("Posted message: %s" % message)
a_news.published = True
Session().commit()
else:
print("Tried to post message: %s \nFailed with resp: %s" %
(message, resp.content))
def delete(self, id=None):
"""
删除
:param id:
:return:
"""
if not id:
return 200, 'nothing need to delete'
with Session() as ss:
ss.query(self.table).filter(self.table.id == id).\
delete(synchronize_session=False)
return 200, 'delete {} done'.format(id)
def create_book(**data):
try:
sess = Session()
book = Book(name=data['name'],
author=data['author'],
description=data['description'])
sess.add(book)
sess.commit()
result = True
except Exception:
result = False
return result
def add():
if request.method == "POST":
title = request.form['title']
video_link = request.form['video_link']
notes_link = request.form['notes_link']
new_session = Session(title=title,
video_link=video_link,
notes_link=notes_link)
db.session.add(new_session)
db.session.commit()
return render_template("add.html")
def delete_user(user_id):
try:
result = False
sess = Session()
user = sess.query(User).get(user_id)
if user:
sess.delete(user)
sess.commit()
result = True
except Exception:
result = False
return result
def save(headers_and_options, row_header, schedules_data):
session = Session()
for row_index, row in enumerate(schedules_data):
for col_index, col in enumerate(row):
session.merge(
Archive(class_id=row_header[row_index]['id'],
major_id=headers_and_options[col_index]['id'],
info=json.dumps(col, ensure_ascii=False)))
session.commit()
session.close()
def delete_book(book_id):
try:
result = False
sess = Session()
book = sess.query(Book).get(book_id)
if book:
sess.delete(book)
sess.commit()
result = True
except Exception:
result = False
return result
def handle(self, *args, **options):
links = ['https://www.facebook.com/318748909507/videos/649968942464224',
'https://www.facebook.com/318748909507/videos/2612971758972997/',
'https://www.facebook.com/318748909507/videos/498942800766464/',
'https://www.facebook.com/318748909507/videos/527572888153782/',
'https://www.facebook.com/318748909507/videos/926772904410122/',
'https://www.facebook.com/318748909507/videos/2574431759464489/',
'https://www.facebook.com/318748909507/videos/247198643102613/',
'https://www.facebook.com/318748909507/videos/1588663631296750/',
'https://www.facebook.com/318748909507/videos/2665635223721596/',
'https://www.facebook.com/318748909507/videos/2669484819990940/',
'https://www.facebook.com/318748909507/videos/535514280498748/',
'https://www.facebook.com/318748909507/videos/3697736870267369/',
'https://www.facebook.com/318748909507/videos/705004410305115/',
'https://www.facebook.com/318748909507/videos/3025730300817570/',
'https://www.facebook.com/318748909507/videos/222023952224132/',
'https://www.facebook.com/318748909507/videos/659991487900808/',
'https://www.facebook.com/318748909507/videos/629913900921785/',
'https://www.facebook.com/318748909507/videos/165132848228069/',
'https://www.facebook.com/318748909507/videos/184435959355973/',
'https://www.facebook.com/318748909507/videos/244576203543813/',
'https://www.facebook.com/318748909507/videos/276445793512600/',
'https://www.facebook.com/318748909507/videos/710323713052933/',
'https://www.facebook.com/318748909507/videos/246632956586240/',
'https://www.facebook.com/318748909507/videos/556846081927489/',
'https://www.facebook.com/318748909507/videos/171019884353180/'
]
user_model = get_user_model()
username = '******'
user = user_model.objects.get(
username=username
)
group = Group()
group.name = 'Soccer Drills 4'
group.user = user
group.save()
index = 0
for link in links:
session = Session()
session.user = user
session.group = group
session.link = link
session.index = index
session.save()
index += 1
