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 v1_nearby():
try:
check_params(request, ['session'])
user = validate_session(request.form['session'])
except StandardError as e:
return respond(str(e), code=400), 400
return respond("SUCCESS", data={'nearby': [{}]})
def v1_ping():
try:
check_params(request, ['session'])
user = validate_session(request.form['session'])
except StandardError as e:
return respond(str(e), code=400), 400
return respond("PONG", data={'now': datetime.utcnow()})
def v1_getuser():
try:
check_params(request, ['session'])
user = validate_session(request.form['session'])
except StandardError as e:
return respond(str(e), code=400), 400
return respond("SUCCESS", data={'user': user.getDict()})
def v1_logout():
try:
check_params(request, ['session'])
user = validate_session(request.form['session'])
except StandardError as e:
return respond(str(e), code=400), 400
delete_session(request.form['session'])
return respond("SUCCESS")
def v1_checkin():
try:
check_params(request, ['session', 'lat', 'lng'])
user = validate_session(request.form['session'])
except StandardError as e:
return respond(str(e), code=400), 400
user.lat = request.form['lat']
user.lng = request.form['lng']
db.session.commit()
return respond("SUCCESS")
def create(**kwargs):
check_params(Supplier, kwargs)
supplier = Supplier(**kwargs)
try:
db.session.add(supplier)
db.session.commit()
except Exception, e:
print e
db.session.rollback()
pass
def create(**kwargs):
check_params(Product, kwargs)
pd = Product(**kwargs)
try:
db.session.add(pd)
db.session.commit()
except Exception, e:
print e
db.session.rollback()
pass
def create(**kwargs):
check_params(RaidType, kwargs)
raidtype = RaidType(**kwargs)
try:
db.session.add(raidtype)
db.session.commit()
except Exception, e:
print e
db.session.rollback()
pass
def create(**kwargs):
check_params(Raid, kwargs)
idc = Raid(**kwargs)
try:
db.session.add(idc)
db.session.commit()
except Exception, e:
print e
db.session.rollback()
pass
def create(**kwargs):
check_params(ManagementCard, kwargs)
management = ManagementCard(**kwargs)
try:
db.session.add(management)
db.session.commit()
except Exception, e:
print e
db.session.rollback()
pass
def create(**kwargs):
check_params(Cabinet, kwargs)
cabinet = Cabinet(**kwargs)
try:
db.session.add(cabinet)
db.session.commit()
except Exception, e:
print e
db.session.rollback()
pass
def create(**kwargs):
check_params(Status, kwargs)
status = Status(**kwargs)
try:
db.session.add(status)
db.session.commit()
except Exception, e:
print e
db.session.rollback()
pass
def v1_admin_getUsers():
try:
check_params(request, ['key'])
if request.form['key'] != app.config['ADMIN_SECRET_KEY']:
raise StandardError('Bad. Go away.')
except StandardError as e:
return respond(str(e), code=400), 400
users = []
for u in User.query.all():
users.append({'id': u.id, 'username': u.username})
return respond("SUCCESS", data={'users': users, 'count': len(users)})
def create(**kwargs):
check_params(Manufacturers, kwargs)
man = Manufacturers(**kwargs)
try:
db.session.add(man)
db.session.commit()
except Exception, e:
print e
db.session.rollback()
pass
def v1_admin_getUser():
try:
check_params(request, ['key', 'uid'])
if request.form['key'] != app.config['ADMIN_SECRET_KEY']:
raise StandardError('Bad. Go away.')
uid = request.form['uid']
except StandardError as e:
return respond(str(e), code=400), 400
user = User.query.filter(User.id == uid).first()
if not user:
return respond("Unknown user", code=404)
return respond("SUCCESS", data={'user': user.getDict()})
def v1_activity_start():
try:
check_params(request, ['session', 'id'])
user = validate_session(request.form['session'])
except StandardError as e:
return respond(str(e), code=400), 400
activity = Activity.query.filter(Activity.id == request.form['id']).first()
if activity == None:
return respond("Unknown activity", code=105), 400
score = Score(user, activity)
db.session.add(score)
db.session.commit()
return respond("Completed!", data={'id': score.id})
def v1_activity_history():
try:
check_params(request, ['session'])
user = validate_session(request.form['session'])
except StandardError as e:
return respond(str(e), code=400), 400
scores = Score.query.filter(Score.user == user).all()
activities = []
for score in scores:
activities.append({
'id': score.id,
'name': score.activity.name,
'start': time.mktime(score.start.timetuple()),
'end': time.mktime(score.end.timetuple()),
'points': score.activity.points,
'skill': score.activity.skill.name,
'completed': score.completed
})
return respond("SUCCESS", data={'activities': activities})
def v1_activity_complete():
try:
check_params(request, ['session', 'id'])
user = validate_session(request.form['session'])
except StandardError as e:
return respond(str(e), code=400), 400
score = Score.query.filter(Score.id == request.form['id']).first()
if score == None:
return respond("Unknown score", code=104), 400
if score.user.id != user.id:
return respond("Stop haxing", code=999), 400
if score.completed:
return respond("Activity already completed!", code=105), 400
score.end = datetime.utcnow()
score.completed = True
db.session.commit()
return respond("Completed!", data={'xp_gained': score.activity.points})
def v1_location():
try:
check_params(request, ['session', 'id'])
user = validate_session(request.form['session'])
except StandardError as e:
return respond(str(e), code=400), 400
location = Location.query.filter(Location.id == request.form['id']).first()
if location == None:
return respond("Unknown location", code=103), 500
loc = {
'name': location.name,
'lat': location.lat,
'lng': location.lng,
}
activities = Activity.query.filter(Activity.location == location).all()
acts = []
for a in activities:
acts.append({'name': a.name, 'desc': a.desc, 'points': a.points})
return respond("SUCCESS", data={'location': loc, 'activities': acts})
def v1_login():
try:
check_params(request, ['user', 'pass'])
except StandardError as e:
return respond(str(e), code=400), 400
username = str(request.form['user'])
password = str(request.form['pass'])
user = User.query.filter(User.username == username).first()
if user == None or not bcrypt.check_password_hash(user.password, password):
return respond("Unknown or invalid username/password", code=400), 400
# 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})
"""
import logging
import multiprocessing
import time
from app.client import Client
from app.utils import parse_args, check_params, setup_logging
if __name__ == '__main__':
args = parse_args()
print('Downloading wallpapers with arguments:')
for arg in vars(args):
print("{0:<15} {1:<15}".format(arg, getattr(args, arg)))
start = time.time()
if not check_params(args):
logging.error(f'Program params wasn\'t correct!')
exit(1)
setup_logging(args.log_file, args.verbose)
num_processes = max(multiprocessing.cpu_count() - 1, 1)
client = Client(
path=args.path,
num_processes=num_processes,
start_time=args.start_time,
end_time=args.end_time,
resolution=args.resolution,
timeout=args.timeout
).prepare().run()
