adds more advanced database handling unsing sql alchemy

- moves app into package
- adds sql alchemy equipment
- moves templates into server package
- add app.db sqlite file

app.py

@@ -1,277 +1,5 @@
-# Python standard libraries
-import json
-import os
-import sqlite3
-
-# Third-party libraries
-import flask
-from flask import Flask, redirect, request, url_for
-from flask_login import (
-    LoginManager,
-    current_user,
-    login_required,
-    login_user,
-    logout_user,
-)
-from oauthlib.oauth2 import WebApplicationClient
-import requests
-
-# Internal imports
-from database.db import init_db_command
-from database.user import User
-from database.user import dbCalendar
-
-import backend.caltojson as caltojson
-
-import google.oauth2.credentials
-import google_auth_oauthlib.flow
-import googleapiclient.discovery
-
 # Configuration
-
-CLIENT_SECRETS_FILE = "certificate/client_secret.json"
-
-# This OAuth 2.0 access scope allows for full read/write access to the
-# authenticated user's account and requires requests to use an SSL connection.
-SCOPES = ["https://www.googleapis.com/auth/userinfo.email", "https://www.googleapis.com/auth/userinfo.profile", "https://www.googleapis.com/auth/calendar.readonly", "openid"]
-API_SERVICE_NAME = 'calendar'
-API_VERSION = 'v3'
-
-GOOGLE_CLIENT_ID ="377787187748-shuvi4iq5bi4gdet6q3ioataimobs4lh.apps.googleusercontent.com"
-GOOGLE_CLIENT_SECRET = "Hu_YWmKsVKUcLwyeINYzdKfZ"
-GOOGLE_DISCOVERY_URL = (
-    "https://accounts.google.com/.well-known/openid-configuration"
-)
-# Flask app setup
-app = Flask(__name__,
-            static_folder='static',
-            template_folder='template')
-app.secret_key = os.environ.get("SECRET_KEY") or os.urandom(24)
-
-# User session management setup
-# https://flask-login.readthedocs.io/en/latest
-login_manager = LoginManager()
-login_manager.init_app(app)
-
-# Naive database setup
-try:
-    init_db_command()
-except sqlite3.OperationalError:
-    # Assume it's already been created
-    pass
-
-# OAuth 2 client setup
-client = WebApplicationClient(GOOGLE_CLIENT_ID)
-
-# Flask-Login helper to retrieve a user from our db
-@login_manager.user_loader
-def load_user(user_id):
-    return User.get(user_id)
-
-@app.route("/")
-def account():
-    return flask.redirect('account')
-
-@app.route("/account")
-def index():
-    if current_user.is_authenticated:
-        updateCalendars()
-        return (flask.render_template('account.html',
-            username = current_user.name, email = current_user.email, profile_img=current_user.profile_pic
-            )
-        )
-    else:
-        return flask.render_template('login.html')
-
-def get_google_provider_cfg():
-    return requests.get(GOOGLE_DISCOVERY_URL).json()
-
-class Calendar:
-    def __init__(self, name, toggle='False', color="#000000"):
-        self.name = name
-        self.color = color
-        self.toggle=toggle
-def calendarsFromDb():
-    calendars = dbCalendar.getCalendars(current_user.id)
-    pyCalendars = []
-    for calendar in calendars:
-        name = calendar[2]
-        calId = calendar[1]
-        toggle = calendar[3]
-        color = calendar[4]
-
-        pyCalendars.append(Calendar(name, toggle, color))
-
-    return pyCalendars
-
-
-@app.route("/calendar")
-@login_required
-def calendar():
-    calendars = calendarsFromDb()
-    return flask.render_template('calendar.html', calendars=calendars)
-
-def getCalendarJson():
-    if 'credentials' not in flask.session:
-        return flask.redirect('login/google')
-
-    # Load credentials from the session.
-    credentials = google.oauth2.credentials.Credentials(
-      **flask.session['credentials'])
-    todaysCal = caltojson.generateJsonFromCalendarEntries(credentials)
-
-    with open('./userinfo/' + current_user.id + '/calendarevents.json', 'w') as outfile:
-        json.dump(todaysCal, outfile)
-
-    return todaysCal
-
-
-def updateCalendars():
-    if 'credentials' not in flask.session:
-        return flask.redirect('login/google')
-
-  # Load credentials from the session.
-    credentials = google.oauth2.credentials.Credentials(
-        **flask.session['credentials'])
-
-  
-    calendars = caltojson.getCalendarList(credentials)
-
-    for calendar in calendars:
-        if dbCalendar.getCalendar(current_user.id, calendar.calendarId) == None:
-            dbCalendar.create(current_user.id, calendar.calendarId, calendar.summary, calendar.color)
-
-    print("updated Calendars")
-
-    # Save credentials back to session in case access token was refreshed.
-    # ACTION ITEM: In a production app, you likely want to save these
-    #              credentials in a persistent database instead.
-    flask.session['credentials'] = credentials_to_dict(credentials)
-
-
-@app.route("/login/google")
-def login():
-
-    '''
-    # Find out what URL to hit for Google login
-    google_provider_cfg = get_google_provider_cfg()
-    authorization_endpoint = google_provider_cfg["authorization_endpoint"]
-
-    # Use library to construct the request for Google login and provide
-    # scopes that let you retrieve user's profile from Google
-    request_uri = client.prepare_request_uri(
-        authorization_endpoint,
-        redirect_uri=request.base_url + "/callback",
-        scope=["openid", "email", "profile", "https://www.googleapis.com/auth/calendar.readonly"],
-    )
-    return redirect(request_uri)
-    '''
-
-    # Create flow instance to manage the OAuth 2.0 Authorization Grant Flow steps.
-    flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file(
-        CLIENT_SECRETS_FILE, scopes=SCOPES)
-    # The URI created here must exactly match one of the authorized redirect URIs
-    # for the OAuth 2.0 client, which you configured in the API Console. If this
-    # value doesn't match an authorized URI, you will get a 'redirect_uri_mismatch'
-    # error.
-    flow.redirect_uri = request.base_url + "/callback"
-    authorization_url, state = flow.authorization_url(
-        # Enable offline access so that you can refresh an access token without
-        # re-prompting the user for permission. Recommended for web server apps.
-        access_type='offline',
-        # Enable incremental authorization. Recommended as a best practice.
-        include_granted_scopes='true')
-
-    # Store the state so the callback can verify the auth server response.
-    flask.session['state'] = state
-
-    return flask.redirect(authorization_url)
-
-@app.route("/login/google/callback")
-def callback():
-    # Specify the state when creating the flow in the callback so that it can
-    # verified in the authorization server response.
-    state = flask.session['state']
-
-    flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file(
-        CLIENT_SECRETS_FILE, scopes=SCOPES, state=state)
-    flow.redirect_uri = request.base_url
-
-    # Use the authorization server's response to fetch the OAuth 2.0 tokens.
-    authorization_response = flask.request.url
-    flow.fetch_token(authorization_response=authorization_response)
-
-    # Store credentials in the session.
-    # ACTION ITEM: In a production app, you likely want to save these
-    #              credentials in a persistent database instead.
-    credentials = flow.credentials
-    flask.session['credentials'] = credentials_to_dict(credentials)
-
-    session = flow.authorized_session()
-
-    userinfo = session.get('https://www.googleapis.com/userinfo/v2/me').json()
-
-    # Create a user in your db with the information provided
-    # by Google
-    user = User(
-        id_=userinfo['id'], 
-        name=userinfo['name'], 
-        email=userinfo['email'], 
-        profile_pic=userinfo['picture']
-    )
-
-    # Doesn't exist? Add it to the database.
-    if not User.get(user.id):
-        User.create(user.id, user.name, user.email, user.profile_pic)
-
-    # Begin user session by logging the user in
-    login_user(user)
-    return flask.redirect(flask.url_for('index'))
-
-@app.route("/logout")
-@login_required
-def logout():
-    logout_user()
-    return redirect(url_for("index"))
-
-def credentials_to_dict(credentials):
-  return {'token': credentials.token,
-          'refresh_token': credentials.refresh_token,
-          'token_uri': credentials.token_uri,
-          'client_id': credentials.client_id,
-          'client_secret': credentials.client_secret,
-          'scopes': credentials.scopes}
-
-
-@app.route("/userinfo/<path:user>/calendarevents.json")
-def downloader(user):
-    print(user)
-    path = "/home/raphael/dev/website_ws/website/userinfo/" + user
-    return flask.send_from_directory(path, "calendarevents.json")
-
-# POST
-
-@app.route('/calendar', methods = ['POST', 'DELETE'])
-@login_required
-def user():
-    if request.method == 'POST':
-        calName = request.json.get('calendar_id')
-        color = request.json.get('color')
-        toggle = request.json.get('toggle')
-        
-        if color != None:
-            dbCalendar.updateCalendar(current_user.id, calName, color=color)
-        if toggle != None:
-            dbCalendar.updateCalendar(current_user.id, calName, toggle=toggle)
-        # toggle specific calendar of user
-    elif request.method == 'DELETE':
-        # do nothing
-        return 'NONE'
-    else:
-        # POST Error 405
-        print("405")
-
-    return 'OK'
+from server import app
 
 if __name__ == "__main__":
     context = ('certificate/xip.io.crt', 'certificate/xip.io.key')#certificate and key files

backend

@@ -1 +1 @@
-Subproject commit fed3fddb2182d27a3bd832f354e0ec1b9ac61667
+Subproject commit aaf66a1f105b9baceb13fd59287f8682325270dd

config.py

@@ -0,0 +1,8 @@
+import os
+basedir = os.path.abspath(os.path.dirname(__file__))
+
+class Config(object):
+    # ...
+    SQLALCHEMY_DATABASE_URI = os.environ.get('DATABASE_URL') or \
+        'sqlite:///' + os.path.join(basedir, 'app.db')
+    SQLALCHEMY_TRACK_MODIFICATIONS = False

database/user.py

@@ -1,7 +1,7 @@
 from flask_login import UserMixin
 from pathlib import Path
 
-from database.db import get_db
+from server.database.db import get_db
 
 class User(UserMixin):
     def __init__(self, id_, name, email, profile_pic):

migrations/README

@@ -0,0 +1 @@
+Generic single-database configuration.

migrations/alembic.ini

@@ -0,0 +1,45 @@
+# A generic, single database configuration.
+
+[alembic]
+# template used to generate migration files
+# file_template = %%(rev)s_%%(slug)s
+
+# set to 'true' to run the environment during
+# the 'revision' command, regardless of autogenerate
+# revision_environment = false
+
+
+# Logging configuration
+[loggers]
+keys = root,sqlalchemy,alembic
+
+[handlers]
+keys = console
+
+[formatters]
+keys = generic
+
+[logger_root]
+level = WARN
+handlers = console
+qualname =
+
+[logger_sqlalchemy]
+level = WARN
+handlers =
+qualname = sqlalchemy.engine
+
+[logger_alembic]
+level = INFO
+handlers =
+qualname = alembic
+
+[handler_console]
+class = StreamHandler
+args = (sys.stderr,)
+level = NOTSET
+formatter = generic
+
+[formatter_generic]
+format = %(levelname)-5.5s [%(name)s] %(message)s
+datefmt = %H:%M:%S

migrations/env.py

@@ -0,0 +1,96 @@
+from __future__ import with_statement
+
+import logging
+from logging.config import fileConfig
+
+from sqlalchemy import engine_from_config
+from sqlalchemy import pool
+
+from alembic import context
+
+# this is the Alembic Config object, which provides
+# access to the values within the .ini file in use.
+config = context.config
+
+# Interpret the config file for Python logging.
+# This line sets up loggers basically.
+fileConfig(config.config_file_name)
+logger = logging.getLogger('alembic.env')
+
+# add your model's MetaData object here
+# for 'autogenerate' support
+# from myapp import mymodel
+# target_metadata = mymodel.Base.metadata
+from flask import current_app
+config.set_main_option(
+    'sqlalchemy.url',
+    str(current_app.extensions['migrate'].db.engine.url).replace('%', '%%'))
+target_metadata = current_app.extensions['migrate'].db.metadata
+
+# other values from the config, defined by the needs of env.py,
+# can be acquired:
+# my_important_option = config.get_main_option("my_important_option")
+# ... etc.
+
+
+def run_migrations_offline():
+    """Run migrations in 'offline' mode.
+
+    This configures the context with just a URL
+    and not an Engine, though an Engine is acceptable
+    here as well.  By skipping the Engine creation
+    we don't even need a DBAPI to be available.
+
+    Calls to context.execute() here emit the given string to the
+    script output.
+
+    """
+    url = config.get_main_option("sqlalchemy.url")
+    context.configure(
+        url=url, target_metadata=target_metadata, literal_binds=True
+    )
+
+    with context.begin_transaction():
+        context.run_migrations()
+
+
+def run_migrations_online():
+    """Run migrations in 'online' mode.
+
+    In this scenario we need to create an Engine
+    and associate a connection with the context.
+
+    """
+
+    # this callback is used to prevent an auto-migration from being generated
+    # when there are no changes to the schema
+    # reference: http://alembic.zzzcomputing.com/en/latest/cookbook.html
+    def process_revision_directives(context, revision, directives):
+        if getattr(config.cmd_opts, 'autogenerate', False):
+            script = directives[0]
+            if script.upgrade_ops.is_empty():
+                directives[:] = []
+                logger.info('No changes in schema detected.')
+
+    connectable = engine_from_config(
+        config.get_section(config.config_ini_section),
+        prefix='sqlalchemy.',
+        poolclass=pool.NullPool,
+    )
+
+    with connectable.connect() as connection:
+        context.configure(
+            connection=connection,
+            target_metadata=target_metadata,
+            process_revision_directives=process_revision_directives,
+            **current_app.extensions['migrate'].configure_args
+        )
+
+        with context.begin_transaction():
+            context.run_migrations()
+
+
+if context.is_offline_mode():
+    run_migrations_offline()
+else:
+    run_migrations_online()

migrations/script.py.mako

@@ -0,0 +1,24 @@
+"""${message}
+
+Revision ID: ${up_revision}
+Revises: ${down_revision | comma,n}
+Create Date: ${create_date}
+
+"""
+from alembic import op
+import sqlalchemy as sa
+${imports if imports else ""}
+
+# revision identifiers, used by Alembic.
+revision = ${repr(up_revision)}
+down_revision = ${repr(down_revision)}
+branch_labels = ${repr(branch_labels)}
+depends_on = ${repr(depends_on)}
+
+
+def upgrade():
+    ${upgrades if upgrades else "pass"}
+
+
+def downgrade():
+    ${downgrades if downgrades else "pass"}

migrations/versions/92db2e496087_.py

@@ -0,0 +1,52 @@
+"""empty message
+
+Revision ID: 92db2e496087
+Revises: 
+Create Date: 2020-04-20 21:33:50.061962
+
+"""
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision = '92db2e496087'
+down_revision = None
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.create_table('calendar',
+    sa.Column('usr_id', sa.String(length=21), nullable=True),
+    sa.Column('calendar_id', sa.String(length=256), nullable=False),
+    sa.Column('name', sa.String(length=256), nullable=True),
+    sa.Column('toggle', sa.String(length=8), nullable=True),
+    sa.Column('color', sa.String(length=16), nullable=True),
+    sa.PrimaryKeyConstraint('calendar_id')
+    )
+    op.create_index(op.f('ix_calendar_name'), 'calendar', ['name'], unique=False)
+    op.create_index(op.f('ix_calendar_usr_id'), 'calendar', ['usr_id'], unique=False)
+    op.create_table('user',
+    sa.Column('id', sa.String(length=21), nullable=False),
+    sa.Column('username', sa.String(length=64), nullable=True),
+    sa.Column('email', sa.String(length=120), nullable=True),
+    sa.Column('profile_pic', sa.String(length=256), nullable=True),
+    sa.Column('password_hash', sa.String(length=128), nullable=True),
+    sa.PrimaryKeyConstraint('id')
+    )
+    op.create_index(op.f('ix_user_email'), 'user', ['email'], unique=True)
+    op.create_index(op.f('ix_user_username'), 'user', ['username'], unique=True)
+    # ### end Alembic commands ###
+
+
+def downgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_index(op.f('ix_user_username'), table_name='user')
+    op.drop_index(op.f('ix_user_email'), table_name='user')
+    op.drop_table('user')
+    op.drop_index(op.f('ix_calendar_usr_id'), table_name='calendar')
+    op.drop_index(op.f('ix_calendar_name'), table_name='calendar')
+    op.drop_table('calendar')
+    # ### end Alembic commands ###

server/__init__.py

@@ -0,0 +1,28 @@
+
+import os
+import sqlite3
+
+from flask import Flask
+from config import Config
+from flask_sqlalchemy import SQLAlchemy
+from flask_migrate import Migrate
+
+from flask_login import LoginManager 
+
+# Flask app setup
+app = Flask(__name__,
+            static_folder='static',
+            template_folder='template')
+app.secret_key = os.environ.get("SECRET_KEY") or os.urandom(24)
+
+app.config.from_object(Config)
+
+db = SQLAlchemy(app)
+migrate = Migrate(app, db)
+
+# User session management setup
+# https://flask-login.readthedocs.io/en/latest
+login_manager = LoginManager(app)
+
+
+from server import routes, models

server/googleHandler.py

@@ -0,0 +1,162 @@
+import google.oauth2.credentials
+import google_auth_oauthlib.flow
+import googleapiclient.discovery
+
+import backend.caltojson as caltojson
+from oauthlib.oauth2 import WebApplicationClient
+import flask
+
+# Python standard libraries
+import json
+import os
+import sqlite3
+
+# Third-party libraries
+import flask
+from flask import Flask, redirect, request, url_for
+from flask_login import (
+    LoginManager,
+    current_user,
+    login_required,
+    login_user,
+    logout_user,
+)
+import requests
+
+from server.models import Calendar as dbCalendar
+
+# Configuration
+CLIENT_SECRETS_FILE = "certificate/client_secret.json"
+
+# This OAuth 2.0 access scope allows for full read/write access to the
+# authenticated user's account and requires requests to use an SSL connection.
+SCOPES = ["https://www.googleapis.com/auth/userinfo.email", "https://www.googleapis.com/auth/userinfo.profile", "https://www.googleapis.com/auth/calendar.readonly", "openid"]
+API_SERVICE_NAME = 'calendar'
+API_VERSION = 'v3'
+
+GOOGLE_CLIENT_ID ="377787187748-shuvi4iq5bi4gdet6q3ioataimobs4lh.apps.googleusercontent.com"
+GOOGLE_CLIENT_SECRET = "Hu_YWmKsVKUcLwyeINYzdKfZ"
+GOOGLE_DISCOVERY_URL = (
+    "https://accounts.google.com/.well-known/openid-configuration"
+)
+
+# OAuth 2 client setup
+client = WebApplicationClient(GOOGLE_CLIENT_ID)
+
+
+
+def login():
+    # Create flow instance to manage the OAuth 2.0 Authorization Grant Flow steps.
+    flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file(
+        CLIENT_SECRETS_FILE, scopes=SCOPES)
+    # The URI created here must exactly match one of the authorized redirect URIs
+    # for the OAuth 2.0 client, which you configured in the API Console. If this
+    # value doesn't match an authorized URI, you will get a 'redirect_uri_mismatch'
+    # error.
+    flow.redirect_uri = request.base_url + "/callback"
+    authorization_url, state = flow.authorization_url(
+        # Enable offline access so that you can refresh an access token without
+        # re-prompting the user for permission. Recommended for web server apps.
+        access_type='offline',
+        # Enable incremental authorization. Recommended as a best practice.
+        include_granted_scopes='true')
+
+    # Store the state so the callback can verify the auth server response.
+    flask.session['state'] = state
+    # Flask-Login helper to retrieve a user from our db
+    return authorization_url
+
+def verifyResponse():
+    # Specify the state when creating the flow in the callback so that it can
+    # verified in the authorization server response.
+    state = flask.session['state']
+
+    flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file(
+        CLIENT_SECRETS_FILE, scopes=SCOPES, state=state)
+    flow.redirect_uri = request.base_url
+
+    # Use the authorization server's response to fetch the OAuth 2.0 tokens.
+    authorization_response = flask.request.url
+    flow.fetch_token(authorization_response=authorization_response)
+
+    # Store credentials in the session.
+    # ACTION ITEM: In a production app, you likely want to save these
+    #              credentials in a persistent database instead.
+    credentials = flow.credentials
+    flask.session['credentials'] = credentials_to_dict(credentials)
+
+    session = flow.authorized_session()
+    return session 
+
+
+def get_google_provider_cfg():
+    return requests.get(GOOGLE_DISCOVERY_URL).json()
+
+class Calendar:
+    def __init__(self, name, toggle='False', color="#000000"):
+        self.name = name
+        self.color = color
+        self.toggle=toggle
+
+def calendarsFromDb():
+    calendars = dbCalendar.getCalendars(dbCalendar, current_user.id)
+    pyCalendars = []
+    for calendar in calendars:
+        name = calendar.name
+        calId = calendar.calendar_id
+        toggle = calendar.toggle
+        color = calendar.color
+
+        pyCalendars.append(Calendar(name, toggle, color))
+
+    return pyCalendars
+
+
+def getCalendarJson():
+    if 'credentials' not in flask.session:
+        return flask.redirect('login/google')
+
+    # Load credentials from the session.
+    credentials = google.oauth2.credentials.Credentials(
+      **flask.session['credentials'])
+    todaysCal = caltojson.generateJsonFromCalendarEntries(credentials)
+
+    with open('./userinfo/' + current_user.id + '/calendarevents.json', 'w') as outfile:
+        json.dump(todaysCal, outfile)
+
+    return todaysCal
+
+
+def updateCalendars():
+    if 'credentials' not in flask.session:
+        return flask.redirect('login/google')
+
+  # Load credentials from the session.
+    credentials = google.oauth2.credentials.Credentials(
+        **flask.session['credentials'])
+
+  
+    calendars = caltojson.getCalendarList(credentials)
+
+    for calendar in calendars:
+
+        if dbCalendar.getCalendar(dbCalendar, current_user.id, calendar.calendarId) == None:
+            dbCalendar.create(dbCalendar, current_user.id, calendar.calendarId, calendar.summary, calendar.color)
+
+    print("updated Calendars")
+
+    # Save credentials back to session in case access token was refreshed.
+    # ACTION ITEM: In a production app, you likely want to save these
+    #              credentials in a persistent database instead.
+    flask.session['credentials'] = credentials_to_dict(credentials)
+
+
+def credentials_to_dict(credentials):
+  return {'token': credentials.token,
+          'refresh_token': credentials.refresh_token,
+          'token_uri': credentials.token_uri,
+          'client_id': credentials.client_id,
+          'client_secret': credentials.client_secret,
+          'scopes': credentials.scopes}
+
+

server/models.py

@@ -0,0 +1,62 @@
+from flask_login import UserMixin
+from server import login_manager, db
+
+@login_manager.user_loader
+def load_user(id):
+    return User.query.get(id)
+
+class User(UserMixin, db.Model):
+    id = db.Column(db.String(21), primary_key=True)
+    username = db.Column(db.String(64), index=True, unique=True)
+    email = db.Column(db.String(120), index=True, unique=True)
+    profile_pic = db.Column(db.String(256))
+    password_hash = db.Column(db.String(128))
+
+    def __repr__(self):
+        return '<User {}>'.format(self.username)    
+
+class Calendar(db.Model):
+    usr_id = db.Column(db.String(21), index=True)
+    calendar_id = db.Column(db.String(256), primary_key=True)
+    name = db.Column(db.String(256), index=True)
+    toggle = db.Column(db.String(8))
+    color = db.Column(db.String(16))
+
+    def getCalendars(self, user_id):
+        calendars = self.query.filter(Calendar.usr_id==user_id)
+        
+        return calendars
+
+    def getCalendar(self, user_id, calendar_id):
+        calendars = self.query.filter(self.usr_id==user_id, self.calendar_id==calendar_id)
+        
+        calendar = None
+        for c in calendars:
+            calendar = c
+
+        if not calendar:
+            return None
+        
+        return calendar
+    
+    @staticmethod
+    def updateCalendar(user_id, calendar_name, toggle=None, color=None):
+
+        calendar = Calendar.query.filter(Calendar.usr_id==user_id, Calendar.name==calendar_name).first()
+
+
+        print("updating")
+        if(toggle != None):
+            print(toggle)
+            calendar.toggle = toggle
+            db.session.commit()
+
+        if(color != None):
+            calendar.color = color
+            db.session.commit()
+
+    def create(self, user_id, calendar_id, name, color, toggle = 'True'):
+        newcal = Calendar(usr_id=user_id, calendar_id=calendar_id, name=name, toggle=toggle, color=color)
+        
+        db.session.add(newcal)
+        db.session.commit()

server/routes.py

@@ -0,0 +1,124 @@
+# Python standard libraries
+import json
+import os
+import sqlite3
+
+# Third-party libraries
+import flask
+from flask import Flask, redirect, request, url_for
+from flask_login import (
+    LoginManager,
+    current_user,
+    login_required,
+    login_user,
+    logout_user,
+)
+import requests
+
+import server.googleHandler as google
+
+from server import login_manager, app, db
+from server.models import User, Calendar
+
+@app.route("/")
+def account():
+    return flask.redirect('account')
+
+@app.route("/account")
+def index():
+    if current_user.is_authenticated:
+        google.updateCalendars()
+        return (flask.render_template('account.html',
+            username = current_user.username, email = current_user.email, profile_img=current_user.profile_pic
+            )
+        )
+    else:
+        return flask.render_template('login.html')
+
+@app.route("/calendar")
+@login_required
+def calendar():
+    calendars = google.calendarsFromDb()
+    return flask.render_template('calendar.html', calendars=calendars)
+
+@app.route("/login/google")
+def login():
+    authorization_url = google.login()
+
+    return flask.redirect(authorization_url)
+
+@app.route("/login/google/callback")
+def callback():
+    session = google.verifyResponse()
+    
+    userinfo = session.get('https://www.googleapis.com/userinfo/v2/me').json()
+    
+    # Create a user in your db with the information provided
+    # by Google
+
+    # Doesn't exist? Add it to the database.
+    if not User.query.get(userinfo['id']):
+        newser = User(
+            id=userinfo['id'], 
+            username=userinfo['name'], 
+            email=userinfo['email'], 
+            profile_pic=userinfo['picture'],
+            password_hash=""
+        )   
+        db.session.add(newser)
+        db.session.commit()
+
+    user = User.query.get(userinfo['id'])
+
+    # Begin user session by logging the user in
+    print("login:" + user.id)
+
+    login_user(user)
+
+    return flask.redirect(flask.url_for('index'))
+
+@app.route("/logout")
+@login_required
+def logout():
+    logout_user()
+    return redirect(url_for("index"))
+
+def credentials_to_dict(credentials):
+  return {'token': credentials.token,
+          'refresh_token': credentials.refresh_token,
+          'token_uri': credentials.token_uri,
+          'client_id': credentials.client_id,
+          'client_secret': credentials.client_secret,
+          'scopes': credentials.scopes}
+
+
+@app.route("/userinfo/<path:user>/calendarevents.json")
+def downloader(user):
+    print(user)
+    path = "/home/raphael/dev/website_ws/website/userinfo/" + user
+    return flask.send_from_directory(path, "calendarevents.json")
+
+# POST
+
+@app.route('/calendar', methods = ['POST', 'DELETE'])
+@login_required
+def user():
+    if request.method == 'POST':
+        calName = request.json.get('calendar_id')
+        color = request.json.get('color')
+        toggle = request.json.get('toggle')
+        
+        if color != None:
+            Calendar.updateCalendar(current_user.id, calName, color=color)
+        if toggle != None:
+            Calendar.updateCalendar(current_user.id, calName, toggle=toggle)
+        # toggle specific calendar of user
+    elif request.method == 'DELETE':
+        # do nothing
+        return 'NONE'
+    else:
+        # POST Error 405
+        print("405")
+
+    return 'OK'
+