Added Laravel project and removed sensitive data

.bowerrc

@@ -0,0 +1,3 @@
+{
+  "directory": "public/vendor/bower_components"
+}

CONTRIBUTING.md

@@ -0,0 +1,3 @@
+# Contribution Guidelines
+
+Please submit all issues and pull requests to the [laravel/framework](http://github.com/laravel/framework) repository!

Gruntfile.js

@@ -0,0 +1,106 @@
+'use strict';
+
+module.exports = function(grunt) {
+
+    //Paths to folders
+    var paths = {
+        app: 'app',
+        assets: 'assets',
+        css: 'public/css',
+        js: 'public/js',
+        fonts: 'public/fonts',
+        views: 'app/views'
+    };
+
+    //Load tasks in Gruntfile
+    require('jit-grunt')(grunt);
+
+
+    // Project configuration.
+	grunt.initConfig({
+		pkg: grunt.file.readJSON('package.json'),
+        paths: paths,
+        autoprefixer: {
+            options: {
+                map: true
+            },
+            css: {
+                expand: true,
+                flatten: true,
+                src: '<%= paths.css %>/*.css',
+                dest: '<%= paths.css %>'
+            },
+        },
+        concat: {
+            options: {
+                separator: ';',
+                stripBanners: true,
+                banner: '/*! <%= pkg.name %> - v<%= pkg.version %> - '
+                    + '<%= grunt.template.today("yyyy-mm-dd") %> */',
+                sourceMap: true
+            },
+            js: {
+                files: {
+                    '<%= paths.js %>/main.js %>': '<%= paths.assets %>/js/*.js %>'
+                }
+            }
+
+        },
+        clean: {
+            js: ['<%= paths.js%>'],
+            css: ['<%= paths.css%>']
+        },
+        cssmin: {
+            minify: {
+                expand: true,
+                cwd: '<%= paths.css %>',
+                src: ['*.css', '!*.min.css'],
+                dest: '',
+                ext: '.min.css'
+            }
+        },
+        jshint: {
+            all: ['Gruntfile.js']
+        },
+        sass: {
+            dist: {
+                files: [{
+                    src: ['<%= paths.assets %>/sass/master.scss'],
+                    dest: '<%= paths.css %>/master.css'
+                }],
+
+                options: {
+                    loadPath: [
+                        'vendor/bower_components/bourbon/dist',
+                        'vendor/bower_components/neat/app/assets/stylesheets'
+                    ]
+                }
+            }
+        },
+        uglify: {
+			options: {
+				banner: '/*! <%= pkg.name %> - <%= pkg.author %> -<%= grunt.template.today("yyyy-mm-dd") %> */\n'
+			},
+			build: {
+				src: 'src/<%= pkg.name %>.js',
+				dest: 'build/<%= pkg.name %>.min.js'
+			}
+		},
+        watch: {
+            sass: {
+                files: '<%= paths.assets %>/sass/**/*.scss',
+                tasks: ['sass']
+            }
+        }
+	});
+
+	// Default task(s).
+	grunt.registerTask('default', [
+        'clean',
+        'sass',
+        'autoprefixer',
+        'cssmin',
+        'jshint',
+        'concat',
+        'uglify']);
+};

app/config/app.php

@@ -0,0 +1,201 @@
+<?php
+error_reporting(error_reporting() & ~E_DEPRECATED);
+return array(
+
+	/*
+	|--------------------------------------------------------------------------
+	| Application Debug Mode
+	|--------------------------------------------------------------------------
+	|
+	| When your application is in debug mode, detailed error messages with
+	| stack traces will be shown on every error that occurs within your
+	| application. If disabled, a simple generic error page is shown.
+	|
+	*/
+
+	'debug' => $_ENV['APP_DEBUG'] ?: false,
+
+	/*
+	|--------------------------------------------------------------------------
+	| Application URL
+	|--------------------------------------------------------------------------
+	|
+	| This URL is used by the console to properly generate URLs when using
+	| the Artisan command line tool. You should set this to the root of
+	| your application so that it is used when running Artisan tasks.
+	|
+	*/
+
+	'url' => $_ENV['APP_URL'] ?: 'http://localhost',
+
+	/*
+	|--------------------------------------------------------------------------
+	| Application Timezone
+	|--------------------------------------------------------------------------
+	|
+	| Here you may specify the default timezone for your application, which
+	| will be used by the PHP date and date-time functions. We have gone
+	| ahead and set this to a sensible default for you out of the box.
+	|
+	*/
+
+	'timezone' => 'America/Puerto_Rico',
+
+	/*
+	|--------------------------------------------------------------------------
+	| Application Locale Configuration
+	|--------------------------------------------------------------------------
+	|
+	| The application locale determines the default locale that will be used
+	| by the translation service provider. You are free to set this value
+	| to any of the locales which will be supported by the application.
+	|
+	*/
+
+	'locale' => 'en',
+
+	/*
+	|--------------------------------------------------------------------------
+	| Application Fallback Locale
+	|--------------------------------------------------------------------------
+	|
+	| The fallback locale determines the locale to use when the current one
+	| is not available. You may change the value to correspond to any of
+	| the language folders that are provided through your application.
+	|
+	*/
+
+	'fallback_locale' => 'en',
+
+	/*
+	|--------------------------------------------------------------------------
+	| Encryption Key
+	|--------------------------------------------------------------------------
+	|
+	| This key is used by the Illuminate encrypter service and should be set
+	| to a random, 32 character string, otherwise these encrypted strings
+	| will not be safe. Please do this before deploying an application!
+	|
+	*/
+
+	// 'key' => 'YourSecretKey!!!',
+	'key' => 'JozBz0yQBrZ5kEcPvgxch3RR3E3INSGs',
+
+	'cipher' => MCRYPT_RIJNDAEL_256,
+
+	/*
+	|--------------------------------------------------------------------------
+	| Autoloaded Service Providers
+	|--------------------------------------------------------------------------
+	|
+	| The service providers listed here will be automatically loaded on the
+	| request to your application. Feel free to add your own services to
+	| this array to grant expanded functionality to your applications.
+	|
+	*/
+
+	'providers' => array(
+
+		'Illuminate\Foundation\Providers\ArtisanServiceProvider',
+		'Illuminate\Auth\AuthServiceProvider',
+		'Illuminate\Cache\CacheServiceProvider',
+		'Illuminate\Session\CommandsServiceProvider',
+		'Illuminate\Foundation\Providers\ConsoleSupportServiceProvider',
+		'Illuminate\Routing\ControllerServiceProvider',
+		'Illuminate\Cookie\CookieServiceProvider',
+		'Illuminate\Database\DatabaseServiceProvider',
+		'Illuminate\Encryption\EncryptionServiceProvider',
+		'Illuminate\Filesystem\FilesystemServiceProvider',
+		'Illuminate\Hashing\HashServiceProvider',
+		'Illuminate\Html\HtmlServiceProvider',
+		'Illuminate\Log\LogServiceProvider',
+		'Illuminate\Mail\MailServiceProvider',
+		'Illuminate\Database\MigrationServiceProvider',
+		'Illuminate\Pagination\PaginationServiceProvider',
+		'Illuminate\Queue\QueueServiceProvider',
+		'Illuminate\Redis\RedisServiceProvider',
+		'Illuminate\Remote\RemoteServiceProvider',
+		'Illuminate\Auth\Reminders\ReminderServiceProvider',
+		'Illuminate\Database\SeedServiceProvider',
+		'Illuminate\Session\SessionServiceProvider',
+		'Illuminate\Translation\TranslationServiceProvider',
+		'Illuminate\Validation\ValidationServiceProvider',
+		'Illuminate\View\ViewServiceProvider',
+		'Illuminate\Workbench\WorkbenchServiceProvider',
+		'Way\Generators\GeneratorsServiceProvider',
+		'Barryvdh\DomPDF\ServiceProvider',
+		'Zizaco\Entrust\EntrustServiceProvider'
+
+	),
+
+	/*
+	|--------------------------------------------------------------------------
+	| Service Provider Manifest
+	|--------------------------------------------------------------------------
+	|
+	| The service provider manifest is used by Laravel to lazy load service
+	| providers which are not needed for each request, as well to keep a
+	| list of all of the services. Here, you may set its storage spot.
+	|
+	*/
+
+	'manifest' => storage_path().'/meta',
+
+	/*
+	|--------------------------------------------------------------------------
+	| Class Aliases
+	|--------------------------------------------------------------------------
+	|
+	| This array of class aliases will be registered when this application
+	| is started. However, feel free to register as many as you wish as
+	| the aliases are "lazy" loaded so they don't hinder performance.
+	|
+	*/
+
+	'aliases' => array(
+
+		'App'               => 'Illuminate\Support\Facades\App',
+		'Artisan'           => 'Illuminate\Support\Facades\Artisan',
+		'Auth'              => 'Illuminate\Support\Facades\Auth',
+		'Blade'             => 'Illuminate\Support\Facades\Blade',
+		'Cache'             => 'Illuminate\Support\Facades\Cache',
+		'ClassLoader'       => 'Illuminate\Support\ClassLoader',
+		'Config'            => 'Illuminate\Support\Facades\Config',
+		'Controller'        => 'Illuminate\Routing\Controller',
+		'Cookie'            => 'Illuminate\Support\Facades\Cookie',
+		'Crypt'             => 'Illuminate\Support\Facades\Crypt',
+		'DB'                => 'Illuminate\Support\Facades\DB',
+		'Eloquent'          => 'Illuminate\Database\Eloquent\Model',
+		'Event'             => 'Illuminate\Support\Facades\Event',
+		'File'              => 'Illuminate\Support\Facades\File',
+		'Form'              => 'Illuminate\Support\Facades\Form',
+		'Hash'              => 'Illuminate\Support\Facades\Hash',
+		'HTML'              => 'Illuminate\Support\Facades\HTML',
+		'Input'             => 'Illuminate\Support\Facades\Input',
+		'Lang'              => 'Illuminate\Support\Facades\Lang',
+		'Log'               => 'Illuminate\Support\Facades\Log',
+		'Mail'              => 'Illuminate\Support\Facades\Mail',
+		'Paginator'         => 'Illuminate\Support\Facades\Paginator',
+		'Password'          => 'Illuminate\Support\Facades\Password',
+		'Queue'             => 'Illuminate\Support\Facades\Queue',
+		'Redirect'          => 'Illuminate\Support\Facades\Redirect',
+		'Redis'             => 'Illuminate\Support\Facades\Redis',
+		'Request'           => 'Illuminate\Support\Facades\Request',
+		'Response'          => 'Illuminate\Support\Facades\Response',
+		'Route'             => 'Illuminate\Support\Facades\Route',
+		'Schema'            => 'Illuminate\Support\Facades\Schema',
+		'Seeder'            => 'Illuminate\Database\Seeder',
+		'Session'           => 'Illuminate\Support\Facades\Session',
+		'SoftDeletingTrait' => 'Illuminate\Database\Eloquent\SoftDeletingTrait',
+		'SSH'               => 'Illuminate\Support\Facades\SSH',
+		'Str'               => 'Illuminate\Support\Str',
+		'URL'               => 'Illuminate\Support\Facades\URL',
+		'Validator'         => 'Illuminate\Support\Facades\Validator',
+		'View'              => 'Illuminate\Support\Facades\View',
+		'PDF'				=> 'Barryvdh\DomPDF\Facade',
+        'Entrust' => 'Zizaco\Entrust\EntrustFacade'
+
+
+	),
+
+);

app/config/auth.php

@@ -0,0 +1,71 @@
+<?php
+
+return array(
+
+	/*
+	|--------------------------------------------------------------------------
+	| Default Authentication Driver
+	|--------------------------------------------------------------------------
+	|
+	| This option controls the authentication driver that will be utilized.
+	| This driver manages the retrieval and authentication of the users
+	| attempting to get access to protected areas of your application.
+	|
+	| Supported: "database", "eloquent"
+	|
+	*/
+
+	'driver' => 'eloquent',
+
+	/*
+	|--------------------------------------------------------------------------
+	| Authentication Model
+	|--------------------------------------------------------------------------
+	|
+	| When using the "Eloquent" authentication driver, we need to know which
+	| Eloquent model should be used to retrieve your users. Of course, it
+	| is often just the "User" model but you may use whatever you like.
+	|
+	*/
+
+	'model' => 'User',
+
+	/*
+	|--------------------------------------------------------------------------
+	| Authentication Table
+	|--------------------------------------------------------------------------
+	|
+	| When using the "Database" authentication driver, we need to know which
+	| table should be used to retrieve your users. We have chosen a basic
+	| default value but you may easily change it to any table you like.
+	|
+	*/
+
+	'table' => 'users',
+
+	/*
+	|--------------------------------------------------------------------------
+	| Password Reminder Settings
+	|--------------------------------------------------------------------------
+	|
+	| Here you may set the settings for password reminders, including a view
+	| that should be used as your password reminder e-mail. You will also
+	| be able to set the name of the table that holds the reset tokens.
+	|
+	| The "expire" time is the number of minutes that the reminder should be
+	| considered valid. This security feature keeps tokens short-lived so
+	| they have less time to be guessed. You may change this as needed.
+	|
+	*/
+
+	'reminder' => array(
+
+		'email' => 'emails.auth.reminder',
+
+		'table' => 'password_reminders',
+
+		'expire' => 60,
+
+	),
+
+);

app/config/cache.php

@@ -0,0 +1,89 @@
+<?php
+
+return array(
+
+	/*
+	|--------------------------------------------------------------------------
+	| Default Cache Driver
+	|--------------------------------------------------------------------------
+	|
+	| This option controls the default cache "driver" that will be used when
+	| using the Caching library. Of course, you may use other drivers any
+	| time you wish. This is the default when another is not specified.
+	|
+	| Supported: "file", "database", "apc", "memcached", "redis", "array"
+	|
+	*/
+
+	'driver' => 'file',
+
+	/*
+	|--------------------------------------------------------------------------
+	| File Cache Location
+	|--------------------------------------------------------------------------
+	|
+	| When using the "file" cache driver, we need a location where the cache
+	| files may be stored. A sensible default has been specified, but you
+	| are free to change it to any other place on disk that you desire.
+	|
+	*/
+
+	'path' => storage_path().'/cache',
+
+	/*
+	|--------------------------------------------------------------------------
+	| Database Cache Connection
+	|--------------------------------------------------------------------------
+	|
+	| When using the "database" cache driver you may specify the connection
+	| that should be used to store the cached items. When this option is
+	| null the default database connection will be utilized for cache.
+	|
+	*/
+
+	'connection' => null,
+
+	/*
+	|--------------------------------------------------------------------------
+	| Database Cache Table
+	|--------------------------------------------------------------------------
+	|
+	| When using the "database" cache driver we need to know the table that
+	| should be used to store the cached items. A default table name has
+	| been provided but you're free to change it however you deem fit.
+	|
+	*/
+
+	'table' => 'cache',
+
+	/*
+	|--------------------------------------------------------------------------
+	| Memcached Servers
+	|--------------------------------------------------------------------------
+	|
+	| Now you may specify an array of your Memcached servers that should be
+	| used when utilizing the Memcached cache driver. All of the servers
+	| should contain a value for "host", "port", and "weight" options.
+	|
+	*/
+
+	'memcached' => array(
+
+		array('host' => '127.0.0.1', 'port' => 11211, 'weight' => 100),
+
+	),
+
+	/*
+	|--------------------------------------------------------------------------
+	| Cache Key Prefix
+	|--------------------------------------------------------------------------
+	|
+	| When utilizing a RAM based store such as APC or Memcached, there might
+	| be other applications utilizing the same cache. So, we'll specify a
+	| value to get prefixed to all our keys so we can avoid collisions.
+	|
+	*/
+
+	'prefix' => 'laravel',
+
+);

app/config/compile.php

@@ -0,0 +1,18 @@
+<?php
+
+return array(
+
+	/*
+	|--------------------------------------------------------------------------
+	| Additional Compiled Classes
+	|--------------------------------------------------------------------------
+	|
+	| Here you may specify additional classes to include in the compiled file
+	| generated by the `artisan optimize` command. These should be classes
+	| that are included on basically every request into the application.
+	|
+	*/
+
+
+
+);

app/config/database.php

@@ -0,0 +1,97 @@
+<?php
+
+return array(
+
+	/*
+	|--------------------------------------------------------------------------
+	| PDO Fetch Style
+	|--------------------------------------------------------------------------
+	|
+	| By default, database results will be returned as instances of the PHP
+	| stdClass object; however, you may desire to retrieve records in an
+	| array format for simplicity. Here you can tweak the fetch style.
+	|
+	*/
+
+	'fetch' => PDO::FETCH_CLASS,
+
+	/*
+	|--------------------------------------------------------------------------
+	| Default Database Connection Name
+	|--------------------------------------------------------------------------
+	|
+	| Here you may specify which of the database connections below you wish
+	| to use as your default connection for all database work. Of course
+	| you may use many connections at once using the Database library.
+	|
+	*/
+
+	'default' => 'mysql',
+
+	/*
+	|--------------------------------------------------------------------------
+	| Database Connections
+	|--------------------------------------------------------------------------
+	|
+	| Here are each of the database connections setup for your application.
+	| Of course, examples of configuring each database platform that is
+	| supported by Laravel is shown below to make development simple.
+	|
+	|
+	| All database work in Laravel is done through the PHP PDO facilities
+	| so make sure you have the driver for your particular database of
+	| choice installed on your machine before you begin development.
+	|
+	*/
+
+	'connections' => array(
+
+		'mysql' => array(
+			'driver'    => 'mysql',
+			'host'      => $_ENV['MYSQL_HOST'] ?: 'localhost',
+			'database'  => $_ENV['MYSQL_DATABASE'] ?: 'laravel',
+			'username'  => $_ENV['MYSQL_USERNAME'] ?: 'root',
+			'password'  => $_ENV['MYSQL_PASSWORD'] ?: '',
+			'charset'   => 'utf8',
+			'collation' => 'utf8_unicode_ci',
+			'prefix'    => '',
+		),
+	),
+
+	/*
+	|--------------------------------------------------------------------------
+	| Migration Repository Table
+	|--------------------------------------------------------------------------
+	|
+	| This table keeps track of all the migrations that have already run for
+	| your application. Using this information, we can determine which of
+	| the migrations on disk haven't actually been run in the database.
+	|
+	*/
+
+	'migrations' => 'migrations',
+
+	/*
+	|--------------------------------------------------------------------------
+	| Redis Databases
+	|--------------------------------------------------------------------------
+	|
+	| Redis is an open source, fast, and advanced key-value store that also
+	| provides a richer set of commands than a typical key-value systems
+	| such as APC or Memcached. Laravel makes it easy to dig right in.
+	|
+	*/
+
+	'redis' => array(
+
+		'cluster' => false,
+
+		'default' => array(
+			'host'     => '127.0.0.1',
+			'port'     => 6379,
+			'database' => 0,
+		),
+
+	),
+
+);

app/config/mail.php

@@ -0,0 +1,124 @@
+<?php
+
+return array(
+
+	/*
+	|--------------------------------------------------------------------------
+	| Mail Driver
+	|--------------------------------------------------------------------------
+	|
+	| Laravel supports both SMTP and PHP's "mail" function as drivers for the
+	| sending of e-mail. You may specify which one you're using throughout
+	| your application here. By default, Laravel is setup for SMTP mail.
+	|
+	| Supported: "smtp", "mail", "sendmail", "mailgun", "mandrill", "log"
+	|
+	*/
+
+	'driver' => 'smtp',
+
+	/*
+	|--------------------------------------------------------------------------
+	| SMTP Host Address
+	|--------------------------------------------------------------------------
+	|
+	| Here you may provide the host address of the SMTP server used by your
+	| applications. A default option is provided that is compatible with
+	| the Mailgun mail service which will provide reliable deliveries.
+	|
+	*/
+
+	'host' => 'smtp.gmail.com',
+
+	/*
+	|--------------------------------------------------------------------------
+	| SMTP Host Port
+	|--------------------------------------------------------------------------
+	|
+	| This is the SMTP port used by your application to deliver e-mails to
+	| users of the application. Like the host we have set this value to
+	| stay compatible with the Mailgun e-mail application by default.
+	|
+	*/
+
+	'port' => 465,
+
+	/*
+	|--------------------------------------------------------------------------
+	| Global "From" Address
+	|--------------------------------------------------------------------------
+	|
+	| You may wish for all e-mails sent by your application to be sent from
+	| the same address. Here, you may specify a name and address that is
+	| used globally for all e-mails that are sent by your application.
+	|
+	*/
+
+	'from' => array('address' => 'olas.rrp@upr.edu', 'name' => 'OLAS Mail'),
+
+	/*
+	|--------------------------------------------------------------------------
+	| E-Mail Encryption Protocol
+	|--------------------------------------------------------------------------
+	|
+	| Here you may specify the encryption protocol that should be used when
+	| the application send e-mail messages. A sensible default using the
+	| transport layer security protocol should provide great security.
+	|
+	*/
+
+	'encryption' => 'ssl',
+
+	/*
+	|--------------------------------------------------------------------------
+	| SMTP Server Username
+	|--------------------------------------------------------------------------
+	|
+	| If your SMTP server requires a username for authentication, you should
+	| set it here. This will get used to authenticate with your server on
+	| connection. You may also set the "password" value below this one.
+	|
+	*/
+
+	'username' => 'olas.rrp@upr.edu',
+
+	/*
+	|--------------------------------------------------------------------------
+	| SMTP Server Password
+	|--------------------------------------------------------------------------
+	|
+	| Here you may set the password required by your SMTP server to send out
+	| messages from your application. This will be given to the server on
+	| connection so that the application will be able to send messages.
+	|
+	*/
+
+	'password' => 'rectoria2015',
+
+	/*
+	|--------------------------------------------------------------------------
+	| Sendmail System Path
+	|--------------------------------------------------------------------------
+	|
+	| When using the "sendmail" driver to send e-mails, we will need to know
+	| the path to where Sendmail lives on this server. A default path has
+	| been provided here, which will work well on most of your systems.
+	|
+	*/
+
+	'sendmail' => '/usr/sbin/sendmail -bs',
+
+	/*
+	|--------------------------------------------------------------------------
+	| Mail "Pretend"
+	|--------------------------------------------------------------------------
+	|
+	| When this option is enabled, e-mail will not actually be sent over the
+	| web and will instead be written to your application's logs files so
+	| you may inspect the message. This is great for local development.
+	|
+	*/
+
+	'pretend' => false,
+
+);

app/config/queue.php

@@ -0,0 +1,85 @@
+<?php
+
+return array(
+
+	/*
+	|--------------------------------------------------------------------------
+	| Default Queue Driver
+	|--------------------------------------------------------------------------
+	|
+	| The Laravel queue API supports a variety of back-ends via an unified
+	| API, giving you convenient access to each back-end using the same
+	| syntax for each one. Here you may set the default queue driver.
+	|
+	| Supported: "sync", "beanstalkd", "sqs", "iron", "redis"
+	|
+	*/
+
+	'default' => 'sync',
+
+	/*
+	|--------------------------------------------------------------------------
+	| Queue Connections
+	|--------------------------------------------------------------------------
+	|
+	| Here you may configure the connection information for each server that
+	| is used by your application. A default configuration has been added
+	| for each back-end shipped with Laravel. You are free to add more.
+	|
+	*/
+
+	'connections' => array(
+
+		'sync' => array(
+			'driver' => 'sync',
+		),
+
+		'beanstalkd' => array(
+			'driver' => 'beanstalkd',
+			'host'   => 'localhost',
+			'queue'  => 'default',
+			'ttr'    => 60,
+		),
+
+		'sqs' => array(
+			'driver' => 'sqs',
+			'key'    => 'your-public-key',
+			'secret' => 'your-secret-key',
+			'queue'  => 'your-queue-url',
+			'region' => 'us-east-1',
+		),
+
+		'iron' => array(
+			'driver'  => 'iron',
+			'host'    => 'mq-aws-us-east-1.iron.io',
+			'token'   => 'your-token',
+			'project' => 'your-project-id',
+			'queue'   => 'your-queue-name',
+			'encrypt' => true,
+		),
+
+		'redis' => array(
+			'driver' => 'redis',
+			'queue'  => 'default',
+		),
+
+	),
+
+	/*
+	|--------------------------------------------------------------------------
+	| Failed Queue Jobs
+	|--------------------------------------------------------------------------
+	|
+	| These options configure the behavior of failed queue job logging so you
+	| can control which database and table are used to store the jobs that
+	| have failed. You may change them to any database / table you wish.
+	|
+	*/
+
+	'failed' => array(
+
+		'database' => 'mysql', 'table' => 'failed_jobs',
+
+	),
+
+);

app/config/remote.php

@@ -0,0 +1,59 @@
+<?php
+
+return array(
+
+	/*
+	|--------------------------------------------------------------------------
+	| Default Remote Connection Name
+	|--------------------------------------------------------------------------
+	|
+	| Here you may specify the default connection that will be used for SSH
+	| operations. This name should correspond to a connection name below
+	| in the server list. Each connection will be manually accessible.
+	|
+	*/
+
+	'default' => 'production',
+
+	/*
+	|--------------------------------------------------------------------------
+	| Remote Server Connections
+	|--------------------------------------------------------------------------
+	|
+	| These are the servers that will be accessible via the SSH task runner
+	| facilities of Laravel. This feature radically simplifies executing
+	| tasks on your servers, such as deploying out these applications.
+	|
+	*/
+
+	'connections' => array(
+
+		'production' => array(
+			'host'      => '',
+			'username'  => '',
+			'password'  => '',
+			'key'       => '',
+			'keyphrase' => '',
+			'root'      => '/var/www',
+		),
+
+	),
+
+	/*
+	|--------------------------------------------------------------------------
+	| Remote Server Groups
+	|--------------------------------------------------------------------------
+	|
+	| Here you may list connections under a single group name, which allows
+	| you to easily access all of the servers at once using a short name
+	| that is extremely easy to remember, such as "web" or "database".
+	|
+	*/
+
+	'groups' => array(
+
+		'web' => array('production')
+
+	),
+
+);

app/config/services.php

@@ -0,0 +1,31 @@
+<?php
+
+return array(
+
+	/*
+	|--------------------------------------------------------------------------
+	| Third Party Services
+	|--------------------------------------------------------------------------
+	|
+	| This file is for storing the credentials for third party services such
+	| as Stripe, Mailgun, Mandrill, and others. This file provides a sane
+	| default location for this type of information, allowing packages
+	| to have a conventional place to find your various credentials.
+	|
+	*/
+
+	'mailgun' => array(
+		'domain' => '',
+		'secret' => '',
+	),
+
+	'mandrill' => array(
+		'secret' => '',
+	),
+
+	'stripe' => array(
+		'model'  => 'User',
+		'secret' => '',
+	),
+
+);

app/config/session.php

@@ -0,0 +1,140 @@
+<?php
+
+return array(
+
+	/*
+	|--------------------------------------------------------------------------
+	| Default Session Driver
+	|--------------------------------------------------------------------------
+	|
+	| This option controls the default session "driver" that will be used on
+	| requests. By default, we will use the lightweight native driver but
+	| you may specify any of the other wonderful drivers provided here.
+	|
+	| Supported: "file", "cookie", "database", "apc",
+	|            "memcached", "redis", "array"
+	|
+	*/
+
+	'driver' => 'file',
+
+	/*
+	|--------------------------------------------------------------------------
+	| Session Lifetime
+	|--------------------------------------------------------------------------
+	|
+	| Here you may specify the number of minutes that you wish the session
+	| to be allowed to remain idle before it expires. If you want them
+	| to immediately expire on the browser closing, set that option.
+	|
+	*/
+
+	'lifetime' => 120,
+
+	'expire_on_close' => false,
+
+	/*
+	|--------------------------------------------------------------------------
+	| Session File Location
+	|--------------------------------------------------------------------------
+	|
+	| When using the native session driver, we need a location where session
+	| files may be stored. A default has been set for you but a different
+	| location may be specified. This is only needed for file sessions.
+	|
+	*/
+
+	'files' => storage_path().'/sessions',
+
+	/*
+	|--------------------------------------------------------------------------
+	| Session Database Connection
+	|--------------------------------------------------------------------------
+	|
+	| When using the "database" or "redis" session drivers, you may specify a
+	| connection that should be used to manage these sessions. This should
+	| correspond to a connection in your database configuration options.
+	|
+	*/
+
+	'connection' => null,
+
+	/*
+	|--------------------------------------------------------------------------
+	| Session Database Table
+	|--------------------------------------------------------------------------
+	|
+	| When using the "database" session driver, you may specify the table we
+	| should use to manage the sessions. Of course, a sensible default is
+	| provided for you; however, you are free to change this as needed.
+	|
+	*/
+
+	'table' => 'sessions',
+
+	/*
+	|--------------------------------------------------------------------------
+	| Session Sweeping Lottery
+	|--------------------------------------------------------------------------
+	|
+	| Some session drivers must manually sweep their storage location to get
+	| rid of old sessions from storage. Here are the chances that it will
+	| happen on a given request. By default, the odds are 2 out of 100.
+	|
+	*/
+
+	'lottery' => array(2, 100),
+
+	/*
+	|--------------------------------------------------------------------------
+	| Session Cookie Name
+	|--------------------------------------------------------------------------
+	|
+	| Here you may change the name of the cookie used to identify a session
+	| instance by ID. The name specified here will get used every time a
+	| new session cookie is created by the framework for every driver.
+	|
+	*/
+
+	'cookie' => 'olas_session',
+
+	/*
+	|--------------------------------------------------------------------------
+	| Session Cookie Path
+	|--------------------------------------------------------------------------
+	|
+	| The session cookie path determines the path for which the cookie will
+	| be regarded as available. Typically, this will be the root path of
+	| your application but you are free to change this when necessary.
+	|
+	*/
+
+	'path' => '/',
+
+	/*
+	|--------------------------------------------------------------------------
+	| Session Cookie Domain
+	|--------------------------------------------------------------------------
+	|
+	| Here you may change the domain of the cookie used to identify a session
+	| in your application. This will determine which domains the cookie is
+	| available to in your application. A sensible default has been set.
+	|
+	*/
+
+	'domain' => null,
+
+	/*
+	|--------------------------------------------------------------------------
+	| HTTPS Only Cookies
+	|--------------------------------------------------------------------------
+	|
+	| By setting this option to true, session cookies will only be sent back
+	| to the server if the browser has a HTTPS connection. This will keep
+	| the cookie from being sent to you if it can not be done securely.
+	|
+	*/
+
+	'secure' => false,
+
+);

app/config/testing/cache.php

@@ -0,0 +1,20 @@
+<?php
+
+return array(
+
+	/*
+	|--------------------------------------------------------------------------
+	| Default Cache Driver
+	|--------------------------------------------------------------------------
+	|
+	| This option controls the default cache "driver" that will be used when
+	| using the Caching library. Of course, you may use other drivers any
+	| time you wish. This is the default when another is not specified.
+	|
+	| Supported: "file", "database", "apc", "memcached", "redis", "array"
+	|
+	*/
+
+	'driver' => 'array',
+
+);

app/config/testing/session.php

@@ -0,0 +1,21 @@
+<?php
+
+return array(
+
+	/*
+	|--------------------------------------------------------------------------
+	| Default Session Driver
+	|--------------------------------------------------------------------------
+	|
+	| This option controls the default session "driver" that will be used on
+	| requests. By default, we will use the lightweight native driver but
+	| you may specify any of the other wonderful drivers provided here.
+	|
+	| Supported: "native", "cookie", "database", "apc",
+	|            "memcached", "redis", "array"
+	|
+	*/
+
+	'driver' => 'array',
+
+);

app/config/view.php

@@ -0,0 +1,31 @@
+<?php
+
+return array(
+
+	/*
+	|--------------------------------------------------------------------------
+	| View Storage Paths
+	|--------------------------------------------------------------------------
+	|
+	| Most templating systems load templates from disk. Here you may specify
+	| an array of paths that should be checked for your views. Of course
+	| the usual Laravel view path has already been registered for you.
+	|
+	*/
+
+	'paths' => array(__DIR__.'/../views'),
+
+	/*
+	|--------------------------------------------------------------------------
+	| Pagination View
+	|--------------------------------------------------------------------------
+	|
+	| This view will be used to render the pagination link output, and can
+	| be easily customized here to show any view you like. A clean view
+	| compatible with Twitter's Bootstrap is given to you by default.
+	|
+	*/
+
+	'pagination' => 'pagination::slider-3',
+
+);

app/config/workbench.php

@@ -0,0 +1,31 @@
+<?php
+
+return array(
+
+	/*
+	|--------------------------------------------------------------------------
+	| Workbench Author Name
+	|--------------------------------------------------------------------------
+	|
+	| When you create new packages via the Artisan "workbench" command your
+	| name is needed to generate the composer.json file for your package.
+	| You may specify it now so it is used for all of your workbenches.
+	|
+	*/
+
+	'name' => '',
+
+	/*
+	|--------------------------------------------------------------------------
+	| Workbench Author E-Mail Address
+	|--------------------------------------------------------------------------
+	|
+	| Like the option above, your e-mail address is used when generating new
+	| workbench packages. The e-mail is placed in your composer.json file
+	| automatically after the package is created by the workbench tool.
+	|
+	*/
+
+	'email' => '',
+
+);

app/controllers/ActivitiesController.php

@@ -0,0 +1,763 @@
+<?php
+
+class ActivitiesController extends \BaseController {
+
+    /**
+     * Save a new activity
+     *
+     * @param int $id The id of the parent course
+     * @return Response Redirect to the parent course's page
+     */
+    public function create($id)
+    {
+        /** Validation rules */
+        $validator = Validator::make(
+            array(
+                'name' => Input::get('name'),
+                'description' => Input::get('description')
+            ),
+            array(
+                'name' => 'required|unique:activities,course_id,'.$id,
+                'description' => 'required|min:10'
+            )
+        );
+
+        /** If validation fails */
+        if ($validator->fails())
+        {
+            /** Prepare error message */
+            $message = 'Error(s) creating a new Activity<ul>';
+
+            foreach ($validator->messages()->all('<li>:message</li>') as $validationError)
+            {
+                $message.=$validationError;
+            }
+
+            $message.='</ul>';
+
+            /** Send error message and old data */
+            Session::flash('status', 'danger');
+            Session::flash('message', $message);
+            return Redirect::back()->withInput();
+        }
+        else
+        {
+            /** Instantiate new activity */
+            $activity = new Activity;
+            $activity->name= Input::get('name');
+            $activity->description = Input::get('description');
+            $activity->course_id = $id;
+            $activity->date = date('Y-m-d');
+
+            /** If activity is saved, send success message */
+            if($activity->save())
+            {
+                Session::flash('status', 'success');
+                Session::flash('message', 'Activity created.');
+                return Redirect::action('ActivitiesController@show', array($activity->id));
+            }
+
+            /** If saving fails, send error message and old data */
+            else
+            {
+                Session::flash('status', 'warning');
+                Session::flash('message', 'Error adding Activity. Please try again later.');
+                return Redirect::back()->withInput();
+            }
+        }
+    }
+
+    /**
+     *
+     */
+    public function show($id)
+    {
+        $activity = Activity::find($id);
+
+        // If activity does not exist, display 404
+        if(!$activity)
+            App::abort('404');
+
+        // Get activity's course
+        $course = Course::where('id', '=', $activity->course_id)->firstOrFail();
+
+        // If activity does not belong to the requesting user, display 403
+        if ($course->user_id != Auth::id())
+            App::abort('403', 'Access Forbidden');
+
+        // Get active semesters
+        $active_semesters= array();
+        $active_semesters_collection = Semester::select('id')->where('is_visible', 1)->where('start', '<=', date('Y-m-d H:i:s'))->where('end', '>=', date('Y-m-d H:i:s'))->get();
+        foreach ($active_semesters_collection as $active_semester)
+        {
+            $active_semesters[]=$active_semester->id;
+        }
+            // Added the function htmlspecialchars to activity name string because it was corrupting Jquery code while using quotes on page rendering. - Carlos R Caraballo 1/18/2019
+        $title = $course->code.$course->number.'-'.$course->section.': '.htmlspecialchars($activity->name, ENT_QUOTES).' <span class="small attention">('.$course->semester->code.')</span>';
+        $outcomes = Outcome::orderBy('name', 'asc')->get();
+        $outcomes_achieved = json_decode($activity->outcomes_achieved, true);
+        $outcomes_attempted = json_decode($activity->outcomes_attempted, true);
+
+        return View::make('local.professors.activity', compact('activity', 'title', 'outcomes', 'outcomes_achieved', 'outcomes_attempted', 'course', 'student_count', 'active_semesters'));
+    }
+
+
+    public function assess($id)
+    {
+        $activity = Activity::find($id);
+
+        // If activity does not exist, display 404
+        if(!$activity)
+            App::abort('404');
+
+        // Get activity's course
+        $course = Course::where('id', '=', $activity->course_id)->firstOrFail();
+
+        // If activity does not belong to the requesting user, display 403
+        if ($course->user_id != Auth::id())
+            App::abort('403', 'Access Forbidden');
+
+        $title = 'Assessment Sheet';
+        $students = $course->students;
+
+        // Get rubric contents
+        $rubric = Rubric::find($activity->rubric_id);
+        $rubric_contents = json_decode($rubric->contents);
+
+        // Get results
+        $assessments = DB::table('assessments')->join('students', 'assessments.student_id','=','students.id')->where('activity_id', '=', $activity->id)->orderBy('assessments.id', 'asc')->get();
+
+        // Decode the scores (blade workaround)
+        $scores_array = array();
+        foreach ($assessments as $index=>$assessment)
+        {
+            $scores_array[$assessment->id] = json_decode($assessment->scores, true);
+        }
+
+        return View::make('local.professors.assessment', compact('activity', 'title', 'students', 'course', 'rubric_contents', 'assessments', 'scores_array', 'rubric'));
+    }
+
+    public function saveAssessment()
+    {
+        try
+        {
+            $exception = DB::transaction(function()
+            {
+                DB::transaction(function()
+                {
+                    // Student assessment data
+                    $student_data = json_decode(Input::get('student_scores'));
+
+                    // Outcome count
+                    $outcomeCount = Outcome::all()->count();
+
+
+                    // Activity
+                    $activity = Activity::find(Input::get('activity_id'));
+
+                    // Create or update student scores
+                    if($activity->outcomes_attempted==NULL)
+                    {
+                        // For each student, save her/his assessment in the db
+                        foreach ($student_data as $single_student_data)
+                        {
+                            // Find student by id
+                            $student = Student::find($single_student_data->student_id);
+
+                            $comments = trim($single_student_data->comments);
+                            if($comments=='')
+                            {
+                                $comments = NULL;
+                            }
+
+                            // Add the assessment to the pivot table
+                            $student->assessed_activities()->attach($activity->id, array(
+                                'scores' => json_encode($single_student_data->scores),
+                                'percentage'=>$single_student_data->percentage,
+                                'comments' => $single_student_data->comments
+                            ));
+                        }
+                    }
+                    else
+                    {
+                        // For each student, save her/his assessment in the db
+                        foreach ($student_data as $single_student_data)
+                        {
+                            // Find student by id
+                            $student = Student::find($single_student_data->student_id);
+
+                            $comments = trim($single_student_data->comments);
+                            if($comments=='')
+                            {
+                                $comments = NULL;
+                            }
+
+                            // Update the assessment in the pivot table
+                            $student->assessed_activities()->updateExistingPivot($activity->id, array(
+                                'scores' => json_encode($single_student_data->scores),
+                                'percentage'=>$single_student_data->percentage,
+                                'comments' => $single_student_data->comments
+                            ));
+
+                        }
+
+                    }
+
+
+                    // Prepare arrays for criteria achievement for this activity
+                    $criteria_achievement = json_decode(Input::get('criteria_achievement'));
+                    $outcomes_attempted = array_fill(1, $outcomeCount, 0);
+                    $outcomes_achieved = array_fill(1, $outcomeCount, 0);
+
+                    // Fetch parent course's criteria achievement by outcome, if it exists
+                    $course = $activity->course;
+                    $course_outcomes_attempted = NULL;
+                    $course_outcomes_achieved = NULL;
+
+                    if($course->outcomes_attempted==NULL)
+                    {
+                        $course_outcomes_attempted = array_fill(1, $outcomeCount, 0);
+                        $course_outcomes_achieved = array_fill(1, $outcomeCount, 0);
+                    }
+                    else
+                    {
+                        // the second argument is necessary to convert it into an array
+                        $course_outcomes_attempted = json_decode($course->outcomes_attempted, true);
+                        $course_outcomes_achieved = json_decode($course->outcomes_achieved, true);
+                    }
+
+
+                    foreach($criteria_achievement as $criterion_id=>$criterion_achieved)
+                    {
+                        // Find corresponding learning outcome
+                        $criterion = Criterion::withTrashed()->find($criterion_id);
+                        $outcome = Outcome::find($criterion->outcome_id);
+
+                        // If criterion is achieved (1), add 1 to all arrays
+                        if($criterion_achieved===1)
+                        {
+                            $outcomes_attempted[$outcome->id]+=1;
+                            $outcomes_achieved[$outcome->id]+=1;
+                            $course_outcomes_attempted[$outcome->id]+=1;
+                            $course_outcomes_achieved[$outcome->id]+=1;
+                        }
+                        // Else if it's 0, only add to the attempted outcomes arrays
+                        elseif($criterion_achieved===0)
+                        {
+                            $outcomes_attempted[$outcome->id]+=1;
+                            $course_outcomes_attempted[$outcome->id]+=1;
+                        }
+                    }
+
+                    // If all values are 0, throw exception
+                    if(count(array_unique($outcomes_attempted))==1 && $outcomes_attempted[1]==0)
+                        throw new Exception("Error Processing Request", 1);
+
+
+
+                    // Set activity fields
+                    $activity->criteria_achieved = Input::get('criteria_achievement');
+                    $activity->criteria_achieved_percentage = Input::get('criteria_achieved_percentage');
+                    $activity->outcomes_attempted = json_encode($outcomes_attempted);
+                    $activity->outcomes_achieved = json_encode($outcomes_achieved);
+
+
+                    // Publish results if not a draft. That is, update the activity's course.
+                    if(Input::get('draft')==false)
+                    {
+                        // Update course
+                        $course->outcomes_achieved = json_encode($course_outcomes_achieved);
+                        $course->outcomes_attempted = json_encode($course_outcomes_attempted);
+                        $course->save();
+
+                        $activity->draft = false;
+
+                    }
+                    else
+                    {
+                        // Set draft to true
+                        $activity->draft = true;
+                    }
+
+                    // Save activity
+                    $activity->save();
+
+
+                    // Recalculate course outcomes
+                    $activities = DB::table('activities')
+                        ->where('course_id', $activity->course->id)
+                        ->where('draft', 0)
+                        ->get();
+
+
+                    // Check if any assessed activities remain
+                    $remainingAssessed = false;
+                    foreach ($activities as $activity1)
+                    {
+                        if($activity1->outcomes_attempted!=NULL)
+                        {
+                            $remainingAssessed =true;
+                            break;
+                        }
+                    }
+
+                    //If there are still evaluated activities in the course, recalculate course outcomes
+                    if(count($activities) && $remainingAssessed)
+                    {
+                        $outcomeCount = Outcome::all()->count();
+
+                        // Variables to hold recalculated outcomes for the course
+                        $course_outcomes_attempted = array_fill(1, $outcomeCount, 0);
+                        $course_outcomes_achieved = array_fill(1, $outcomeCount, 0);
+
+                        // For each activity
+                        foreach ($activities as $activity2)
+                        {
+                            // If activity has been assessed
+                            if($activity2->outcomes_attempted!=NULL)
+                            {
+                                // Get the achieved criteria
+                                $criteria_achievement = json_decode($activity2->criteria_achieved, true);
+                                foreach($criteria_achievement as $criterion_id=>$criterion_achieved)
+                                {
+                                    // Find corresponding learning outcome;
+                                    $criterion = Criterion::withTrashed()->find($criterion_id);
+                                    $outcome = Outcome::find($criterion->outcome_id);
+
+                                    // If criterion is achieved (1), add 1 to both arrays
+                                    if($criterion_achieved === 1)
+                                    {
+                                        $course_outcomes_attempted[$outcome->id]+=1;
+                                        $course_outcomes_achieved[$outcome->id]+=1;
+                                    }
+                                    // Else, only add to the attempted outcomes arrays
+                                    elseif($criterion_achieved === 0)
+                                    {
+                                        $course_outcomes_attempted[$outcome->id]+=1;
+                                    }
+                                }
+                            }
+                        }
+
+                        // Update course
+                        DB::table('courses')
+                        ->where('id', $course->id)
+                        ->update(array(
+                            'outcomes_attempted'=> json_encode($course_outcomes_attempted),
+                            'outcomes_achieved'=> json_encode($course_outcomes_achieved),
+                            'updated_at' => date('Y-m-d H:i:s'))
+                        );
+                    }
+                    // Otherwise, set them all to NULL
+                    else
+                    {
+                        DB::table('courses')
+                        ->where('id', $course->id)
+                        ->update(array(
+                            'outcomes_attempted'=> NULL,
+                            'outcomes_achieved'=> NULL,
+                            'updated_at' => date('Y-m-d H:i:s'))
+                        );
+                    }
+
+                });
+            });
+
+            if(is_null($exception))
+            {
+                Session::flash('status', 'success');
+                Session::flash('message', 'Assessment Saved. To add transforming actions click "Transforming Actions".');
+                return action('ActivitiesController@show', array(Input::get('activity_id')));
+            }
+
+        }
+        catch(Exception $e)
+        {
+            Log::info('e:'.$e);
+            Session::flash('status', 'danger');
+            Session::flash('message', 'Error saving assessment. Try again later.');
+
+            return action('ActivitiesController@show', array(Input::get('activity_id')));
+
+        }
+    }
+
+    public function deleteAssessment()
+    {
+
+        try
+        {
+            $exception = DB::transaction(function()
+            {
+                $activity = DB::table('activities')->where('id', Input::get('id'))->first();
+
+                $course = DB::table('courses')->where('id', $activity->course_id)->first();
+
+
+                // Reset results in activity
+                DB::table('activities')
+                    ->where('id', Input::get('id'))
+                    ->update(array(
+                        'draft' => 0,
+                        'outcomes_attempted'=> NULL,
+                        'outcomes_achieved'=> NULL,
+                        'criteria_achieved'=> NULL,
+                        'transforming_actions'=> NULL,
+                        'assessment_comments'=> NULL,
+                        'criteria_achieved_percentage'=> NULL,
+                        'updated_at' => date('Y-m-d H:i:s'))
+                    );
+
+                // Delete students score
+                DB::table('assessments')->where('activity_id', $activity->id)->delete();
+
+                // Recalculate course outcomes
+                $activities = DB::table('activities')
+                    ->where('course_id', $course->id)
+                    ->where('draft', 0)
+                    ->get();
+
+
+                // Check if any assessed activties remain
+                $remainingAssessed = false;
+                foreach ($activities as $activity)
+                {
+                    if($activity->outcomes_attempted!=NULL)
+                    {
+                        $remainingAssessed =true;
+                        break;
+                    }
+                }
+
+                //If there are still evaluated activities in the course, recalculate course outcomes
+                if(count($activities) && $remainingAssessed)
+                {
+                    $outcomeCount = Outcome::all()->count();
+
+                    // Variables to hold recalculated outcomes for the course
+                    $course_outcomes_attempted = array_fill(1, $outcomeCount, 0);
+                    $course_outcomes_achieved = array_fill(1, $outcomeCount, 0);
+
+                    // For each activity
+                    foreach ($activities as $activity)
+                    {
+                        // If activity has been assessed
+                        if($activity->outcomes_attempted!=NULL)
+                        {
+                            // Get the achieved criteria
+                            $criteria_achievement = json_decode($activity->criteria_achieved, true);
+                            foreach($criteria_achievement as $criterion_id=>$criterion_achieved)
+                            {
+                                // Find corresponding learning outcome;
+                                $criterion = Criterion::withTrashed()->find($criterion_id);
+                                $outcome = Outcome::find($criterion->outcome_id);
+
+                                // If criterion is achieved (1), add 1 to both arrays
+                                if($criterion_achieved === 1)
+                                {
+                                    $course_outcomes_attempted[$outcome->id]+=1;
+                                    $course_outcomes_achieved[$outcome->id]+=1;
+                                }
+                                // Else, only add to the attempted outcomes arrays
+                                elseif($criterion_achieved === 0)
+                                {
+                                    $course_outcomes_attempted[$outcome->id]+=1;
+                                }
+                            }
+                        }
+                    }
+
+                    // Update course
+                    DB::table('courses')
+                    ->where('id', $course->id)
+                    ->update(array(
+                        'outcomes_attempted'=> json_encode($course_outcomes_attempted),
+                        'outcomes_achieved'=> json_encode($course_outcomes_achieved),
+                        'updated_at' => date('Y-m-d H:i:s'))
+                    );
+                }
+                // Otherwise, set them all to NULL
+                else
+                {
+                    DB::table('courses')
+                    ->where('id', $course->id)
+                    ->update(array(
+                        'outcomes_attempted'=> NULL,
+                        'outcomes_achieved'=> NULL,
+                        'updated_at' => date('Y-m-d H:i:s'))
+                    );
+                }
+            });
+
+            if(is_null($exception))
+            {
+                Session::flash('status', 'success');
+                Session::flash('message', 'Assessment deleted.');
+                return Redirect::back();
+            }
+
+        }
+        catch (Exception $e)
+        {
+            Session::flash('status', 'danger');
+            Session::flash('message', 'Error saving  assessment. Try again later.');
+
+            return Redirect::back();
+        }
+    }
+
+    public function destroy($id)
+    {
+        $course = Activity::find($id)->course;
+
+        if(Activity::destroy($id))
+        {
+            // Recalculate course outcomes
+            $activities = $course->activities;
+
+            // Check if any assessed activties remain
+            $remainingAssessed = false;
+            foreach ($course->activities as $activity)
+            {
+                if($activity->outcomes_attempted!=NULL)
+                {
+                    $remainingAssessed =true;
+                    break;
+                }
+            }
+
+            //If there are still evaluated activities in the course, recalculate course outcomes
+            if(!$course->activities->isEmpty() && $remainingAssessed )
+            {
+                $outcomeCount = Outcome::all()->count();
+
+                // Variables to hold recalculated outcomes for the course
+                $course_outcomes_attempted = array_fill(1, $outcomeCount, 0);
+                $course_outcomes_achieved = array_fill(1, $outcomeCount, 0);
+
+                // For each activity
+                foreach ($activities as $activity)
+                {
+                  // If activity has been assessed
+                  if($activity->outcomes_attempted!=NULL)
+                  {
+                    // Get the achieved criteria
+                    $criteria_achievement = json_decode($activity->criteria_achieved, true);
+                    foreach($criteria_achievement as $criterion_id=>$criterion_achieved)
+                    {
+                      // Find corresponding learning outcome;
+                      $criterion = Criterion::withTrashed()->find($criterion_id);
+                      $outcome = Outcome::find($criterion->outcome_id);
+
+                      // If criterion is achieved (1), add 1 to both arrays
+                      if($criterion_achieved === 1)
+                      {
+                        $course_outcomes_attempted[$outcome->id]+=1;
+                        $course_outcomes_achieved[$outcome->id]+=1;
+                      }
+                      // Else, only add to the attempted outcomes arrays
+                      elseif($criterion_achieved === 0)
+                      {
+                        $course_outcomes_attempted[$outcome->id]+=1;
+                      }
+                    }
+                  }
+                }
+
+                // Update course
+                $course->outcomes_achieved = json_encode($course_outcomes_achieved);
+                $course->outcomes_attempted = json_encode($course_outcomes_attempted);
+            }
+            else
+            {
+                $course->outcomes_achieved = NULL;
+                $course->outcomes_attempted = NULL;
+            }
+
+            if($course->save())
+            {
+                Session::flash('status', 'success');
+                Session::flash('message', 'Activity deleted.');
+            }
+            else
+            {
+                Session::flash('status', 'danger');
+                Session::flash('message', 'Error deleting activity. Try again later.');
+                return Redirect::back();
+            }
+
+            return Redirect::action('CoursesController@show', array($course->id));
+        }
+        else
+        {
+            Session::flash('status', 'danger');
+            Session::flash('message', 'Error deleting activity. Try again later.');
+            return Redirect::back();
+        }
+    }
+
+    public function update($id)
+    {
+        try
+        {
+            $activity = Activity::find($id);
+
+            if(Input::has('update_activity_information'))
+            {
+                /** Validation rules */
+                $validator = Validator::make(
+                    array(
+                        'name' => Input::get('name'),
+                        'description' => Input::get('description'),
+                        'date' => Input::get('date'),
+                    ),
+                    array(
+                        'name' => 'required|unique:activities,course_id,'.$id,
+                        'description' => 'required|min:10',
+                        'date' => 'required|dateFormat:Y-m-d'
+                    ),
+                    array(
+                        'date.dateFormat'=>'The date does not match the correct format: yyyy-mm-dd.'
+                    )
+                );
+
+                /** If validation fails */
+                if ($validator->fails())
+                {
+                    /** Prepare error message */
+                    $message = 'Error(s) updating the Activity<ul>';
+
+                    foreach ($validator->messages()->all('<li>:message</li>') as $validationError)
+                    {
+                        $message.=$validationError;
+                    }
+
+                    $message.='</ul>';
+
+                    /** Send error message and old data */
+                    Session::flash('status', 'warning');
+                    Session::flash('message', $message);
+                    return Redirect::back()->withInput();
+                }
+
+                /** Update activity info */
+                $activity->name = Input::get('name');
+                $activity->description = Input::get('description');
+                $activity->date = Input::get('date');
+            }
+            elseif(Input::has('update_transforming_actions'))
+            {
+                if(trim(Input::get('transforming_actions')) !="")
+                    $activity->transforming_actions = Input::get('transforming_actions');
+                else
+                    $activity->transforming_actions = NULL;
+            }
+            elseif(Input::has('update_assessment_comments'))
+            {
+                if(trim(Input::get('assessment_comments')) !="")
+                    $activity->assessment_comments = Input::get('assessment_comments');
+                else
+                    $activity->assessment_comments = NULL;
+            }
+            else
+            {
+                Session::flash('status', 'danger');
+                Session::flash('message', 'Error updating Activity. Please try again later.');
+                return Redirect::action('ActivitiesController@show', array($activity->id));
+            }
+
+            $activity->save();
+
+            /** If activity is saved, send success message */
+            Session::flash('status', 'success');
+            Session::flash('message', 'Activity succesfully updated.');
+            return Redirect::action('ActivitiesController@show', array($activity->id));
+
+        }
+        catch(Exception $e)
+        {
+            Session::flash('status', 'warning');
+            Session::flash('message', 'Error updating Activity. Please try again later.');
+            return Redirect::action('ActivitiesController@show', array($activity->id));
+        }
+
+    }
+
+    //TODO the code in the next 2 functions is the same as the assess function except for the view returned. try to refactor this to avoid copying code.
+
+    public function viewAssessment($id)
+    {
+        $activity = Activity::find($id);
+
+        // If activity does not exist, display 404
+        if(!$activity)
+            App::abort('404');
+
+        // Get activity's course
+        $course = Course::where('id', '=', $activity->course_id)->firstOrFail();
+
+        // If activity does not belong to the requesting user, display 403
+        if ($course->user_id != Auth::id())
+            App::abort('403', 'Access Forbidden');
+
+        $title = 'Assessment Sheet';
+        $students = $course->students;
+
+        // Get rubric contents
+        $rubric_contents = Rubric::select('contents')->where('id', '=', $activity->rubric_id)->get();
+        $rubric_contents = json_decode($rubric_contents['0']->contents);
+
+        $rubric = Rubric::find($activity->rubric_id);
+
+        // Get results
+        $assessments = DB::table('assessments')->where('activity_id', '=', $activity->id)->orderBy('id', 'asc')->get();
+
+        // Decode the scores (blade workaround)
+        $scores_array = array();
+        foreach ($assessments as $index=>$assessment)
+        {
+            $scores_array[$assessment->id] = json_decode($assessment->scores, true);
+        }
+
+        return View::make('local.professors.view_assessment', compact('activity', 'title', 'students', 'course', 'rubric_contents', 'assessments', 'scores_array', 'rubric'));
+    }
+
+    public function printAssessment($id)
+    {
+        $activity = Activity::find($id);
+
+        // If activity does not exist, display 404
+        if(!$activity)
+            App::abort('404');
+
+        // Get activity's course
+        $course = Course::where('id', '=', $activity->course_id)->firstOrFail();
+
+        // If activity does not belong to the requesting user, display 403
+        if ($course->user_id != Auth::id())
+            App::abort('403', 'Access Forbidden');
+
+        $title = 'Assessment Sheet';
+        $students = $course->students;
+
+        // Get rubric contents
+        $rubric_contents = Rubric::select('contents')->where('id', '=', $activity->rubric_id)->get();
+        $rubric_contents = json_decode($rubric_contents['0']->contents);
+
+        $rubric = Rubric::find($activity->rubric_id);
+
+        // Get results
+        $assessments = DB::table('assessments')->where('activity_id', '=', $activity->id)->orderBy('id', 'asc')->get();
+
+        // Decode the scores (blade workaround)
+        $scores_array = array();
+        foreach ($assessments as $index=>$assessment)
+        {
+            $scores_array[$assessment->id] = json_decode($assessment->scores, true);
+        }
+
+        return View::make('local.professors.print_assessment', compact('activity', 'title', 'students', 'course', 'rubric_contents', 'assessments', 'scores_array', 'rubric'));
+    }
+
+
+}

app/controllers/AdministratorsController.php

@@ -0,0 +1,207 @@
+<?php
+
+class AdministratorsController extends \BaseController
+{
+    public function overview()
+    {
+        //Total amount of learning outcomes
+        $outcomeCount = Outcome::withTrashed()->count();
+
+        // Id for excluding UHS from records
+        $uhs_school_id = School::where('name', 'LIKE', '%UHS%')->first()->id;
+        $uhs_program_id = Program::where('name', 'LIKE', '%UHS%')->first()->id;
+
+        $schools = School::where('id', '!=', $uhs_school_id)->orderBy('name', 'asc')->get();
+        $title = 'Campus Overview';
+        $outcomes = Outcome::withTrashed()->select('id', 'name', 'expected_outcome')->orderBy('name', 'asc')->get();
+
+        $undergrad_outcomes_achieved = array_fill(1, $outcomeCount, 0);
+        $undergrad_outcomes_attempted = array_fill(1, $outcomeCount, 0);
+        $grad_outcomes_achieved = array_fill(1, $outcomeCount, 0);
+        $grad_outcomes_attempted = array_fill(1, $outcomeCount, 0);
+
+        /**
+         * Calculate campus wide outcome performance
+         */
+
+        // Calculate campus wide outcome performance for undergrad and grad
+        foreach (Course::with('program')
+            ->where('program_id', '!=', $uhs_program_id)
+            ->where('code', '!=', 'TEST')
+            ->whereNotNull('outcomes_achieved')
+            ->whereIn('semester_id', Session::get('semesters_ids'))->get() as $course)
+        {
+            if(!$course->program->is_graduate)
+            {
+                $course_outcomes_achieved =json_decode($course->outcomes_achieved, true);
+                $course_outcomes_attempted =json_decode($course->outcomes_attempted, true);
+                for($i=1; $i<=count($undergrad_outcomes_attempted); $i++)
+                {
+
+                    $undergrad_outcomes_achieved[$i]+=$course_outcomes_achieved[$i];
+                    $undergrad_outcomes_attempted[$i]+=$course_outcomes_attempted[$i];
+                }
+            }
+            else
+            {
+                $course_outcomes_achieved =json_decode($course->outcomes_achieved, true);
+                $course_outcomes_attempted =json_decode($course->outcomes_attempted, true);
+                for($i=1; $i<=count($grad_outcomes_attempted); $i++)
+                {
+
+                    $grad_outcomes_achieved[$i]+=$course_outcomes_achieved[$i];
+                    $grad_outcomes_attempted[$i]+=$course_outcomes_attempted[$i];
+                }
+            }
+
+        }
+
+        /**
+         * Calculate how many programs achieved and attempted each outcome
+         */
+
+        // Number of programs that achieved a particular learning outcome
+        $achievedUndergradProgramsPerOutcome = array_fill(1, $outcomeCount, 0);
+
+        // Number of programs that attempted a particular learning outcome
+        $attemptedUndergradProgramsPerOutcome = array_fill(1, $outcomeCount, 0);
+
+        // Names of programs doing assessment
+        // Fetch programs with participation
+        $participating_undergrad_programs = DB::table('VIEW_participating_programs')
+            ->whereIn('semester_id', Session::get('semesters_ids'))
+            ->where('is_graduate', 0)
+            ->groupBy('id')
+            ->orderBy('name', 'asc')
+            ->get();
+
+        $output = array();
+
+
+        // For each outcome
+        foreach ($outcomes as $outcome)
+        {
+            // For each program with courses that do assessment
+            foreach (Program::with(array('courses' => function($query){
+                $query->whereNotNull('outcomes_attempted');
+                $query->where('code', '!=', 'TEST');
+                $query->whereIn('semester_id', Session::get('semesters_ids'));
+            }))->where('is_graduate', 0)->orderBy('name', 'asc')->get() as $program)
+            {
+                // To acummulate all criteria for one program
+                $achieved_outcomes_per_undergrad_program = array_fill(1, $outcomeCount, 0);
+                $attempted_outcomes_per_undergrad_program = array_fill(1, $outcomeCount, 0);
+
+                //Flag for counting programs
+                $flag =false;
+
+                // For each course in the program
+                foreach ($program->courses as $course)
+                {
+                    // If the outcome in question is being evaluated
+                    $course_outcomes_attempted2 = json_decode($course->outcomes_attempted, true);
+                    $course_outcomes_achieved2 = json_decode($course->outcomes_achieved, true);
+                    if(array_key_exists($outcome->id, $course_outcomes_attempted2 )
+                        && $course_outcomes_attempted2[$outcome->id]>0)
+                    {
+                        $achieved_outcomes_per_undergrad_program[$outcome->id]+=$course_outcomes_achieved2[$outcome->id];
+                        $attempted_outcomes_per_undergrad_program[$outcome->id]+=$course_outcomes_attempted2[$outcome->id];
+
+
+                        // Add one to the programs assessing, if it wasn't added before
+                        if(!$flag)
+                        {
+                            $attemptedUndergradProgramsPerOutcome[$outcome->id]+=1;
+                            $flag= true;
+                        }
+                    }
+
+                    // $output[] = 'ACHIEVED: '.$program->name.'-'.json_encode($achieved_outcomes_per_undergrad_program);
+                    // $output[] = 'ATTEMPTED: '.$program->name.'-'.json_encode($attempted_outcomes_per_undergrad_program);
+
+                }
+                //If the accumulated achieved criteria for a specific outcome in a program divided by the accumulated attempted criteria for a specific outcome in a program is greated than the expected outcome
+                if($attempted_outcomes_per_undergrad_program[$outcome->id]!=0 && (float)$achieved_outcomes_per_undergrad_program[$outcome->id]/$attempted_outcomes_per_undergrad_program[$outcome->id]*100 >= $outcome->expected_outcome)
+                {
+                    $achievedUndergradProgramsPerOutcome[$outcome->id]+=1;
+                    // $output[]= 'END OF PROGRAM: '.$program->name.'-'.json_encode($achievedUndergradProgramsPerOutcome);
+                }
+            }
+        }
+
+
+        /**
+         * Calculate how many programs achieved and attempted each outcome
+         */
+
+        // Number of programs that achieved a particular learning outcome
+        $achievedGradProgramsPerOutcome = array_fill(1, $outcomeCount, 0);
+
+        // Number of programs that attempted a particular learning outcome
+        $attemptedGradProgramsPerOutcome = array_fill(1, $outcomeCount, 0);
+
+        // Names of programs doing assessment
+        $participating_grad_programs = DB::table('VIEW_participating_programs')
+            ->whereIn('semester_id', Session::get('semesters_ids'))
+            ->where('is_graduate', 1)
+            ->groupBy('id')
+            ->orderBy('name', 'asc')
+            ->get();
+
+        $output = array();
+
+
+        // For each outcome
+        foreach ($outcomes as $outcome)
+        {
+            // For each program with courses that do assessment
+            foreach (Program::with(array('courses' => function($query){
+                $query->whereNotNull('outcomes_attempted');
+                $query->where('code', '!=', 'TEST');
+                $query->whereIn('semester_id', Session::get('semesters_ids'));
+            }))->where('is_graduate', 1)->orderBy('name', 'asc')->get() as $program)
+            {
+                // To acummulate all criteria for one program
+                $achieved_outcomes_per_grad_program = array_fill(1, $outcomeCount, 0);
+                $attempted_outcomes_per_grad_program = array_fill(1, $outcomeCount, 0);
+
+                //Flag for counting programs
+                $flag =false;
+
+                // For each course in the program
+                foreach ($program->courses as $course)
+                {
+                    // If the outcome in question is being evaluated
+                    $course_outcomes_attempted2 = json_decode($course->outcomes_attempted, true);
+                    $course_outcomes_achieved2 = json_decode($course->outcomes_achieved, true);
+                    if(array_key_exists($outcome->id, $course_outcomes_attempted2 )
+                        && $course_outcomes_attempted2[$outcome->id]>0)
+                    {
+                        $achieved_outcomes_per_grad_program[$outcome->id]+=$course_outcomes_achieved2[$outcome->id];
+                        $attempted_outcomes_per_grad_program[$outcome->id]+=$course_outcomes_attempted2[$outcome->id];
+
+
+                        // Add one to the programs assessing, if it wasn't added before
+                        if(!$flag)
+                        {
+                            $attemptedGradProgramsPerOutcome[$outcome->id]+=1;
+                            $flag= true;
+                        }
+                    }
+
+                    // $output[] = 'ACHIEVED: '.$program->name.'-'.json_encode($achieved_outcomes_per_grad_program);
+                    // $output[] = 'ATTEMPTED: '.$program->name.'-'.json_encode($attempted_outcomes_per_grad_program);
+
+                }
+                //If the accumulated achieved criteria for a specific outcome in a program divided by the accumulated attempted criteria for a specific outcome in a program is greated than the expected outcome
+                if($attempted_outcomes_per_grad_program[$outcome->id]!=0 && (float)$achieved_outcomes_per_grad_program[$outcome->id]/$attempted_outcomes_per_grad_program[$outcome->id]*100 >= $outcome->expected_outcome)
+                {
+                    $achievedGradProgramsPerOutcome[$outcome->id]+=1;
+                    // $output[]= 'END OF PROGRAM: '.$program->name.'-'.json_encode($achievedGradProgramsPerOutcome);
+                }
+            }
+        }
+
+        return View::make('local.managers.admins.overview', compact('title', 'schools', 'outcomes', 'undergrad_outcomes_achieved', 'undergrad_outcomes_attempted', 'grad_outcomes_achieved', 'grad_outcomes_attempted', 'attemptedUndergradProgramsPerOutcome', 'participating_undergrad_programs', 'achievedUndergradProgramsPerOutcome', 'attemptedGradProgramsPerOutcome', 'participating_grad_programs', 'achievedGradProgramsPerOutcome'));
+    }
+}

app/controllers/AnnualPlansController.php

@@ -0,0 +1,112 @@
+<?php
+
+class AnnualPlansController extends \BaseController {
+
+  /**
+   * Checks whether a user has permission to view a page in this controller
+   *
+   * @var User $user        Authenticated user
+   */
+  private function userHasAccess($program_id)
+  {
+    $user = Auth::user();
+
+    switch ($user->role) {
+      case '3':
+        $programs = $user->programs->lists('id');
+
+        // If program does not belong to user, show 403
+        if(!in_array($program_id, $programs))
+          return false;
+
+        break;
+
+      case '2':
+        $programs = Program::where('school_id', $user->school_id)->lists('id');
+
+        // If program is not in user's school, show 403
+        if(!in_array($program_id, $programs))
+          return false;
+
+        break;
+      case '4':
+        return false;
+    }
+
+    return true;
+  }
+
+  /**
+   * Lists annual plans by year and program
+   * @var string $title     Title for page
+   * @var Program $programs Collection of programs user has access to
+   * @var User $user        Authenticated user
+   * @var Quinquennium $quinquenniums      All current or past quinquenniums
+   * @var Quinquennium $current_quinquennium      Current quinquennium
+   */
+  public function index()
+  {
+    $title = 'Annual Plans';
+    $user = Auth::user();
+    $quinquenniums = Quinquennium::where('start_date','<=', date('Y-m-d'))->get();
+    $current_quinquennium = Quinquennium::
+      where('start_date', '<=', date('Y-m-d'))
+      ->where('end_date', '>=', date('Y-m-d'))
+      ->first();
+
+    switch ($user->role) {
+      case '1':
+        $programs = Program::all();
+        break;
+      case '2':
+        $programs = Program::where('school_id', $user->school_id)->get();
+        break;
+      case 3:
+        $programs = $user->programs;
+        break;
+      default:
+        App::abort('404');
+        break;
+    }
+
+    return View::make('local.managers.shared.index_annual_plans', compact('title', 'quinquenniums', 'programs', 'current_quinquennium'));
+  }
+
+  /**
+   * Page to create a new plan for the current quinquennium
+   * @var string $title     Title for page
+   * @var Program $programs Collection of programs user has access to
+   * @var Outcome $outcomes      List of outcomes ordered by name
+   * @var User $user      Currently logged user
+   * @var Course $courses      Courses for a particular program
+   */
+  public function create(Program $program)
+  {
+    $title = 'New Annual Plan for '.$program->name;
+    $user = Auth::user();
+    $outcomes = Outcome::orderBy('name')->get();
+
+    $current_quinquennium = Quinquennium::
+      where('start_date', '<=', date('Y-m-d'))
+      ->where('end_date', '>=', date('Y-m-d'))
+      ->first();
+
+    $courses = Course::
+      select('id', 'code', 'number', 'name')
+      ->where('program_id', $program->id)
+      ->groupBy('name')
+      ->orderBy('code','ASC')
+      ->orderBy('number','ASC')
+      ->orderBy('name','ASC')
+      ->get();
+
+    // Check if user can create a plan
+    if(!$this->userHasAccess($program->id))
+    {
+      return View::make('global.403');
+    }
+
+    return View::make('local.managers.shared.create_annual_plan', compact('title', 'program', 'current_quinquennium', 'outcomes', 'courses'));
+  }
+
+}

app/controllers/AuthController.php

@@ -0,0 +1,184 @@
+<?php
+
+class AuthController extends \BaseController {
+
+	/**
+	 * Display a listing of the resource.
+	 * GET /auth
+	 *
+	 * @return Response
+	 */
+	public function showLogin()
+	{
+		$title ="Online Learning Assessment System";
+		return View::make('global.login', compact('title'));
+	}
+
+	public function login()
+	{
+		/** Validate data */
+		$validator = Validator::make(
+			Input::all(),
+			array(
+				'email'=>'required|email',
+    			'password'=>'required|min:4|max:16'
+			)
+		);
+
+		if(!$validator->fails())
+		{
+//			TODO: Remove this for production environment
+            if (App::environment('local', 'staging')) {
+			    return $this->processLogin();
+            }
+			try {
+				// User input
+				$username = str_replace('@upr.edu', '', Input::get('email'));
+				$password = Input::get('password');
+
+				// Radius connection info
+				$radius = radius_auth_open();
+				$radius_ip = '136.145.223.27';
+				$radius_secret = '8reC6ujatArecHe63spech5Wa';
+
+				radius_add_server($radius, $radius_ip, 1812, $radius_secret, 5, 3);
+
+				// Create radius request and add params
+				radius_create_request($radius, RADIUS_ACCESS_REQUEST);
+				radius_put_attr($radius, RADIUS_USER_NAME, $username);
+				radius_put_attr($radius, RADIUS_USER_PASSWORD, $password);
+
+				$result = radius_send_request($radius);
+
+				switch ($result) {
+					// Credentials are correct
+					case RADIUS_ACCESS_ACCEPT:
+
+						return $this->processLogin();
+						break;
+					case RADIUS_ACCESS_REJECT:
+						// If email is a workshop email,
+						if(Input::get('email') == 'taller1@upr.edu' && Input::get('password') == 'o34eAvaluo'){
+							return $this->processLogin();
+						}
+
+						// Tell user credentials are incorrect
+						Session::flash('status', 'danger');
+						Session::flash('message', 'Incorrect email/password combination.');
+						return Redirect::action('AuthController@showLogin');
+						break;
+					// Throw exception in case of any other error
+					default:
+						throw new Exception("-", 1);
+						break;
+				}
+
+			}
+			catch(Exception $e){
+				// Tell user access is denied and return to login page.
+				Session::flash('status', 'danger');
+				Session::flash('message', 'An error occurred while connecting to the authentication service. Please try again later. If the problem persists, contact the help desk at x. 80400 or the administrators at oeae.uprrp.edu.');
+				return Redirect::action('AuthController@showLogin');
+			}
+			return Redirect::route('login');
+		}
+		else
+		{
+            /** Prepare error message */
+            $message = '<ul>';
+
+            foreach ($validator->messages()->all('<li>:message</li>') as $validationError)
+            {
+                $message.=$validationError;
+            }
+
+            $message.='</ul>';
+
+			Session::flash('status', 'danger');
+			Session::flash('message', $message);
+			return Redirect::action('AuthController@showLogin');
+		}
+	}
+
+	private function processLogin(){
+		// Get user record in OLAS database, if it exists
+		$user = User::where('email', Input::get('email'))->first();
+
+		// If user exists in the database AND is authorized
+		if($user and $user->has_access)
+		{
+			// Log in user and direct to main page
+			Auth::login($user);
+
+			// Get last visible AND running term;
+			$semester = Semester::
+				where('is_visible', 1)
+				->where('start', '<=', date('Y-m-d H:i:s'))
+				->orderBy('start', 'DESC')
+				->first();
+
+			Session::forget('current_semester');
+			Session::put('current_semester', $semester);
+
+			// Push into semesters variable
+			$semesters_id = array();
+			$semesters_info = array();
+
+			$semesters_ids[] = $semester->id;
+			$semesters_info[] = $semester->name.' ('.$semester->code.')';
+
+			// Put semesters information arrays into Session
+			Session::forget('semesters_ids');
+			Session::put('semesters_ids', $semesters_ids);
+
+			Session::forget('semesters_info');
+			Session::put('semesters_info', $semesters_info);
+
+			// Record last login
+			User::where('id', Auth::user()->id)
+				->update(array(
+					'last_login' => DB::raw('NOW()')
+				)
+			);
+
+			if(!Auth::user()->office_phone){
+				return Redirect::action('UsersController@edit');
+			}
+
+			// Redirect depending on user
+			switch (Auth::user()->role) {
+				case 1:
+					return Redirect::intended('administrator');
+					break;
+
+				case 2:
+					return Redirect::intended('school-coordinator');
+					break;
+
+				case 3:
+					return Redirect::intended('program-coordinator');
+					break;
+
+				case 4:
+					return Redirect::intended('professor');
+					break;
+			}
+		}
+		else
+		{
+			// Tell user access is denied and return to login page.
+			Session::flash('status', 'danger');
+			Session::flash('message', 'You are not an authorized user. You may request access by contacting oeae.uprrp.edu.');
+			return Redirect::action('AuthController@showLogin');
+		}
+	}
+
+	public function logout()
+	{
+		Auth::logout();
+		Session::flush();
+		return Redirect::action('AuthController@showLogin');
+
+	}
+
+}

app/controllers/BaseController.php

@@ -0,0 +1,18 @@
+<?php
+
+class BaseController extends Controller {
+
+	/**
+	 * Setup the layout used by the controller.
+	 *
+	 * @return void
+	 */
+	protected function setupLayout()
+	{
+		if ( ! is_null($this->layout))
+		{
+			$this->layout = View::make($this->layout);
+		}
+	}
+
+}

app/controllers/Controller.php

@@ -0,0 +1,10 @@
+<?php namespace App\Http\Controllers;
+
+use Illuminate\Routing\Controller as BaseController;
+use Illuminate\Foundation\Validation\ValidatesRequests;
+
+abstract class Controller extends BaseController {
+
+	use ValidatesRequests;
+
+}

app/controllers/CoursesController.php

@@ -0,0 +1,470 @@
+<?php
+
+class CoursesController extends \BaseController {
+
+	/**
+	 * Display the specified resource.
+	 *
+	 * @param  int  $id
+	 * @return Response
+	 */
+	public function show($id)
+	{
+
+		$course = Course::with('semester')->where('id', $id)->first();
+		$title=$course->code.$course->number.'-'.$course->section.' <span class="small attention">('.$course->semester->code.')</span>';
+
+		// If course does not exist, display 404
+		if(!$course)
+            App::abort('404');
+
+        // If course does not belong to the person
+        if ($course->user_id != Auth::id())
+        	App::abort('403', 'Access forbidden.');
+
+		$activities = $course->activities;
+		$students = $course->students;
+
+		$outcomes = Outcome::orderBy('name', 'asc')->get();
+		$outcomes_achieved = json_decode($course->outcomes_achieved, true);
+        $outcomes_attempted = json_decode($course->outcomes_attempted, true);
+
+        // Get active semesters
+        $active_semesters= array();
+        $active_semesters_collection = Semester::select('id')->where('is_visible', 1)->where('start', '<=', date('Y-m-d H:i:s'))->where('end', '>=', date('Y-m-d H:i:s'))->get();
+        foreach ($active_semesters_collection as $active_semester)
+        {
+        	$active_semesters[]=$active_semester->id;
+        }
+
+		return View::make('local.professors.course', compact('title', 'course', 'activities', 'students', 'outcomes', 'outcomes_achieved', 'outcomes_attempted', 'active_semesters'));
+	}
+
+
+
+	/**
+	 * Display the specified course, but with limited information.
+	 *
+	 * @param  int  $id
+	 * @return Response
+	 */
+	public function showLimited($id)
+	{
+		$course = Course::with('semester')->where('id', $id)->first();
+		$students = $course->students;
+		$title=$course->code.$course->number.'-'.$course->section.' <span class="small attention">('.$course->semester->code.')</span>';
+
+		// If course does not exist, display 404
+		if(!$course)
+            App::abort('404');
+
+		$activities = $course->activities;
+		$students = $course->students;
+
+		$outcomes = Outcome::orderBy('name', 'asc')->get();
+		$outcomes_achieved = json_decode($course->outcomes_achieved, true);
+        $outcomes_attempted = json_decode($course->outcomes_attempted, true);
+
+        $schools = School::all();
+
+        $rubrics = array();
+        foreach ($activities as $activity )
+        {
+        	if($activity->rubric_id!=NULL)
+    		{
+    			$rubrics[]=$activity->rubric;
+    		}
+        }
+
+		return View::make('local.managers.shared.limited-course', compact('title', 'course', 'activities', 'students', 'outcomes', 'outcomes_achieved', 'outcomes_attempted', 'schools', 'rubrics', 'students'));
+	}
+
+
+	/**
+	 * Show grouped sections of a course
+	 */
+
+	public function showGrouped($code, $number, $semester_code)
+	{
+        $title=$code.$number.' ('.$semester_code.')';
+        $semester = Semester::where('code', $semester_code)->first();
+        $role = Auth::user()->role;
+
+        $grouped_courses = Course::
+        	where('code', $code)
+        	->where('number', $number)
+        	->where('semester_id', $semester->id)
+        	->groupBy(array('code', 'number'))->get();
+
+        $outcomes = Outcome::orderBy('name', 'asc')->get();
+        $outcomeCount = Outcome::all()->count();
+
+        foreach ($grouped_courses as $index => $grouped_course)
+        {
+            // Blank outcomes for one course
+            $outcomes_achieved = array_fill(1, $outcomeCount, 0);
+            $outcomes_attempted = array_fill(1, $outcomeCount, 0);
+
+            // Find sections for this course
+            $sections = Course::
+            	where('code', $grouped_course->code)
+            	->where('number', $grouped_course->number)
+            	->where('semester_id', $grouped_course->semester_id)
+            	->get();
+
+            // For each of the sections, add the attempted and achieved criteria per outcome
+            foreach ($sections as $section)
+            {
+                if($section->outcomes_achieved!=NULL)
+                {
+                    $section_outcomes_achieved =json_decode($section->outcomes_achieved, true);
+                    $section_outcomes_attempted =json_decode($section->outcomes_attempted, true);
+                    for($i=1; $i<=count($outcomes_attempted); $i++)
+                    {
+                        $outcomes_achieved[$i]+=$section_outcomes_achieved[$i];
+                        $outcomes_attempted[$i]+=$section_outcomes_attempted[$i];
+                    }
+                }
+            }
+        }
+
+        $section_ids = Course::
+        	where('code', $code)
+        	->where('number', $number)
+        	->where('semester_id', $semester->id)
+        	->lists('id');
+
+            $activities = Activity::with('course')->whereNotNull('transforming_actions')->whereIn('course_id', $section_ids)->orderBy('name')->groupBy('transforming_actions')->get();
+
+		return View::make('local.managers.shared.grouped_course', compact('role', 'title', 'grouped_courses', 'outcomes', 'outcomes_attempted', 'outcomes_achieved', 'sections', 'transforming_actions', 'activities'));
+	}
+
+	/**
+	 * Printable version for a course (grouped sections)
+	 */
+
+	public function print_course($code, $number, $semester_code)
+	{
+        $title=$code.$number.' ('.$semester_code.')';
+        $semester = Semester::where('code', $semester_code)->first();
+        $role = Auth::user()->role;
+
+        $grouped_courses = Course::
+        	where('code', $code)
+        	->where('number', $number)
+        	->where('semester_id', $semester->id)
+        	->groupBy(array('code', 'number'))->get();
+
+        $outcomes = Outcome::orderBy('name', 'asc')->get();
+        $outcomeCount = Outcome::all()->count();
+
+        foreach ($grouped_courses as $index => $grouped_course)
+        {
+            // Blank outcomes for one course
+            $outcomes_achieved = array_fill(1, $outcomeCount, 0);
+            $outcomes_attempted = array_fill(1, $outcomeCount, 0);
+
+            // Find sections for this course
+            $sections = Course::
+            	where('code', $grouped_course->code)
+            	->where('number', $grouped_course->number)
+            	->where('semester_id', $grouped_course->semester_id)
+            	->get();
+
+            // For each of the sections, add the attempted and achieved criteria per outcome
+            foreach ($sections as $section)
+            {
+                if($section->outcomes_achieved!=NULL)
+                {
+                    $section_outcomes_achieved =json_decode($section->outcomes_achieved, true);
+                    $section_outcomes_attempted =json_decode($section->outcomes_attempted, true);
+                    for($i=1; $i<=count($outcomes_attempted); $i++)
+                    {
+                        $outcomes_achieved[$i]+=$section_outcomes_achieved[$i];
+                        $outcomes_attempted[$i]+=$section_outcomes_attempted[$i];
+                    }
+                }
+            }
+        }
+
+        $section_ids = Course::
+        	where('code', $code)
+        	->where('number', $number)
+        	->where('semester_id', $semester->id)
+        	->lists('id');
+
+        // Activities with transforming actions
+       	$activities = Activity::with('course')->whereNotNull('transforming_actions')->whereIn('course_id', $section_ids)->orderBy('name')->groupBy('transforming_actions')->get();
+
+		return View::make('local.managers.shared.print_course', compact('role', 'title', 'grouped_courses', 'outcomes', 'outcomes_attempted', 'outcomes_achieved', 'sections', 'activities'));
+	}
+
+
+    private function excelConv(&$value, $key)
+    {
+        Log::debug('CoursesController@excelConv');
+
+        $value = iconv('UTF-8', 'Windows-1252//IGNORE', $value);
+
+    }
+
+
+
+
+    public function exportGrades($id)
+    {
+        // Find course
+        $course = Course::find($id);
+
+        // Set file name and open file
+        $filename = 'olas_student_grades_'.$course->code.$course->number.$course->section.$course->semester->code.'_'.time().'.csv';
+        $file= fopen('exports/'.$filename, 'w');
+
+        // To add an empty line to the csv
+        $empty_line = array(' ');
+
+        // Set section name at the top
+        fputcsv($file, array($course->code.$course->number.$course->section.' ('.$course->semester->code.')'));
+        fputcsv($file, $empty_line);
+
+        // Individual activity tables -----------------------------------------
+
+        // For each activity
+        foreach($course->assessedActivities as $activity) {
+            // Set name
+
+            $activity_name = iconv('UTF-8', 'Windows-1252//IGNORE', $activity->name);
+            fputcsv($file, array($activity_name));
+
+            // Get assessments
+            $assessments = DB::table('assessments')->join('students', 'assessments.student_id','=','students.id')->where('activity_id', '=', $activity->id)->orderBy('assessments.id', 'asc')->get();
+
+            // Get rubric contents
+            $rubric_contents = json_decode($activity->rubric->contents);
+
+            $criterion_list = array('#', 'Name', 'School', 'Major');
+
+            // Set criterion names
+            foreach ($rubric_contents as $criterion) {
+                $criterion_list[] = $criterion->name;
+            }
+            $criterion_list[] = 'Percentage';
+            $criterion_list[] = 'Comments';
+
+            // Change encoding to be compatible with Excel
+            array_walk($criterion_list, array($this,'excelConv'));
+
+            fputcsv($file, $criterion_list);
+
+            // Set student info and scores for each criterion
+            foreach ($assessments as $assessment) {
+                $student = Student::find($assessment->student_id);
+                $scores = json_decode($assessment->scores, true);
+                fputcsv($file, array_merge(
+                    array($student->number, $student->name, $student->school_code, $student->conc_code),
+                    $scores,
+                    array($assessment->percentage, $assessment->comments)));
+            }
+            fputcsv($file, $empty_line);
+        }
+
+        // Table with all activities and grades
+
+        // Set headers for table
+        $activity_list = array('#', 'Name', 'School', 'Major');
+        foreach($course->assessedActivities as $activity) {
+            $activity_list[]=$activity->name;
+        }
+        $activity_list[] = 'Average';
+
+        fputcsv($file, $empty_line);
+        fputcsv($file, array('All Activities'));
+
+        // Change encoding to be compatible with Excel
+        array_walk($activity_list, array($this,'excelConv'));
+
+        fputcsv($file, $activity_list);
+
+        // For each student, set info
+        foreach ($activity->course->students as $student) {
+            $student_record= array($student->number, $student->name, $student->school_code, $student->conc_code);
+
+            $assessed_activities = $course->assessedActivities;
+            // Iterate over activities, get percentages and add them to the record array
+            foreach ($assessed_activities as $activity) {
+                $percentage = DB::table('assessments')
+                    ->select('percentage')
+                    ->where('student_id', '=', $student->id)
+                    ->where('activity_id', '=', $activity->id)->first();
+
+                $student_record[] = $percentage->percentage;
+            }
+
+            // Average
+            $student_record[] = array_sum(
+                                    array_slice(
+                                        $student_record,
+                                        4,
+                                        count($assessed_activities)
+                                    )
+                                )/count($assessed_activities);
+
+            fputcsv($file, $student_record);
+        }
+
+        // Close the file
+        fclose($file);
+
+        // Return response for download
+        return Response::download('exports/'.$filename);
+    }
+
+    public function reassign()
+    {
+        $title = 'Course Management';
+        $programs = Program::with('school')->orderBy('name', 'asc')->get();
+        $users = User::select(array('id', 'first_name', 'surnames'))->orderBy('surnames', 'asc')->orderBy('first_name', 'asc')->get();
+        $semesters = Semester::where('is_visible', '1')->orderBy('start', 'asc')->get();
+        return View::make('local.managers.admins.reassign', compact('title', 'programs', 'users', 'semesters'));
+    }
+
+    public function update()
+    {
+        if(Input::get('reassign_program'))
+        {
+            $code = strtoupper(trim(str_replace('*', '%', Input::get('code'))));
+            $number = strtoupper(trim(str_replace('*', '%', Input::get('number'))));
+            $section = strtoupper(trim(str_replace('*', '%', Input::get('section'))));
+
+            if(!$code && !$number && !$section)
+            {
+                Session::flash('status','danger');
+                Session::flash('message','At least one field is required.');
+
+                return Redirect::back()->withInput();
+            }
+
+            $update_query = Course::orderBy('code', 'asc')->orderBy('number', 'asc')->orderBy('section', 'asc');
+            $fetch_query = Course::orderBy('code', 'asc')->orderBy('number', 'asc')->orderBy('section', 'asc');
+
+            if($code)
+            {
+                $update_query->where('code', 'LIKE', $code);
+                $fetch_query->where('code', 'LIKE', $code);
+            }
+
+            if($number)
+            {
+                $update_query->where('number', 'LIKE', $number);
+                $fetch_query->where('number', 'LIKE', $number);
+            }
+
+            if($section)
+            {
+                $update_query->where('section', 'LIKE', $section);
+                $fetch_query->where('section', 'LIKE', $section);
+            }
+            // If section is blank, results can be grouped by code and number
+            else
+            {
+                $fetch_query->groupBy(array('code', 'number'));
+            }
+
+            $affected_rows = $fetch_query->get();
+
+            // If there are results
+            if(!$affected_rows->isEmpty())
+            {
+                // Try updating and flash success message if successful
+                if($update_query->update(array('program_id'=>Input::get('program'))))
+                {
+                    Session::flash('courses', json_encode($affected_rows));
+                    Session::flash('status', 'success');
+                    Session::flash('message', 'Courses succesfully updated.');
+
+                    if($section)
+                    {
+                        Session::flash('show_sections', true);
+                    }
+
+                }
+                else
+                {
+                    Session::flash('status', 'danger');
+                    Session::flash('message', 'Error reassigning courses to a program. Try again later.');
+                }
+            }
+            else
+            {
+                Session::flash('status', 'warning');
+                Session::flash('message', 'No courses matched your criteria. Try to broaden your search.');
+            }
+
+            return Redirect::back()->withInput();
+        }
+        elseif(Input::get('reassign_professor'))
+        {
+
+            $code = strtoupper(trim(str_replace('*', '%', Input::get('code_prof'))));
+            $number = strtoupper(trim(str_replace('*', '%', Input::get('number_prof'))));
+            $section = strtoupper(trim(str_replace('*', '%', Input::get('section_prof'))));
+            $user = Input::get('user_prof');
+            $semester = Input::get('semester_prof');
+
+
+            if(!$code || !$number || !$section)
+            {
+                Session::flash('status','danger');
+                Session::flash('message','Error assigning professor to a course. All fields are required.');
+
+                return Redirect::back()->withInput();
+            }
+
+            $update_query = Course::
+                where('code', '=', $code)
+                ->where('number', '=', $number)
+                ->where('section', '=', $section)
+                ->where('semester_id', '=', $semester);
+            $fetch_query = Course::
+                where('code', '=', $code)
+                ->where('number', '=', $number)
+                ->where('section', '=', $section)
+                ->orderBy('code', 'asc')
+                ->orderBy('number', 'asc')
+                ->orderBy('section', 'asc');
+
+            $affected_rows = $fetch_query->get();
+
+            // If there are results
+            if(!$affected_rows->isEmpty())
+            {
+                try
+                {
+                    // Try updating and flash success message if successful
+                    $update_query->update(array('user_id'=>$user));
+
+                    Session::flash('status', 'success');
+                    Session::flash('message', 'Successfully changed professor for '.$code.$number.'-'.$section);
+                }
+                catch(Exception $e)
+                {
+                    Session::flash('status', 'danger');
+                    Session::flash('message', 'An error occurred when changing professor for '.$code.$number.'-'.$section).'.';
+                }
+            }
+            else
+            {
+                Session::flash('status', 'warning');
+                Session::flash('message', 'No course matches your criteria. Try again with different values.');
+            }
+
+            return Redirect::back()->withInput();
+        }
+        else
+        {
+
+        }
+    }
+
+
+}

app/controllers/CriteriaController.php

@@ -0,0 +1,397 @@
+<?php
+
+class CriteriaController extends \BaseController {
+
+    /**
+     * Display a listing of the resource.
+     *
+     * @return Response
+     */
+    public function fetchCriterion()
+    {
+        return Criterion::find(Input::get('id'));
+    }
+
+    public function fetchCriterionWithTrashed()
+    {
+        return Criterion::withTrashed()->find(Input::get('id'));
+    }
+
+
+    public function isCriterionUnique($input, $existing_criterion = NULL)
+    {
+        // dd($input);
+        Log::info('isCriterionUnique');
+
+        if(Input::get('program_id')!=0)
+            $program_id = $input['program_id'];
+        else
+            $program_id = NULL;
+
+        $saved_criterion = Criterion::
+            withTrashed()
+            ->where('name', '=', $input['name'])
+            ->where('outcome_id', '=', $input['outcome_id'])
+            ->where('program_id', '=', $program_id)
+            // ->where('description12', '=', $input['description12'])
+            // ->where('description34', '=', $input['description34'])
+            // ->where('description56', '=', $input['description56'])
+            // ->where('description78', '=', $input['description78'])
+            ->first();
+
+    
+
+        if($saved_criterion)
+            return false;
+        else
+            return true;
+    }
+
+    private function cleanInput()
+    {
+        $clean_input = array();
+
+        $clean_input['name'] = trim(preg_replace('/\t+/', '', Input::get('name')));
+
+
+        $trimmed = trim(preg_replace('/\t+/', '', Input::get('subcriteria')));
+
+        Log::info('trimmed 1 -->'.$trimmed.'<--');
+
+
+        if($trimmed ==''){
+            $trimmed = NULL;
+        }
+        else{
+            $trimmed = json_encode(preg_split('/\r\n/', $trimmed));
+        }
+
+        Log::info('trimmed 2 -->'.$trimmed.'<--');
+
+
+        $clean_input['subcriteria'] = $trimmed;
+        $clean_input['outcome_id'] = trim(preg_replace('/\t+/', '', Input::get('outcome_id')));
+        $clean_input['program_id'] = trim(preg_replace('/\t+/', '', Input::get('program_id')));
+        $clean_input['description12'] = trim(preg_replace('/\t+/', '', Input::get('description12')));
+        $clean_input['description34'] = trim(preg_replace('/\t+/', '', Input::get('description34')));
+        $clean_input['description56'] = trim(preg_replace('/\t+/', '', Input::get('description56')));
+        $clean_input['description78'] = trim(preg_replace('/\t+/', '', Input::get('description78')));
+        $clean_input['copyright'] = trim(preg_replace('/\t+/', '', Input::get('copyright')));
+        $clean_input['notes'] = trim(preg_replace('/\t+/', '', Input::get('notes')));
+
+        return $clean_input;
+    }
+
+    private function makeValidator($clean_input)
+    {
+        /** Validation rules */
+        return Validator::make(
+            array(
+                'name' => $clean_input['name'],
+                'subcriteria' => $clean_input['subcriteria'],
+                'outcome_id' => $clean_input['outcome_id'],
+                'description12' => $clean_input['description12'],
+                'description34' => $clean_input['description34'],
+                'description56' => $clean_input['description56'],
+                'description78' => $clean_input['description78'],
+                'notes' => $clean_input['notes'],
+                'copyright' => $clean_input['copyright'],
+            ),
+            array(
+                'name' => 'required|string',
+                'subcriteria' => 'string',
+                'outcome_id' => 'required|numeric|integer',
+                'description12' => 'required|string',
+                'description34' => 'required|string',
+                'description56' => 'required|string',
+                'description78' => 'required|string',
+                'notes' => 'string',
+                'copyright' => 'string',
+            ),
+            array(
+                'description12.required' => 'The Beginning (1-2) field is required.',
+                'description34.required' => 'The In Progress (3-4) field is required.',
+                'description56.required' => 'The Satisfactory (5-6) field is required.',
+                'description78.required' => 'The Excellent (7-8) field is required.',
+            )
+        );
+    }
+
+    /**
+     * Create a new criterion.
+     *
+     * @return Redirect Redirect back to form page
+     */
+    public function create()
+    {
+        $clean_input = $this->cleanInput();
+
+        /** Validation rules */
+        $validator = $this->makeValidator($clean_input);
+
+        /** If validation fails */
+        if ($validator->fails())
+        {
+            /** Prepare error message */
+            $message = '<p>Error(s) creating a new Criterion:</p><ul>';
+
+            foreach ($validator->messages()->all('<li>:message</li>') as $validationError)
+            {
+                $message.=$validationError;
+            }
+
+            $message.='</ul>';
+
+            /** Send error message and old data */
+            Session::flash('status', 'danger');
+            Session::flash('message', $message);
+            return Redirect::to('criteria')->withInput();
+        }
+        else
+        {
+            // Check criterion uniqueness
+            if(!$this->isCriterionUnique($clean_input))
+            {
+                /** Send error message and old data */
+                Session::flash('status', 'danger');
+                Session::flash('message', 'This criterion is a duplicate of an already saved criterion because its name and associated program are the same.');
+                return Redirect::to('criteria')->withInput();
+            }
+
+            /** Instantiate new criterion */
+            $criterion = new Criterion;
+            $criterion->name= $clean_input['name'];
+            $criterion->subcriteria = $clean_input['subcriteria'];
+            $criterion->outcome_id= $clean_input['outcome_id'];
+            $criterion->description12 = $clean_input['description12'];
+            $criterion->description34 = $clean_input['description34'];
+            $criterion->description56 = $clean_input['description56'];
+            $criterion->description78 = $clean_input['description78'];
+
+            if(Input::get('copyright'))
+                $criterion->copyright = $clean_input['copyright'];
+
+            if(Input::get('notes'))
+                $criterion->notes = $clean_input['notes'];
+
+            // Set program
+            if(Input::get('program_id')!=0)
+                $criterion->program_id = $clean_input['program_id'];
+            else
+                $criterion->program_id = NULL;
+
+
+            /** If criterion is saved, send success message */
+            if($criterion->save())
+            {
+                Session::flash('status', 'success');
+                Session::flash('message', 'Criterion created: "'.$criterion->name.'".');
+                return Redirect::to('criteria')->withInput(Input::only('outcome_id'));
+            }
+
+            /** If saving fails, send error message and old data */
+            else
+            {
+                Session::flash('status', 'danger');
+                Session::flash('message', '<p>Error creating Criterion. Please try again later.</p>');
+                return Redirect::to('learning-outcomes-criteria')->withInput();
+            }
+        }
+    }
+
+    public function edit()
+    {
+        $title = "Criteria";
+        $outcomes = Outcome::orderBy('name', 'ASC')->get();
+        $schools = School::orderBy('name', 'ASC')->get();
+        $criteria = Criterion::withTrashed()->orderBy('name', 'ASC')->get();
+        $programs = Program::orderBy('name', 'ASC')->get();
+
+        return View::make('local.managers.admins.criteria', compact('title', 'outcomes', 'schools', 'criteria', 'programs'));
+    }
+
+    public function update()
+    {
+        $criterion = Criterion::withTrashed()->find(Input::get('id'));
+
+        $clean_input = $this->cleanInput();
+
+        /** Validation rules */
+        $validator = $this->makeValidator($clean_input);
+
+        /** If validation fails */
+        if ($validator->fails())
+        {
+            /** Prepare error message */
+            $message = 'Error(s) updating the Criterion: <ul>';
+
+            foreach ($validator->messages()->all('<li>:message</li>') as $validationError)
+            {
+                $message.=$validationError;
+            }
+
+            $message.='</ul>';
+
+            /** Send error message and old data */
+            Session::flash('status', 'danger');
+            Session::flash('message', $message);
+            return Redirect::back()->withInput();
+        }
+        else
+        {
+
+            // // Check criterion uniqueness
+            // if(!$this->isCriterionUnique($clean_input, $criterion))
+            // {
+            //     /** Send error message and old data */
+            //     Session::flash('status', 'danger');
+            //     Session::flash('message', 'This criterion is a duplicate of an already saved criterion because its name, assoaciated school or program, and progress indicators are the same.');
+            //     return Redirect::to('criteria')->withInput();
+            // }
+
+            /** Set info */
+            $criterion->name= $clean_input['name'];
+            $criterion->subcriteria = $clean_input['subcriteria'];
+            $criterion->outcome_id= $clean_input['outcome_id'];
+            $criterion->description12 = $clean_input['description12'];
+            $criterion->description34 = $clean_input['description34'];
+            $criterion->description56 = $clean_input['description56'];
+            $criterion->description78 = $clean_input['description78'];
+
+            // Set program
+            if(Input::get('program_id')!=0)
+                $criterion->program_id = Input::get('program_id');
+            else
+                $criterion->program_id = NULL;
+
+            // Set status
+            if(Input::get('status')==0)
+                $criterion->deleted_at = date('Y-m-d H:i:s');
+            else
+                $criterion->deleted_at = NULL;
+
+            if(Input::get('copyright'))
+                $criterion->copyright = $clean_input['copyright'];
+            else
+                $criterion->copyright=NULL;
+
+            if(Input::get('notes'))
+                $criterion->notes = $clean_input['notes'];
+            else
+                $criterion->notes=NULL;
+
+            /** If criterion is updated, send success message */
+            if($criterion->save())
+            {
+                Session::flash('status', 'success');
+                Session::flash('message', 'Updated criterion: "'.$criterion->name.'"');
+                return Redirect::back();
+            }
+
+            /** If saving fails, send error message and old data */
+            else
+            {
+                Session::flash('status', 'danger');
+                Session::flash('message', 'Error updating the Criterion. Please try again later.');
+                return Redirect::back()->withInput();
+            }
+        }
+    }
+
+    public function index()
+    {
+        $title = "Learning Outcomes and Criteria";
+        $outcomes = Outcome::orderBy('name', 'ASC')->get();
+        $schools = School::orderBy('name', 'ASC')->get();
+        $criteria = Criterion::withTrashed()->orderBy('name', 'ASC')->get();
+
+        return View::make('global.view-learning-outcomes-criteria', compact('title', 'outcomes', 'schools', 'criteria'));
+
+    }
+
+    public function destroy()
+    {
+        $criterion = Criterion::withTrashed()->find(Input::get('id'));
+        if(!$criterion->trashed())
+        {
+            try
+            {
+                $criterion->delete();
+                Session::flash('status', 'success');
+                Session::flash('message', 'Deactivated criterion: "'.$criterion->name.'"');
+            }
+            catch (Exception $e)
+            {
+                Session::flash('status', 'danger');
+                Session::flash('message', 'Error deactivating criterion."'.$criterion->name.'"');
+            }
+            return Redirect::back();
+        }
+        else
+        {
+            try
+            {
+                $criterion->restore();
+                Session::flash('status', 'success');
+                Session::flash('message', 'Reactivated criterion: "'.$criterion->name.'"');
+            }
+            catch (Exception $e)
+            {
+                Session::flash('status', 'danger');
+                Session::flash('message', 'Error reactivating criterion: "'.$criterion->name.'".');
+            }
+            return Redirect::back();
+
+        }
+    }
+
+    public function filterCriteria()
+    {
+        switch (Input::get('filter'))
+        {
+            case 'all':
+                return Criteria::all();
+                break;
+
+            case 'school':
+                // If scoord
+                if(Auth::user()->role == '2')
+                {
+
+                    // Fetch all the programs whose school is the user's
+                    $program_ids = DB::table('programs')->where('school_id', Auth::user()->school_id)->lists('id');
+
+                    // Return all criteria belonging to any of those programs
+                    return Criterion::
+                        whereIn('program_id', $program_ids)
+                        ->orderBy('name', 'ASC')
+                        ->get();
+                }
+
+                // If pcoord
+                else
+                {
+                    // Fetch all the programs from the user's school;
+                    $program_ids = DB::table('programs')->where('school_id', Auth::user()->programs[0]->school->id)->lists('id');
+
+                    return Criterion::
+                        whereIn('program_id', $program_ids)
+                        ->orderBy('name', 'ASC')
+                        ->get();
+                }
+
+                break;
+
+            case 'program':
+                return Criterion::
+                    whereIn('program_id', Auth::user()->programs->lists('id'))
+                    ->orderBy('name', 'ASC')
+                    ->get();
+                break;
+
+            default:
+                return Criteria::all();
+                break;
+        }
+    }
+}

app/controllers/FeedbackController.php

@@ -0,0 +1,93 @@
+<?php
+
+class FeedbackController extends \BaseController {
+
+	/**
+	 * Show the form for creating a new resource.
+	 *
+	 * @return Response
+	 */
+	public function create()
+	{
+		$title = "Feedback Form";
+		$schools = School::orderBy('name','asc');
+		$user = Auth::user();
+		return View::make('global.feedback', compact('title', 'schools', 'user'));
+	}
+
+	public function send()
+	{
+        /** Validation rules */
+        $validator = Validator::make(
+            array(
+                'type' => Input::get('type'),
+                'email' => Input::get('email'),
+                'comment' => Input::get('comment')
+            ),
+            array(
+                'type' => 'required|numeric|integer',
+                'email' => 'required|email',
+                'comment' => 'required'
+            )
+        );
+
+        /** If validation fails */
+        if ($validator->fails())
+        {
+            /** Prepare error message */
+            $message = '<p>Error(s) in the form</p><ul>';
+
+            foreach ($validator->messages()->all('<li>:message</li>') as $validationError)
+            {
+                $message.=$validationError;
+            }
+
+            $message.='</ul>';
+
+            /** Send error message and old data */
+            Session::flash('status', 'warning');
+            Session::flash('message', $message);
+            return Redirect::back()->withInput();
+        }
+        else
+        {
+        	$data = array('type'=>'', 'comment'=>'', 'email'=>'');
+        	$data['comment']=Input::get('comment');
+        	$data['email']=Input::get('email');
+
+        	switch (Input::get('type')) {
+        		case '0':
+        			$data['type']='Error Report';
+        			break;
+
+        		case '1':
+        			$data['type']='Question';
+        			break;
+
+        		case '2':
+        			$data['type']='Suggestion';
+        			break;
+
+        		case '3':
+        			$data['type']='Other';
+        			break;
+
+        		default:
+        			$data['type']='Other';
+        			break;
+        	}
+
+          	Mail::send('emails.feedback-email-copy', $data, function($message){
+        		$message
+        		->to(Input::get('email'), Auth::user()->first_name.' '.Auth::user()->surnames)
+                ->cc('oeae.uprrp@upr.edu')
+        		->subject('Feedback for OLAS');
+    		});
+
+            Session::flash('status', 'success');
+            Session::flash('message', '<p>Success! Check your email for a copy of your message. Thank you for your feedback. </p>');
+            return Redirect::back();
+        }
+	}
+
+}

app/controllers/FiveYearPlansController.php

@@ -0,0 +1,568 @@
+<?php
+
+class FiveYearPlansController extends \BaseController {
+
+	/**
+	 * Checks whether a user has permission to view a page in this controller
+	 *
+	 * @var User $user				Authenticated user
+	 */
+	private function userHasAccess($program_id)
+	{
+		$user = Auth::user();
+
+		switch ($user->role) {
+			case '3':
+				$programs = $user->programs->lists('id');
+
+				// If program does not belong to user, show 403
+				if(!in_array($program_id, $programs))
+					return false;
+
+				break;
+
+			case '2':
+				$programs = Program::where('school_id', $user->school_id)->lists('id');
+
+				// If program is not in user's school, show 403
+				if(!in_array($program_id, $programs))
+					return false;
+
+				break;
+			case '4':
+				return false;
+		}
+
+		return true;
+	}
+
+	/**
+	 * Page to create a new plan for the current quinquennium
+	 * @var string $title			Title for page
+	 * @var Program $programs	Collection of programs user has access to
+	 * @var Outcome $outcomes      List of outcomes ordered by name
+	 * @var User $user      Currently logged user
+	 * @var Course $courses      Courses for a particular program
+	 */
+	public function create(Program $program)
+	{
+		$title = 'New Five Year Plan for '.$program->name;
+		$user = Auth::user();
+		$outcomes = Outcome::orderBy('name')->get();
+
+		$current_quinquennium = Quinquennium::
+			where('start_date', '<=', date('Y-m-d'))
+			->where('end_date', '>=', date('Y-m-d'))
+			->first();
+
+		$courses = Course::
+			select('id', 'code', 'number', 'name')
+			->where('program_id', $program->id)
+			->groupBy('name')
+			->orderBy('code','ASC')
+			->orderBy('number','ASC')
+			->orderBy('name','ASC')
+			->get();
+
+		// Check if user can create a plan
+		if(!$this->userHasAccess($program->id))
+		{
+			return View::make('global.403');
+		}
+
+		return View::make('local.managers.shared.create_five_year_plan', compact('title', 'program', 'current_quinquennium', 'outcomes', 'courses'));
+	}
+
+	/**
+	 * Lists five year plans by quinquennium and program
+	 * @var string $title			Title for page
+	 * @var Program $programs	Collection of programs user has access to
+	 * @var User $user				Authenticated user
+	 */
+	public function index()
+	{
+		$title = 'Five Year Plans';
+		$user = Auth::user();
+		$quinquenniums = Quinquennium::all();
+		$current_quinquennium = Quinquennium::
+			where('start_date', '<=', date('Y-m-d'))
+			->where('end_date', '>=', date('Y-m-d'))
+			->first();
+
+		switch ($user->role) {
+			case '1':
+				$programs = Program::all();
+				break;
+			case '2':
+				$programs = Program::where('school_id', $user->school_id)->get();
+				break;
+			case 3:
+				$programs = $user->programs;
+				break;
+			default:
+				App::abort('404');
+				break;
+		}
+
+		return View::make('local.managers.shared.index_five_year_plans', compact('title', 'quinquenniums', 'programs', 'current_quinquennium'));
+	}
+
+	/**
+	 * Processes and stores five year plan for a particular program
+	 *
+	 * @var array $input			JSON object containing new plan information
+	 * @var FiveYearPlan $plan			Instance of newly created plan
+	 * @var FypPart $mini_plan			Instance of limited annual plan belonging to five year plan
+	 * @var string response			Encoded JSON string containing response for the browser
+	 * @return string 			Encoded JSON string
+	 */
+	public function store()
+	{
+		header('Content-Type: application/json');
+
+		$input = json_decode(Input::get('five_year_plan')); // Get plan as string
+
+		DB::beginTransaction();
+
+		try {
+
+			// Create five year plan base structure
+			$plan = FiveYearPlan::create(array(
+					'program_id' => $input->program_id,
+					'quinquennium_id' => $input->quinquennium_id,
+				)
+			);
+
+			foreach ($input->mini_plans as $mini_plan_input) {
+
+				$mini_plan_validator = Validator::make(
+				    array(
+				        'year_start' => $mini_plan_input->year_start,
+						'year_end' => $mini_plan_input->year_end
+				    ),
+				    array(
+				        'year_start' => 'required|integer|digits:4',
+				        'year_end' => 'required|integer|digits:4'
+				    )
+				);
+
+				/** If validation fails */
+				if ($mini_plan_validator->fails())
+				{
+				    $response = array(
+						'status' => 'danger',
+					);
+				}
+
+
+				$mini_plan = FypPart::create(array(
+						'five_year_plan_id' => $plan->id,
+						'year_start' => $mini_plan_input->year_start,
+						'year_end' => $mini_plan_input->year_end,
+					)
+				);
+
+				foreach ($mini_plan_input->outcomes as $index => $outcome_input) {
+
+					$outcomes_validator = Validator::make(
+					    array(
+					        'fyp_part_id'=> $mini_plan->id,
+					        'outcome_id'=> $outcome_input->id,
+					        'objectives'=> json_encode($outcome_input->objectives),
+					        'courses'=> json_encode($outcome_input->courses),
+					    ),
+					    array(
+					        'fyp_part_id'=> 'required|integer',
+					        'outcome_id'=> 'required|integer',
+					        'objectives'=> 'required',
+					        'courses'=> 'required',
+					    )
+					);
+
+					/** If validation fails */
+					if ($outcomes_validator->fails())
+					{
+					    $response = array(
+							'status' => 'danger',
+						);
+					}
+
+					FypPartOutcome::create(array(
+							'fyp_part_id'=> $mini_plan->id,
+							'outcome_id'=> $outcome_input->id,
+							'objectives'=> json_encode($outcome_input->objectives),
+							'courses'=> json_encode($outcome_input->courses),
+							'display_order'=> $index + 1,
+						)
+					);
+				}
+			}
+
+
+			DB::commit();
+
+			Session::flash('status', 'success');
+			Session::flash('message', 'Five Year Plan created. You can review it below. Click the Edit button if you want to make any changes. To submit your plan, click the Submit button. Please note that submitted plans are final.');
+
+			$response = array(
+				'status' => 'success',
+				'message' => $input->quinquennium_id,
+				'redirect_url' => URL::action('FiveYearPlansController@show', array('program'=> $plan->program_id, 'five_year_plan'=> $plan->id))
+			);
+
+			echo json_encode($response);
+			return;
+
+		} catch (Exception $e) {
+
+			DB::rollBack();
+
+			$response = array(
+				'status' => 'danger',
+				'message' => $e->getMessage()
+			);
+
+			echo json_encode($response);
+
+		}
+	}
+
+
+	/**
+	 * Shows five year plan
+	 *
+	 * @param Program $program			Program to which the plan belongs to
+	 * @param FiveYearPlan $plan			An instance of the Five Year Plan to show
+	 * @var string $quinquennium_start_date		Year when the quinquennium starts
+	 * @var string $quinquennium_end_date		Year when the quinquennium ends
+	 * @var string title			Title of the page
+	 * @var Program $programs			Logged user's program(s)
+	 * @var Outcome $outcomes			List of all outcomes
+	 */
+	public function show(Program $program, FiveYearPlan $plan)
+	{
+
+		$outcomes = Outcome::orderBy('name')->get();
+
+		$quinquennium_start_date = date('Y', strtotime($plan->quinquennium->start_date));
+		$quinquennium_end_date = date('Y', strtotime($plan->quinquennium->end_date));
+
+		$title = $quinquennium_start_date.'-'.$quinquennium_end_date.' Five Year Plan for '.$program->name;
+
+		// Check if user can create a plan
+		if(!$this->userHasAccess($program->id))
+		{
+			return View::make('global.403');
+		}
+
+		return View::make('local.managers.shared.show_five_year_plan', compact('title', 'program', 'plan', 'outcomes'));
+	}
+
+	/**
+	 * Page to edit a plan for the current quinquennium
+	 * @var string $title			Title for page
+	 * @var Program $programs	Collection of programs user has access to
+	 * @var User $user				Authenticated user
+	 */
+	public function edit(Program $program, FiveYearPlan $plan)
+	{
+		$title = 'Edit Five Year Plan for '.$program->name;
+		$user = Auth::user();
+		$outcomes = Outcome::orderBy('name')->get();
+
+		$current_quinquennium = Quinquennium::
+			where('start_date', '<=', date('Y-m-d'))
+			->where('end_date', '>=', date('Y-m-d'))
+			->first();
+
+		$courses = Course::
+			select('id', 'code', 'number', 'name')
+			->where('program_id', $program->id)
+			->groupBy('name')
+			->orderBy('code','ASC')
+			->orderBy('number','ASC')
+			->orderBy('name','ASC')
+			->get();
+
+		// Check if user can create a plan
+		if(!$this->userHasAccess($program->id))
+		{
+			return View::make('global.403');
+		}
+
+		return View::make('local.managers.shared.edit_five_year_plan', compact('title', 'program', 'current_quinquennium', 'outcomes', 'courses', 'plan'));
+	}
+
+	/**
+	 * Processes and stores five year plan for a particular program
+	 *
+	 * @var array $input			JSON object containing new plan information
+	 * @var FiveYearPlan $plan			Instance of newly created plan
+	 * @var FypPart $mini_plan			Instance of limited annual plan belonging to five year plan
+	 * @var string response			Encoded JSON string containing response for the browser
+	 * @return string 			Encoded JSON string
+	 */
+	public function update()
+	{
+		if(Input::get('submit'))
+		{
+
+		}
+		elseif(Input::get('revert'))
+		{
+
+		}
+		else
+		{
+			header('Content-Type: application/json');
+
+			$input = json_decode(Input::get('five_year_plan')); // Get plan as string
+
+			DB::beginTransaction();
+
+			try {
+
+				$plan = FiveYearPlan::find($input->plan_id);
+				$plan->updated_at = date('Y-m-d H:i:s');
+				$plan->save();
+
+				// Delete all annual (mini) plans and consequently, all their outcomes
+				FypPart::where('five_year_plan_id', $plan->id)->delete();
+
+				foreach ($input->mini_plans as $mini_plan_input) {
+
+					$mini_plan_validator = Validator::make(
+					    array(
+					        'year_start' => $mini_plan_input->year_start,
+							'year_end' => $mini_plan_input->year_end
+					    ),
+					    array(
+					        'year_start' => 'required|integer|digits:4',
+					        'year_end' => 'required|integer|digits:4'
+					    )
+					);
+
+					/** If validation fails */
+					if ($mini_plan_validator->fails())
+					{
+					    $response = array(
+							'status' => 'danger',
+						);
+					}
+
+
+					$mini_plan = FypPart::create(array(
+							'five_year_plan_id' => $plan->id,
+							'year_start' => $mini_plan_input->year_start,
+							'year_end' => $mini_plan_input->year_end,
+						)
+					);
+
+					foreach ($mini_plan_input->outcomes as $index => $outcome_input) {
+
+						$outcomes_validator = Validator::make(
+						    array(
+						        'fyp_part_id'=> $mini_plan->id,
+						        'outcome_id'=> $outcome_input->id,
+						        'objectives'=> json_encode($outcome_input->objectives),
+						        'courses'=> json_encode($outcome_input->courses),
+						    ),
+						    array(
+						        'fyp_part_id'=> 'required|integer',
+						        'outcome_id'=> 'required|integer',
+						        'objectives'=> 'required',
+						        'courses'=> 'required',
+						    )
+						);
+
+						/** If validation fails */
+						if ($outcomes_validator->fails())
+						{
+						    $response = array(
+								'status' => 'danger',
+							);
+						}
+
+						FypPartOutcome::create(array(
+								'fyp_part_id'=> $mini_plan->id,
+								'outcome_id'=> $outcome_input->id,
+								'objectives'=> json_encode($outcome_input->objectives),
+								'courses'=> json_encode($outcome_input->courses),
+								'display_order'=> $index + 1,
+							)
+						);
+					}
+				}
+
+
+				DB::commit();
+
+				Session::flash('status', 'success');
+				Session::flash('message', 'Five Year Plan updated.');
+
+				$response = array(
+					'status' => 'success',
+					'message' => $input->quinquennium_id,
+					'redirect_url' => URL::action('FiveYearPlansController@show', array('program'=> $plan->program_id, 'five_year_plan'=> $plan->id))
+				);
+
+				echo json_encode($response);
+				return;
+
+			} catch (Exception $e) {
+
+				DB::rollBack();
+
+				$response = array(
+					'status' => 'danger',
+					'message' => $e->getMessage().' '.$e->getLine()
+				);
+
+				echo json_encode($response);
+
+			}
+		}
+	}
+
+
+	public function msWord(FiveYearPlan $plan)
+	{
+		try {
+
+			$filename = 'OLAS Five Year Plan for '.$plan->program->name.' ('.date('d-m-Y').').docx';
+			require_once 'PHPWord-0.12.1/src/PhpWord/Autoloader.php';
+			\PhpOffice\PhpWord\Autoloader::register();
+
+			// Instantiate new document
+			$phpWord = new \PhpOffice\PhpWord\PhpWord();
+
+			// -----------------
+
+
+			// $styleTable = array(
+			// 	'borderColor'=>'006699',
+			   //           	'borderSize'=>6,
+			   //          	'cellMargin'=>50);
+			// $styleFirstRow = array('bgColor'=>'DD0026');
+			// $phpWord->addTableStyle('table', $styleTable, $styleFirstRow);
+
+			/* Note: any element you append to a document must reside inside of a Section. */
+
+			// // Adding an empty Section to the document...
+			// $section = $phpWord->addSection();
+
+
+			// $table = $section->addTable('table');
+			// $table->addRow(3);
+			// $table->addCell(3300)->addText("Col 1");
+			// $table->addCell(3300)->addText("Col 2");
+			// $table->addCell(3300)
+			// ->addTable('table')
+			// ->addRow(2)->addCell(3300)
+			// ->addText("Col 1");
+
+			// ----------------
+
+
+			// Add new section. All elements must be inside a section
+			$section_style = array(
+			    'orientation' => 'landscape',
+			    'lineNumbering' => array(
+			    	'start' => 1
+			    ),
+			);
+			$section = $phpWord->addSection($section_style);
+
+
+			// Table styles
+			$table_styles = $tableStyle = array(
+			    'borderColor' => 'd0d0d0',
+			    'borderSize'  => 6,
+			    'cellMargin'  => 500
+			);
+			$header_styles = array(
+				'bgColor' => 'FDFBE2',
+				'valign' => 'center',
+				'bold' => true,
+			);
+
+			$first_column_styles = array(
+				'bgColor' => 'F5F5F5',
+				'valign' => 'center',
+				'bold' => true,
+			);
+
+			$rowspan_restart = array('vMerge' => 'restart');
+			$rowspan_continue = array('vMerge' => 'continue');
+
+
+			foreach($plan->fypParts as $number => $mini_plan)
+			{
+				$table = $section->addTable('table'.$number, $table_styles);
+
+				// Header row
+				$table->addRow(700, array('exactHeight'=>true));
+				$table->addCell(3300, $header_styles)->addText("Academic Year");
+				$table->addCell(3300, $header_styles)->addText("Learning Outcome to be assessed");
+				$table->addCell(3300, $header_styles)->addText("Learning Objectives");
+				$table->addCell(3300, $header_styles)->addText("Courses to use for assessment");
+
+				// Body
+				foreach($mini_plan->fypPartOutcomes as $index => $outcome)
+				{
+					$table->addRow();
+
+					// If outcome is the first, include multi-row year column
+					if($index == 0)
+					{
+						$table->addCell(3300, array_merge($first_column_styles, $rowspan_restart))->addText($mini_plan->year_start.'-'.$mini_plan->year_end);
+					}
+					else
+					{
+						$table->addCell(3300, array_merge($first_column_styles, $rowspan_continue))->addText('');
+					}
+
+					// Outcome name
+					$table->addCell(3300)->addText($outcome->outcome->name);
+
+					// Objectives
+					$cell = $table->addCell(3300);
+
+					foreach(json_decode($outcome->objectives) as $objective)
+					{
+						$cell->addText('• '.$objective->text);
+					}
+
+					// Courses
+					$cell = $table->addCell(3300);
+
+					foreach(json_decode($outcome->courses) as $course)
+					{
+						$cell->addText(trim('• '.$course->code.$course->number.': '.$course->name));
+					}
+				}
+
+				$section->addTextBreak(2);
+			}
+
+
+
+			// Saving the document as OOXML file...
+			$objWriter = \PhpOffice\PhpWord\IOFactory::createWriter($phpWord, 'Word2007');
+
+
+			$objWriter->save('exports/'.$filename);
+
+			return Response::download('exports/'.$filename);
+
+		}
+		catch(Exception $e)
+		{
+			Session::flash('status', 'danger');
+			Session::flash('message', 'An error occurred while generating the document. Try again later or contact an administrator.');
+
+			return Redirect::back();
+		}
+	}
+
+}

app/controllers/HomeController.php

@@ -0,0 +1,112 @@
+<?php
+
+class HomeController extends BaseController {
+
+	/*
+	|--------------------------------------------------------------------------
+	| Default Home Controller
+	|--------------------------------------------------------------------------
+	|
+	| You may wish to use controllers instead of, or in addition to, Closure
+	| based routes. That's great! Here is an example controller method to
+	| get you started. To route to this controller, just add the route:
+	|
+	|	Route::get('/', 'HomeController@showWelcome');
+	|
+	*/
+
+	public function showWelcome()
+	{
+		try {
+			require_once 'PHPWord-0.12.1/src/PhpWord/Autoloader.php';
+			\PhpOffice\PhpWord\Autoloader::register();
+
+			// Creating the new document...
+			$phpWord = new \PhpOffice\PhpWord\PhpWord();
+
+			$styleTable = array('borderColor'=>'006699',
+              'borderSize'=>6,
+              'cellMargin'=>50);
+			$styleFirstRow = array('bgColor'=>'66BBFF');
+			$phpWord->addTableStyle('myTable', $styleTable, $styleFirstRow);
+
+			/* Note: any element you append to a document must reside inside of a Section. */
+
+			// Adding an empty Section to the document...
+			$section = $phpWord->addSection();
+			// Adding Text element to the Section having font styled by default...
+			$section->addText(
+			    htmlspecialchars(
+			        '"Learn from yesterday, live for today, hope for tomorrow. '
+			            . 'The important thing is not to stop questioning." '
+			            . '(Albert Einstein)'
+			    )
+			);
+
+			$table = $section->addTable('myTable');
+			$table->addRow(3);
+			$table->addCell(1200)->addText("Col 1");
+			$table->addCell(1200)->addText("Col 2");
+			$table->addCell(1200)
+			->addTable('myTable')
+			->addRow(2)->addCell(1200)
+			->addText("Col 1");
+
+			/*
+			 * Note: it's possible to customize font style of the Text element you add in three ways:
+			 * - inline;
+			 * - using named font style (new font style object will be implicitly created);
+			 * - using explicitly created font style object.
+			 */
+
+			// Adding Text element with font customized inline...
+			$section->addText(
+			    htmlspecialchars(
+			        '"Great achievement is usually born of great sacrifice, '
+			            . 'and is never the result of selfishness." '
+			            . '(Napoleon Hill)'
+			    ),
+			    array('name' => 'Tahoma', 'size' => 10)
+			);
+
+
+			// Adding Text element with font customized using named font style...
+			$fontStyleName = 'oneUserDefinedStyle';
+			$phpWord->addFontStyle(
+			    $fontStyleName,
+			    array('name' => 'Tahoma', 'size' => 10, 'color' => '1B2232', 'bold' => true)
+			);
+			$section->addText(
+			    htmlspecialchars(
+			        '"The greatest accomplishment is not in never falling, '
+			            . 'but in rising again after you fall." '
+			            . '(Vince Lombardi)'
+			    ),
+			    $fontStyleName
+			);
+
+
+			// Adding Text element with font customized using explicitly created font style object...
+			$fontStyle = new \PhpOffice\PhpWord\Style\Font();
+			$fontStyle->setBold(true);
+			$fontStyle->setName('Tahoma');
+			$fontStyle->setSize(13);
+			$myTextElement = $section->addText(
+			    htmlspecialchars('"Believe you can and you\'re halfway there." (Theodor Roosevelt)')
+			);
+			$myTextElement->setFontStyle($fontStyle);
+
+			// Saving the document as OOXML file...
+			$objWriter = \PhpOffice\PhpWord\IOFactory::createWriter($phpWord, 'Word2007');
+			
+
+			$objWriter->save('helloWorld2.docx');
+
+			return Response::download('helloWorld2.docx');
+			
+		}
+		catch(Exception $e)
+		{
+		}
+	}
+}

app/controllers/ObjectivesController.php

@@ -0,0 +1,237 @@
+<?php
+
+class ObjectivesController extends \BaseController {
+
+    /**
+     * Display a listing of the resource.
+     *
+     * @return Response
+     */
+    public function fetch()
+    {
+        try
+        {
+            $outcome_id = Input::get('outcome_id');
+            $program_id = Input::get('program_id');
+            $format = Input::get('format');
+
+
+            $objectives = Objective::select('id', 'outcome_id', 'program_id', 'text');
+
+            if($outcome_id)
+            {
+                $objectives->where('outcome_id', $outcome_id);
+            }
+
+            if($program_id)
+            {
+                $objectives->where('program_id', $program_id);
+            }
+
+            if($format == 'select')
+            {
+                $string = '';
+                foreach ($objectives->get() as $objective)
+                {
+                    $string.='<option value="'.$objective->id.'">'.$objective->text.'</option>';
+                }
+
+                echo $string;
+                return;
+            }
+            else
+            {
+                return $objectives->get();
+            }
+        }
+        catch (Exception $e)
+        {
+            echo $e->getMessage();
+            return;
+        }
+
+    }
+
+  /**
+   * Edit the learning objectives per learning outcome for a program
+   */
+  public function index($program)
+  {
+    $role = Auth::user()->role;
+
+    // Redirect users if they try to access forbidden page
+  	if($role == 2 && $program->school_id != Auth::user()->school_id)
+  	{
+		return Redirect::to('/');
+  	}
+  	else if($role == 3 && !in_array($program->id, Auth::user()->programs->lists('id')))
+  	{
+		return Redirect::to('/');
+  	}
+  	else if($role == 4)
+  	{
+		return Redirect::to('/');
+  	}
+
+    $title = 'Learning Objectives ('.$program->name.')';
+    $objectives = $program->objectives;
+
+    // Eager load outcomes related to objectives
+    // $program->load('outcomes');
+    //
+    $outcomes = Outcome::select('id', 'name')->get();
+
+    return View::make('local.managers.shared.objectives.index', compact('title', 'objectives', 'role', 'program', 'outcomes'));
+  }
+
+  public function create()
+  {
+    try
+    {
+      $outcome_id = Input::get('outcome_id');
+      $program_id = Input::get('program_id');
+      $learning_objective = trim(Input::get('learning_objective'));
+
+
+      $validator = Validator::make(
+          array(
+              'outcome_id' => $outcome_id,
+              'program_id' => $program_id,
+              'learning_objective' => $learning_objective
+          ),
+          array(
+              'outcome_id' => 'required|integer',
+              'program_id' => 'required|integer',
+              'learning_objective' => 'required|min:1',
+          )
+      );
+
+      if($validator->fails())
+      {
+        /** Prepare error message */
+        $message = '<p>Error(s) creating a new Learning Objective: </p><ul>';
+
+        foreach ($validator->messages()->all('<li>:message</li>') as $validationError)
+        {
+            $message.=$validationError;
+        }
+
+        $message.='</ul>';
+
+        /** Send error message and old data */
+        Session::flash('status', 'danger');
+        Session::flash('message', $message);
+        return Redirect::back()->withInput();
+      }
+
+      DB::table('objectives')->insert(array(
+        'outcome_id' => $outcome_id,
+        'program_id' => $program_id,
+        'text' => $learning_objective
+      ));
+
+      /** Send success message */
+        Session::flash('status', 'success');
+        Session::flash('message', 'New Learning Objective successfully created.');
+        return Redirect::back();
+    }
+    catch(Exception $e)
+    {
+      /** Send error message and old data */
+        Session::flash('status', 'danger');
+        Session::flash('message', 'An error ocurred trying to create a new Learning Objective. Please try again later.'.$e->getMessage());
+        return Redirect::back()->withInput();
+    }
+  }
+
+  /**
+   * Update objective
+   */
+  public function update()
+  {
+    try
+    {
+      $outcome_id = Input::get('edit_outcome_id');
+      $objective_id = Input::get('edit_objective_id');
+      $active = Input::get('edit_active');
+      $learning_objective = trim(Input::get('edit_learning_objective'));
+
+      $validator = Validator::make(
+          array(
+            'outcome_id' => $outcome_id,
+            'objective_id' => $objective_id,
+            'active' => $active,
+            'learning_objective' => $learning_objective
+          ),
+          array(
+            'outcome_id' => 'required|integer',
+            'objective_id' => 'required|integer',
+            'active' => 'required|integer|boolean',
+            'learning_objective' => 'required|min:1',
+          )
+      );
+
+      if($validator->fails())
+      {
+        /** Prepare error message */
+        $message = '<p>Error(s) updating the Learning Objective: </p><ul>';
+
+        foreach ($validator->messages()->all('<li>:message</li>') as $validationError)
+        {
+            $message.=$validationError;
+        }
+
+        $message.='</ul>';
+
+        /** Send error message and old data */
+        Session::flash('status', 'danger');
+        Session::flash('message', $message);
+        return Redirect::back()->withInput();
+      }
+
+      DB::table('objectives')
+        ->where('id', $objective_id)
+        ->update(array(
+          'outcome_id' => $outcome_id,
+          'text' => $learning_objective,
+          'active' => $active,
+      ));
+
+      /** Send success message */
+        Session::flash('status', 'success');
+        Session::flash('message', 'Learning Objective successfully updated.');
+        return Redirect::back();
+    }
+    catch(Exception $e)
+    {
+      	/** Send error message and old data */
+        Session::flash('status', 'danger');
+        Session::flash('message', 'An error ocurred trying to create a new Learning Objective. Please try again later.'.$e->getMessage());
+        return Redirect::back()->withInput();
+    }
+  }
+
+  /**
+   * Check what this was for
+   * @return [type] [description]
+   */
+  public function fetchObjective()
+  {
+    $validator = Validator::make(
+      array(
+        'objective_id' => Input::get('objective_id')
+      ),
+      array(
+        'objective_id' => 'required|integer',
+      )
+    );
+
+    if($validator->fails())
+    {
+      return '';
+    }
+    $res = DB::table('objectives')->where('id', Input::get('objective_id'))->first();
+
+    return json_encode($res);
+  }
+}

app/controllers/OutcomesController.php

@@ -0,0 +1,547 @@
+<?php
+
+class OutcomesController extends \BaseController {
+
+
+    /**
+     * Show all Learning Outcomes and expected values
+     *
+     */
+    public function index()
+    {
+        $title = "Learning Outcomes";
+        $outcomes = Outcome::withTrashed()->orderBy('name', 'ASC')->get();
+        $schools = School::orderBy('name', 'ASC')->get();
+
+        return View::make('local.managers.admins.learning-outcomes', compact('title', 'outcomes', 'schools'));
+    }
+    // TODO: Change to home page
+    public function newIndex()
+    {
+        $title = "Learning Outcomes";
+        $outcomes = Outcome::withTrashed()->orderBy('name', 'ASC')->get();
+        $schools = School::orderBy('name', 'ASC')->get();
+
+        return View::make('local.managers.admins.new-learning-outcomes', compact('title', 'outcomes', 'schools'));
+//        return View::make('local.managers.admins.learning-outcomes', compact('title', 'outcomes', 'schools'));
+    }
+
+    public function show($id)
+    {
+        DB::disableQueryLog();
+        $outcome = Outcome::find($id);
+
+        $undergradResults=array("names"=>array(), "schools"=>array(), "achieved"=>array(), "attempted"=>array(), "successRate"=>array());
+        $gradResults = array("names"=>array(), "schools"=>array(), "achieved"=>array(), "attempted"=>array(), "successRate"=>array());
+
+        //Calculate performance for this outcome for each undergrad program
+        $undergradPrograms = Program::where('is_graduate','=', 0)
+            ->where(function($query)
+            {
+                if(Auth::user()->school_id)
+                {
+                    $query->where('school_id', Auth::user()->school_id);
+                }
+            })
+            ->with('courses')
+            ->orderBy('name', 'asc')->get();
+
+        foreach($undergradPrograms as $program)
+        {
+            $undergradResults["names"][$program->id]=$program->name;
+            $undergradResults["schools"][$program->id]=$program->school->name;
+            $programAssessed=false;
+
+            $undergradResults["attempted"][$program->id]=0;
+            $undergradResults["achieved"][$program->id]=0;
+
+            foreach($program->courses as $course)
+            {
+                $course_outcomes_achieved = json_decode($course->outcomes_achieved, true);
+                $course_outcomes_attempted = json_decode($course->outcomes_attempted, true);
+
+                $attemptedCriteriaCount=0;
+                $achievedCriteriaCount=0;
+
+                // If this outcome was evaluated
+                if(
+                    $course_outcomes_attempted
+                    && array_key_exists($outcome->id, $course_outcomes_attempted)
+                    && $course_outcomes_attempted[$outcome->id]!=0)
+                {
+                    // Count +1 for attempted and achieved in the program
+                    $attemptedCriteriaCount+=$course_outcomes_attempted[$outcome->id];
+                    $achievedCriteriaCount+=$course_outcomes_achieved[$outcome->id];
+                    $programAssessed=true;
+
+                    if($attemptedCriteriaCount>0  &&(float)$achievedCriteriaCount/$attemptedCriteriaCount*100 > $outcome->expected_outcome)
+                    {
+                        $undergradResults["achieved"][$program->id]+=1;
+                    }
+                    $undergradResults["attempted"][$program->id]+=1;
+                }
+            }
+
+            // Calculate success rate for this program
+            if($programAssessed && $undergradResults["attempted"][$program->id]>0)
+                $undergradResults["successRate"][$program->id]= round((float)$undergradResults["achieved"][$program->id]/$undergradResults["attempted"][$program->id]*100, 2).'%';
+            else
+                $undergradResults["successRate"][$program->id]= 'N/M';
+        }
+
+
+        //Calculate performance for this outcome for each grad program
+        $gradPrograms = Program::where('is_graduate','=', 1)
+            ->where(function($query)
+            {
+                if(Auth::user()->school_id)
+                {
+                    $query->where('school_id', Auth::user()->school_id);
+                }
+            })
+            ->with(array('courses'=>function($query)
+            {
+                $query->whereNotNull('outcomes_attempted');
+            }))
+            ->orderBy('name', 'asc')->get();
+
+        foreach($gradPrograms as $program)
+        {
+            $gradResults["names"][$program->id]=$program->name;
+            $gradResults["schools"][$program->id]=$program->school->name;
+
+            $programAssessed=false;
+
+            $gradResults["attempted"][$program->id]=0;
+            $gradResults["achieved"][$program->id]=0;
+
+            foreach($program->courses as $course)
+            {
+                $course_outcomes_achieved = json_decode($course->outcomes_achieved, true);
+                $course_outcomes_attempted = json_decode($course->outcomes_attempted, true);
+
+                $attemptedCriteriaCount=0;
+                $achievedCriteriaCount=0;
+
+                // If this outcome was evaluated
+                if(
+                    $course_outcomes_attempted
+                    && array_key_exists($outcome->id, $course_outcomes_attempted)
+                    && $course_outcomes_attempted[$outcome->id]!=0)
+                {
+                    // Count +1 for attempted and achieved in the program
+                    $attemptedCriteriaCount+=$course_outcomes_attempted[$outcome->id];
+                    $achievedCriteriaCount+=$course_outcomes_achieved[$outcome->id];
+                    $programAssessed=true;
+
+                    if($attemptedCriteriaCount>0  &&(float)$achievedCriteriaCount/$attemptedCriteriaCount*100 > $outcome->expected_outcome)
+                    {
+                        $gradResults["achieved"][$program->id]+=1;
+                    }
+                    $gradResults["attempted"][$program->id]+=1;
+                }
+            }
+
+            // Calculate success rate for this program
+            if($programAssessed && $gradResults["attempted"][$program->id]>0)
+                $gradResults["successRate"][$program->id]= round((float)$gradResults["achieved"][$program->id]/$gradResults["attempted"][$program->id]*100, 2).'%';
+            else
+                $gradResults["successRate"][$program->id]= 'N/M';
+        }
+
+        $title = "Outcome Results: ".$outcome->name;
+
+        return View::make('local.managers.admins.learning-outcome', compact('title', 'outcome', 'undergradResults', 'gradResults'));
+    }
+
+    public function newShow($id)
+    {
+//        DB::disableQueryLog();
+        $outcome = Outcome::find($id);
+        $title = $outcome->name;
+
+        return View::make('local.managers.admins.new-learning-outcome', compact('title', 'outcome'));
+    }
+
+    public function update()
+    {
+        $outcomeArray = json_decode(Input::get('outcomeArray'), true);
+        Session::flash('status', 'success');
+        Session::flash('message', 'Learning Outcomes updated.');
+
+        foreach ($outcomeArray as $outcomeObject)
+        {
+
+
+            $validator = Validator::make(
+                array(
+                    'name' => $outcomeObject['name'],
+                    'definition' => $outcomeObject['definition'],
+                    'expected_outcome' => $outcomeObject['expected_outcome']
+                ),
+                array(
+                    'name' => 'required',
+                    'definition' => 'required',
+                    'expected_outcome' => 'required|numeric'
+                )
+            );
+
+            if(!$validator->fails())
+            {
+                try
+                {
+                    $outcome = Outcome::withTrashed()
+                        ->where('id','=', $outcomeObject['id'])
+                        ->firstOrFail();
+                    $outcome->name = $outcomeObject['name'];
+                    $outcome->definition = $outcomeObject['definition'];
+                    $outcome->expected_outcome = $outcomeObject['expected_outcome'];
+                    $outcome->save();
+
+                    // If delete is 1, and outcome isn't already trashed, delete
+                    if($outcomeObject['delete']==1 && !$outcome->trashed())
+                        $outcome->delete();
+                    // If delete is 0, and outcome is already trashed, restore
+                    elseif($outcomeObject['delete']==0 && $outcome->trashed())
+                        $outcome->restore();
+                }
+
+                catch(Exception $e)
+                {
+
+                    Session::flash('message', $e->getMessage());
+                }
+            }
+            else
+            {
+                /** Prepare error message */
+                $message = 'Error(s) updating the Learning Outcomes: <ul>';
+
+                foreach ($validator->messages()->all('<li>:message</li>') as $validationError)
+                {
+                    $message.=$validationError;
+                }
+
+                $message.='</ul>';
+
+                /** Send error message and old data */
+                Session::flash('status', 'danger');
+                Session::flash('message', $message);
+                return;
+            }
+        }
+
+        return;
+    }
+
+    public function fetchCriteria()
+    {
+
+        if(Input::get('filter'))
+        {
+            switch (Input::get('filter'))
+            {
+                case 'all':
+                    return Outcome::find(Input::get('id'))->criteria;
+                    break;
+
+                case 'school':
+                    // If scoord
+                    if(Auth::user()->role == '2')
+                    {
+
+                        // Fetch all the programs whose school is the user's
+                        $program_ids = DB::table('programs')->where('school_id', Auth::user()->school_id)->lists('id');
+
+                        // Return all criteria belonging to any of those programs
+                        return Criterion::
+                            where('outcome_id', Input::get('id'))
+                            ->whereIn('program_id', $program_ids)
+                            ->orderBy('name', 'ASC')
+                            ->get();
+
+                    }
+
+                    // If pcoord
+                    else
+                    {
+
+                        // Fetch all the programs from the user's school;
+                        $program_ids = DB::table('programs')->where('school_id', Auth::user()->programs[0]->school->id)->lists('id');
+
+                        return Criterion::
+                            where('outcome_id', Input::get('id'))
+                            ->whereIn('program_id', $program_ids)
+                            ->orderBy('name', 'ASC')
+                            ->get();
+                    }
+
+                    break;
+
+                case 'program':
+                    return Criterion::
+                        where('outcome_id', Input::get('id'))
+                        ->whereIn('program_id', Auth::user()->programs->lists('id'))
+                        ->orderBy('name', 'ASC')
+                        ->get();
+                    break;
+
+                default:
+                    return Outcome::find(Input::get('id'))->criteria;
+                    break;
+            }
+        }
+        else
+        {
+            return Outcome::find(Input::get('id'))->criteria;
+        }
+    }
+
+    /**
+     * Create a new learning outcome.
+     */
+    public function create()
+    {
+        /** Validation rules */
+        $validator = Validator::make(
+            array(
+                'name' => Input::get('name'),
+                'definition' => Input::get('definition')
+            ),
+            array(
+                'name' => 'required|unique:outcomes',
+                'definition' => 'required|min:10'
+            )
+        );
+
+        /** If validation fails */
+        if ($validator->fails())
+        {
+            /** Prepare error message */
+            $message = '<p>Error(s) creating a new Learning Outcome</p><ul>';
+
+            foreach ($validator->messages()->all('<li>:message</li>') as $validationError)
+            {
+                $message.=$validationError;
+            }
+
+            $message.='</ul>';
+
+            /** Send error message and old data */
+            Session::flash('status', 'warning');
+            Session::flash('message', $message);
+            return Redirect::to('learning-outcomes-criteria')->withInput();
+        }
+        else
+        {
+            /** Instantiate new outcome */
+            $outcome = new Outcome;
+            $outcome->name= Input::get('name');
+            $outcome->definition = Input::get('definition');
+
+            /** If outcome is saved, send success message */
+            if($outcome->save())
+            {
+                Session::flash('status', 'success');
+                Session::flash('message', '<p>Learning Outcome added.</p>');
+                return Redirect::to('learning-outcomes-criteria');
+            }
+
+            /** If saving fails, send error message and old data */
+            else
+            {
+                Session::flash('status', 'warning');
+                Session::flash('message', '<p>Error adding Learning Outcome. Please try again later.</p>');
+                return Redirect::to('learning-outcomes-criteria')->withInput();
+            }
+        }
+    }
+
+    public function fetchOutcome()
+    {
+        $id = Input::get('id');
+
+        $outcome = Outcome::find($id);
+
+        $outcome->criteria;
+
+        return array
+        (
+            'outcome' => $outcome
+        );
+    }
+
+    public function managerAssessmentReports()
+    {
+        $outcomes = Outcome::select(array('id', 'name', 'expected_outcome'))->orderBy('name', 'ASC')->get();
+
+        switch (Auth::user()->role) {
+            case 1:
+                $title = "Campus Assessment Reports";
+                return View::make('local.managers.admins.assessment_reports', compact('title', 'outcomes'));
+                break;
+            case 2:
+                $title = "School Assessment Reports";
+                return View::make('local.managers.sCoords.assessment_reports', compact('title', 'outcomes'));
+                break;
+            case 3:
+                $title = "Program Assessment Reports";
+                $programs  = Auth::user()->programs;
+                return View::make('local.managers.pCoords.assessment_reports', compact('title', 'outcomes', 'programs'));
+                break;
+            default:
+                App::abort('404');
+                break;
+        }
+
+    }
+
+    /**
+     * Campus Assessment Reports
+     */
+    public function assessmentReport($outcome_id)
+    {
+        $outcome = Outcome::find($outcome_id);
+
+        if(!$outcome)
+            App::abort('404');
+        $title = "Assessment Report: ".$outcome->name;
+
+
+        $schools = School::
+            has('courses')
+            ->with(array('programs'=>function($query) use($outcome_id){
+                $query
+                ->has('courses')
+                ->with(array('courses'=>function($query2) use($outcome_id){
+                    $query2
+                    ->has('activities')
+                    ->whereNotNull('outcomes_attempted')
+                    // ->where('outcomes_attempted', 'NOT LIKE', '%"'.$outcome_id.'":0%')
+                    ->whereIn('semester_id', Session::get('semesters_ids'))
+                    ->groupBy(array('code', 'number'));
+                }));
+            }))
+         ->get();
+
+        return View::make('local.managers.admins.assessment_report', compact('title', 'outcome', 'schools'));
+    }
+
+    // TODO: Change later
+    public function newAssessmentReport($outcome_id)
+    {
+        $outcome = Outcome::find($outcome_id);
+
+        if(!$outcome)
+            App::abort('404');
+        $title = "Assessment Report: ".$outcome->name;
+
+        $schools = School::
+        has('courses')
+            ->with(array('programs'=>function($query) use($outcome_id){
+                $query
+                    ->has('courses')
+                    ->with(array('courses'=>function($query2) use($outcome_id){
+                        $query2
+                            ->has('activities')
+                            ->whereNotNull('outcomes_attempted')
+                            // ->where('outcomes_attempted', 'NOT LIKE', '%"'.$outcome_id.'":0%')
+                            ->whereIn('semester_id', Session::get('semesters_ids'))
+                            ->groupBy(array('code', 'number'));
+                    }));
+            }))
+            ->get();
+
+        return View::make('local.managers.admins.assessment_report', compact('title', 'outcome', 'schools'));
+    }
+
+    /**
+     * School Assessment Reports
+     */
+    public function schoolAssessmentReport($outcome_id)
+    {
+        $outcome = Outcome::find($outcome_id);
+
+        if(!$outcome)
+            App::abort('404');
+        $title = "Assessment Report: ".$outcome->name;
+
+
+        $school = School::
+            where('id', Auth::user()->school_id)
+            ->has('courses')
+            ->with(array('programs'=>function($query){
+            $query
+            ->has('courses')
+            ->with(array('courses'=>function($query2){
+                $query2
+                ->has('activities')
+                ->whereNotNull('outcomes_attempted')
+                ->whereIn('semester_id', Session::get('semesters_ids'))
+                ->groupBy(array('code', 'number'));
+            }));
+         }))
+         ->first();
+
+        return View::make('local.managers.sCoords.assessment_report', compact('title', 'outcome', 'school'));
+    }
+
+    /**
+     *    Program Assessment Reports
+     */
+    public function programAssessmentReport($outcome_id, $program_id)
+    {
+        $outcome = Outcome::find($outcome_id);
+
+        if(!$outcome)
+            App::abort('404');
+        $title = "Assessment Report: ".$outcome->name;
+
+
+        $program = Program::
+            where('id', $program_id)
+            ->has('courses')
+            ->with(array('courses'=>function($query){
+                $query
+                ->has('activities')
+                ->whereNotNull('outcomes_attempted')
+                ->whereIn('semester_id', Session::get('semesters_ids'))
+                ->groupBy(array('code', 'number'));
+            }))
+            ->first();
+
+        return View::make('local.managers.pCoords.assessment_report', compact('title', 'outcome', 'program'));
+    }
+
+
+    public function professorAssessmentReports()
+    {
+        $outcomes = Outcome::select(array('id', 'name', 'expected_outcome'))->orderBy('name', 'ASC')->get();
+        $title = "My Courses' Assessment Reports";
+
+        return View::make('local.professors.assessment_reports', compact('title', 'outcomes'));
+
+    }
+
+
+    // Report for a single professor with a single learning outcome
+    public function professorAssessmentReport($outcome_id)
+    {
+        $outcome = Outcome::find($outcome_id);
+
+        if(!$outcome)
+            App::abort('404');
+        $title = "My Courses' Assessment Report: ".$outcome->name;
+
+
+        $courses = Course::
+            where('user_id', Auth::user()->id)
+            ->has('activities')
+            ->whereNotNull('outcomes_attempted')
+            ->whereIn('semester_id', Session::get('semesters_ids'))
+            ->groupBy(array('code', 'number'))
+            ->get();
+
+        return View::make('local.professors.assessment_report', compact('title', 'outcome', 'courses'));
+    }
+}

app/controllers/ProfessorsController.php

@@ -0,0 +1,122 @@
+<?php
+
+class ProfessorsController extends \BaseController
+{
+
+	private $grouped_courses;
+
+	public function __construct()
+    {
+        $this->courses = Auth::user()->courses;
+    }
+
+	public function overview()
+	{
+        $title='My Courses';
+        $grouped_courses = Course::where('user_id', Auth::user()->id)->whereIn('semester_id', Session::get('semesters_ids'))->groupBy(array('code', 'number', 'semester_id'))->get();
+        $outcomes = Outcome::orderBy('name', 'asc')->get();
+        $outcomeCount = Outcome::all()->count();
+
+
+        $grouped_outcomes_achieved_results = array();
+        $grouped_outcomes_attempted_results = array();
+        $grouped_sections = array();
+
+        foreach ($grouped_courses as $index => $grouped_course)
+        {
+            // Blank outcomes for one course
+            $outcomes_achieved = array_fill(1, $outcomeCount, 0);
+            $outcomes_attempted = array_fill(1, $outcomeCount, 0);
+
+            // Find sections belonging to user with identifier of one course
+            $sections = Course::where('user_id', Auth::user()->id)->where('code', $grouped_course->code)->whereIn('semester_id', Session::get('semesters_ids'))->where('number', $grouped_course->number)->where('semester_id', $grouped_course->semester_id)->get();
+
+            // For each of the professor's course sections, add the attempted and achieved criteria per outcome
+            foreach ($sections as $section)
+            {
+                if($section->outcomes_achieved!=NULL)
+                {
+                    $section_outcomes_achieved =json_decode($section->outcomes_achieved, true);
+                    $section_outcomes_attempted =json_decode($section->outcomes_attempted, true);
+                    for($i=1; $i<=count($outcomes_attempted); $i++)
+                    {
+                        $outcomes_achieved[$i]+=$section_outcomes_achieved[$i];
+                        $outcomes_attempted[$i]+=$section_outcomes_attempted[$i];
+                    }
+                }
+            }
+
+            $grouped_outcomes_achieved_results[]=$outcomes_achieved;
+            $grouped_outcomes_attempted_results[]=$outcomes_attempted;
+            $grouped_sections[] = $sections;
+
+        }
+
+		return View::make('local.professors.overview', compact('title', 'grouped_courses', 'outcomes', 'grouped_outcomes_attempted_results', 'grouped_outcomes_achieved_results', 'grouped_sections'));
+	}
+
+    public function program()
+    {
+        $program =  Auth::user()->programs[0];
+        $title='Your Program: '.$program->name;
+        $program_courses = Course::where('program_id','=', $program->id)->whereIn('semester_id', Session::get('semesters_ids'))->get();
+        $outcomes = Outcome::orderBy('name', 'asc')->get();
+        $outcomeCount = Outcome::all()->count();
+
+        $outcomes_achieved = array_fill(1, $outcomeCount, 0);
+        $outcomes_attempted = array_fill(1, $outcomeCount, 0);
+
+        foreach ($program_courses as $course)
+        {
+            if($course->outcomes_achieved!=NULL)
+            {
+                $course_outcomes_achieved =json_decode($course->outcomes_achieved, true);
+                $course_outcomes_attempted =json_decode($course->outcomes_attempted, true);
+                for($i=1; $i<=count($outcomes_attempted); $i++)
+                {
+                    $outcomes_achieved[$i]+=$course_outcomes_achieved[$i];
+                    $outcomes_attempted[$i]+=$course_outcomes_attempted[$i];
+                }
+            }
+        }
+
+        // Program contact information
+        $scoords = User::where('school_id', $program->school_id)
+            ->where('role', 2)
+            ->get();
+        $pcoords = User::
+            select('users.*')
+            ->join('program_user', 'users.id', '=', 'program_user.user_id')
+            ->where('role', 3)
+            ->where('program_id', $program->id)
+            ->get();
+
+        return View::make('local.professors.program', compact('title', 'outcomes', 'outcomes_attempted', 'outcomes_achieved', 'scoords', 'pcoords'));
+    }
+
+
+    public function generalStudiesOverview(){
+
+        $title='General Component Assessment Overview';
+
+        try{
+            $programs = Program::generalComponentPrograms();
+        }
+        catch(Exception $e){
+            dd('Unable to find general component programs');
+        }
+
+        $outcomes = Outcome::orderBy('name', 'asc')->get();
+        $schools = School::all();
+        $program_packs = array();
+        if(!$programs->isEmpty()){
+            foreach ($programs as $program) {
+                $program_packs[]= $program->assessmentOverview();
+            }
+        }
+
+        return View::make('local.managers.shared.general_studies_overview', compact('title', 'outcomes', 'schools', 'program_packs'));
+
+
+    }
+}

app/controllers/ProgramCoordinatorsController.php

@@ -0,0 +1,109 @@
+<?php
+
+class ProgramCoordinatorsController extends \BaseController {
+
+    public function overview()
+    {
+        //TODO Find a better way to prevent non-scoords from reaching the page
+        switch(Auth::user()->role)
+        {
+            case 1:
+                return Redirect::to('administrator');
+                break;
+            case 2:
+                return Redirect::to('school-coordinator');
+                break;
+        }
+
+        $title = 'Program Coordinator Overview';
+
+        $programs = Auth::user()->programs;
+
+        $outcomes = Outcome::orderBy('name', 'asc')->get();
+        $outcomeCount = Outcome::all()->count();
+
+        $programs_array = array();
+        $programs_contact = array();
+
+        foreach ($programs as $program)
+        {
+          $program_array = array();
+
+          $program_array['program'] = $program;
+
+          $program_array['outcomes_achieved'] = array_fill(1, $outcomeCount, 0);
+          $program_array['outcomes_attempted'] = array_fill(1, $outcomeCount, 0);
+
+          $program_array['program_courses'] = $program->courses;
+          $program_array['grouped_objectives'] = $program->objectives();
+
+          $program_array['assessed_courses_count']=0;
+          foreach ($program_array['program_courses'] as $course)
+          {
+            if($course->outcomes_achieved!=NULL)
+            {
+              $program_array['course_outcomes_achieved'] =json_decode($course->outcomes_achieved, true);
+              $program_array['course_outcomes_attempted'] =json_decode($course->outcomes_attempted, true);
+              for($i=1; $i<=count($program_array['outcomes_attempted']); $i++)
+              {
+                $program_array['outcomes_achieved'][$i]+=$program_array['course_outcomes_achieved'][$i];
+                $program_array['outcomes_attempted'][$i]+=$program_array['course_outcomes_attempted'][$i];
+              }
+              $program_array['assessed_courses_count']+=1;
+            }
+          }
+
+          /**
+           * List of grouped courses (grouped sections)
+           */
+
+          $program_array['grouped_courses'] = Course::
+            select(DB::raw('name, code, number, max(outcomes_attempted) as outcomes_attempted, semester_id, program_id'))
+            ->with('semester')
+            ->with('program')
+            ->where('program_id', $program->id)
+            ->whereIn('semester_id', Session::get('semesters_ids'))
+            ->groupBy(array('code', 'number', 'semester_id'))
+            ->orderBy('code')
+            ->orderBy('number')
+            ->orderBy('semester_id')
+            ->get();
+
+
+          $programs_array[] = $program_array;
+
+
+          // Program contact information
+          $users = User::
+              select('users.*')
+              ->leftJoin('program_user', 'users.id', '=', 'program_user.user_id')
+              ->where(function($query) use($program)
+              {
+                $query
+                    ->where('school_id', $program->school_id)
+                    ->where('role', 2);
+              })
+              ->orWhere(function($query) use($program)
+              {
+                $query
+                    ->where('role', 3)
+                    ->where('program_id', $program->id);
+              })
+              ->orWhere(function($query) use($program)
+              {
+                $query
+                    ->where('role', 4)
+                    ->where('program_id', $program->id);
+              })
+              ->get();
+
+
+            $programs_contact[] = $users;
+
+        }
+
+
+        return View::make('local.managers.pCoords.overview', compact('title', 'programs', 'outcomes', 'programs_array', 'programs_contact'));
+    }
+
+}

app/controllers/ProgramsController.php

@@ -0,0 +1,156 @@
+<?php
+
+class ProgramsController extends \BaseController
+{
+
+  /**
+   * Shows a particular program
+   */
+  public function show($id)
+  {
+
+    $program = Program::find($id);
+    $title= $program->school->name.': '.$program->name;
+    $program_courses = $program->courses;
+    $outcomes = Outcome::orderBy('name', 'asc')->get();
+    $schools = School::all();
+    $outcomeCount = Outcome::all()->count();
+
+
+    $outcomes_achieved = array_fill(1, $outcomeCount, 0);
+    $outcomes_attempted = array_fill(1, $outcomeCount, 0);
+
+    $assessed_courses_count=0;
+    foreach ($program_courses as $course)
+    {
+        if($course->outcomes_achieved!=NULL)
+        {
+            $course_outcomes_achieved =json_decode($course->outcomes_achieved, true);
+            $course_outcomes_attempted =json_decode($course->outcomes_attempted, true);
+            for($i=1; $i<=count($outcomes_attempted); $i++)
+            {
+                $outcomes_achieved[$i]+=$course_outcomes_achieved[$i];
+                $outcomes_attempted[$i]+=$course_outcomes_attempted[$i];
+            }
+            $assessed_courses_count+=1;
+        }
+    }
+
+    /**
+     * List of grouped courses (grouped sections)
+     */
+
+    $grouped_courses = Course::
+      select(DB::raw('name, code, number, max(outcomes_attempted) as outcomes_attempted, semester_id, program_id'))
+      ->with('semester')
+      ->with('program')
+      ->where('program_id', $program->id)
+      ->whereIn('semester_id', Session::get('semesters_ids'))
+      ->groupBy(array('code', 'number', 'semester_id'))
+      ->orderBy('code')
+      ->orderBy('number')
+      ->orderBy('semester_id')
+      ->get();
+
+    // Program contact information
+    $users = User::
+        select('users.*')
+        ->leftJoin('program_user', 'users.id', '=', 'program_user.user_id')
+        ->where(function($query) use($program)
+        {
+            $query
+                ->where('school_id', $program->school_id)
+                ->where('role', 2);
+        })
+        ->orWhere(function($query) use($program)
+        {
+            $query
+                ->where('role', 3)
+                ->where('program_id', $program->id);
+        })
+        ->orWhere(function($query) use($program)
+        {
+            $query
+                ->where('role', 4)
+                ->where('program_id', $program->id);
+        })
+        ->get();
+
+    return View::make('local.managers.shared.program', compact('title', 'outcomes', 'outcomes_attempted', 'outcomes_achieved', 'schools', 'program_courses', 'assessed_courses_count', 'grouped_courses', 'program', 'users'));
+
+}
+
+  /**
+   * Info to print a program
+   */
+  public function print_program($id)
+  {
+
+    $program = Program::find($id);
+    $title= $program->name.' Assessment Report - '.date('m/d/Y');
+    $program_courses = $program->courses;
+    $outcomes = Outcome::orderBy('name', 'asc')->get();
+    $schools = School::all();
+    $outcomeCount = Outcome::all()->count();
+
+
+    $outcomes_achieved = array_fill(1, $outcomeCount, 0);
+    $outcomes_attempted = array_fill(1, $outcomeCount, 0);
+
+    $assessed_courses_count=0;
+    foreach ($program_courses as $course)
+    {
+      if($course->outcomes_achieved!=NULL)
+      {
+        $course_outcomes_achieved =json_decode($course->outcomes_achieved, true);
+        $course_outcomes_attempted =json_decode($course->outcomes_attempted, true);
+        for($i=1; $i<=count($outcomes_attempted); $i++)
+        {
+          $outcomes_achieved[$i]+=$course_outcomes_achieved[$i];
+          $outcomes_attempted[$i]+=$course_outcomes_attempted[$i];
+        }
+        $assessed_courses_count+=1;
+      }
+    }
+
+    /**
+     * List of grouped courses (grouped sections)
+     */
+
+    $grouped_courses = Course::
+      select(DB::raw('name, code, number, max(outcomes_attempted) as outcomes_attempted, semester_id, program_id'))
+      ->with('semester')
+      ->with('program')
+      ->where('program_id', $program->id)
+      ->whereIn('semester_id', Session::get('semesters_ids'))
+      ->groupBy(array('code', 'number', 'semester_id'))
+      ->orderBy('code')
+      ->orderBy('number')
+      ->orderBy('semester_id')
+      ->get();
+
+    return View::make('local.managers.shared.print_program', compact('title', 'program', 'outcomes', 'outcomes_attempted', 'outcomes_achieved', 'schools', 'program_courses', 'assessed_courses_count', 'grouped_courses'));
+  }
+
+
+  /**
+   * A list of all programs
+   */
+  public function index()
+  {
+    $title = "Programs by School";
+    $programs = Program::orderBy('name')->get();
+    $schools = School::all();
+
+    return View::make('local.managers.shared.programs', compact('programs', 'schools', 'title'));
+  }
+
+  /**
+  * Fetch a program
+  */
+  public function fetch()
+  {
+    Log::info('id:'.Input::get('id'));
+    return School::find(Input::get('id'))->programs;
+  }
+}

app/controllers/RubricsController.php

@@ -0,0 +1,316 @@
+<?php
+
+class RubricsController extends \BaseController {
+
+    /**
+     * Show the form for creating a new rubric
+     *
+     * @return Response
+     */
+    public function newRubric($activity_id)
+    {
+        $activity = Activity::find($activity_id);
+
+        // If activity does not exist, display 404
+        if (!$activity)
+            App::abort('404');
+
+        $title = 'Rubric for <em>'.$activity->name.'</em>';
+
+        // Select templates that belong to everyone or belong to the activity's course's school
+        $templates = Template::
+        where('is_visible', '=', 1)
+        ->where(function($query) use ($activity)
+        {
+            if(Auth::user()->role != 1){
+                $query
+                ->where('school_id', $activity->course->program->school->id)
+                ->orWhere('school_id', '=', NULL);
+            }
+        })
+        ->orderBy('name', 'ASC')->get();
+
+        $rubrics = Auth::user()->rubrics;
+        $outcomes = Outcome::orderBy('name', 'ASC')->get();
+        $criteria = Criterion::orderBy('name', 'ASC')->get();
+        $rubric = $activity->rubric;
+
+        return View::make('local.professors.rubrics', compact('title', 'templates', 'outcomes', 'criteria', 'rubrics', 'activity', 'rubric'));
+    }
+
+    /**
+     * Save a new rubric
+     *
+     * @return Response
+     */
+    public function create()
+    {
+
+        DB::beginTransaction();
+
+        try
+        {
+            // Get rubric contents
+            $rubric_contents= json_decode(Input::get('contents'));
+
+            // Process rubric
+            $rubric = new Rubric;
+            $rubric->name = Input::get('name');
+            $rubric->contents = json_encode($rubric_contents);
+            $rubric->expected_percentage = Input::get('expected_percentage');
+            $rubric->expected_points = Input::get('expected_points');
+            $rubric->user_id = Auth::id();
+            $rubric->save();
+
+            // Process activity
+            $activity = Activity::find(Input::get('activity_id'));
+            $activity->rubric_id = $rubric->id;
+            $activity->save();
+
+            DB::commit();
+
+            Session::flash('status', 'success');
+            Session::flash('message', 'Rubric assigned.');
+
+            return action('ActivitiesController@show', array($activity->id));
+
+
+        }
+        catch(Exception $e)
+        {
+            DB::rollBack();
+            Session::flash('status', 'danger');
+            Session::flash('message', 'Error creating Rubric. Try again later.');
+        }
+    }
+
+    /**
+     * Return a specific template
+     *
+     * @return Template
+     */
+    public function fetch()
+    {
+        return Rubric::find(Input::get('id'));
+    }
+
+    /**
+     * Update a rubric
+     *
+     * @return Response
+     */
+    public function update()
+    {
+        $rubric = Rubric::find(Input::get('id'));
+        $rubric->name = Input::get('name');
+        $rubric->contents = Input::get('contents');
+        $rubric->expected_percentage = Input::get('expected_percentage');
+        $rubric->expected_points = Input::get('expected_points');
+
+        DB::beginTransaction();
+
+        try {
+            // Get associated activity
+            $activity= Activity::where('rubric_id', '=', $rubric->id)->first();
+
+            // If the associated activity has been assessed, delete the records
+            if($activity->outcomes_attempted!=NULL)
+            {
+                DB::table('assessments')->where('activity_id', '=', $activity->id)->delete();
+                $activity->criteria_achieved_percentage= NULL;
+                $activity->criteria_achieved= NULL;
+                $activity->outcomes_achieved=NULL;
+                $activity->outcomes_attempted=NULL;
+
+            }
+
+            $rubric->save();
+            $activity->save();
+
+            // Get all the course's activities
+            $course = Course::find($activity->course->id);
+            $activities = $course->activities;
+
+            // Check if any assessed activities remain
+            $remainingAssessed = false;
+            foreach ($course->activities as $activity)
+            {
+                if($activity->outcomes_attempted!=NULL)
+                {
+                    $remainingAssessed =true;
+                    break;
+                }
+            }
+
+            //If there are still evaluated activities in the course, recalculate course outcomes
+            if(!$activities->isEmpty() && $remainingAssessed)
+            {
+                // Variables to hold recalculated outcomes for the course
+                $course_outcomes_attempted = array_fill(1, Outcome::all()->count(), 0);
+                $course_outcomes_achieved = array_fill(1, Outcome::all()->count(), 0);
+
+                // For each activity
+                foreach ($activities as $activity)
+                {
+                    // If activity has been assessed
+                    if($activity->outcomes_attempted!=NULL)
+                    {
+                        // Get the achieved criteria
+                        $criteria_achievement = json_decode($activity->criteria_achieved, true);
+                        foreach($criteria_achievement as $criterion_id=>$criterion_achieved)
+                        {
+                            // Find corresponding learning outcome;
+                            $criterion = Criterion::find($criterion_id);
+                            $outcome = Outcome::find($criterion->outcome_id);
+
+                            // If criterion is achieved (1), add 1 to both arrays
+                            if($criterion_achieved === 1)
+                            {
+                                $course_outcomes_attempted[$outcome->id]+=1;
+                                $course_outcomes_achieved[$outcome->id]+=1;
+                            }
+                            // Else, only add to the attempted outcomes arrays
+                            elseif($criterion_achieved === 0)
+                            {
+                                $course_outcomes_attempted[$outcome->id]+=1;
+                            }
+                        }
+                    }
+                }
+
+                // Update course
+                $course->outcomes_achieved = json_encode($course_outcomes_achieved);
+                $course->outcomes_attempted = json_encode($course_outcomes_attempted);
+
+            }
+            else
+            {
+                // Update course
+                $course->outcomes_achieved = NULL;
+                $course->outcomes_attempted = NULL;
+
+            }
+
+            $course->save();
+            DB::commit();
+
+            Session::flash('status', 'success');
+            Session::flash('message', 'Rubric updated.');
+
+            return action('ActivitiesController@show', array($activity->id));
+        }
+        catch (Exception $e)
+        {
+            DB::rollBack();
+            Session::flash('status', 'danger');
+            Session::flash('message', 'Error: The rubric could not be updated. Try again later.');
+        }
+    }
+
+    /**
+     * Remove the specified resource from storage.
+     *
+     * @return Response
+     */
+    public function destroy()
+    {
+        $rubric = Rubric::find(Input::get('id'));
+
+        if($rubric->delete())
+        {
+            Session::flash('status', 'success');
+            Session::flash('message', 'Rubric deleted.');
+        }
+        else
+        {
+            Session::flash('status', 'danger');
+            Session::flash('message', 'Error: The rubric could not be deleted. Try again later.');
+        }
+
+        return;
+    }
+
+    /**
+     * Show a specific rubric
+     *
+     * @return Response
+     */
+    public function show($activity_id)
+    {
+        $activity = Activity::find($activity_id);
+        // Get activity's course
+        $course = Course::where('id', '=', $activity->course_id)->firstOrFail();
+
+        // If activity does not belong to the requesting user, display 403
+        if ($course->user_id != Auth::id())
+                App::abort('403', 'Access Forbidden');
+
+        $rubric = Rubric::where('id', '=', $activity->rubric_id)->firstOrFail();
+        $title = $activity->name.': '.$rubric->name;
+        return View::make('local.professors.viewrubric', compact('rubric', 'activity', 'title', 'course'));
+    }
+
+    /**
+     * Show a specific rubric without some course and user information
+     *
+     * @return Response
+     */
+    public function show_limited($rubric_id)
+    {
+        // If user is a professor, display 403.
+        if (Auth::user()->role == 4)
+                App::abort('403', 'Access Forbidden');
+
+        $rubric = Rubric::where('id', '=', $rubric_id)->firstOrFail();
+        $title = $rubric->name;
+        $role = Auth::user()->role;
+        return View::make('local.managers.shared.view_rubric_limited', compact('rubric', 'title', 'role'));
+    }
+
+    public function download($activity_id, $rubric_id)
+    {
+        $activity = Activity::find($activity_id);
+        // Get activity's course
+        $course = Course::where('id', '=', $activity->course_id)->firstOrFail();
+
+        // If activity does not belong to the requesting user, display 403
+        if ($course->user_id != Auth::id())
+                App::abort('403', 'Access Forbidden');
+
+        $rubric = Rubric::where('id', '=', $activity->rubric_id)->firstOrFail();
+        $title = $activity->name.': '.$rubric->name;
+        return View::make('local.professors.downloadrubric', compact('rubric', 'activity', 'title', 'course'));
+    }
+
+    public function printview($activity_id, $rubric_id)
+    {
+        $activity = Activity::find($activity_id);
+        // Get activity's course
+        $course = Course::where('id', '=', $activity->course_id)->firstOrFail();
+
+        // If activity does not belong to the requesting user, display 403
+        if ($course->user_id != Auth::id())
+                App::abort('403', 'Access Forbidden');
+
+        $rubric = Rubric::where('id', '=', $activity->rubric_id)->firstOrFail();
+        $title = $activity->name.': '.$rubric->name;
+        return View::make('local.professors.printrubric', compact('rubric', 'activity', 'title', 'course'));
+    }
+
+    public function fetchRubricCriterion()
+    {
+        $rubric = Rubric::findOrFail(Input::get('rubric_id'));
+        $criterion_id = Input::get('criterion_id');
+
+        $rubric_contents = json_decode($rubric->contents);
+
+        foreach ($rubric_contents as $key => $criterion)
+        {
+            if($criterion->id == $criterion_id)
+            {
+                return json_encode($criterion);
+            }
+        }
+    }
+
+}

app/controllers/SchoolCoordinatorsController.php

@@ -0,0 +1,287 @@
+<?php
+
+class SchoolCoordinatorsController extends \BaseController {
+    
+    private function participatingPrograms($school)
+    {
+        return DB::table('VIEW_participating_programs')
+            ->where('school_id', $school->id)
+            ->whereIn('semester_id', Session::get('semesters_ids'))
+            ->lists('id');
+    }
+
+    public function overview()
+    {
+        DB::disableQueryLog();
+        Log::debug('user'.Auth::user()->id);
+
+        //TODO Find a better way to prevent non-scoords from reaching the page
+        switch(Auth::user()->role)
+        {
+        case 1:
+            return Redirect::to('administrator');
+            break;
+        case 3:
+            return Redirect::to('program-coordinator');
+            break;
+        }
+
+        $schools = School::orderBy('name', 'asc')->get();
+        $school = Auth::user()->school;
+        $title = $school->name.' '.'Overview';
+        $id = $school->id;
+
+        $outcomes = Outcome::orderBy('name', 'asc')->get();
+        $outcomeCount = Outcome::all()->count();
+
+            /**
+             * List of grouped courses (grouped sections)
+             */
+
+            $program_ids= $school->programs->lists('id');
+
+            $undergrad_programs = DB::table('programs')
+            ->select('id', 'name', 'school_id', 'is_graduate')
+            ->where('is_graduate', '=', 0)
+            ->where('school_id', '=', $id)
+            ->orderBy('name', 'ASC')
+            ->get();
+
+            $grad_programs = DB::table('programs')
+            ->select('id', 'name', 'school_id', 'is_graduate')
+            ->where('is_graduate', '=', 1)
+            ->where('school_id', '=', $id)
+            ->orderBy('name', 'ASC')
+            ->get();
+    
+
+            $grad_grouped_courses = Course::
+                select(DB::raw('courses.name, courses.code, courses.number, max(courses.outcomes_attempted) as outcomes_attempted, courses.semester_id, courses.program_id'))
+                ->with('semester')
+                ->with('program')
+                ->whereIn('courses.program_id', $program_ids)
+                ->whereIn('courses.semester_id', Session::get('semesters_ids'))
+                ->leftJoin('programs', 'courses.program_id', '=', 'programs.id')
+                ->where('programs.is_graduate', '=', 1)
+                ->groupBy(array('courses.code', 'courses.number', 'courses.semester_id'))
+                ->orderBy('courses.code')
+                ->orderBy('courses.number')
+                ->orderBy('courses.semester_id')
+                ->get();
+
+            $undergrad_grouped_courses = Course::
+                select(DB::raw('courses.name, courses.code, courses.number, max(courses.outcomes_attempted) as outcomes_attempted, courses.semester_id, courses.program_id'))
+                ->with('semester')
+                ->with('program')
+                ->whereIn('courses.program_id', $program_ids)
+                ->whereIn('courses.semester_id', Session::get('semesters_ids'))
+                ->leftJoin('programs', 'courses.program_id', '=', 'programs.id')
+                ->where('programs.is_graduate', '=', 0)
+                ->groupBy(array('courses.code', 'courses.number', 'courses.semester_id'))
+                ->orderBy('courses.code')
+                ->orderBy('courses.number')
+                ->orderBy('courses.semester_id')
+                ->get();
+
+            // Fetch programs with participation
+            $participating_programs = $this->participatingPrograms($school);
+
+
+            /**
+             * Calculate how many sections are doing assessment
+             */
+
+            $undergrad_outcomes_achieved = array_fill(1, $outcomeCount, 0);
+            $undergrad_outcomes_attempted = array_fill(1, $outcomeCount, 0);
+            $undergrad_assessed_sections_count = 0;
+            $undergrad_school_sections_count = 0;
+
+            $grad_outcomes_achieved = array_fill(1, $outcomeCount, 0);
+            $grad_outcomes_attempted = array_fill(1, $outcomeCount, 0);
+            $grad_assessed_sections_count = 0;
+            $grad_school_sections_count = 0;
+
+            foreach($school->programs as $program)
+            {
+                foreach ($program->courses as $course)
+                {
+                    if(!$course->program->is_graduate)
+                    {
+                        if($course->outcomes_achieved != NULL)
+                        {
+                            $course_outcomes_achieved =json_decode($course->outcomes_achieved, true);
+                            $course_outcomes_attempted =json_decode($course->outcomes_attempted, true);
+                            for($i=1; $i<=count($undergrad_outcomes_attempted); $i++)
+                            {
+                                $undergrad_outcomes_achieved[$i]+=$course_outcomes_achieved[$i];
+                                $undergrad_outcomes_attempted[$i]+=$course_outcomes_attempted[$i];
+                            }
+                            $undergrad_assessed_sections_count+=1;
+                        }
+                        $undergrad_school_sections_count+=1;
+                    }
+                    else
+                    {
+                        if($course->outcomes_achieved != NULL)
+                        {
+                            $course_outcomes_achieved =json_decode($course->outcomes_achieved, true);
+                            $course_outcomes_attempted =json_decode($course->outcomes_attempted, true);
+                            for($i=1; $i<=count($grad_outcomes_attempted); $i++)
+                            {
+                                $grad_outcomes_achieved[$i]+=$course_outcomes_achieved[$i];
+                                $grad_outcomes_attempted[$i]+=$course_outcomes_attempted[$i];
+                            }
+                            $grad_assessed_sections_count+=1;
+                        }
+                        $grad_school_sections_count+=1;
+                    }
+                }    
+            }
+
+            /**
+             * Calculate how many programs achieved and attempted each outcome in this school
+             */
+
+            // Number of programs that achieved a particular learning outcome
+            $achievedUndergradProgramsPerOutcome = array_fill(1, $outcomeCount, 0);
+
+            // Number of programs that attempted a particular learning outcome
+            $attemptedUndergradProgramsPerOutcome = array_fill(1, $outcomeCount, 0);
+
+            // Fetch programs with participation for the school
+            $participating_undergrad_programs = DB::table('VIEW_participating_programs')
+                ->whereIn('semester_id', Session::get('semesters_ids'))
+                ->where('is_graduate', 0)
+                ->where('school_id', $school->id)
+                ->groupBy('id')
+                ->get();
+
+            $output = array();
+
+
+            // For each outcome 
+            foreach ($outcomes as $outcome)
+            {
+                // For each program with courses that do assessment
+                $programs_with_courses = Program::with(array('courses' => function($query){
+                    $query->whereNotNull('outcomes_attempted');
+                    $query->whereIn('semester_id', Session::get('semesters_ids'));
+                }))->where('is_graduate', 0)->where('school_id', $school->id)->orderBy('name', 'asc')->get();
+
+                foreach ($programs_with_courses as $program)
+                {
+                    // To acummulate all criteria for one program
+                    $achieved_outcomes_per_undergrad_program = array_fill(1, $outcomeCount, 0);
+                    $attempted_outcomes_per_undergrad_program = array_fill(1, $outcomeCount, 0);
+
+                    //Flag for counting programs
+                    $flag =false;
+
+                    // For each course in the program
+                    foreach ($program->courses as $course)
+                    {
+                        // If the outcome in question is being evaluated
+                        $course_outcomes_attempted2 = json_decode($course->outcomes_attempted, true);
+                        $course_outcomes_achieved2 = json_decode($course->outcomes_achieved, true);
+                        if(array_key_exists($outcome->id, $course_outcomes_attempted2 )
+                            && $course_outcomes_attempted2[$outcome->id]>0)
+                        {
+                            $achieved_outcomes_per_undergrad_program[$outcome->id]+=$course_outcomes_achieved2[$outcome->id];
+                            $attempted_outcomes_per_undergrad_program[$outcome->id]+=$course_outcomes_attempted2[$outcome->id];
+
+                            // Add one to the programs assessing, if it wasn't added before
+                            if(!$flag)
+                            {
+                                $attemptedUndergradProgramsPerOutcome[$outcome->id]+=1;
+                                $flag= true;
+                            }
+                        }
+
+                        // $output[] = 'ACHIEVED: '.$program->name.'-'.json_encode($achieved_outcomes_per_undergrad_program);
+                        // $output[] = 'ATTEMPTED: '.$program->name.'-'.json_encode($attempted_outcomes_per_program);
+
+                    }
+                    //If the accumulated achieved criteria for a specific outcome in a program divided by the accumulated attempted criteria for a specific outcome in a program is greated than the expected outcome
+                    if($attempted_outcomes_per_undergrad_program[$outcome->id]!=0 && (float)$achieved_outcomes_per_undergrad_program[$outcome->id]/$attempted_outcomes_per_undergrad_program[$outcome->id]*100 >= $outcome->expected_outcome)
+                    {
+                        $achievedUndergradProgramsPerOutcome[$outcome->id]+=1;
+                        // $output[]= 'END OF PROGRAM: '.$program->name.'-'.json_encode($achievedProgramsPerOutcome);
+                    }
+                }
+            }
+
+            /**
+             * Calculate how many programs achieved and attempted each outcome in this school
+             */
+
+            // Number of programs that achieved a particular learning outcome
+            $achievedGradProgramsPerOutcome = array_fill(1, $outcomeCount, 0);
+
+            // Number of programs that attempted a particular learning outcome
+            $attemptedGradProgramsPerOutcome = array_fill(1, $outcomeCount, 0);
+
+            // Fetch programs with participation for the school
+            $participating_grad_programs = DB::table('VIEW_participating_programs')
+                ->whereIn('semester_id', Session::get('semesters_ids'))
+                ->where('is_graduate', 1)
+                ->where('school_id', $school->id)
+                ->groupBy('id')
+                ->get();
+
+            $output = array();
+
+
+            // For each outcome 
+            foreach ($outcomes as $outcome)
+            {
+                // For each program with courses that do assessment
+                $programs_with_courses = Program::with(array('courses' => function($query){
+                    $query->whereNotNull('outcomes_attempted');
+                    $query->whereIn('semester_id', Session::get('semesters_ids'));
+                }))->where('is_graduate', 1)->where('school_id', $school->id)->orderBy('name', 'asc')->get();
+
+                foreach ($programs_with_courses as $program)
+                {
+                    // To acummulate all criteria for one program
+                    $achieved_outcomes_per_grad_program = array_fill(1, $outcomeCount, 0);
+                    $attempted_outcomes_per_grad_program = array_fill(1, $outcomeCount, 0);
+
+                    //Flag for counting programs
+                    $flag =false;
+
+                    // For each course in the program
+                    foreach ($program->courses as $course)
+                    {
+                        // If the outcome in question is being evaluated
+                        $course_outcomes_attempted2 = json_decode($course->outcomes_attempted, true);
+                        $course_outcomes_achieved2 = json_decode($course->outcomes_achieved, true);
+                        if(array_key_exists($outcome->id, $course_outcomes_attempted2 )
+                            && $course_outcomes_attempted2[$outcome->id]>0)
+                        {
+                            $achieved_outcomes_per_grad_program[$outcome->id]+=$course_outcomes_achieved2[$outcome->id];
+                            $attempted_outcomes_per_grad_program[$outcome->id]+=$course_outcomes_attempted2[$outcome->id];
+
+                            // Add one to the programs assessing, if it wasn't added before
+                            if(!$flag)
+                            {
+                                $attemptedGradProgramsPerOutcome[$outcome->id]+=1;
+                                $flag= true;
+                            }
+                        }
+
+                        // $output[] = 'ACHIEVED: '.$program->name.'-'.json_encode($achieved_outcomes_per_grad_program);
+                        // $output[] = 'ATTEMPTED: '.$program->name.'-'.json_encode($attempted_outcomes_per_program);
+
+                    }
+                    //If the accumulated achieved criteria for a specific outcome in a program divided by the accumulated attempted criteria for a specific outcome in a program is greated than the expected outcome
+                    if($attempted_outcomes_per_grad_program[$outcome->id]!=0 && (float)$achieved_outcomes_per_grad_program[$outcome->id]/$attempted_outcomes_per_grad_program[$outcome->id]*100 >= $outcome->expected_outcome)
+                    {
+                        $achievedGradProgramsPerOutcome[$outcome->id]+=1;
+                        // $output[]= 'END OF PROGRAM: '.$program->name.'-'.json_encode($achievedProgramsPerOutcome);
+                    }
+                }
+            }
+            return View::make('local.managers.shared.school', compact('title', 'outcomes','undergrad_programs', 'grad_programs', 'undergrad_outcomes_attempted', 'grad_outcomes_attempted', 'undergrad_outcomes_achieved', 'grad_outcomes_achieved', 'schools', 'school', 'undergrad_assessed_sections_count', 'grad_assessed_sections_count', 'undergrad_school_sections_count', 'grad_school_sections_count', 'achievedUndergradProgramsPerOutcome', 'achievedGradProgramsPerOutcome', 'attemptedUndergradProgramsPerOutcome', 'attemptedGradProgramsPerOutcome', 'grad_grouped_courses', 'undergrad_grouped_courses', 'participating_programs', 'participating_undergrad_programs', 'participating_grad_programs'));
+        }
+
+}

app/controllers/SchoolsController.php

@@ -0,0 +1,409 @@
+<?php
+
+class SchoolsController extends \BaseController
+{
+
+    private function participatingPrograms($school)
+    {
+        return DB::table('VIEW_participating_programs')
+            ->where('school_id', $school->id)
+            ->whereIn('semester_id', Session::get('semesters_ids'))
+            ->lists('id');
+    }
+
+	public function show($id)
+	{
+        ini_set('memory_limit', '256M');
+        DB::connection()->disableQueryLog();
+        $school = School::find($id);
+        $title= $school->name;
+        $schools = School::all();
+
+        $outcomes = Outcome::orderBy('name', 'asc')->get();
+        $outcomeCount = Outcome::all()->count();
+
+
+        /**
+         * List of grouped courses (grouped sections)
+         */
+
+        $program_ids= $school->programs->lists('id');
+
+        $undergrad_programs = DB::table('programs')
+        ->select('id', 'name', 'school_id', 'is_graduate')
+        ->where('is_graduate', '=', 0)
+        ->where('school_id', '=', $id)
+        ->orderBy('name', 'ASC')
+        ->get();
+
+        $grad_programs = DB::table('programs')
+        ->select('id', 'name', 'school_id', 'is_graduate')
+        ->where('is_graduate', '=', 1)
+        ->where('school_id', '=', $id)
+        ->orderBy('name', 'ASC')
+        ->get();
+   
+
+        $grad_grouped_courses = Course::
+            select(DB::raw('courses.name, courses.code, courses.number, max(courses.outcomes_attempted) as outcomes_attempted, courses.semester_id, courses.program_id'))
+            ->with('semester')
+            ->with('program')
+            ->whereIn('courses.program_id', $program_ids)
+            ->whereIn('courses.semester_id', Session::get('semesters_ids'))
+            ->leftJoin('programs', 'courses.program_id', '=', 'programs.id')
+            ->where('programs.is_graduate', '=', 1)
+            ->groupBy(array('courses.code', 'courses.number', 'courses.semester_id'))
+            ->orderBy('courses.code')
+            ->orderBy('courses.number')
+            ->orderBy('courses.semester_id')
+            ->get();
+
+        $undergrad_grouped_courses = Course::
+            select(DB::raw('courses.name, courses.code, courses.number, max(courses.outcomes_attempted) as outcomes_attempted, courses.semester_id, courses.program_id'))
+            ->with('semester')
+            ->with('program')
+            ->whereIn('courses.program_id', $program_ids)
+            ->whereIn('courses.semester_id', Session::get('semesters_ids'))
+            ->leftJoin('programs', 'courses.program_id', '=', 'programs.id')
+            ->where('programs.is_graduate', '=', 0)
+            ->groupBy(array('courses.code', 'courses.number', 'courses.semester_id'))
+            ->orderBy('courses.code')
+            ->orderBy('courses.number')
+            ->orderBy('courses.semester_id')
+            ->get();
+
+        // Fetch programs with participation
+        $participating_programs = $this->participatingPrograms($school);
+
+
+        /**
+         * Calculate how many sections are doing assessment
+         */
+
+        $undergrad_outcomes_achieved = array_fill(1, $outcomeCount, 0);
+        $undergrad_outcomes_attempted = array_fill(1, $outcomeCount, 0);
+        $undergrad_assessed_sections_count = 0;
+        $undergrad_school_sections_count = 0;
+
+        $grad_outcomes_achieved = array_fill(1, $outcomeCount, 0);
+        $grad_outcomes_attempted = array_fill(1, $outcomeCount, 0);
+        $grad_assessed_sections_count = 0;
+        $grad_school_sections_count = 0;
+
+        foreach($school->programs as $program)
+        {
+        	foreach ($program->courses as $course)
+        	{
+                if(!$course->program->is_graduate)
+                {
+                    if($course->outcomes_achieved != NULL)
+                    {
+                        $course_outcomes_achieved =json_decode($course->outcomes_achieved, true);
+                        $course_outcomes_attempted =json_decode($course->outcomes_attempted, true);
+                        for($i=1; $i<=count($undergrad_outcomes_attempted); $i++)
+                        {
+                            $undergrad_outcomes_achieved[$i]+=$course_outcomes_achieved[$i];
+                            $undergrad_outcomes_attempted[$i]+=$course_outcomes_attempted[$i];
+                        }
+                        $undergrad_assessed_sections_count+=1;
+                    }
+                    $undergrad_school_sections_count+=1;
+                }
+                else
+                {
+                    if($course->outcomes_achieved != NULL)
+                    {
+                        $course_outcomes_achieved =json_decode($course->outcomes_achieved, true);
+                        $course_outcomes_attempted =json_decode($course->outcomes_attempted, true);
+                        for($i=1; $i<=count($grad_outcomes_attempted); $i++)
+                        {
+                            $grad_outcomes_achieved[$i]+=$course_outcomes_achieved[$i];
+                            $grad_outcomes_attempted[$i]+=$course_outcomes_attempted[$i];
+                        }
+                        $grad_assessed_sections_count+=1;
+                    }
+                    $grad_school_sections_count+=1;
+                }
+            }    
+        }
+
+        /**
+         * Calculate how many programs achieved and attempted each outcome in this school
+         */
+
+        // Number of programs that achieved a particular learning outcome
+        $achievedUndergradProgramsPerOutcome = array_fill(1, $outcomeCount, 0);
+
+        // Number of programs that attempted a particular learning outcome
+        $attemptedUndergradProgramsPerOutcome = array_fill(1, $outcomeCount, 0);
+
+        // Fetch programs with participation for the school
+        $participating_undergrad_programs = DB::table('VIEW_participating_programs')
+            ->whereIn('semester_id', Session::get('semesters_ids'))
+            ->where('is_graduate', 0)
+            ->where('school_id', $school->id)
+            ->groupBy('id')
+            ->get();
+
+        $output = array();
+
+
+        // For each outcome 
+        foreach ($outcomes as $outcome)
+        {
+            // For each program with courses that do assessment
+            $programs_with_courses = Program::with(array('courses' => function($query){
+                $query->whereNotNull('outcomes_attempted');
+                $query->whereIn('semester_id', Session::get('semesters_ids'));
+            }))->where('is_graduate', 0)->where('school_id', $school->id)->orderBy('name', 'asc')->get();
+
+            foreach ($programs_with_courses as $program)
+            {
+                // To acummulate all criteria for one program
+                $achieved_outcomes_per_undergrad_program = array_fill(1, $outcomeCount, 0);
+                $attempted_outcomes_per_undergrad_program = array_fill(1, $outcomeCount, 0);
+
+                //Flag for counting programs
+                $flag =false;
+
+                // For each course in the program
+                foreach ($program->courses as $course)
+                {
+                    // If the outcome in question is being evaluated
+                    $course_outcomes_attempted2 = json_decode($course->outcomes_attempted, true);
+                    $course_outcomes_achieved2 = json_decode($course->outcomes_achieved, true);
+                    if(array_key_exists($outcome->id, $course_outcomes_attempted2 )
+                        && $course_outcomes_attempted2[$outcome->id]>0)
+                    {
+                        $achieved_outcomes_per_undergrad_program[$outcome->id]+=$course_outcomes_achieved2[$outcome->id];
+                        $attempted_outcomes_per_undergrad_program[$outcome->id]+=$course_outcomes_attempted2[$outcome->id];
+
+                        // Add one to the programs assessing, if it wasn't added before
+                        if(!$flag)
+                        {
+                            $attemptedUndergradProgramsPerOutcome[$outcome->id]+=1;
+                            $flag= true;
+                        }
+                    }
+
+                    // $output[] = 'ACHIEVED: '.$program->name.'-'.json_encode($achieved_outcomes_per_undergrad_program);
+                    // $output[] = 'ATTEMPTED: '.$program->name.'-'.json_encode($attempted_outcomes_per_program);
+
+                }
+                //If the accumulated achieved criteria for a specific outcome in a program divided by the accumulated attempted criteria for a specific outcome in a program is greated than the expected outcome
+                if($attempted_outcomes_per_undergrad_program[$outcome->id]!=0 && (float)$achieved_outcomes_per_undergrad_program[$outcome->id]/$attempted_outcomes_per_undergrad_program[$outcome->id]*100 >= $outcome->expected_outcome)
+                {
+                    $achievedUndergradProgramsPerOutcome[$outcome->id]+=1;
+                    // $output[]= 'END OF PROGRAM: '.$program->name.'-'.json_encode($achievedProgramsPerOutcome);
+                }
+            }
+        }
+
+        /**
+         * Calculate how many programs achieved and attempted each outcome in this school
+         */
+
+        // Number of programs that achieved a particular learning outcome
+        $achievedGradProgramsPerOutcome = array_fill(1, $outcomeCount, 0);
+
+        // Number of programs that attempted a particular learning outcome
+        $attemptedGradProgramsPerOutcome = array_fill(1, $outcomeCount, 0);
+
+        // Fetch programs with participation for the school
+        $participating_grad_programs = DB::table('VIEW_participating_programs')
+            ->whereIn('semester_id', Session::get('semesters_ids'))
+            ->where('is_graduate', 1)
+            ->where('school_id', $school->id)
+            ->groupBy('id')
+            ->get();
+
+        $output = array();
+
+
+        // For each outcome 
+        foreach ($outcomes as $outcome)
+        {
+            // For each program with courses that do assessment
+            $programs_with_courses = Program::with(array('courses' => function($query){
+                $query->whereNotNull('outcomes_attempted');
+                $query->whereIn('semester_id', Session::get('semesters_ids'));
+            }))->where('is_graduate', 1)->where('school_id', $school->id)->orderBy('name', 'asc')->get();
+
+            foreach ($programs_with_courses as $program)
+            {
+                // To acummulate all criteria for one program
+                $achieved_outcomes_per_grad_program = array_fill(1, $outcomeCount, 0);
+                $attempted_outcomes_per_grad_program = array_fill(1, $outcomeCount, 0);
+
+                //Flag for counting programs
+                $flag =false;
+
+                // For each course in the program
+                foreach ($program->courses as $course)
+                {
+                    // If the outcome in question is being evaluated
+                    $course_outcomes_attempted2 = json_decode($course->outcomes_attempted, true);
+                    $course_outcomes_achieved2 = json_decode($course->outcomes_achieved, true);
+                    if(array_key_exists($outcome->id, $course_outcomes_attempted2 )
+                        && $course_outcomes_attempted2[$outcome->id]>0)
+                    {
+                        $achieved_outcomes_per_grad_program[$outcome->id]+=$course_outcomes_achieved2[$outcome->id];
+                        $attempted_outcomes_per_grad_program[$outcome->id]+=$course_outcomes_attempted2[$outcome->id];
+
+                        // Add one to the programs assessing, if it wasn't added before
+                        if(!$flag)
+                        {
+                            $attemptedGradProgramsPerOutcome[$outcome->id]+=1;
+                            $flag= true;
+                        }
+                    }
+
+                    // $output[] = 'ACHIEVED: '.$program->name.'-'.json_encode($achieved_outcomes_per_grad_program);
+                    // $output[] = 'ATTEMPTED: '.$program->name.'-'.json_encode($attempted_outcomes_per_program);
+
+                }
+                //If the accumulated achieved criteria for a specific outcome in a program divided by the accumulated attempted criteria for a specific outcome in a program is greated than the expected outcome
+                if($attempted_outcomes_per_grad_program[$outcome->id]!=0 && (float)$achieved_outcomes_per_grad_program[$outcome->id]/$attempted_outcomes_per_grad_program[$outcome->id]*100 >= $outcome->expected_outcome)
+                {
+                    $achievedGradProgramsPerOutcome[$outcome->id]+=1;
+                    // $output[]= 'END OF PROGRAM: '.$program->name.'-'.json_encode($achievedProgramsPerOutcome);
+                }
+            }
+        }
+        if($school->id == 13){
+            return View::make('local.managers.shared.school-uhs', compact('title', 'outcomes','undergrad_programs', 'grad_programs', 'undergrad_outcomes_attempted', 'grad_outcomes_attempted', 'undergrad_outcomes_achieved', 'grad_outcomes_achieved', 'schools', 'school', 'undergrad_assessed_sections_count', 'grad_assessed_sections_count', 'undergrad_school_sections_count', 'grad_school_sections_count', 'achievedUndergradProgramsPerOutcome', 'achievedGradProgramsPerOutcome', 'attemptedUndergradProgramsPerOutcome', 'attemptedGradProgramsPerOutcome', 'grad_grouped_courses', 'undergrad_grouped_courses', 'participating_programs', 'participating_undergrad_programs', 'participating_grad_programs'));
+        }else{
+            return View::make('local.managers.shared.school', compact('title', 'outcomes','undergrad_programs', 'grad_programs', 'undergrad_outcomes_attempted', 'grad_outcomes_attempted', 'undergrad_outcomes_achieved', 'grad_outcomes_achieved', 'schools', 'school', 'undergrad_assessed_sections_count', 'grad_assessed_sections_count', 'undergrad_school_sections_count', 'grad_school_sections_count', 'achievedUndergradProgramsPerOutcome', 'achievedGradProgramsPerOutcome', 'attemptedUndergradProgramsPerOutcome', 'attemptedGradProgramsPerOutcome', 'grad_grouped_courses', 'undergrad_grouped_courses', 'participating_programs', 'participating_undergrad_programs', 'participating_grad_programs'));
+        }
+    }
+
+    public function print_school($id)
+    {
+        ini_set('memory_limit', '256M');
+        DB::connection()->disableQueryLog();
+
+        $school = School::find($id);
+        $title= $school->name.' Assessment Report - '.date('m/d/Y');
+
+        $outcomes = Outcome::orderBy('name', 'asc')->get();
+        $outcomeCount = Outcome::all()->count();
+
+
+
+
+        /**
+         * List of courses (grouped sections)
+         */
+
+        $program_ids= $school->programs->lists('id');
+
+        $grouped_courses = Course::
+            select(DB::raw('name, code, number, max(outcomes_attempted) as outcomes_attempted, semester_id, program_id'))
+            ->with('semester')
+            ->with('program')
+            ->whereIn('program_id', $program_ids)
+            ->whereIn('semester_id', Session::get('semesters_ids'))
+            ->groupBy(array('code', 'number', 'semester_id'))
+            ->orderBy('code')
+            ->orderBy('number')
+            ->orderBy('semester_id')
+            ->get();
+
+        // Fetch programs with participation
+        $participating_programs = $this->participatingPrograms($school);
+
+        /**
+         * Calculate how many sections are doing assessment
+         */
+
+        $outcomes_achieved = array_fill(1, $outcomeCount, 0);
+        $outcomes_attempted = array_fill(1, $outcomeCount, 0);
+        $assessed_sections_count = 0;
+        $school_sections_count = 0;
+
+        foreach($school->programs as $program)
+        {
+            foreach ($program->courses as $course)
+            {
+              if($course->outcomes_achieved!=NULL)
+              {
+                $course_outcomes_achieved =json_decode($course->outcomes_achieved, true);
+                $course_outcomes_attempted =json_decode($course->outcomes_attempted, true);
+                for($i=1; $i<=count($outcomes_attempted); $i++)
+                {
+                  $outcomes_achieved[$i]+=$course_outcomes_achieved[$i];
+                  $outcomes_attempted[$i]+=$course_outcomes_attempted[$i];
+                }
+
+                $assessed_sections_count+=1;
+              }
+              $school_sections_count+=1;
+            }
+        }
+
+        /**
+         * Calculate how many programs achieved and attempted each outcome in this school
+         */
+
+        // Number of programs that achieved a particular learning outcome
+        $achievedProgramsPerOutcome = array_fill(1, $outcomeCount, 0);
+
+        // Number of programs that attempted a particular learning outcome
+        $attemptedProgramsPerOutcome = array_fill(1, $outcomeCount, 0);
+
+        $output = array();
+
+
+        // For each outcome
+        foreach ($outcomes as $outcome)
+        {
+            // For each program with courses that do assessment
+            foreach (Program::with(array('courses' => function($query){
+                $query->whereNotNull('outcomes_attempted');
+                $query->whereIn('semester_id', Session::get('semesters_ids'));
+            }))->where('school_id', $school->id)->orderBy('name', 'asc')->get() as $program)
+            {
+                // To acummulate all criteria for one program
+                $achieved_outcomes_per_program = array_fill(1, $outcomeCount, 0);
+                $attempted_outcomes_per_program = array_fill(1, $outcomeCount, 0);
+
+                //Flag for counting programs
+                $flag =false;
+
+                // For each course in the program
+                foreach ($program->courses as $course)
+                {
+                    // If the outcome in question is being evaluated
+                    $course_outcomes_attempted2 = json_decode($course->outcomes_attempted, true);
+                    $course_outcomes_achieved2 = json_decode($course->outcomes_achieved, true);
+                    if(array_key_exists($outcome->id, $course_outcomes_attempted2 )
+                        && $course_outcomes_attempted2[$outcome->id]>0)
+                    {
+                        $achieved_outcomes_per_program[$outcome->id]+=$course_outcomes_achieved2[$outcome->id];
+                        $attempted_outcomes_per_program[$outcome->id]+=$course_outcomes_attempted2[$outcome->id];
+
+                        // Add one to the programs assessing, if it wasn't added before
+                        if(!$flag)
+                        {
+                            $attemptedProgramsPerOutcome[$outcome->id]+=1;
+                            $flag= true;
+                        }
+                    }
+
+                    // $output[] = 'ACHIEVED: '.$program->name.'-'.json_encode($achieved_outcomes_per_program);
+                    // $output[] = 'ATTEMPTED: '.$program->name.'-'.json_encode($attempted_outcomes_per_program);
+
+                }
+                //If the accumulated achieved criteria for a specific outcome in a program divided by the accumulated attempted criteria for a specific outcome in a program is greated than the expected outcome
+                if($attempted_outcomes_per_program[$outcome->id]!=0 && (float)$achieved_outcomes_per_program[$outcome->id]/$attempted_outcomes_per_program[$outcome->id]*100 >= $outcome->expected_outcome)
+                {
+                    $achievedProgramsPerOutcome[$outcome->id]+=1;
+                    // $output[]= 'END OF PROGRAM: '.$program->name.'-'.json_encode($achievedProgramsPerOutcome);
+                }
+            }
+        }
+
+       return View::make('local.managers.shared.print_school', compact('title', 'outcomes', 'outcomes_attempted', 'outcomes_achieved', 'school', 'assessed_sections_count', 'school_sections_count', 'achievedProgramsPerOutcome', 'attemptedProgramsPerOutcome', 'grouped_courses', 'participating_programs'));
+    }
+
+}

app/controllers/SectionsController.php

@@ -0,0 +1,82 @@
+<?php namespace App\Http\Controllers;
+
+use App\Http\Requests;
+use App\Http\Controllers\Controller;
+
+class SectionsController extends Controller {
+
+	/**
+	 * Display a listing of the resource.
+	 *
+	 * @return Response
+	 */
+	public function index()
+	{
+		//
+	}
+
+	/**
+	 * Show the form for creating a new resource.
+	 *
+	 * @return Response
+	 */
+	public function create()
+	{
+		//
+	}
+
+	/**
+	 * Store a newly created resource in storage.
+	 *
+	 * @return Response
+	 */
+	public function store()
+	{
+		//
+	}
+
+	/**
+	 * Display the specified resource.
+	 *
+	 * @param  int  $id
+	 * @return Response
+	 */
+	public function show($id)
+	{
+		//
+	}
+
+	/**
+	 * Show the form for editing the specified resource.
+	 *
+	 * @param  int  $id
+	 * @return Response
+	 */
+	public function edit($id)
+	{
+		//
+	}
+
+	/**
+	 * Update the specified resource in storage.
+	 *
+	 * @param  int  $id
+	 * @return Response
+	 */
+	public function update($id)
+	{
+		//
+	}
+
+	/**
+	 * Remove the specified resource from storage.
+	 *
+	 * @param  int  $id
+	 * @return Response
+	 */
+	public function destroy($id)
+	{
+		//
+	}
+
+}

app/controllers/SemestersController.php

@@ -0,0 +1,101 @@
+<?php 
+
+class SemestersController extends \BaseController {
+
+	public function filterSemesters()
+	{
+		$semesters_ids = array();
+		$semesters_info = array();
+
+		if(count(Input::get('semesters_ids')))
+		{
+			// For each selected semester, fetch its info to add to the Session arrays
+			foreach (Input::get('semesters_ids') as $semester_id) {
+				$semesters_ids[] = $semester_id;
+				$semester = Semester::find($semester_id);
+				$semesters_info[] = $semester->name.' ('.$semester->code.')';
+
+			}
+
+			// Put semesters information arrays into Session
+			Session::forget('semesters_ids');
+			Session::put('semesters_ids', $semesters_ids);
+			Session::forget('semesters_info');
+			Session::put('semesters_info', $semesters_info);
+		}
+
+		return Redirect::back();
+	}
+
+	public function edit()
+	{
+		$title = "Semester Management";
+		$semesters = Semester::all();
+
+		return View::make('local.managers.admins.semesters', compact('title', 'semesters'));
+	}
+
+	public function update()
+	{
+		/** Validate data */
+		$validator = Validator::make(
+			Input::all(),
+			array(
+				'id'=>'required|integer',
+    			'start'=>'required|date_format:m/d/y H:i:s',
+    			'end'=>'required|date_format:m/d/y H:i:s',
+    			'visible'=>'required|integer',
+			),
+			array(
+				'start.date_format' => 'The start date must be in this format: mm/dd/yyyy hh:mm:ss',
+				'end.date_format' => 'The end date must be in this format: mm/dd/yyyy hh:mm:ss',
+			)
+		);
+
+		if(!$validator->fails())
+		{
+
+			$semester = Semester::find(Input::get('id'));
+			$semester->start = date('Y-m-d H:i:s', strtotime(Input::get('start')));
+			$semester->end = date('Y-m-d H:i:s', strtotime(Input::get('end')));
+			// $semester->start = strtotime(Input::get('start'));
+			// $semester->end = strtotime(Input::get('end'));
+			$semester->is_visible = Input::get('visible');
+
+			try 
+			{
+				if($semester->save())
+				{
+					Session::flash('status', 'success');
+				 	Session::flash('message', $semester->name.' updated ('.date('m/d/y h:i:s a').').');
+				}
+				else
+				{
+					Session::flash('status', 'danger');
+					Session::flash('message', 'Error updating '.$semester->name.'. Try again later. If the problem persists, contact a super-administrator ('.date('m/d/y h:i:s a').').');	
+				}
+			} catch (Exception $e) {
+					Session::flash('status', 'danger');
+					Session::flash('message', 'Error updating '.$semester->name.'. Contact a super-administrator ('.date('m/d/y h:i:s a').').');	
+						
+			}
+		}
+		else
+		{
+            /** Prepare error message */
+            $message = '<ul>';
+
+            foreach ($validator->messages()->all('<li>:message</li>') as $validationError)
+            {
+                $message.=$validationError;
+            }
+
+            $message.='</ul>';
+
+			Session::flash('status', 'danger');
+			Session::flash('message', $message);
+		}
+	}
+
+
+}

app/controllers/StudentsController.php

@@ -0,0 +1,138 @@
+<?php
+
+class StudentsController extends \BaseController {
+
+  public function show($semester_id, $course_identifier, $number)
+  {
+
+  	$student = Student::where('number', '=', $number)->first();
+  	$code = substr($course_identifier, 0, 4);
+  	$number = substr($course_identifier, 4, 4);
+  	$section = substr($course_identifier, 9, 4);
+  	$course = Course::where('code', $code)->where('number', $number)->where('section', $section)->where('semester_id', $semester_id)->first();
+  	$title = $student->name;
+
+  	$activities = $course->assessedActivities;
+  	$activitiesArray = array();
+  	foreach ($activities as $activity)
+  	{
+  		$activitiesArray[]=$activity->id;
+  	}
+
+    // If the student has be assessed
+    if(!$activities->isEmpty())
+    {
+      // Get the assessments
+      $assessments = DB::table('assessments')->whereIn('activity_id', $activitiesArray)->where('student_id', '=', $student->id)->orderBy('created_at')->get();
+
+      // foreach ($assessments as $assessed_activity)
+      // {
+      //   $outcomes_achieved = array_fill(1, Outcome::all()->count(), 0);
+      //   $outcomes_attempted = array_fill(1, Outcome::all()->count(), 0);
+
+      //   $single_activity_scores = json_decode($assessed_activity->scores);
+      //   foreach($single_activity_scores as $criterion_id => $criterion_score)
+      //   {
+      //       // Find corresponding learning outcome;
+      //       $criterion = Criterion::withTrashed()->find($criterion_id);
+      //       $outcome = Outcome::find($criterion->outcome_id);
+
+      //       // If criterion is achieved (1), add 1 to all arrays
+      //       if($criterion_score >= Rubric::find($activity->rubric_id)->expected_points)
+      //       {
+      //           $outcomes_attempted[$outcome->id]+=1;
+      //           $outcomes_achieved[$outcome->id]+=1;;
+      //       }
+      //       // Else, only add to the attempted outcomes array
+      //       else
+      //       {
+      //           $outcomes_attempted[$outcome->id]+=1;
+      //       }
+      //   }
+
+      //   $outcomes_per_activity = array_fill(1, Outcome::all()->count(), 0);
+      //   foreach ($outcomes_attempted as $index=>$outcome_attempted)
+      //   {
+      //     if($outcomes_attempted[$index]!=0)
+      //     {
+      //       // For each outcome in the activity, calculate and save the percentage
+      //       $outcomes_per_activity[$index] = (float)$outcomes_achieved[$index]/$outcomes_attempted[$index]*100;
+      //     }
+      //   }
+
+      //   //Save to activity array
+      //   $activitiesArray[]=$outcomes_per_activity;
+      // }
+    }
+    else
+      $assessments = NULL;
+
+    return View::make('local.professors.student', compact('student', 'course', 'title', 'assessments'));
+  }
+
+  public function printStudentReport($semester_id, $course_identifier, $number)
+  {
+
+    $student = Student::where('number', '=', $number)->first();
+    $code = substr($course_identifier, 0, 4);
+    $number = substr($course_identifier, 4, 4);
+    $section = substr($course_identifier, 9, 4);
+    $course = Course::where('code', $code)->where('number', $number)->where('section', $section)->where('semester_id', $semester_id)->first();
+    $title = $student->name;
+
+    $activities = $course->assessedActivities;
+    $activitiesArray = array();
+    foreach ($activities as $activity)
+    {
+      $activitiesArray[]=$activity->id;
+    }
+
+    if(!$activities->isEmpty())
+    {
+      $assessments = DB::table('assessments')->whereIn('activity_id', $activitiesArray)->where('student_id', '=', $student->id)->get();
+
+      foreach ($assessments as $assessed_activity)
+      {
+        $outcomes_achieved = array_fill(1, Outcome::all()->count(), 0);
+        $outcomes_attempted = array_fill(1, Outcome::all()->count(), 0);
+
+        $single_activity_scores = json_decode($assessed_activity->scores);
+        foreach($single_activity_scores as $criterion_id=>$criterion_score)
+        {
+            // Find corresponding learning outcome;
+            $criterion = Criterion::withTrashed()->find($criterion_id);
+            $outcome = Outcome::find($criterion->outcome_id);
+
+            // If criterion is achieved (1), add 1 to all arrays
+            if($criterion_score >= Rubric::find($activity->rubric_id)->expected_points)
+            {
+                $outcomes_attempted[$outcome->id]+=1;
+                $outcomes_achieved[$outcome->id]+=1;;
+            }
+            // Else, only add to the attempted outcomes array
+            else
+            {
+                $outcomes_attempted[$outcome->id]+=1;
+            }
+        }
+
+        $outcomes_per_activity = array_fill(1, Outcome::all()->count(), 0);
+        foreach ($outcomes_attempted as $index=>$outcome_attempted)
+        {
+          if($outcomes_attempted[$index]!=0)
+          {
+            // For each outcome in the activity, calculate and save the percentage
+            $outcomes_per_activity[$index] = (float)$outcomes_achieved[$index]/$outcomes_attempted[$index]*100;
+          }
+        }
+
+        //Save to activity array
+        $activitiesArray[]=$outcomes_per_activity;
+      }
+    }
+    else
+      $assessments = NULL;
+
+    return View::make('local.professors.print_student_report', compact('student', 'course', 'title', 'assessments', 'activitiesArray'));
+  }
+}

app/controllers/TemplatesController.php

@@ -0,0 +1,248 @@
+<?php
+
+class TemplatesController extends \BaseController {
+
+	/**
+	 * List all templates, grouped by program
+	 */
+	public function index()
+	{
+		$title = 'Rubric List';
+
+		$global_templates = Template::whereNull('school_id')->whereNull('program_id')->get();
+
+		$schools = School::with('programs.templates')
+		->orderBy('name')
+		->get();
+
+		$templates = Template::orderBy('name')->get();
+
+		return View::make('local.managers.admins.rubric_list', compact('title', 'global_templates','schools', 'templates'));
+	}
+
+	public function schoolCoordinatorIndex()
+	{
+		$title = 'Rubric List';
+
+		$global_templates = Template::whereNull('school_id')->whereNull('program_id')->get();
+
+		$schools = School::with('programs.templates')
+		->orderBy('name')
+		->get();
+
+		$templates = Template::orderBy('name')->get();
+
+		return View::make('local.managers.admins.rubric_list', compact('title', 'global_templates','schools', 'templates'));
+	}
+
+	public function show(Template $template)
+	{
+	    $title = $template->name;
+	    return View::make('local.managers.admins.view_template', compact('template', 'title'));
+	}
+
+	/**
+	 * Show the form for creating a new rubric
+	 *
+	 * @return Response
+	 */
+	public function newTemplate()
+	{
+		$title= "Rubric Builder";
+
+		$templates = Template::orderBy('name', 'ASC')->get();
+		$outcomes = Outcome::orderBy('name', 'ASC')->get();
+		$criteria = Criterion::orderBy('name', 'ASC')->get();
+		$schools = School::orderBy('name', 'ASC')->get();
+		$role = Auth::user()->role;
+
+		$templates = NULL;
+		$programs = NULL;
+		// Returns templates depending on the type of user
+		if( $role == 1)
+		{
+			$templates = Template::orderBy('name', 'ASC')->get();
+			$programs = Program::orderBy('name', 'ASC')->get();
+
+		} elseif ($role == 2)
+		{
+			$templates = Template::where('school_id', '=', Auth::user()->school->id )->orWhere('school_id', '=', NULL)->orderBy('name', 'ASC')->get();
+			$programs = Auth::user()->school->programs;
+		}
+		elseif ($role == 3)
+		{
+			$templates = Template::where('school_id', '=', Auth::user()->programs[0]->school->id)->orWhere('school_id', '=', NULL)->orderBy('name', 'ASC')->get();
+			$programs = Auth::user()->programs()->get();
+		}
+
+		return View::make('local.managers.shared.rubrics', compact('title', 'templates', 'outcomes', 'criteria', 'schools', 'programs'));
+	}
+
+	/**
+	 * Save a new rubric
+	 *
+	 * @return Response
+	 */
+	public function create()
+	{
+
+		$template = new Template;
+
+		$template->name = Input::get('name');
+		$template->contents = Input::get('contents');
+		$template->is_visible = Input::get('is_visible');
+		$template->expected_percentage = Input::get('expected_percentage');
+		$template->expected_points = Input::get('expected_points');
+
+		// If user can set the school (that is, if school_id is not undefined)
+		// set the school id or set to null
+		if(is_numeric(Input::get('school_id')))
+		{
+			if(Input::get('school_id')!=0)
+				$template->school_id = Input::get('school_id');
+			elseif(Input::get('school_id')==0)
+				$template->school_id = NULL;
+		}
+
+		// If user can set the program (that is, if program_id is not undefined)
+		// set the program id or set to null
+		if(is_numeric(Input::get('program_id')))
+		{
+			if(Input::get('program_id')!=0)
+				$template->program_id = Input::get('program_id');
+			elseif(Input::get('program_id')==0)
+				$template->program_id = NULL;
+		}
+
+		// If the user is any coordinator, set the school id
+		// If the user is a program coordinator, also set program id
+		switch (Auth::user()->role) {
+			case 2:
+				$template->school_id = Auth::user()->school->id;
+				break;
+
+			case 3:
+				$template->school_id = Auth::user()->programs[0]->school->id;
+				$template->program_id = Auth::user()->programs[0]->id;
+				break;
+		}
+
+		if($template->save())
+		{
+			Session::flash('status', 'success');
+			Session::flash('message', 'Rubric created. You can now select it from the list.');
+		}
+		else
+		{
+			Session::flash('status', 'danger');
+			Session::flash('message', 'Rubric could not be created.');
+		}
+	}
+
+	/**
+	 * Return a specific template
+	 *
+	 * @return Template
+	 */
+	public function fetch()
+	{
+		return Template::find(Input::get('id'));
+	}
+
+	/**
+	 * Update the specified resource in storage.
+	 *
+	 * @return Response
+	 */
+	public function update()
+	{
+		$template = Template::find(Input::get('id'));
+		$template->name = Input::get('name');
+		$template->contents = Input::get('contents');
+		$template->is_visible = Input::get('is_visible');
+		$template->expected_percentage = Input::get('expected_percentage');
+		$template->expected_points = Input::get('expected_points');
+
+
+		// If user can set the school (that is, if school_id is not undefined)
+		// set the school id or set to null
+		if(is_numeric(Input::get('school_id')))
+		{
+			if(Input::get('school_id')!=0)
+				$template->school_id = Input::get('school_id');
+			elseif(Input::get('school_id')==0)
+				$template->school_id = NULL;
+		}
+
+		// If user can set the program (that is, if program_id is not undefined)
+		// set the program id or set to null
+		if(is_numeric(Input::get('program_id')))
+		{
+			if(Input::get('program_id')!=0)
+				$template->program_id = Input::get('program_id');
+			elseif(Input::get('program_id')==0)
+				$template->program_id = NULL;
+		}
+
+		if($template->save())
+		{
+			Session::flash('status', 'success');
+			Session::flash('message', 'Rubric updated ('.date('m/d/y, h:i:s a').').');
+		}
+		else
+		{
+			Session::flash('status', 'danger');
+			Session::flash('message', 'Rubric could not be updated ('.date('m/d/y, h:i:s a').').');
+		}
+	}
+
+	/**
+	 * Remove the specified resource from storage.
+	 *
+	 * @return Response
+	 */
+	public function destroy()
+	{
+		$template = Template::find(Input::get('id'));
+
+		if($template->delete())
+		{
+			Session::flash('status', 'success');
+			Session::flash('message', 'Rubric deleted.');
+		}
+		else
+		{
+			Session::flash('status', 'danger');
+			Session::flash('message', 'Rubric could not be deleted.');
+		}
+
+		return;
+	}
+
+	public function printview($id)
+	{
+		try {
+			$template = Template::find($id);
+
+			$title = $template->name;
+
+			if($template->school_id!=NULL)
+				$school= $template->school->name;
+			else
+				$school = 'All Schools';
+
+			if($template->program_id!=NULL)
+				$program= $template->program->name;
+			else
+				$program = 'All Programs';
+
+			return View::make('local.managers.shared.print_rubric', compact('title', 'template', 'school', 'program'));
+		}
+		catch (Exception $e) {
+			Session::flash('status', 'danger');
+			Session::flash('message', $e->getMessage());
+			return Redirect::back();
+		}
+	}
+
+}

app/controllers/UsersController.php

@@ -0,0 +1,416 @@
+<?php
+
+class UsersController extends \BaseController {
+
+	/**
+	 * Display a listing of the users.
+	 *
+	 * @return Response
+	 */
+	public function index()
+	{
+		$title="Users";
+
+		$users = User::
+			with('programs', 'school')
+			->orderBy('surnames')
+			->orderBy('first_name')
+			->get();
+
+		$schools = School::orderBy('name', 'asc')->get();
+		$access_level  = count(User::select('role')->where('has_access', 1)->groupBy('role')->get());
+
+		return View::make('local.managers.admins.users', compact('title', 'users', 'schools', 'access_level'));
+	}
+
+	/**
+	 * Show the form for editing the user.
+	 *
+	 * @param  int  $id
+	 * @return Response
+	 */
+	public function edit()
+	{
+		$user = Auth::user();
+		$title = "Profile";
+		$schools = School::orderBy('name', 'asc')->get();
+		$programs = $user->programs;
+		return View::make('global.profile', compact('user', 'title', 'schools', 'programs'));
+	}
+
+	/**
+	 * Create the user in storage.
+	 *
+	 * @param  int  $id
+	 * @return Response
+	 */
+	public function store()
+    {
+    	$user = Auth::user();
+	    if(Input::get('submit_new_user') && Auth::user()->role==1)
+	    {
+
+	    	$first_name = strtoupper(Input::get('new_first_name'));
+	    	$surnames = strtoupper(Input::get('new_surnames'));
+	    	$email = strtolower(Input::get('new_email'));
+	    	$school_id = Input::get('new_school');
+
+	    	// Validation rules
+	        $validator = Validator::make(
+	            array(
+	                'first_name' => $first_name,
+	                'surnames' => $surnames,
+	                'email' => $email,
+	                'school_id' => $school_id,
+	            ),
+	            array(
+	                'first_name' => 'required',
+	                'surnames' => 'required',
+	                'email' => 'required|email',
+	                'school_id' => 'integer',
+	            )
+	        );
+
+	        /** If validation fails */
+	        if ($validator->fails())
+	        {
+	            /** Prepare error message */
+	            $message = 'Error(s) creating a user:<ul>';
+
+	            foreach ($validator->messages()->all('<li>:message</li>') as $validationError)
+	            {
+	                $message.=$validationError;
+	            }
+
+	            $message.='</ul>';
+
+	            /** Send error message and old data */
+	            Session::flash('status', 'danger');
+	            Session::flash('message', $message);
+	            return Redirect::back()->withInput();
+	        }
+
+
+	        DB::beginTransaction();
+	        try
+	        {
+                switch (Input::get('new_role'))
+                {
+                	case '1':
+
+                		User::create(array(
+                			'first_name' => $first_name,
+                			'surnames' => $surnames,
+                			'email'=> $email,
+                			'role'=> 1,
+                			'school_id'=> NULL,
+                			'has_access' => 1
+                		));
+                		break;
+
+                	case '2':
+                		User::create(array(
+                			'first_name' => $first_name,
+                			'surnames' => $surnames,
+                			'email'=> $email,
+                			'role'=> 2,
+                			'school_id'=> (int)Input::get('new_school'), // como que aqui
+                			'has_access' => 1
+                		));
+
+                		break;
+
+                	case '3':
+                		$user = User::create(array(
+                			'first_name' => $first_name,
+                			'surnames' => $surnames,
+                			'email'=> $email,
+                			'role'=> 3,
+                			'school_id'=> NULL,
+                			'has_access' => 1
+                		));
+
+                		// Attach new programs
+                		foreach (Input::get('programs') as $key => $program_id)
+                		{
+                			$user->programs()->attach($program_id);
+                		}
+
+                		$user->save();
+                		break;
+
+                	case '4':
+
+                		$user = User::create(array(
+                			'first_name' => $first_name,
+                			'surnames' => $surnames,
+                			'email'=> $email,
+                			'role'=> 4,
+                			'school_id'=> NULL,
+                			'has_access' => 1
+                		));
+
+                		// Attach new programs
+                		foreach (Input::get('new_programs') as $key => $program_id)
+                		{
+                			$user->programs()->attach($program_id);
+                		}
+                		$user->save();
+                		break;
+                }
+
+	            DB::commit();
+
+                Session::flash('status', 'success');
+                Session::flash('message', 'User created ('.date('m/d/y h:i:s A').')');
+                return Redirect::back();
+
+	        }
+	        catch(Exception $e)
+	        {
+	        	DB::rollBack();
+
+	            Session::flash('status', 'danger');
+	            Session::flash('message', 'Error creating. Try again later or contact the system administrator.');
+
+	            return Redirect::back();
+	        }
+	    }
+	    else
+	    	App::abort('404');
+    }
+
+	/**
+	 * Update the user in storage.
+	 *
+	 * @param  int  $id
+	 * @return Response
+	 */
+	public function update()
+    {
+    	$user = Auth::user();
+        if(Input::get('submit_contact_info'))
+    	{
+	        // Validation rules
+	        $validator = Validator::make(
+	            array(
+                    'office_phone' => Input::get('office_phone'),
+                    'office_extension' => Input::get('office_extension'),
+	                'cell_phone' => Input::get('cell_phone'),
+	            ),
+	            array(
+                    'office_phone' => 'string|max:20|required_with:office_extension',
+	                'office_extension' => 'digits_between:1,5|required_with:office_phone|unique:users,office_extension,'.$user->id,
+                    'cell_phone' => 'string|max:20'
+	            )
+	        );
+
+	        /** If validation fails */
+	        if ($validator->fails())
+	        {
+	            /** Prepare error message */
+	            $message = 'Error(s) updating your Contact nformation<ul>';
+
+	            foreach ($validator->messages()->all('<li>:message</li>') as $validationError)
+	            {
+	                $message.=$validationError;
+	            }
+
+	            $message.='</ul>';
+
+	            /** Send error message and old data */
+	            Session::flash('status', 'danger');
+	            Session::flash('message', $message);
+	            return Redirect::back()->withInput();
+	        }
+	        else
+	        {
+	            /** Set new contact info */
+	            if(Input::get('office_phone'))
+                {
+                    $user->office_phone = Input::get('office_phone');
+                    $user->office_extension = Input::get('office_extension');
+                }
+				else
+				{
+					$user->office_phone = NULL;
+                    $user->office_extension = NULL;
+				}
+
+                if(Input::get('cell_phone'))
+                {
+                    $user->cell_phone = Input::get('cell_phone');
+                }
+				else
+				{
+                    $user->cell_phone = NULL;
+				}
+
+	            /** If alt email is updated, send success message */
+	            if($user->save())
+	            {
+	                Session::flash('status', 'success');
+	                Session::flash('message', 'Contact Information updated.');
+	                return Redirect::back();
+	            }
+
+	            /** If saving fails, send error message and old data */
+	            else
+	            {
+	                Session::flash('status', 'warning');
+	                Session::flash('message', 'Error updating your Contact Information. Please try again later.');
+	                return Redirect::back()->withInput();
+	            }
+	        }
+	    }
+
+	    else if(Input::get('submit_roles') && Auth::user()->role==1)
+	    {
+	        try
+	        {
+	            $exception = DB::transaction(function()
+	            {
+                    $user = User::find(Input::get('id'));
+
+                    switch (Input::get('role')) {
+                    	case '1':
+                    		$user->role = 1;
+                    		$user->school_id = NULL;
+
+                    		// Delete all programs associated to the user
+                    		$user->programs()->detach();
+
+                    		$user->has_access = 1;
+
+                    		break;
+
+                    	case '2':
+                    		$user->role = 2;
+                    		$user->school_id = Input::get('school');
+
+                    		// Delete all programs associated to the user
+                    		$user->programs()->detach();
+
+
+                    		break;
+
+                    	case '3':
+                    		$user->role = 3;
+                    		$user->school_id = NULL;
+
+                    		// Delete all programs associated to the user
+                    		$user->programs()->detach();
+
+                    		// Attach new programs
+                    		foreach (Input::get('programs') as $key => $program_id)
+                    		{
+                    			$user->programs()->attach($program_id);
+                    		}
+                    		// $user->program_id = Input::get('program');
+
+                    		break;
+
+                    	case '4':
+                    		$user->role = 4;
+                    		$user->school_id = NULL;
+
+                    		// Delete all programs associated to the user
+                    		$user->programs()->detach();
+
+                    		// Attach new programs
+                    		foreach (Input::get('programs') as $key => $program_id)
+                    		{
+                    			$user->programs()->attach($program_id);
+                    		}
+                    		// $user->program_id = Input::get('program');
+
+                    		break;
+                    }
+
+                    $user->has_access = Input::get('has_access');
+                    $user->save();
+
+	            });
+
+	            if(is_null($exception))
+	            {
+	                Session::flash('status', 'success');
+	                Session::flash('message', 'User <b>'.User::find(Input::get('id'))->email.'</b> updated ('.date('m/d/y h:i:s A').'). To ensure proper access, click \'Update\' in the \'Access Level\' section at the bottom of the page.');
+	                return Redirect::back();
+	            }
+
+	        }
+	        catch(Exception $e)
+	        {
+	            Session::flash('status', 'danger');
+	            Session::flash('message', 'Error updating users. Try again later.');
+
+	            return Redirect::back();
+	        }
+	    }
+	    else
+	    	App::abort('403');
+    }
+
+    public function updateAccess()
+    {
+    	try
+        {
+            $exception = DB::transaction(function()
+            {
+                switch (Input::get('access_level')) {
+		    		case '1':
+		    			DB::table('users')
+			            ->whereIn('role', array(1))
+			            ->update(array('has_access' => 1));
+
+			            DB::table('users')
+			            ->whereIn('role', array(2, 3, 4))
+			            ->update(array('has_access' => 0));
+		    			break;
+
+		    		case '2':
+		    			DB::table('users')
+			            ->whereIn('role', array(1, 2))
+			            ->update(array('has_access' => 1));
+
+			            DB::table('users')
+			            ->whereIn('role', array(3, 4))
+			            ->update(array('has_access' => 0));
+		    			break;
+
+		    		case '3':
+		    			DB::table('users')
+			            ->whereIn('role', array(1, 2, 3))
+			            ->update(array('has_access' => 1));
+
+			            DB::table('users')
+			            ->whereIn('role', array(4))
+			            ->update(array('has_access' => 0));
+		    			break;
+
+		    		case '4':
+		    			DB::table('users')
+			            ->whereIn('role', array(1, 2, 3, 4))
+			            ->update(array('has_access' => 1));
+		    			break;
+		    	}
+            });
+
+            if(is_null($exception))
+            {
+                Session::flash('status', 'success');
+                Session::flash('message', 'Access level updated ('.date('m/d/y, h:i:s a').').');
+            }
+
+        }
+        catch(Exception $e)
+        {
+            Session::flash('status', 'danger');
+            Session::flash('message', 'Error updating access level. Try again later ('.date('m/d/y, h:i:s a').').');
+        }
+
+        return Redirect::back();
+    }
+
+}

app/database/.gitignore

@@ -0,0 +1 @@
+*.sqlite

app/database/migrations/2014_10_05_052350_create_schools_table.php

@@ -0,0 +1,34 @@
+<?php
+
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Database\Migrations\Migration;
+
+class CreateSchoolsTable extends Migration {
+
+	/**
+	 * Run the migrations.
+	 *
+	 * @return void
+	 */
+	public function up()
+	{
+		Schema::create('schools', function(Blueprint $table)
+		{
+			$table->engine = 'InnoDB';
+			$table->increments('id');
+			$table->string('name', 50);
+			$table->timestamps();
+		});
+	}
+
+	/**
+	 * Reverse the migrations.
+	 *
+	 * @return void
+	 */
+	public function down()
+	{
+		Schema::drop('schools');
+	}
+
+}

app/database/migrations/2014_10_05_055013_create_programs_table.php

@@ -0,0 +1,41 @@
+<?php
+
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Database\Migrations\Migration;
+
+class CreateProgramsTable extends Migration {
+
+	/**
+	 * Run the migrations.
+	 *
+	 * @return void
+	 */
+	public function up()
+	{
+		Schema::create('programs', function(Blueprint $table)
+		{
+			$table->engine = 'InnoDB';
+			$table->increments('id');
+			$table->string('name', 50);
+			$table->integer('school_id')->unsigned();
+			$table->boolean('restrict_rubrics')->default(false);
+			$table->timestamps();
+		});
+
+		Schema::table('programs', function(Blueprint $table)
+		{
+			$table->foreign('school_id')->references('id')->on('schools')->onDelete('cascade')->onUpdate('cascade');
+		});
+	}
+
+	/**
+	 * Reverse the migrations.
+	 *
+	 * @return void
+	 */
+	public function down()
+	{
+		Schema::drop('programs');
+	}
+
+}

app/database/migrations/2014_10_06_050335_create_users_table.php

@@ -0,0 +1,43 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+
+class CreateUsersTable extends Migration {
+
+	/**
+	 * Run the migrations.
+	 *
+	 * @return void
+	 */
+	public function up()
+	{
+		Schema::create('users', function(Blueprint $table)
+		{
+			$table->engine = 'InnoDB';
+			$table->increments('id');
+			$table->string('first_name', 20);
+			$table->string('surnames', 40);
+			$table->string('email', 50)->unique();
+			$table->string('alternate_email', 50)->unique()->nullable();
+			$table->string('password', 255);
+			$table->integer('role');
+			$table->integer('school_id')->nullable();
+			$table->integer('program_id')->nullable();
+			$table->rememberToken();
+			$table->timestamps();
+		});
+	}
+
+
+	/**
+	 * Reverse the migrations.
+	 *
+	 * @return void
+	 */
+	public function down()
+	{
+		Schema::drop('users');
+	}
+
+}

app/database/migrations/2014_10_12_100000_create_password_resets_table.php

@@ -0,0 +1,33 @@
+<?php
+
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Database\Migrations\Migration;
+
+class CreatePasswordResetsTable extends Migration {
+
+	/**
+	 * Run the migrations.
+	 *
+	 * @return void
+	 */
+	public function up()
+	{
+		Schema::create('password_resets', function(Blueprint $table)
+		{
+			$table->string('email')->index();
+			$table->string('token')->index();
+			$table->timestamp('created_at');
+		});
+	}
+
+	/**
+	 * Reverse the migrations.
+	 *
+	 * @return void
+	 */
+	public function down()
+	{
+		Schema::drop('password_resets');
+	}
+
+}

app/database/migrations/2014_11_10_035949_create_rubrics_table.php

@@ -0,0 +1,43 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+
+class CreateRubricsTable extends Migration {
+
+	/**
+	 * Run the migrations.
+	 *
+	 * @return void
+	 */
+	public function up()
+	{
+		Schema::create('rubrics', function(Blueprint $table)
+		{
+			$table->increments('id');
+			$table->string('name');
+			$table->text('contents');
+			$table->integer('expected_percentage');
+			$table->integer('expected_points');
+			$table->integer('user_id')->unsigned();
+			$table->timestamps();
+		});
+
+		Schema::table('rubrics', function(Blueprint $table)
+		{
+			$table->foreign('user_id')->references('id')->on('users')->onDelete('cascade')->onUpdate('cascade');
+		});
+	}
+
+
+	/**
+	 * Reverse the migrations.
+	 *
+	 * @return void
+	 */
+	public function down()
+	{
+		Schema::drop('rubrics');
+	}
+
+}

app/database/migrations/2014_11_29_210957_create_templates_table.php

@@ -0,0 +1,34 @@
+<?php
+
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Database\Migrations\Migration;
+
+class CreateTemplatesTable extends Migration {
+
+	/**
+	 * Run the migrations.
+	 *
+	 * @return void
+	 */
+	public function up()
+	{
+		Schema::create('templates', function(Blueprint $table)
+		{
+			$table->increments('id');
+			$table->string('name');
+			$table->text('contents');
+			$table->timestamps();
+		});
+	}
+
+	/**
+	 * Reverse the migrations.
+	 *
+	 * @return void
+	 */
+	public function down()
+	{
+		Schema::drop('templates');
+	}
+
+}

app/database/migrations/2014_11_29_211309_create_courses_table.php

@@ -0,0 +1,43 @@
+<?php
+
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Database\Migrations\Migration;
+
+class CreateCoursesTable extends Migration {
+
+	/**
+	 * Run the migrations.
+	 *
+	 * @return void
+	 */
+	public function up()
+	{
+		Schema::create('courses', function(Blueprint $table)
+		{
+			$table->increments('id');
+			$table->string('name');
+			$table->char('code', 8);
+			$table->char('section', 3);
+			$table->integer('program_id')->unsigned();
+			$table->integer('user_id')->unsigned();
+			$table->timestamps();
+		});
+
+		Schema::table('courses', function(Blueprint $table)
+		{
+			$table->foreign('program_id')->references('id')->on('programs')->onDelete('cascade')->onUpdate('cascade');
+			$table->foreign('user_id')->references('id')->on('users')->onDelete('cascade')->onUpdate('cascade');
+		});
+	}
+
+	/**
+	 * Reverse the migrations.
+	 *
+	 * @return void
+	 */
+	public function down()
+	{
+		Schema::drop('courses');
+	}
+
+}

app/database/migrations/2014_11_29_211310_create_activities_table.php

@@ -0,0 +1,42 @@
+<?php
+
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Database\Migrations\Migration;
+
+class CreateActivitiesTable extends Migration {
+
+	/**
+	 * Run the migrations.
+	 *
+	 * @return void
+	 */
+	public function up()
+	{
+		Schema::create('activities', function(Blueprint $table)
+		{
+			$table->increments('id');
+			$table->string('name');
+			$table->string('description');
+			$table->integer('course_id')->unsigned();
+			$table->integer('rubric_id')->unsigned()->nullable();
+			$table->timestamps();
+		});
+
+		Schema::table('activities', function(Blueprint $table)
+		{
+			$table->foreign('course_id')->references('id')->on('courses')->onDelete('cascade')->onUpdate('cascade');
+			$table->foreign('rubric_id')->references('id')->on('rubrics')->onDelete('cascade')->onUpdate('cascade');
+		});
+	}
+
+	/**
+	 * Reverse the migrations.
+	 *
+	 * @return void
+	 */
+	public function down()
+	{
+		Schema::drop('activities');
+	}
+
+}

app/database/migrations/2014_11_29_212240_create_outcomes_table.php

@@ -0,0 +1,36 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+
+class CreateOutcomesTable extends Migration {
+
+	/**
+	 * Run the migrations.
+	 *
+	 * @return void
+	 */
+	public function up()
+	{
+		Schema::create('outcomes', function(Blueprint $table)
+		{
+			$table->increments('id');
+			$table->string('name');
+			$table->text('definition');
+			$table->integer('expected_outcome')->default(67);
+			$table->timestamps();
+		});
+	}
+
+
+	/**
+	 * Reverse the migrations.
+	 *
+	 * @return void
+	 */
+	public function down()
+	{
+		Schema::drop('outcomes');
+	}
+
+}

app/database/migrations/2014_11_29_212341_create_criteria_table.php

@@ -0,0 +1,45 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+
+class CreateCriteriaTable extends Migration {
+
+	/**
+	 * Run the migrations.
+	 *
+	 * @return void
+	 */
+	public function up()
+	{
+		Schema::create('criteria', function(Blueprint $table)
+		{
+			$table->increments('id');
+			$table->string('name');
+			$table->text('description12');
+			$table->text('description34');
+			$table->text('description56');
+			$table->text('description78');
+			$table->integer('outcome_id')->unsigned();
+
+			$table->timestamps();
+		});
+
+		Schema::table('criteria', function(Blueprint $table)
+		{
+			$table->foreign('outcome_id')->references('id')->on('outcomes')->onDelete('cascade')->onUpdate('cascade');
+		});
+	}
+
+
+	/**
+	 * Reverse the migrations.
+	 *
+	 * @return void
+	 */
+	public function down()
+	{
+		Schema::drop('criteria');
+	}
+
+}

app/database/migrations/2014_11_29_214028_create_semesters_table.php

@@ -0,0 +1,33 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+
+class CreateSemestersTable extends Migration {
+
+	/**
+	 * Run the migrations.
+	 *
+	 * @return void
+	 */
+	public function up()
+	{
+		Schema::create('semesters', function(Blueprint $table)
+		{
+			$table->increments('id');
+			$table->timestamps();
+		});
+	}
+
+
+	/**
+	 * Reverse the migrations.
+	 *
+	 * @return void
+	 */
+	public function down()
+	{
+		Schema::drop('semesters');
+	}
+
+}

app/database/migrations/2014_11_30_134022_create_students_table.php

@@ -0,0 +1,43 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+
+class CreateStudentsTable extends Migration {
+
+	/**
+	 * Run the migrations.
+	 *
+	 * @return void
+	 */
+	public function up()
+	{
+		Schema::create('students', function(Blueprint $table)
+		{
+			$table->engine = 'InnoDB';
+			$table->increments('id');
+			$table->char('number', 9);
+			$table->string('name', 100);
+			$table->integer('program_id')->unsigned()->nullable();
+
+			$table->timestamps();
+		});
+
+		Schema::table('students', function(Blueprint $table)
+		{
+			$table->foreign('program_id')->references('id')->on('programs')->onDelete('cascade')->onUpdate('cascade');
+		});
+	}
+
+
+	/**
+	 * Reverse the migrations.
+	 *
+	 * @return void
+	 */
+	public function down()
+	{
+		Schema::drop('students');
+	}
+
+}

app/database/migrations/2014_12_07_214036_create_course_student_table.php

@@ -0,0 +1,41 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+
+class CreateCourseStudentTable extends Migration {
+
+	/**
+	 * Run the migrations.
+	 *
+	 * @return void
+	 */
+	public function up()
+	{
+		Schema::create('course_student', function(Blueprint $table)
+		{
+			$table->increments('id');
+			$table->integer('course_id')->unsigned();
+			$table->integer('student_id')->unsigned();
+			$table->timestamps();
+		});
+
+		Schema::table('course_student', function(Blueprint $table)
+		{
+			$table->foreign('course_id')->references('id')->on('courses')->onDelete('cascade')->onUpdate('cascade');
+			$table->foreign('student_id')->references('id')->on('students')->onDelete('cascade')->onUpdate('cascade');
+		});
+	}
+
+
+	/**
+	 * Reverse the migrations.
+	 *
+	 * @return void
+	 */
+	public function down()
+	{
+		Schema::drop('course_student');
+	}
+
+}

app/database/migrations/2015_01_09_171350_create_assessments_table.php

@@ -0,0 +1,41 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+
+class CreateAssessmentsTable extends Migration {
+
+	/**
+	 * Run the migrations.
+	 *
+	 * @return void
+	 */
+	public function up()
+	{
+		Schema::create('assessments', function(Blueprint $table)
+		{
+			$table->increments('id');
+			$table->integer('activity_id')->unsigned();
+			$table->integer('student_id')->unsigned();
+			$table->timestamps();
+		});
+
+		Schema::table('assessments', function(Blueprint $table)
+		{
+			$table->foreign('activity_id')->references('id')->on('activities')->onDelete('cascade')->onUpdate('cascade');
+			$table->foreign('student_id')->references('id')->on('students')->onDelete('cascade')->onUpdate('cascade');
+		});
+	}
+
+
+	/**
+	 * Reverse the migrations.
+	 *
+	 * @return void
+	 */
+	public function down()
+	{
+		Schema::drop('assessments');
+	}
+
+}

app/database/migrations/2015_01_12_204310_add_columns_to_activities_table.php

@@ -0,0 +1,37 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+
+class AddColumnsToActivitiesTable extends Migration {
+
+	/**
+	 * Run the migrations.
+	 *
+	 * @return void
+	 */
+	public function up()
+	{
+		Schema::table('activities', function(Blueprint $table)
+		{
+			$table->text('criteria_achieved')->nullable();
+			$table->text('outcomes_achieved')->nullable();
+			$table->text('outcomes_attempted')->nullable();
+		});
+	}
+
+
+	/**
+	 * Reverse the migrations.
+	 *
+	 * @return void
+	 */
+	public function down()
+	{
+		Schema::table('activities', function(Blueprint $table)
+		{
+			$table->dropColumn(array('criteria_achieved', 'outcomes_achieved', 'outcomes_attempted'));
+		});
+	}
+
+}

app/database/migrations/2015_01_12_222859_add_columns_to_assessments_table.php

@@ -0,0 +1,37 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+
+class AddColumnsToAssessmentsTable extends Migration {
+
+	/**
+	 * Run the migrations.
+	 *
+	 * @return void
+	 */
+	public function up()
+	{
+		Schema::table('assessments', function(Blueprint $table)
+		{
+			$table->text('scores')->nullable();
+			$table->integer('total')->nullable();
+			$table->decimal('average', 5, 2)->nullable();
+		});
+	}
+
+
+	/**
+	 * Reverse the migrations.
+	 *
+	 * @return void
+	 */
+	public function down()
+	{
+		Schema::table('assessments', function(Blueprint $table)
+		{
+			$table->dropColumn(array('scores', 'total', 'average'));
+		});
+	}
+
+}

app/database/migrations/2015_01_13_010052_add_index_to_assessments_table.php

@@ -0,0 +1,35 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+
+class AddIndexToAssessmentsTable extends Migration {
+
+	/**
+	 * Run the migrations.
+	 *
+	 * @return void
+	 */
+	public function up()
+	{
+		Schema::table('assessments', function(Blueprint $table)
+		{
+			$table->unique(array('activity_id', 'student_id'));
+		});
+	}
+
+
+	/**
+	 * Reverse the migrations.
+	 *
+	 * @return void
+	 */
+	public function down()
+	{
+		Schema::table('assessments', function(Blueprint $table)
+		{
+			$table->dropUnique('assessments_activity_id_student_id_unique');
+		});
+	}
+
+}

app/database/migrations/2015_01_13_142849_add_column_to_criteria_table.php

@@ -0,0 +1,37 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+
+class AddColumnToCriteriaTable extends Migration {
+
+	/**
+	 * Run the migrations.
+	 *
+	 * @return void
+	 */
+	public function up()
+	{
+		Schema::table('criteria', function(Blueprint $table)
+		{
+			$table->integer('user_id')->unsigned()->nullable();
+			$table->foreign('user_id')->references('id')->on('users');
+		});
+	}
+
+
+	/**
+	 * Reverse the migrations.
+	 *
+	 * @return void
+	 */
+	public function down()
+	{
+		Schema::table('criteria', function(Blueprint $table)
+		{
+			$table->dropColumn('user_id');
+			$table->dropForeign('user_id');
+		});
+	}
+
+}

app/database/migrations/2015_01_14_140724_add_columns_to_courses_table.php

@@ -0,0 +1,37 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+
+class AddColumnsToCoursesTable extends Migration {
+
+	/**
+	 * Run the migrations.
+	 *
+	 * @return void
+	 */
+	public function up()
+	{
+		Schema::table('courses', function(Blueprint $table)
+		{
+			$table->text('criteria_achieved')->nullable();
+			$table->text('outcomes_achieved')->nullable();
+			$table->text('outcomes_attempted')->nullable();
+
+		});
+	}
+
+	/**
+	 * Reverse the migrations.
+	 *
+	 * @return void
+	 */
+	public function down()
+	{
+		Schema::table('courses', function(Blueprint $table)
+		{
+			$table->dropColumn(array('criteria_achieved', 'outcomes_achieved', 'outcomes_attempted'));
+		});
+	}
+
+}

app/database/migrations/2015_01_21_124809_add_column_to_courses_table.php

@@ -0,0 +1,35 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+
+class AddColumnToCoursesTable extends Migration {
+
+	/**
+	 * Run the migrations.
+	 *
+	 * @return void
+	 */
+	public function up()
+	{
+		Schema::table('courses', function(Blueprint $table)
+		{
+			$table->char('number', 4)->default('0000');
+		});
+	}
+
+
+	/**
+	 * Reverse the migrations.
+	 *
+	 * @return void
+	 */
+	public function down()
+	{
+		Schema::table('courses', function(Blueprint $table)
+		{
+			$table->dropColumn('number');
+		});
+	}
+
+}

app/database/migrations/2015_01_22_195515_add_column_to_templates_table.php

@@ -0,0 +1,45 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+
+class AddColumnToTemplatesTable extends Migration {
+
+	/**
+	 * Run the migrations.
+	 *
+	 * @return void
+	 */
+	public function up()
+	{
+		Schema::table('templates', function(Blueprint $table)
+		{
+			$table->integer('school_id')->unsigned()->nullable();
+		});
+
+		Schema::table('templates', function(Blueprint $table)
+		{
+			$table
+				->foreign('school_id')
+				->references('id')
+				->on('schools')
+				->onDelete('cascade')
+				->onUpdate('cascade');
+		});
+	}
+
+
+	/**
+	 * Reverse the migrations.
+	 *
+	 * @return void
+	 */
+	public function down()
+	{
+		Schema::table('templates', function(Blueprint $table)
+		{
+			$table->dropColumn('school_id');
+		});
+	}
+
+}

app/database/migrations/2015_01_23_175455_remove_total_from_assessments_table.php

@@ -0,0 +1,35 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+
+class RemoveTotalFromAssessmentsTable extends Migration {
+
+	/**
+	 * Run the migrations.
+	 *
+	 * @return void
+	 */
+	public function up()
+	{
+		Schema::table('assessments', function(Blueprint $table)
+		{
+			$table->dropColumn('total');
+		});
+	}
+
+
+	/**
+	 * Reverse the migrations.
+	 *
+	 * @return void
+	 */
+	public function down()
+	{
+		Schema::table('assessments', function(Blueprint $table)
+		{
+			$table->integer('total');
+		});
+	}
+
+}

app/database/migrations/2015_01_23_175923_rename_average_in_assessments_table.php

@@ -0,0 +1,40 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+
+class RenameAverageInAssessmentsTable extends Migration {
+
+	/**
+	 * Run the migrations.
+	 *
+	 * @return void
+	 */
+	public function up()
+	{
+		Schema::table('assessments', function(Blueprint $table)
+		{
+			$table->dropColumn('average');
+			$table->decimal('percentage', 5, 2);
+
+			
+		});
+	}
+
+
+	/**
+	 * Reverse the migrations.
+	 *
+	 * @return void
+	 */
+	public function down()
+	{
+		Schema::table('assessments', function(Blueprint $table)
+		{
+			$table->dropColumn('percentage');
+			$table->decimal('average', 5, 2);
+			
+		});
+	}
+
+}

app/database/migrations/2015_01_28_121848_add_index_to_course_student_table.php

@@ -0,0 +1,35 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+
+class AddIndexToCourseStudentTable extends Migration {
+
+	/**
+	 * Run the migrations.
+	 *
+	 * @return void
+	 */
+	public function up()
+	{
+		Schema::table('course_student', function(Blueprint $table)
+		{
+			$table->unique(array('course_id', 'student_id'));
+		});
+	}
+
+
+	/**
+	 * Reverse the migrations.
+	 *
+	 * @return void
+	 */
+	public function down()
+	{
+		Schema::table('course_student', function(Blueprint $table)
+		{
+			$table->dropUnique('course_student_course_id_student_id_unique');
+		});
+	}
+
+}

app/database/migrations/2015_01_28_133036_add_criteria_achieved_count_to_activities_table.php

@@ -0,0 +1,35 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+
+class AddCriteriaAchievedCountToActivitiesTable extends Migration {
+
+	/**
+	 * Run the migrations.
+	 *
+	 * @return void
+	 */
+	public function up()
+	{
+		Schema::table('activities', function(Blueprint $table)
+		{
+			$table->text('criteria_achieved_count')->nullable();
+		});
+	}
+
+
+	/**
+	 * Reverse the migrations.
+	 *
+	 * @return void
+	 */
+	public function down()
+	{
+		Schema::table('activities', function(Blueprint $table)
+		{
+			$table->dropColumn('criteria_achieved_count');
+		});
+	}
+
+}

app/database/migrations/2015_02_05_133245_add_transforming_actions_to_activities_table.php

@@ -0,0 +1,35 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+
+class AddTransformingActionsToActivitiesTable extends Migration {
+
+	/**
+	 * Run the migrations.
+	 *
+	 * @return void
+	 */
+	public function up()
+	{
+		Schema::table('activities', function(Blueprint $table)
+		{
+			$table->text('transforming_actions')->nullable();
+		});
+	}
+
+
+	/**
+	 * Reverse the migrations.
+	 *
+	 * @return void
+	 */
+	public function down()
+	{
+		Schema::table('activities', function(Blueprint $table)
+		{
+			$table->dropColumn('transforming_actions');
+		});
+	}
+
+}

app/database/migrations/2015_02_05_143641_add_assessment_comments_to_activities_table.php

@@ -0,0 +1,35 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+
+class AddAssessmentCommentsToActivitiesTable extends Migration {
+
+	/**
+	 * Run the migrations.
+	 *
+	 * @return void
+	 */
+	public function up()
+	{
+		Schema::table('activities', function(Blueprint $table)
+		{
+			$table->text('assessment_comments')->nullable();
+		});
+	}
+
+
+	/**
+	 * Reverse the migrations.
+	 *
+	 * @return void
+	 */
+	public function down()
+	{
+		Schema::table('activities', function(Blueprint $table)
+		{
+			$table->dropColumn('assessment_comments');
+		});
+	}
+
+}

app/database/migrations/2015_02_06_145359_create_password_reminders_table.php

@@ -0,0 +1,33 @@
+<?php
+
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Database\Migrations\Migration;
+
+class CreatePasswordRemindersTable extends Migration {
+
+	/**
+	 * Run the migrations.
+	 *
+	 * @return void
+	 */
+	public function up()
+	{
+		Schema::create('password_reminders', function(Blueprint $table)
+		{
+			$table->string('email')->index();
+			$table->string('token')->index();
+			$table->timestamp('created_at');
+		});
+	}
+
+	/**
+	 * Reverse the migrations.
+	 *
+	 * @return void
+	 */
+	public function down()
+	{
+		Schema::drop('password_reminders');
+	}
+
+}

app/database/migrations/2015_02_19_143311_add_is_graduate_to_programs_table.php

@@ -0,0 +1,35 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+
+class AddIsGraduateToProgramsTable extends Migration {
+
+	/**
+	 * Run the migrations.
+	 *
+	 * @return void
+	 */
+	public function up()
+	{
+		Schema::table('programs', function(Blueprint $table)
+		{
+			$table->boolean('is_graduate')->default(false);
+		});
+	}
+
+
+	/**
+	 * Reverse the migrations.
+	 *
+	 * @return void
+	 */
+	public function down()
+	{
+		Schema::table('programs', function(Blueprint $table)
+		{
+			$table->dropColumn('is_graduate');
+		});
+	}
+
+}

app/database/migrations/2015_02_25_170516_add_deleted_at_to_outcomes_table.php

@@ -0,0 +1,35 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+
+class AddDeletedAtToOutcomesTable extends Migration {
+
+	/**
+	 * Run the migrations.
+	 *
+	 * @return void
+	 */
+	public function up()
+	{
+		Schema::table('outcomes', function(Blueprint $table)
+		{
+			$table->softDeletes();
+		});
+	}
+
+
+	/**
+	 * Reverse the migrations.
+	 *
+	 * @return void
+	 */
+	public function down()
+	{
+		Schema::table('outcomes', function(Blueprint $table)
+		{
+			$table->dropColumn('deleted_at');
+		});
+	}
+
+}

app/database/migrations/2015_02_25_170529_add_deleted_at_to_criteria_table.php

@@ -0,0 +1,35 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+
+class AddDeletedAtToCriteriaTable extends Migration {
+
+	/**
+	 * Run the migrations.
+	 *
+	 * @return void
+	 */
+	public function up()
+	{
+		Schema::table('criteria', function(Blueprint $table)
+		{
+			$table->softDeletes();
+		});
+	}
+
+
+	/**
+	 * Reverse the migrations.
+	 *
+	 * @return void
+	 */
+	public function down()
+	{
+		Schema::table('criteria', function(Blueprint $table)
+		{
+			$table->dropColumn('deleted_at');
+		});
+	}
+
+}

app/database/migrations/2015_02_27_201953_add_criteria_achieved_percentage_to_activities_table.php

@@ -0,0 +1,37 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+
+class AddCriteriaAchievedPercentageToActivitiesTable extends Migration {
+
+	/**
+	 * Run the migrations.
+	 *
+	 * @return void
+	 */
+	public function up()
+	{
+		Schema::table('activities', function(Blueprint $table)
+		{
+			$table->dropColumn('criteria_achieved_count');
+			$table->text('criteria_achieved_percentage')->nullable();
+		});
+	}
+
+
+	/**
+	 * Reverse the migrations.
+	 *
+	 * @return void
+	 */
+	public function down()
+	{
+		Schema::table('activities', function(Blueprint $table)
+		{
+			$table->dropColumn('criteria_achieved_percentage');
+			$table->text('criteria_achieved_count')->nullable();
+		});
+	}
+
+}

app/database/migrations/2015_03_04_132321_add_copyright_and_notes_to_criteria_table.php

@@ -0,0 +1,37 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+
+class AddCopyrightAndNotesToCriteriaTable extends Migration {
+
+	/**
+	 * Run the migrations.
+	 *
+	 * @return void
+	 */
+	public function up()
+	{
+		Schema::table('criteria', function(Blueprint $table)
+		{
+			$table->text('copyright')->nullable();
+			$table->text('notes')->nullable();
+		});
+	}
+
+
+	/**
+	 * Reverse the migrations.
+	 *
+	 * @return void
+	 */
+	public function down()
+	{
+		Schema::table('criteria', function(Blueprint $table)
+		{
+			$table->dropColumn(array('copyright', 'notes'));
+
+		});
+	}
+
+}

app/database/migrations/2015_04_13_183730_add_program_id_to_templates_table.php

@@ -0,0 +1,41 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+
+class AddProgramIdToTemplatesTable extends Migration {
+
+	/**
+	 * Run the migrations.
+	 *
+	 * @return void
+	 */
+	public function up()
+	{
+		Schema::table('templates', function(Blueprint $table)
+		{
+			$table->integer('program_id')->unsigned()->nullable();
+		});
+
+		Schema::table('templates', function(Blueprint $table)
+		{
+			$table->foreign('program_id')->references('id')->on('programs');
+		});
+	}
+
+
+	/**
+	 * Reverse the migrations.
+	 *
+	 * @return void
+	 */
+	public function down()
+	{
+		Schema::table('templates', function(Blueprint $table)
+		{
+			$table->dropForeign('templates_program_id_foreign');
+			$table->dropColumn('program_id');
+		});
+	}
+
+}

app/database/migrations/2015_04_28_141931_add_is_visible_to_templates_table.php

@@ -0,0 +1,34 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+
+class AddIsVisibleToTemplatesTable extends Migration {
+
+	/**
+	 * Run the migrations.
+	 *
+	 * @return void
+	 */
+	public function up()
+	{
+		Schema::table('templates', function(Blueprint $table)
+		{
+			$table->boolean('is_visible')->default(false);
+		});
+	}
+
+
+	/**
+	 * Reverse the migrations.
+	 *
+	 * @return void
+	 */
+	public function down()
+	{
+		Schema::table('templates', function(Blueprint $table)
+		{
+			$table->dropColumn('is_visible');
+		});
+	}
+}

app/database/migrations/2015_05_04_162918_remove_expected_outcome_from_outcomes_table.php

@@ -0,0 +1,35 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+
+class RemoveExpectedOutcomeFromOutcomesTable extends Migration {
+
+	/**
+	 * Run the migrations.
+	 *
+	 * @return void
+	 */
+	public function up()
+	{
+		Schema::table('outcomes', function(Blueprint $table)
+		{
+			$table->dropColumn('expected_outcome');
+		});
+	}
+
+
+	/**
+	 * Reverse the migrations.
+	 *
+	 * @return void
+	 */
+	public function down()
+	{
+		Schema::table('outcomes', function(Blueprint $table)
+		{
+			$table->integer('expected_outcome')->after('definition')->default('67');
+		});
+	}
+
+}

app/database/migrations/2015_05_05_083800_add_decimal_expected_outcome_to_outcomes_table.php

@@ -0,0 +1,35 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+
+class AddDecimalExpectedOutcomeToOutcomesTable extends Migration {
+
+	/**
+	 * Run the migrations.
+	 *
+	 * @return void
+	 */
+	public function up()
+	{
+		Schema::table('outcomes', function(Blueprint $table)
+		{
+			$table->decimal('expected_outcome',5,2)->after('definition')->default('66.66');
+		});
+	}
+
+
+	/**
+	 * Reverse the migrations.
+	 *
+	 * @return void
+	 */
+	public function down()
+	{
+		Schema::table('outcomes', function(Blueprint $table)
+		{
+			$table->dropColumn('expected_outcome');
+		});
+	}
+
+}

app/database/migrations/2015_05_18_095002_add_first_login_to_users_table.php

@@ -0,0 +1,35 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+
+class AddFirstLoginToUsersTable extends Migration {
+
+	/**
+	 * Run the migrations.
+	 *
+	 * @return void
+	 */
+	public function up()
+	{
+		Schema::table('users', function(Blueprint $table)
+		{
+			$table->boolean('password_updated')->after('program_id')->default(false);
+		});
+	}
+
+
+	/**
+	 * Reverse the migrations.
+	 *
+	 * @return void
+	 */
+	public function down()
+	{
+		Schema::table('users', function(Blueprint $table)
+		{
+			$table->dropColumn('password_updated');
+		});
+	}
+
+}

app/database/migrations/2015_05_18_131259_add_columns_to_semesters_table.php

@@ -0,0 +1,40 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+
+class AddColumnsToSemestersTable extends Migration {
+
+	/**
+	 * Run the migrations.
+	 *
+	 * @return void
+	 */
+	public function up()
+	{
+		Schema::table('semesters', function(Blueprint $table)
+		{
+			$table->char('code', 3);
+			$table->timestamp('start')->nullable();
+			$table->timestamp('end')->nullable();
+
+			$table->dropTimestamps();
+		});
+	}
+
+
+	/**
+	 * Reverse the migrations.
+	 *
+	 * @return void
+	 */
+	public function down()
+	{
+		Schema::table('semesters', function(Blueprint $table)
+		{
+			$table->dropColumn(['code', 'start', 'end']);
+			$table->timestamps();
+		});
+	}
+
+}

app/database/migrations/2015_05_18_134926_add_semester_id_to_courses.php

@@ -0,0 +1,41 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+
+class AddSemesterIdToCourses extends Migration {
+
+	/**
+	 * Run the migrations.
+	 *
+	 * @return void
+	 */
+	public function up()
+	{
+		Schema::table('courses', function(Blueprint $table)
+		{
+			$table->integer('semester_id')->unsigned()->default(1)->after('user_id');
+		});
+
+		Schema::table('courses', function(Blueprint $table)
+		{
+			$table->foreign('semester_id')->references('id')->on('semesters');
+		});
+	}
+
+
+	/**
+	 * Reverse the migrations.
+	 *
+	 * @return void
+	 */
+	public function down()
+	{
+		Schema::table('courses', function(Blueprint $table)
+		{
+			$table->dropForeign('courses_semester_id_foreign');
+			$table->dropColumn('semester_id');
+		});
+	}
+
+}

app/database/migrations/2015_06_10_092319_add_name_to_semesters_table.php

@@ -0,0 +1,35 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+
+class AddNameToSemestersTable extends Migration {
+
+	/**
+	 * Run the migrations.
+	 *
+	 * @return void
+	 */
+	public function up()
+	{
+		Schema::table('semesters', function(Blueprint $table)
+		{
+			$table->string('name', 25)->after('code')->default('');
+		});
+	}
+
+
+	/**
+	 * Reverse the migrations.
+	 *
+	 * @return void
+	 */
+	public function down()
+	{
+		Schema::table('semesters', function(Blueprint $table)
+		{
+			$table->dropColumn('name');	
+		});
+	}
+
+}

app/database/migrations/2015_06_12_085247_add_visibility_to_semesters_table.php

@@ -0,0 +1,35 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+
+class AddVisibilityToSemestersTable extends Migration {
+
+	/**
+	 * Run the migrations.
+	 *
+	 * @return void
+	 */
+	public function up()
+	{
+		Schema::table('semesters', function(Blueprint $table)
+		{
+			$table->boolean('is_visible')->default(false);
+		});
+	}
+
+
+	/**
+	 * Reverse the migrations.
+	 *
+	 * @return void
+	 */
+	public function down()
+	{
+		Schema::table('semesters', function(Blueprint $table)
+		{
+			$table->dropColumn('is_visible');
+		});
+	}
+
+}

app/database/migrations/2015_06_16_092223_add_has_access_to_users.php

@@ -0,0 +1,35 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+
+class AddHasAccessToUsers extends Migration {
+
+	/**
+	 * Run the migrations.
+	 *
+	 * @return void
+	 */
+	public function up()
+	{
+		Schema::table('users', function(Blueprint $table)
+		{
+			$table->boolean('has_access')->after('program_id')->default(false);
+		});
+	}
+
+
+	/**
+	 * Reverse the migrations.
+	 *
+	 * @return void
+	 */
+	public function down()
+	{
+		Schema::table('users', function(Blueprint $table)
+		{
+			$table->dropColumn('has_access');
+		});
+	}
+
+}

app/database/migrations/2015_06_18_103255_add_expected_percentage_and_points_to_templates_table.php

@@ -0,0 +1,36 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+
+class AddExpectedPercentageAndPointsToTemplatesTable extends Migration {
+
+	/**
+	 * Run the migrations.
+	 *
+	 * @return void
+	 */
+	public function up()
+	{
+		Schema::table('templates', function(Blueprint $table)
+		{
+			$table->integer('expected_percentage')->after('contents')->default(70);
+			$table->integer('expected_points')->after('expected_percentage')->default(5);
+		});
+	}
+
+
+	/**
+	 * Reverse the migrations.
+	 *
+	 * @return void
+	 */
+	public function down()
+	{
+		Schema::table('templates', function(Blueprint $table)
+		{
+			$table->dropColumn(array('expected_percentage', 'expected_points'));
+		});
+	}
+
+}

app/database/migrations/2015_07_10_150430_add_email_to_students_table.php

@@ -0,0 +1,34 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+
+class AddEmailToStudentsTable extends Migration {
+
+	/**
+	 * Run the migrations.
+	 *
+	 * @return void
+	 */
+	public function up()
+	{
+		Schema::table('students', function(Blueprint $table)
+		{
+			$table->string('email', 40)->after('name')->default('no.email.olas@upr.edu');
+		});
+	}
+
+	/**
+	 * Reverse the migrations.
+	 *
+	 * @return void
+	 */
+	public function down()
+	{
+		Schema::table('students', function(Blueprint $table)
+		{
+			$table->dropColumn('email');
+		});
+	}
+
+}

app/database/migrations/2015_07_13_111726_add_code_to_programs_table.php

@@ -0,0 +1,35 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+
+class AddCodeToProgramsTable extends Migration {
+
+	/**
+	 * Run the migrations.
+	 *
+	 * @return void
+	 */
+	public function up()
+	{
+		Schema::table('programs', function(Blueprint $table)
+		{
+			$table->char('code', 4)->after('name')->nullable();
+		});
+	}
+
+
+	/**
+	 * Reverse the migrations.
+	 *
+	 * @return void
+	 */
+	public function down()
+	{
+		Schema::table('programs', function(Blueprint $table)
+		{
+			$table->dropColumn('code');
+		});
+	}
+
+}

app/database/migrations/2015_07_13_132620_add_ssn_and_employee_number_to_users_table.php

@@ -0,0 +1,36 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+
+class AddSsnAndEmployeeNumberToUsersTable extends Migration {
+
+	/**
+	 * Run the migrations.
+	 *
+	 * @return void
+	 */
+	public function up()
+	{
+		Schema::table('users', function(Blueprint $table)
+		{
+			$table->string('ssn', 9)->after('id')->nullable()->unique();
+			$table->string('number', 10)->after('ssn')->nullable()->unique();
+		});
+	}
+
+
+	/**
+	 * Reverse the migrations.
+	 *
+	 * @return void
+	 */
+	public function down()
+	{
+		Schema::table('users', function(Blueprint $table)
+		{
+			$table->dropColumn(array('ssn', 'number'));
+		});
+	}
+
+}

app/database/migrations/2015_08_19_130733_add_semester_id_to_course_student_table.php

@@ -0,0 +1,41 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+
+class AddSemesterIdToCourseStudentTable extends Migration {
+
+	/**
+	 * Run the migrations.
+	 *
+	 * @return void
+	 */
+	public function up()
+	{
+		Schema::table('course_student', function(Blueprint $table)
+		{
+			$table->integer('semester_id')->unsigned()->default(1)->after('student_id');
+		});
+
+		Schema::table('course_student', function(Blueprint $table)
+		{
+			$table->foreign('semester_id')->references('id')->on('semesters');
+		});
+	}
+
+
+	/**
+	 * Reverse the migrations.
+	 *
+	 * @return void
+	 */
+	public function down()
+	{
+		Schema::table('course_student', function(Blueprint $table)
+		{
+			$table->dropForeign('course_student_semester_id_foreign');
+			$table->dropColumn('semester_id');
+		});
+	}
+
+}

app/database/migrations/2015_12_10_145451_add_criteria_weights_to_activities_table.php

@@ -0,0 +1,34 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+
+class AddCriteriaWeightsToActivitiesTable extends Migration {
+
+	/**
+	 * Run the migrations.
+	 *
+	 * @return void
+	 */
+	public function up()
+	{
+		Schema::table('activities', function(Blueprint $table)
+		{
+			$table->text('criteria_weights')->after('criteria_achieved')->nullable();
+		});
+	}
+
+
+	/**
+	 * Reverse the migrations.
+	 *
+	 * @return void
+	 */
+	public function down()
+	{
+		Schema::table('activities', function(Blueprint $table)
+		{
+			$table->dropColumn('criteria_weights');
+		});
+	}
+}

app/database/migrations/2016_01_12_132034_add_program_id_to_criteria_table.php

@@ -0,0 +1,37 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+
+class AddProgramIdToCriteriaTable extends Migration {
+
+	/**
+	 * Run the migrations.
+	 *
+	 * @return void
+	 */
+	public function up()
+	{
+		Schema::table('criteria', function(Blueprint $table)
+		{
+			$table->integer('program_id')->after('user_id')->unsigned()->nullable();
+			$table->foreign('program_id')->references('id')->on('programs')->onDelete('cascade')->onUpdate('cascade');
+		});
+	}
+
+
+	/**
+	 * Reverse the migrations.
+	 *
+	 * @return void
+	 */
+	public function down()
+	{
+		Schema::table('criteria', function(Blueprint $table)
+		{
+			$table->dropForeign('criteria_program_id_foreign');
+			$table->dropColumn('program_id');
+		});
+	}
+
+}

app/database/migrations/2016_01_27_093808_add_date_to_activities_table.php

@@ -0,0 +1,35 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+
+class AddDateToActivitiesTable extends Migration {
+
+	/**
+	 * Run the migrations.
+	 *
+	 * @return void
+	 */
+	public function up()
+	{
+		Schema::table('activities', function(Blueprint $table)
+		{
+			$table->date('date')->after('rubric_id');
+		});
+	}
+
+
+	/**
+	 * Reverse the migrations.
+	 *
+	 * @return void
+	 */
+	public function down()
+	{
+		Schema::table('activities', function(Blueprint $table)
+		{
+			$table->dropColumn('date');
+		});
+	}
+
+}

app/database/migrations/2016_01_27_134306_add_draft_to_activities_table.php

@@ -0,0 +1,35 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+
+class AddDraftToActivitiesTable extends Migration {
+
+	/**
+	 * Run the migrations.
+	 *
+	 * @return void
+	 */
+	public function up()
+	{
+		Schema::table('activities', function(Blueprint $table)
+		{
+			$table->boolean('draft')->after('date')->default(0);
+		});
+	}
+
+
+	/**
+	 * Reverse the migrations.
+	 *
+	 * @return void
+	 */
+	public function down()
+	{
+		Schema::table('activities', function(Blueprint $table)
+		{
+			$table->dropColumn('draft');
+		});
+	}
+
+}

app/database/migrations/2016_03_11_085258_add_school_and_concentration_codes_to_students_table.php

@@ -0,0 +1,37 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+
+class AddSchoolAndConcentrationCodesToStudentsTable extends Migration {
+
+	/**
+	 * Run the migrations.
+	 *
+	 * @return void
+	 */
+	public function up()
+	{
+		Schema::table('students', function(Blueprint $table)
+		{
+			$table->char('school_code', 2)->after('name')->nullable();
+			$table->char('conc_code', 4)->after('school_code')->nullable();
+		});
+	}
+
+
+	/**
+	 * Reverse the migrations.
+	 *
+	 * @return void
+	 */
+	public function down()
+	{
+		Schema::table('students', function(Blueprint $table)
+		{
+			$table->dropColumn(array('school_code', 'conc_code'));
+			
+		});
+	}
+
+}