def schedule_check( job ):
# make sure file exists and estimated time has been calculated
if not os.path.exists( job['path'] ):
return False
if not job['estimated_time']:
return False
# load schedule
schedule = database.get_schedule()
current_time = datetime.datetime.now()
hours, minutes = job['estimated_time'].split(":")
# add minutes to time
current_time = current_time.replace( minute=(current_time.minute + int(minutes) ) )
current_hour = current_time.hour
# check to see if interval is all good
for i in range(int(hours)+1):
schedule_day = schedule[ str(current_time.weekday()) ]
if schedule_day[ current_hour + i ] == 0:
return False
return True
def update_schedule(channelid):
if "twitch_user" not in session:
return redirect(url_for("mainpage"))
# Perform simple validation on the schedule. Tidying up human entry
# is the job of the front end; if you send "1pm" to the back end,
# you will simply get back an error, nothing more. The front end is
# supposed to have already converted this to "13:00", which is the
# only format we accept here.
schedule = []
sched = "<unknown cause>" # in case we get an unexpected ValueError
try:
for day in range(7):
sched = request.form.get("sched%d" % day, "")
if ',' in sched: raise ValueError
for time in sched.split():
hr, min = time.split(
":") # Raises ValueError if wrong number of colons
if not (0 <= int(hr) < 24):
raise ValueError # Also raises if not integer
if not (0 <= int(min) < 60): raise ValueError
schedule.append(" ".join(sched.split()))
except ValueError:
return "Schedule format error: " + sched, 400
tz = request.form.get("sched_tz")
if not tz:
# No TZ specified? Use what we have, if possible, otherwise
# demand one from the user. The front end will normally try
# to provide a default timezone, so most users won't have
# to worry about this.
tz = database.get_schedule(channelid)[0]
if not tz:
return "Please specify a timezone", 400
database.set_schedule(channelid, tz, schedule)
return redirect(url_for("mainpage"))
def classinfo():
if not session.has_key('user'):
return redirect(url_for("about"))
username=session['user']
name=database.get_name(username)
osis=database.get_osis(username)
digits=database.get_id(username)
email=database.get_email(username)
schedule=database.get_schedule(username)
classes=database.get_class_info()
if request.method=='GET':
return render_template("class.html"
,name=name
,osis=osis
,digits=digits
,email=email
,classes=classes
,schedule=schedule
,get=True)
if request.method=="POST":
value=request.form['button']
value=value.split(" ")
index=int(value[1])-1
validate=True
if (str(value[0])=="set"):
period=classes[index][0]
clas=classes[index]
schedule=database.get_schedule(username)
if schedule[int(period)-1][1]=="free":
database.set_period(username,period,clas)
else:
validate=False
if (str(value[0])=="req"):
req=classes[index]
period=classes[index][0]
if database.has_lunch(username,period) or l_equal(schedule[int(period)-1],req):
validate=False
else:
database.post_request(username,req)
return render_template("class.html"
,name=name
,osis=osis
,digits=digits
,email=email
,classes=classes
,schedule=schedule
,validate=validate)
def apply_schedule():
with app.app_context():
for entry in database.get_outputs():
pin = entry['pin']
output = entry['output']
if isinstance(pin, int):
schedule = database.get_schedule(output)
output_scheduler.apply_outputs(schedule, pin)
def mainpage(channelid=None):
# NOTE: If we've *reduced* the required scopes, this will still force a re-login.
# However, it'll be an easy login, as Twitch will recognize the existing auth.
if "twitch_token" not in session or session.get(
"twitch_auth_scopes") != REQUIRED_SCOPES:
return render_template("login.html")
user = session["twitch_user"]
if channelid is None: channelid = user["_id"]
try:
channelid = str(int(channelid))
except ValueError:
# If you go to /editor/somename, redirect to /editor/equivalent-id
# Bookmarking the version with the ID will be slightly faster, but
# streamers will usually want to share the version with the name.
users = query("helix/users", token="app", params={"login":
channelid})["data"]
# users is either an empty list (bad login) or a list of one.
if not users: return redirect("/")
return redirect("/editor/" + users[0]["id"])
if not may_edit_channel(user["_id"], channelid):
return redirect(url_for("mainpage"))
database.create_user(
channelid
) # Just in case, make sure the database has the basic structure
channel = get_channel_setup(channelid)
sched_tz, schedule, sched_tweet = database.get_schedule(channelid)
if "twitter_oauth" in session:
auth = session["twitter_oauth"]
username = auth["screen_name"]
twitter = "Twitter connected: " + username
tweets = list_scheduled_tweets(auth["oauth_token"],
auth["oauth_token_secret"], sched_tz)
else:
twitter = Markup(
"""<div id="login-twitter"><a href="/login-twitter"><img src="/static/Twitter_Social_Icon_Square_Color.svg" alt="Twitter logo"><div>Connect with Twitter</div></a></div>"""
)
tweets = []
error = session.get("last_error_message", "")
session["last_error_message"] = ""
return render_template(
"index.html",
twitter=twitter,
username=user["display_name"],
channel=channel,
channelid=channelid,
error=error,
setups=database.list_setups(channelid),
sched_tz=sched_tz,
schedule=schedule,
sched_tweet=sched_tweet,
checklist=database.get_checklist(channelid),
timers=database.list_timers(channelid),
tweets=tweets,
)
def profile():
if not session.has_key('user'):
return redirect(url_for('about'))
username=session['user']
name=database.get_name(username)
osis=database.get_osis(username)
digits=database.get_id(username)
email=database.get_email(username)
schedule=database.get_schedule(username)
notif=database.get_notification(username)
if request.method=='GET':
return render_template("profile.html"
,name=name
,osis=osis
,digits=digits
,schedule=schedule
,email=email
,accept=notif["accept"]
,accepted=notif["accepted"]
)
elif request.method=="POST":
value=request.form["button"]
value=value.split(" ")
index=int(value[1])-1
if str(value[0])=="drop":
schedule=database.get_schedule(username)
clas=schedule[index]
if not (clas[1]=="free" or clas[1]=="Cafe"):
database.drop_period(username,clas[0])
schedule=database.get_schedule(username)
return render_template("profile.html"
,name=name
,osis=osis
,digits=digits
,schedule=schedule
,email=email
,accept=notif["accept"]
,accepted=notif["accepted"]
)
def edit():
if not session.has_key('user'):
return redirect(url_for("about"))
username=session['user']
email=database.get_email(username)
osis=database.get_osis(username)
digit=database.get_id(username)
if request.method=='GET':
return render_template("edit.html"
,username=username
,email=email
,osis=osis
,digit=digit
,loggedout=False)
if request.method=='POST':
if request.form['button']=='Edit':
password=request.form['password']
email=request.form['email']
digit=request.form['digit']
osis=request.form['osis']
lunch=request.form['lunch']
schedule=database.get_schedule(username)
current_lunch=database.get_lunch(username)
pos=database.get_period(username,int(lunch))[1]
if not (pos == 'free' or pos=='Cafe'):
return render_template("edit.html"
,username=username
,email=email
,osis=osis
,digit=digit
,loggedout=False
,invalid=True)
database.set_period(username,current_lunch,["","free","n/a","",""])
database.set_period(username,lunch,[str(lunch),"Cafe","Chi Kun Wang","ZLN5","0"+str(lunch)])
database.set_password(username,password)
database.set_email(username,email)
database.set_id(username,digit)
database.set_osis(username,osis)
return redirect(url_for('profile'))
return redirect(url_for('edit'))
def visit(username=""):
if not session.has_key('user'):
return redirect(url_for('about'))
me=session['user']
if str(username)==str(me):
return redirect(url_for('profile'))
name=database.get_name(username)
osis=database.get_osis(username)
digits=database.get_id(username)
email=database.get_email(username)
schedule=database.get_schedule(username)
notif=database.get_notification(username)
if request.method=='GET':
return render_template("visit.html"
,name=name
,osis=osis
,digits=digits
,schedule=schedule
,email=email
,accept=notif["accept"]
,accepted=notif["accepted"]
)
def make_backup(channelid):
twitchid = channelid
response = "{\n"
# Setups
setups = database.list_setups(twitchid)
response += '\t"setups": [\n'
fields = "category", "title", "tags", "tweet"
for setup in setups:
setup = {field: setup[field] for field in fields}
response += "\t\t" + json.dumps(setup) + ",\n"
response += '\t\t""\n\t],\n'
# Schedule
tz, sched, sched_tweet = database.get_schedule(twitchid)
response += '\t"schedule": [\n'
for day in sched:
response += "\t\t" + json.dumps(day) + ",\n"
response += "\t\t%s,\n\t\t%d\n\t],\n" % (json.dumps(tz), sched_tweet)
# Checklist
checklist = database.get_checklist(twitchid).strip().split("\n")
response += '\t"checklist": [\n'
for item in checklist:
response += "\t\t" + json.dumps(item) + ",\n"
response += '\t\t""\n\t],\n' # Empty string as shim. Ignored on import.
# Timers
timers = database.list_timers(twitchid, full=True)
response += '\t"timers": [\n'
for timer in timers:
item = dict(zip("id title delta maxtime styling".split(), timer))
response += "\t\t" + json.dumps(item) + ",\n"
response += '\t\t""\n\t],\n'
# Footer (marker to show that the file was correctly downloaded)
# This must NOT include any sort of timestamp, as the backup file
# must be completely stable (taking two backups without changing
# anything should result in bit-for-bit identical files).
response += '\t"": "Mustard-Mine Backup"\n}\n'
return Response(response,
mimetype="application/json",
headers={"Content-disposition": "attachment"})
def tradingfloor():
if not session.has_key('user'):
return redirect(url_for("about"))
username=session['user']
name=database.get_name(username)
osis=database.get_osis(username)
digits=database.get_id(username)
email=database.get_email(username)
database.refresh_floor()
floor=database.get_floor()
if request.method=='GET':
return render_template("trading.html"
,name=name
,osis=osis
,digits=digits
,floor=floor
,email=email
,validate=False)
if request.method=='POST':
value=request.form["button"]
value=value.split(" ")
index=int(value[1])-1
req=floor[index]["request"]
period=int(req[0])-1
acceptername=username
postername=floor[index]['username']
schedule=database.get_schedule(username)[period]
validate=False
myself=False
illegaldel=False
try:
if not str(postername)==str(username):
if value[0]=="accept":
if l_equal(req,schedule):
database.accept_request(postername,acceptername,req)
return redirect(url_for("tradingfloor"))
else:
validate=True
elif value[0]=="delete":
validate=True
myself=False
illegaldel=True
else:
if value[0]=="accept":
validate=True
myself=True
else:
database.remove_request(username,req)
database.refresh_floor()
floor=database.get_floor()
return render_template("trading.html"
,name=name
,osis=osis
,digits=digits
,email=email
,floor=floor
,validate=validate
,myself=myself
,illegaldel=illegaldel)
except Exception:
return render_template("trading.html"
,name=name
,osis=osis
,digits=digits
,email=email
,floor=floor
,validate=True)
def get_user_tweets():
auth = session["twitter_oauth"]
sched_tz = database.get_schedule(session["twitch_user"]["_id"])[0]
return list_scheduled_tweets(auth["oauth_token"],
auth["oauth_token_secret"], sched_tz)
