Homework tracker

SchedualeMaker_.idea_.name

SchedualeMaker

SchedualeMaker_.idea_encodings.xml

<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
  <component name="Encoding" useUTFGuessing="true" native2AsciiForPropertiesFiles="false" />
</project>

SchedualeMaker_.idea_misc.xml

<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
  <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.3.2 virtualenv at C:\Users\Q\Envs\Python33" project-jdk-type="Python SDK" />
</project>

SchedualeMaker_.idea_modules.xml

<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
  <component name="ProjectModuleManager">
    <modules>
      <module fileurl="file://$PROJECT_DIR$/.idea/SchedualeMaker.iml" filepath="$PROJECT_DIR$/.idea/SchedualeMaker.iml" />
    </modules>
  </component>
</project>

SchedualeMaker_.idea_SchedualeMaker.iml

<?xml version="1.0" encoding="UTF-8"?>
<module type="PYTHON_MODULE" version="4">
  <component name="NewModuleRootManager">
    <content url="file://$MODULE_DIR$" />
    <orderEntry type="jdk" jdkName="Python 3.3.2 virtualenv at C:\Users\Q\Envs\Python33" jdkType="Python SDK" />
    <orderEntry type="sourceFolder" forTests="false" />
  </component>
  <component name="PyDocumentationSettings">
    <option name="myDocStringFormat" value="Plain" />
  </component>
  <component name="TestRunnerService">
    <option name="projectConfiguration" value="Unittests" />
    <option name="PROJECT_TEST_RUNNER" value="Unittests" />
  </component>
</module>

SchedualeMaker_.idea_scopes_scope_settings.xml

<component name="DependencyValidationManager">
  <state>
    <option name="SKIP_IMPORT_STATEMENTS" value="false" />
  </state>
</component>

SchedualeMaker_.idea_vcs.xml

<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
  <component name="VcsDirectoryMappings">
    <mapping directory="" vcs="" />
  </component>
</project>

SchedualeMaker_bu362.txt

1 |May 5 |Course Introduction & Group Formation
2 |May 7 |Gordon Power Tools 
3 |May 12 |Financial Analysis for Marketing Decisions, with exercises 
4 |May 14 |J’M’s Signature Restaurant 
5 |May 21 |SlimFast Weight Management Products 
6 |May 22 |Live Case Presentation – Bricker Academic BA201: 5:30 – 6:50 pm 
7 |May 26 |SlimFast Weight Management Products (cont’d) 
8 |May 28 |fantastik All-Purpose Cleaners 
9 |Jun 2 |Portable Heat Pad 
10 |Jun 4 |Old El Paso: Make Tonight Taco Night 
Jun 5 |Live Case Report DUE BY 4:00 p.m. 
(Drop boxes outside SBE2201) 
11 |Jun 9 |Old El Paso: Make Tonight Taco Night (cont’d) 
12 |Jun 11 |Camar Autotive Hoist 
13 |Jun 16 |Camar Autotive Hoist (cont’d) /Expectations for Group Cases 
14 |Jun 18 |The Kinkajou Bottle Cutter 
15 |Jun 23 |Le Cerf De Tremblant 
16 |Jun 25 |Gracie Barra London 
17 |Jun 30 |Michael Shaps Winery: Evaluating the “Customer Crush” Opportunity 
18 |July 2 |Marks and Spencer Enters China 
19 |July 7 |Cargill India PVT.LTD. 
20 |July 9 |American Apparel: Unwrapping Ethics 
July 10 |Sweet Leaf Bath Co. Individual Case Summary DUE BY 4:00 p.m. 
(Drop boxes Outside SBE 2201) 
21 |July 14 |Discussion of Individual Case/Preparation for ICE 
22 |July 16 |Course Wrap-up 
23 |Jul 21 |ICE Week 
24 |Jul 23 |ICE Week 

SchedualeMaker_BU393.txt

May 14|Investment Rules Quiz
June 2|NPV, Capital Budgeting Quiz
June 11|WACC Quiz
June 13|Midterm| 3:00pm-5:00pm
June 25|Long Term Financing Quiz
July 7|Taxes and Capital Structure Quiz
July 28|Payout Policy & Leasing Quiz

SchedualeMaker_BU395.txt

1|May 06|Introduction|Course outline
2|May 08|Supply Chain Management I|Chapter 11
3|May 13|Supply Chain Management II|Chapter 11
Case: Amazon.com@P403
4|May 15|Supply Chain Win-Win Contracts|Posted materials on MyLS
5|May 22|Supply Chain Win-Win Contracts|Posted materials on MyLS
|T May 20|NO LECTURE; But students of TR Sections are encouraged to play one or more online games related to this course. One example website is: http://bl-bus-jacobsvm.ads.iu.edu/egames.html
6|May 27|Inventory Management I|Chapter 12
7|May 29|Inventory Management II|Chapter 12
8|June 03|Inventory Management III|Chapter 12
9|June 05|Midterm1 Review|
Midterm 1, Saturday June 07, 2:00-3:30pm; Cover Lectures 1-8
10|June 10|Aggregate Operations Planning I|Chapter 13
11|June 12|Aggregate Operations Planning II|Chapter 13
12|June 17|Aggregate Operations Planning III|Chapter 13
Cases@P503
13|June 19|Material Requirements Planning I|Chapter 14
14|June 24|Material Requirements Planning II|Chapter 14
Case: DMD enterprises@P543
15|June 26|Just-In-Time & Lean Systems I|Chapter 15
16|July 03|Just-In-Time & Lean Systems II|Chapter 15
|M June 30|NO LECTURE; But students of MW Sections are encouraged to play one or more online games related to this course. One example website is: http://bl-bus-jacobsvm.ads.iu.edu/egames.html
17|July 08|Scheduling I|Chapter 16
18|July 10|Midterm 2 Review|
Midterm 2, Saturday July 12, 2:00-3:30pm; Covers Lectures 10-16
19|July 15|Scheduling II|Chapter 16
20|July 17|Scheduling III|Chapter 16

SchedualeMaker_BU398.txt

1|Tues May 6|Course Overview
(R) Chapter 1
2|Thurs May 8|Goals & Strategy
(R) Chapter 2, pp. 47-63
3|Tues May 13|Organizational Design and Effectiveness
(R) Chapter 2, pp. 63-77
4|Thurs May 15|Fundamentals of Organizational Structure
(R) Chapter 3, pp. 84-102
5|Tues May 20|Organizational Structure part II
(R) Chapter 3, pp 102-123
(D) Case questions: Aquarius advertising agency (p. 124) (MyLS Dropbox by 8:30am May 20)
6|Thurs May 22|Introduction to Case Analysis
(R) Group Case Project Guidelines (posted on MyLS)
7|Tues May 27|The External Environment (i)
(R) Chapter 4, pp. 132-144
8|Thurs May 29|The External Environment (ii)
(R) Chapter 4, pp. 145-160
11|Tues Jun 3|Alternative and Emerging Organizational Forms
(R) Alternative and Emerging Organizational Forms Readings (posted on MyLS)
9|Thurs Jun 5|Sustainability in Practice
(D) Case write-up: Make green delicious (p. 535) (MyLS Dropbox by 8:30am Wed Jun 4)
MIDTERM EXAM – Friday Jun 6, 10:00am - 12:00pm; Location TBA
10|Tues Jun 10|Interorganizational Relationships
(R) Chapter 5
(D) Case write-up: Vancity (p. 164) (MyLS Dropbox by 8:30am Monday Jun 9)
12|Thurs Jun 12|Designing Organizations for the International Environment
(R) Chapter 6
(D) Group project – Summary Report (MyLS Dropbox by 6:00pm Friday Jun 13)
13|Tues Jun 17|Organization Size, Life Cycle, and Decline
(R) Chapter 9
14|Thurs Jun 19|Organizational Culture and Ethical Values
(R) Chapter 10
15|Tues Jun 24|Innovation and Change
(R) Chapter 11
16|Thurs Jun 26|Decision-Making Processes
(R) Chapter 12
(D) Group project – Written report (MyLS Dropbox by 6:00pm Friday Jun 27)
|Tues July 1|CANADA DAY (No Class)
17|Thurs July 3|(D) Class Presentations
18|Tues July 8|(D) Class Presentations
19|Thurs July 10|(D) Class Presentations
20|Tues July 15|(D) Class Presentations
21|Thurs July 17|Group Case Project Debriefing
ICE (Integrated case exercise), afternoon of July 17 to July 25, NO CLASSES
22|Tues July 29|Designing Organizations for the Future; Course review

SchedualeMaker_BU415.txt

May 5 |Course Overview|Introduction to MIS |Ch. 1
May 7 |What is an information system?|Piccoli, G. Information Systems Defined (course pack)
May 12 |Strategy and Technology |Ch. 2
May 14 |Zara: Fast Fashion from Savvy Systems |Ch. 3 - Zara Memo Due
May 19 |No Monday classes due to Victoria Day civic holiday
May 21 |Netflix |Ch. 4 - Netflix Memo Due
May 26 |Moore’s Law |Ch. 5
May 28 |Understanding Network Effects |Ch. 7
June 2 |Peer Production, Social Media, and Web 2.0; Facebook |Ch. 8 & 9 - Facebook memo Due
June 4 |Test 1
June 9 |Software Development |Lego Building Exercise
June 11 |Case |Cisco: Implementing ERP (course pack) - Cisco Memo Due
June 16 |Case |Pearson SuccessMaker (course pack) - Pearson Memo Due
June 18 |Case |Fixing the Payment System at Alvade (course pack) - Alvade memo Due
June 23 |Understanding Software |Ch. 10
June 25 |Software in Flux |Ch. 11
June 30 |Case |Business Intelligence @ Canadian Tire (course package) - Canadian Tire memo Due
July 2 |Data Asset |Ch. 12
July 7 |Information Security |Ch. 14
July 9 |Google |Ch. 15 - Google memo due
July 14 |Test 2
July 16 |Technology Impact Assessment Presentations
July 21 |Technology Impact Assessment Presentations
July 23 |Technology Impact Assessment Presentations
July 28 |Special Topics in IS - Make up class for Victoria Day Monday

SchedualeMaker_Course.py

__author__ = 'Q'
import datetime

class Course:

    def __init__(self,course_code,course_name, db):
        self.course_code = course_code
        self.course_name = course_name
        self.db = db

    def add_reading(self,name,date,chapter=None,pages=None):
        date = clean_and_convert_date(date)
        reading = Reading(name,date,chapter,pages)
        self.db.insert_reading(self.course_code, reading)
        return

    def add_test(self,name,date,time):
        if None==time:
            time ="in-class"
        date = clean_and_convert_date(date)
        test = Gradeable(name,date,time)
        self.db.insert_test(self.course_code, test)
        return

    def add_assignment(self,name,date,time=None):
        date = clean_and_convert_date(date)
        assignment = Gradeable(name,date,time)
        self.db.insert_assignment(self.course_code, assignment)
        return



class Reading:
    def __init__(self,name,date,chapter,pages):
        self.name = name
        self.date = date
        self.chapter = chapter
        self.completed = False
        self.pages = pages


class Gradeable:
    def __init__(self,name,date,time):
        self.name = name
        self.date = date
        self.time = time

MONTHS = {'JAN':1,'FEB':2,'MAR':3,'APR':4,
           'MAY':5,'JUNE':6,'JULY':7,'AUG':8,
           'SEP':9,'OCT':10,'NOV':11,'DEC':12}


def clean_and_convert_date(date):
    if None!=date:
        date =date.strip().split()
        if len(date)==3:
            date.pop(0)
        month = date[0]
        day = date[1]
        if month =="Jun":
            month = "June"
        elif month =="Jul":
            month ="July"

        month = MONTHS.get(month.upper())

        date =datetime.datetime(2014,month,int(day))

    return date

SchedualeMaker_Database.py

__author__ = 'Q'

import sqlite3




class DataBase:

    def __init__(self,database_name):
        self.conn = sqlite3.connect(database_name)

    def execute_basic_sql(self,sql):
        cur = self.conn.cursor()
        cur.execute(sql)
        self.conn.commit()
        return

    def execute_with_values(self,sql,values):
        curr = self.conn.cursor()
        curr.execute(sql,values)
        self.conn.commit()
        return

    def close(self):
        self.conn.close()
        return

    def insert_reading(self, course_code, reading):
        sql = ''' INSERT INTO Readings
        VALUES (?, ?, ?, ?, ?, ?)'''
        values = (course_code, reading.name, reading.chapter,reading.date,reading.pages,False)
        self.execute_with_values(sql,values)
        return

    def insert_assignment(self, course_code, assignment):
        sql = ''' INSERT INTO Assignments
        VALUES (?, ?, ?, ?, ?)'''
        values = (course_code, assignment.name,assignment.date, assignment.time,False)
        self.execute_with_values(sql,values)
        return

    def insert_test(self, course_code, test):
        sql = ''' INSERT INTO Tests
        VALUES (?, ?, ?, ?, ?)'''
        values = (course_code, test.name,test.date, test.time, False)
        self.execute_with_values(sql,values)
        return

    def display_table(self,table_name):
        sql = '''SELECT * FROM {0}'''.format(table_name)
        cursor = self.conn.cursor()
        cursor.execute(sql)
        rows = cursor.fetchall()
        for row in rows:
            print(row)

        return

    def display_table_by_date(self,table_name):
        sql = '''SELECT * FROM {0} ORDER BY date'''.format(table_name)
        cursor = self.conn.cursor()
        cursor.execute(sql)
        rows = cursor.fetchall()
        for row in rows:
            print(row)

        return

SchedualeMaker_index.py

# -*- coding: utf-8 -*-

from __future__ import with_statement
from sqlite3 import dbapi2 as sqlite3
from flask import Flask, request, session, g, redirect, url_for, abort, \
     render_template, flash, _app_ctx_stack
import os
app = Flask(__name__)

# configuration
DATABASE = os.path.join(app.root_path, 'summer2014courses.db')
DEBUG = True
SECRET_KEY = 'development key'
USERNAME = 'admin'
PASSWORD = 'default'


# create our little application :)
app = Flask(__name__)
app.config.from_object(__name__)
app.config.from_envvar('FLASKR_SETTINGS', silent=True)




def init_db():
    import LoadDatabase
    LoadDatabase.load_database()




def get_db():
    """Opens a new database connection if there is none yet for the
    current application context.
    """
    top = _app_ctx_stack.top
    if not hasattr(top, 'sqlite_db'):
        sqlite_db = sqlite3.connect(app.config['DATABASE'])
        sqlite_db.row_factory = sqlite3.Row
        top.sqlite_db = sqlite_db


    return top.sqlite_db




@app.teardown_appcontext
def close_db_connection(exception):
    """Closes the database again at the end of the request."""
    top = _app_ctx_stack.top
    if hasattr(top, 'sqlite_db'):
        top.sqlite_db.close()


@app.route('/Assignments')
def show_assignments():
    db = get_db()
    sql = '''SELECT * FROM {0} ORDER BY date'''.format("Assignments")
    cur = db.execute(sql)
    entries = cur.fetchall()
    return render_template('show_assignments.html',entries=entries)

@app.route('/Tests')
def show_tests():
    db = get_db()
    sql = '''SELECT * FROM {0} ORDER BY date'''.format("Tests")
    cur = db.execute(sql)
    entries = cur.fetchall()
    return render_template('show_tests.html',entries=entries)

@app.route('/Readings')
def show_readings():
    db = get_db()
    sql = '''SELECT * FROM {0} ORDER BY date'''.format("Readings")
    cur = db.execute(sql)
    entries = cur.fetchall()
    return render_template('show_readings.html',entries=entries)




if __name__ == '__main__':
    #init_db()
    app.run()

SchedualeMaker_LoadDatabase.py

__author__ = 'Q'
__author__ = 'Q'


from Database import DataBase
from ReadCourseInfo import *
import SetUpDataBase


def load_database():
    SetUpDataBase.reset_database()

    db = DataBase("summer2014courses.db")


    fh = open("bu362.txt","r+",encoding="utf-8")
    bu362 = convert_schedule_to_course(fh,"BU362","Building and Managing A Brand", db)
    fh.close()


    convert_schedule_to_course_bu395("BU395.txt","BU395","Operations Management II",db)


    convert_schedule_to_course_bu398("BU398.txt","BU398","Organizational Behaviour II",db)
    convert_schedule_to_course_bu415("BU415.txt","BU415","Intro Management of IS",db)

    convert_schedule_to_course_bu393("BU393.txt","BU393","Financial Management II",db)

SchedualeMaker_Main.py

__author__ = 'Q'


from Database import DataBase



db = DataBase("summer2014courses.db")

print("-------------Assignments---------------------")
db.display_table_by_date("Assignments")

print("-------------Readings------------------------")
db.display_table_by_date("Readings")

print("-------------Tests------------------------")
db.display_table_by_date("Tests")

db.close()

SchedualeMaker_ReadCourseInfo.py

__author__ = 'Q'

from Course import Course
import re

TIME_PATTERN = r"(\d|\s)\d\:\d\d"

TIME_PATTERN_AMPM = r"(\d|\s)\d\:\d\d\w\w"


def convert_schedule_to_course(schedule,course_code,class_name,db):

    time_prog = re.compile(TIME_PATTERN)
    course = Course(course_code,class_name,db)

    for line in schedule:
        line = line.strip()
        session  = line.split("|")
        if len(session)==3:
            date = session[1]
            reading_name = session[2]
            course.add_reading(reading_name,date)
        elif "DUE" in line.upper():
            name_and_time = session[1]
            time = time_prog.search(name_and_time)
            if None != time:
                time = time.group()
            name = name_and_time.split("DUE")[0].strip()
            course.add_assignment(name,date,time)

    return course

def convert_schedule_to_course_bu395(file_name,course_code,class_name,db):
    course = Course(course_code,class_name,db)
    prev_date =""
    with open(file_name,"r",encoding="utf-8") as schedule:
        for line in schedule:
            line = line.strip()
            session  = line.split("|")
            if len(session)==4:
                date = session[1]
                prev_date = date
                reading_name = session[2]
                chapter=session[3]
                course.add_reading(reading_name,date,chapter)
            elif "CASE" in line.upper():
                name = session[0]
                course.add_assignment(name,prev_date)
            elif "MIDTERM" in line.upper():
                midterm = line.split(",")
                title = midterm[0]
                date = midterm[1]
                time = midterm[2].split(';')[0]
                course.add_test(title,date,time)
    return course


def convert_schedule_to_course_bu398(file_name,course_code,class_name,db):
    course = Course(course_code,class_name,db)
    prev_date = "";
    prog_time = re.compile(TIME_PATTERN_AMPM)

    with open(file_name,"r",encoding="utf-8") as fh:
        schedule = fh.readlines()
        index = 0
        while index<len(schedule):
            session = schedule[index].strip()

            if session.startswith("(R)"):
                session = session[3:]
                chapter_pages = session.split(',')
                chapter = chapter_pages[0]
                pages = None
                if len(chapter_pages)>1:
                    pages = chapter_pages[1]
                course.add_reading(chapter,prev_date,chapter,pages)

            elif session.startswith("(D)"):
                time = prog_time.search(session)
                if None!=time:
                    time = time.group()
                    date = session[-7:-1]
                    index_of_bracket = session.find("(",2)
                    title = session[4:index_of_bracket-1]
                    course.add_assignment(title,date.strip(),time.strip())

            elif "MIDTERM" in session:
                title = "MIDTERM"
                time = prog_time.search(session)
                if None!=time:
                    time = time.group()
                    date = re.search(r"\w\w\w\s\d",session)
                    date = date.group()
                    course.add_test(title,date,time)
            else:
                line = session.split('|')
                if len(line)>=3:
                    prev_date = line[1]
            index+=1


    return course


def convert_schedule_to_course_bu415(file_name,course_code,class_name,db):
    course = Course(course_code,class_name,db)

    with open(file_name,"r",encoding="utf-8") as fh:
        for line in fh:
            day = line.strip().split("|")
            date = day[0]

            if 'TEST' in line.upper():
                name = day[1].strip()
                course.add_test(name,date,"in-class")
            elif 'MEMO' in line.upper():
                reading_memo = day[2].strip()
                mix_list = reading_memo.split("-")

                memo_name = mix_list[1]
                course.add_assignment(memo_name,date,"in-class")

                chapter = mix_list[0]
                course.add_reading(chapter,date,chapter)
            elif len(day)>=3:
                chapter = day[2].strip()
                course.add_reading(chapter,date,chapter)

    return course

def convert_schedule_to_course_bu393(file_name,course_code,class_name,db):
    course = Course(course_code,class_name,db)

    with open(file_name,"r",encoding="utf-8") as fh:
        for line in fh:
            quiz_text = line.strip().split("|")
            date = quiz_text[0]
            title = quiz_text[1]
            time = None
            if len(quiz_text)>2:
                time = quiz_text[2]
            course.add_test(title,date,time)
    return course


def replace_r(file_name):
    with open(file_name,"r+",encoding="utf-8") as fh:
        text = fh.read()
        text = text.replace("\n(R)",'|')
        fh.seek(0)
        fh.write(text)
    return


def remove_combine_every_other_line(file_name):
    '''
    This kind of works but too many inconsistencies in the file for it to be reliable
    '''
    with open(file_name,"r+",encoding="utf-8") as fh:

        lines = fh.readlines()
        new_lines = []
        i=0
        while i < len(lines)-1:
            monday_line = lines[i].strip()
            tuesday_line = lines[i+1].strip()
            new_lines.append(monday_line+'|'+tuesday_line)
            i+=2


        fh.seek(0)
        for line in new_lines:
            print(line,file=fh)
    return

def pull_up_next_line(file_name):

    with open(file_name,"r+",encoding="utf-8") as fh:

        lines = fh.readlines()
        new_lines = []
        i=0
        while i < len(lines)-1:

            match = re.match(r"^\d",lines[i])
            if match:
                line_one = lines[i].strip()
                line_two = lines[i+1].strip()
                new_lines.append(line_one+'|'+line_two)
                i+=2
            else:
                new_lines.append(lines[i])
                i+=1
        fh.seek(0)
        for line in new_lines:
            print(line,file=fh)
    return

SchedualeMaker_SetUpDataBase.py

__author__ = 'Q'
import sqlite3


SQL_Create_Course_Table = '''CREATE TABLE IF NOT EXISTS Courses
             (course_code text, course_name text,complete bool)'''

SQL_Create_Readings_Tables ='''CREATE TABLE IF NOT EXISTS Readings
            (course_code text, reading_name text, chapter int, date text, pages text, complete bool)'''

SQL_Create_Assignment_Tables ='''CREATE TABLE IF NOT EXISTS Assignments
            (course_code text, assignment_name text,  date text, time text, complete bool)'''

SQL_Create_Test_Tables ='''CREATE TABLE IF NOT EXISTS Tests
            (course_code text, test_name text, date text, time text, complete bool)'''

TABLE_NAMES = ["Courses","Readings","Assignments","Tests"]

def create_table(connection,sql):
        cur = connection.cursor()
        cur.execute(sql)
        connection.commit()
        return

def reset_database():

    conn = sqlite3.connect("summer2014courses.db")


    for name in TABLE_NAMES:
        drop = '''DROP TABLE IF EXISTS {0}'''.format(name)
        create_table(conn,drop)


    create_table(conn,SQL_Create_Course_Table)
    create_table(conn,SQL_Create_Readings_Tables)
    create_table(conn,SQL_Create_Assignment_Tables)
    create_table(conn,SQL_Create_Test_Tables)

    conn.close()

SchedualeMaker_TestRegex.py

__author__ = 'Q'


import re
TIME_PATTERN = r"(\d|\s)\d\:\d\d\w\w"

SMALL_PATTERN =":"

string = "Hello 4:00"
string2 = "Hello 4:00pm"

prog = re.compile(TIME_PATTERN)

ans = prog.search(string2)
print(ans.group())

SchedualeMaker_sqlite3.exe

SchedualeMaker_static_css_bootstrap-theme.css

SchedualeMaker_static_css_bootstrap-theme.css.map

SchedualeMaker_static_css_bootstrap-theme.min.css

SchedualeMaker_static_css_bootstrap.css

SchedualeMaker_static_css_bootstrap.css.map

SchedualeMaker_static_css_bootstrap.min.css

SchedualeMaker_static_fonts_glyphicons-halflings-regular.eot

SchedualeMaker_static_fonts_glyphicons-halflings-regular.svg

SchedualeMaker_static_fonts_glyphicons-halflings-regular.ttf

SchedualeMaker_static_fonts_glyphicons-halflings-regular.woff

SchedualeMaker_static_js_bootstrap.js

SchedualeMaker_static_js_bootstrap.min.js

SchedualeMaker_summer2014courses.db

SchedualeMaker_templates_index.html

SchedualeMaker_templates_show_assignments.html

SchedualeMaker_templates_show_readings.html

SchedualeMaker_templates_show_tests.html

Currently provides several pages when hooked up to db of assignments, readings, and tests