Merge branch 'adaptar_a_bd_nueva' into merge-oniel-g-c

app/config/app.php

 		'Illuminate\Workbench\WorkbenchServiceProvider',
 		'Way\Generators\GeneratorsServiceProvider',
 		'Barryvdh\DomPDF\ServiceProvider',
+		'Cornford\Backup\Providers\BackupServiceProvider',
 		'Zizaco\Entrust\EntrustServiceProvider'
 
 	),
 		'App'               => 'Illuminate\Support\Facades\App',
 		'Artisan'           => 'Illuminate\Support\Facades\Artisan',
 		'Auth'              => 'Illuminate\Support\Facades\Auth',
+		'Backup'	        => 'Cornford\Backup\Facades\Backup',
 		'Blade'             => 'Illuminate\Support\Facades\Blade',
 		'Cache'             => 'Illuminate\Support\Facades\Cache',
 		'ClassLoader'       => 'Illuminate\Support\ClassLoader',

app/controllers/ActivitiesController.php

         $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())
+        if ($course->user_id != Auth::id() and Auth::user()->role==4)
             App::abort('403', 'Access Forbidden');
 
         // Get active semesters

app/controllers/AdministratorsController.php

 <?php
 
 class AdministratorsController extends \BaseController
-{
+{	
+	private function outcomes_semesters($selected_semesters, $level)
+	{
+		$min_start="9000-01-01 00:00:00";
+		$max_end="1000-01-01 00:00:00";
+		foreach($selected_semesters as $semester)
+		{
+			if($min_start>$semester->start)
+			{
+				$min_start=$semester->start;
+			}
+			if($max_end<$semester->end)
+			{
+				$max_end=$semester->end;
+			}
+		}
+		$outcomes = Outcome::where(function($query) use ($min_start)
+								   {
+										$query->where('deactivation_date', '>=', $min_start)
+											  ->orWhere('deactivation_date', null);
+								   })
+							->where('activation_date', '<=', $max_end)
+							->where(function($query2) use ($level)
+									{
+										$query2->where("level", $level+1)
+											   ->orWhere("level",3);
+									})
+							->orderBy('name', 'ASC')
+							->get();
+        $outcomeCount = Outcome::where(function($query) use ($min_start)
+									   {
+											$query->where('deactivation_date', '>=', $min_start)
+												  ->orWhere('deactivation_date', null);
+										})
+							->where('activation_date', '<=', $max_end)
+							->where(function($query2) use ($level)
+										{
+											$query2->where("level",$level+1)
+												   ->orWhere("level",3);
+										})
+								->count();
+	
+		foreach($outcomes as $outcome)
+		{
+			
+// 		var_dump($outcome->id);
+// 		print "<br>";
+			$outcomes_attempted[$outcome->id]=$outcome->attempted($selected_semesters, $level);
+			$outcomes_achieved[$outcome->id]=$outcome->achieved($selected_semesters, $level);	
+		}
+
+        $uhs_school_id = School::where('name', 'LIKE', '%UHS%')->first()->id;
+        $uhs_program_id = Program::where('name', 'LIKE', '%UHS%')->first()->id;
+
+        foreach ($outcomes as $outcome)
+        {
+			$achievedProgramsPerOutcome[$outcome->id]=0;         // For each program with courses that do assessment
+			$attemptedProgramsPerOutcome[$outcome->id]=0;         // 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', $level)->where('school_id', '!=', $uhs_school_id)->orderBy('name', 'asc')->get() as $program)
+            {
+				$achieved_outcomes_per_program[$program->id]=0;
+				$attempted_outcomes_per_program[$program->id]=0;
+            	$participating_programs[$program->id]=(object)array('id'=>$program->id, 'name'=>$program->name, 'is_graduate'=> $program->is_graduate, 'school_id'=>$program->school_id);
+
+// 				SELECT ac.id activity_criterion_id, ac.activity_id, ac.expected_student_score, ac.expected_percentage_students_achieving, co.program_id FROM activity_criterion ac, new_criteria c, activities a, objectives o, courses co where co.id=a.course_id and co.semester_id=13 and a.id=ac.activity_id and c.id = ac.criterion_id and o.id=c.objective_id and o.outcome_id = 2 order by program_id
+				$program_attempted_outcome=$program->attempted_outcome($outcome->id, $selected_semesters);
+				$attempted_outcomes_per_program[$program->id]+=$program_attempted_outcome;
+// 				var_dump($program_attempted_outcome);
+// 				exit();
+				if($program_attempted_outcome)
+				{
+					$program_achieved_outcome=$program->achieved_outcome($outcome->id, $selected_semesters);
+					$achieved_outcomes_per_program[$program->id]+=$program_achieved_outcome;
+
+                    $attemptedProgramsPerOutcome[$outcome->id]+=$program_attempted_outcome;
+//                     $attemptedProgramsPerOutcome[$outcome->id]+=1;
+					$achievedProgramsPerOutcome[$outcome->id]+=$program_achieved_outcome;
+// 					$achieved_outcomes_per_program[$outcome->id]=$program->achieved_outcome($outcome->id, $selected_semesters);
+// 					if($attempted_outcomes_per_program[$outcome->id]!=0 && 100.0*$achieved_outcomes_per_program[$outcome->id]/$attempted_outcomes_per_program[$outcome->id] >= $outcome->expected_outcome)
+// 					{
+// 						$achievedProgramsPerOutcome[$outcome->id]+=1;
+// 						// $output[]= 'END OF PROGRAM: '.$program->name.'-'.json_encode($achievedProgramsPerOutcome);
+// 					}
+				}
+			}
+		}
+	
+		return array('outcomes'=>$outcomes,'outcomes_attempted'=>$outcomes_attempted, 'outcomes_achieved'=>$outcomes_achieved, 'attemptedProgramsPerOutcome'=>$attemptedProgramsPerOutcome, 'achievedProgramsPerOutcome'=>$achievedProgramsPerOutcome,'participating_programs'=>$participating_programs);
+	
+	
+	
+	}
     public function overview()
     {
+    
+        $selected_semesters = Semester::find(Session::get('semesters_ids'));
+        
+		$subgraduado=$this->outcomes_semesters($selected_semesters,0);
+        $outcomes_subgrad=$subgraduado['outcomes'];
+        $undergrad_outcomes_achieved=$subgraduado['outcomes_achieved']; 
+        $undergrad_outcomes_attempted=$subgraduado['outcomes_attempted']; 
+        $attemptedUndergradProgramsPerOutcome=$subgraduado['attemptedProgramsPerOutcome']; 
+        $achievedUndergradProgramsPerOutcome=$subgraduado['achievedProgramsPerOutcome']; 
+        $participating_undergrad_programs=$subgraduado['participating_programs']; 
+		
+		
+		$graduado=$this->outcomes_semesters($selected_semesters,1);
+        $outcomes_grad=$graduado['outcomes'];
+        $grad_outcomes_achieved=$graduado['outcomes_achieved']; 
+        $grad_outcomes_attempted=$graduado['outcomes_attempted']; 
+        $attemptedGradProgramsPerOutcome=$graduado['attemptedProgramsPerOutcome']; 
+        $achievedGradProgramsPerOutcome=$graduado['achievedProgramsPerOutcome']; 
+        $participating_grad_programs=$graduado['participating_programs']; 
+		
         //Total amount of learning outcomes
-        $outcomeCount = Outcome::withTrashed()->count();
-
+//         $outcomeCount = Outcome::withTrashed()->count();
+//         $selected_semester = Semester::find(Session::get('semesters_ids')[0]);
+//         $outcomes_subgrad = Outcome::where(function($query) use ($selected_semester)
+//         								   {
+// 												$query->where('deactivation_date', '>=', $selected_semester->start)
+// 													  ->orWhere('deactivation_date', null);
+//         								   })
+//         							->where('activation_date', '<=', $selected_semester->end)
+//         							->where(function($query2)
+//         								    {
+// 												$query2->where("level",1)
+// 													   ->orWhere("level",3);
+//         									})
+//         							->orderBy('name', 'ASC')
+//         							->get();
+//         $outcomeCount_subgrad = Outcome::where(function($query) use ($selected_semester)
+//         									   {
+//         									   		$query->where('deactivation_date', '>=', $selected_semester->start)
+//         									   			  ->orWhere('deactivation_date', null);
+//         									   	})
+//            							->where('activation_date', '<=', $selected_semester->end)
+//      								->where(function($query2)
+//         									    {
+//         									    	$query2->where("level",1)
+//         									    		   ->orWhere("level",3);
+//         									    })
+//         								->count();
+// 
+//         $outcomes_grad = Outcome::where(function($query) use ($selected_semester){$query->where('deactivation_date', '>=', $selected_semester->start)->orWhere('deactivation_date', null);})->where(function($query2){$query2->where("level",2)->orWhere("level",3);})->orderBy('name', 'ASC')->get();
+//         $outcomeCount_grad = Outcome::where(function($query) use ($selected_semester){$query->where('deactivation_date', '>=', $selected_semester->start)->orWhere('deactivation_date', null);})->where(function($query2){$query2->where("level",2)->orWhere("level",3);})->count();
+
+// 		print($outcomeCount_subgrad);
+// 		print($outcomeCount_grad);
         // 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;
+//         $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 by counting the number of students
+         $undergrad_outcomes_attempted will have the number of criteria that was assessed in undergradute courses during the selected semester 
+         $undergrad_outcomes_achieved will have the number of criteria that was assessed in undergradute courses  during the selected semester 
+            where the percentage of students that obtained a better or equal score than the expected_student_score established in the
+            activity_criterion table is greater or equal than the expected_percentage_students_achieving also established in the
+            activity_criterion table         
          */
 
-        // 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];
-                }
-            }
-
-        }
+// 		foreach($outcomes_subgrad as $outcome)
+// 		{
+// 			$undergrad_outcomes_attempted[$outcome->id]=$outcome->attempted($selected_semester->id,0);
+// 			$undergrad_outcomes_achieved[$outcome->id]=$outcome->achieved($selected_semester->id,0);	
+// 		}
+// 		var_dump($undergrad_outcomes_attempted);
+// 		print"<br>";
+// 		var_dump($undergrad_outcomes_achieved);
+// 		print"<br>";
+// 		foreach($outcomes_grad as $outcome)
+// 		{
+// 			$grad_outcomes_attempted[$outcome->id]=$outcome->attempted($selected_semester->id,1);
+// 			$grad_outcomes_achieved[$outcome->id]=$outcome->achieved($selected_semester->id,1);			
+// 		}
 
         /**
          * Calculate how many programs achieved and attempted each outcome
          */
 
         // Number of programs that achieved a particular learning outcome
-        $achievedUndergradProgramsPerOutcome = array_fill(1, $outcomeCount, 0);
+//         $achievedUndergradProgramsPerOutcome = array_fill(1, $outcomeCount_subgrad, 0);
 
         // Number of programs that attempted a particular learning outcome
-        $attemptedUndergradProgramsPerOutcome = array_fill(1, $outcomeCount, 0);
+//         $attemptedUndergradProgramsPerOutcome = array_fill(1, $outcomeCount_subgrad, 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);
-                }
-            }
-        }
-
+//         $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();
 
         /**
-         * Calculate how many programs achieved and attempted each outcome
+         * Calculate how many undergrad programs achieved and attempted each outcome
+         */
+//         foreach ($outcomes_subgrad as $outcome)
+//         {
+//  			$achieved_outcomes_per_undergrad_program[$outcome->id]=0;
+// 			$attempted_outcomes_per_undergrad_program[$outcome->id]=0;
+// 			$achievedUndergradProgramsPerOutcome[$outcome->id]=0;         // For each program with courses that do assessment
+// 			$attemptedUndergradProgramsPerOutcome[$outcome->id]=0;         // 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)->where('school_id', '!=', $uhs_school_id)->orderBy('name', 'asc')->get() as $program)
+//             {
+//             	$participating_undergrad_programs[$program->id]=(object)array('id'=>$program->id, 'name'=>$program->name, 'is_graduate'=> $program->is_graduate, 'school_id'=>$program->school_id,'semestre_id',$selected_semester);
+// 
+// // 				SELECT ac.id activity_criterion_id, ac.activity_id, ac.expected_student_score, ac.expected_percentage_students_achieving, co.program_id FROM activity_criterion ac, new_criteria c, activities a, objectives o, courses co where co.id=a.course_id and co.semester_id=13 and a.id=ac.activity_id and c.id = ac.criterion_id and o.id=c.objective_id and o.outcome_id = 2 order by program_id
+// 				$program_attempted_outcome=$program->attempted_outcome($outcome->id, $selected_semester->id);
+// 				$attempted_outcomes_per_undergrad_program[$outcome->id]+=$program_attempted_outcome;
+// // 				var_dump($program_attempted_outcome);
+// // 				exit();
+// 				if($program_attempted_outcome)
+// 				{
+//                     $attemptedUndergradProgramsPerOutcome[$outcome->id]+=1;
+// 					$achieved_outcomes_per_undergrad_program[$outcome->id]=$program->achieved_outcome($outcome->id, $selected_semester->id);
+// 					if($attempted_outcomes_per_undergrad_program[$outcome->id]!=0 && 100.0*$achieved_outcomes_per_undergrad_program[$outcome->id]/$attempted_outcomes_per_undergrad_program[$outcome->id] >= $outcome->expected_outcome)
+// 					{
+// 						$achievedUndergradProgramsPerOutcome[$outcome->id]+=1;
+// 						// $output[]= 'END OF PROGRAM: '.$program->name.'-'.json_encode($achievedUndergradProgramsPerOutcome);
+// 					}
+// 				}
+// 			}
+// 		}
+// 		var_dump($attempted_outcomes_per_undergrad_program);
+// 		print"<br>";
+// 		var_dump($achieved_outcomes_per_undergrad_program);
+// 		print"<br>";
+// 		var_dump($attemptedUndergradProgramsPerOutcome);
+// 		print"<br>";
+// 		var_dump($achievedUndergradProgramsPerOutcome);
+// 		print"<br>";
+// 		exit();
+        /**
+         * Calculate how many grad programs achieved and attempted each outcome
+         $grad_outcomes_attempted will have the number of criteria that was assessed in gradute courses during the selected semester 
+         $grad_outcomes_achieved will have the number of criteria that was assessed in gradute courses  during the selected semester 
+            where the percentage of students that obtained a better or equal score than the expected_student_score established in the
+            activity_criterion table is greater or equal than the expected_percentage_students_achieving also established in the
+            activity_criterion table         
          */
 
-        // 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'));
+//         $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();
+
+
+//         foreach ($outcomes_grad as $outcome)
+//         {
+//  			$achieved_outcomes_per_grad_program[$outcome->id]=0;
+// 			$attempted_outcomes_per_grad_program[$outcome->id]=0;
+// 			$achievedGradProgramsPerOutcome[$outcome->id]=0;         // For each program with courses that do assessment
+// 			$attemptedGradProgramsPerOutcome[$outcome->id]=0;         // 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)->where('school_id', '!=', $uhs_school_id)->orderBy('name', 'asc')->get() as $program)
+//             {
+//             	$participating_grad_programs[$program->id]=(object)array('id'=>$program->id, 'name'=>$program->name, 'is_graduate'=> $program->is_graduate, 'school_id'=>$program->school_id,'semestre_id',$selected_semester);
+// // 				SELECT ac.id activity_criterion_id, ac.activity_id, ac.expected_student_score, ac.expected_percentage_students_achieving, co.program_id FROM activity_criterion ac, new_criteria c, activities a, objectives o, courses co where co.id=a.course_id and co.semester_id=13 and a.id=ac.activity_id and c.id = ac.criterion_id and o.id=c.objective_id and o.outcome_id = 2 order by program_id
+// 				$program_attempted_outcome=$program->attempted_outcome($outcome->id, $selected_semester->id);
+// 				$attempted_outcomes_per_grad_program[$outcome->id]+=$program_attempted_outcome;
+// // 				var_dump($attempted_outcomes_per_undergrad_program);
+// // 				exit();
+// 				if($program_attempted_outcome)
+// 				{
+//                     $attemptedGradProgramsPerOutcome[$outcome->id]+=1;
+// 					$achieved_outcomes_per_grad_program[$outcome->id]=$program->achieved_outcome($outcome->id, $selected_semester->id);
+// 					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($achievedUndergradProgramsPerOutcome);
+// 					}
+// 				}
+// 			}
+// 		}
+// 		var_dump($grad_outcomes_attempted);
+// 		print("<br>");
+// 		var_dump($grad_outcomes_achieved);
+// 		exit();
+        return View::make('local.managers.admins.overview', compact('title', 'schools', 'outcomes_subgrad', 'outcomes_grad', 'undergrad_outcomes_achieved', 'undergrad_outcomes_attempted', 'grad_outcomes_achieved', 'grad_outcomes_attempted', 'attemptedUndergradProgramsPerOutcome', 'participating_undergrad_programs', 'achievedUndergradProgramsPerOutcome', 'attemptedGradProgramsPerOutcome', 'participating_grad_programs', 'achievedGradProgramsPerOutcome'));
     }
 }

app/controllers/CoursesController.php

 		$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);
+		$level=DB::table('courses')
+			->join('programs','programs.id','=','courses.program_id')
+			->where('courses.id', $id)
+        	->select('programs.is_graduate')
+        	->first();
+
+		$outcomes = Outcome::active_by_semesters(array($course->semester),$level->is_graduate);
+// 		$outcomeCount = count((array)$outcomes);
+		
+		$course = Course::where('id', $id)->first();
+		foreach($outcomes as $outcome)
+		{
+			$outcomes_attempted[$outcome->id]=$outcome->courses_attempted(array($course));
+			$outcomes_achieved[$outcome->id]=$outcome->courses_achieved(array($course));
+		}
+
+// 		$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();
 
 	{
         $title=$code.$number.' ('.$semester_code.')';
         $semester = Semester::where('code', $semester_code)->first();
+//         $selected_semesters = Semester::find(Session::get('semesters_ids'));
         $role = Auth::user()->role;
-
+		$level=DB::table('courses')
+			->join('programs','programs.id','=','courses.program_id')
+			->where('courses.code', $code)
+        	->where('courses.number', $number)
+        	->where('courses.semester_id', $semester->id)
+        	->select('programs.is_graduate')
+        	->first();
+//         var_dump($level);
+//         exit();
         $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();
-
+//         $outcomes = Outcome::orderBy('name', 'asc')->get();
+//         $outcomeCount = Outcome::all()->count();
+		$outcomes = Outcome::active_by_semesters(array($semester),$level->is_graduate);
+		$outcomeCount = count((array)$outcomes);
+		
+		foreach($outcomes as $outcome)
+		{
+			$outcomes_attempted[$outcome->id]=$outcome->courses_attempted($grouped_courses);
+			$outcomes_achieved[$outcome->id]=$outcome->courses_achieved($grouped_courses);
+		}
+		
+		var_dump($outcomes_attempted);
+		print "<br>";
+		var_dump($outcomes_achieved);
+		print "<br>";
         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
+//             // 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];
-                    }
-                }
-            }
+// 
+//             // 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 =count($section->outcomes_attempted());
+// //                     var_dump($section_outcomes_achieved);
+// //                     exit();
+//                     $section_outcomes_attempted =count($section->outcomes_achieved());
+// //                     $section_outcomes_achieved =json_decode($section->outcomes_achieved, true);
+// //                     $section_outcomes_attempted =json_decode($section->outcomes_attempted, true);
+// 					foreach($outcomes as $outcome)
+// 					{
+// 						if(!isset($outcomes_achieved[$outcome->id]))$outcomes_achieved[$outcome->id]=0;
+// 						if(!isset($outcomes_attempted[$outcome->id]))$outcomes_attempted[$outcome->id]=0;
+//                         $outcomes_achieved[$outcome->id]+=$section_outcomes_achieved[$i];
+//                         $outcomes_attempted[$outcome->id]+=$section_outcomes_attempted[$i];					
+// 					
+// 					}
+// //                     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::

app/controllers/OutcomesController.php

 
     public function show($id)
     {
-        DB::disableQueryLog();
-        $outcome = Outcome::find($id);
-
+    	$outcome = Outcome::find($id);
+        $selected_semesters = Semester::find(Session::get('semesters_ids'));
+        $programs=$outcome->programs_attempted($selected_semesters);
+        
         $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)
+        $gradResults=array("names"=>array(), "schools"=>array(), "achieved"=>array(), "attempted"=>array(), "successRate"=>array());
+        foreach($programs as $program_id)
         {
-            $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';
+ //        	var_dump($program_id);
+//         	exit();
+        	$program = Program::where('id','=',$program_id->id)->first();
+        	$school = School::where('id','=',$program->school_id)->first();
+        	if($program->is_graduate)
+        	{
+        		$gradResults['names'][]=$program->name;
+        		$gradResults['schools'][]=$school->name;
+        		$attempted=$program->attempted_criteria_by_outcome($id, $selected_semesters);
+        		$gradResults['attempted'][]=$attempted;
+        		$achieved=$program->achieved_criteria_by_outcome($id, $selected_semesters);
+        		$gradResults['achieved'][]=$achieved;
+        		$gradResults['successRate'][]=sprintf("%.2f",100*$achieved/$attempted); 		
+        		
+        	}
+        	else
+        	{
+        		$undergradResults['names'][]=$program->name;
+        		$undergradResults['schools'][]=$school->name;
+        		$attempted=$program->attempted_criteria_by_outcome($id,$selected_semesters);
+        		$undergradResults['attempted'][]=$attempted;
+        		$achieved=$program->achieved_criteria_by_outcome($id,$selected_semesters);
+        		$undergradResults['achieved'][]=$achieved;
+        		$undergradResults['successRate'][]=sprintf("%.2f",100*$achieved/$attempted); 		
+        	}
+        
         }
-
-
-        //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'));
+           	
+	   	$title = "Outcome Results: ".$outcome->name;
+    	
+        
+//  		$undergradResults["successRate"]
+	
+        return View::make('local.managers.admins.learning-outcome_new', compact('title', 'outcome', 'undergradResults', 'gradResults'));
     }
 
+//     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'));
+//     }
+
     // TODO: Clean up and verify relationships are correct
     public function newShow($id)
     {

app/controllers/ProgramsController.php

   /**
    * 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();
+//     $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;
-        }
-    }
-
+//     $outcomeCount = Outcome::all()->count();
+
+    $selected_semesters = Semester::find(Session::get('semesters_ids'));
+
+	$level=$program->is_graduate;
+	$min_start="9000-01-01 00:00:00";
+	$max_end="1000-01-01 00:00:00";
+	foreach($selected_semesters as $semester)
+	{
+		if($min_start>$semester->start)
+		{
+			$min_start=$semester->start;
+		}
+		if($max_end<$semester->end)
+		{
+			$max_end=$semester->end;
+		}
+	}
+	$outcomes = Outcome::where(function($query) use ($min_start)
+							   {
+									$query->where('deactivation_date', '>=', $min_start)
+										  ->orWhere('deactivation_date', null);
+							   })
+						->where('activation_date', '<=', $max_end)
+						->where(function($query2) use ($level)
+								{
+									$query2->where("level", $level+1)
+										   ->orWhere("level",3);
+								})
+						->orderBy('name', 'ASC')
+						->get();
+	$outcomeCount = Outcome::where(function($query) use ($min_start)
+								   {
+										$query->where('deactivation_date', '>=', $min_start)
+											  ->orWhere('deactivation_date', null);
+									})
+						->where('activation_date', '<=', $max_end)
+						->where(function($query2) use ($level)
+									{
+										$query2->where("level",$level+1)
+											   ->orWhere("level",3);
+									})
+							->count();
+
+	foreach($outcomes as $outcome)
+	{
+		$outcomes_attempted[$outcome->id]=$program->attempted_outcome($outcome->id, $selected_semesters);
+		if($outcomes_attempted[$outcome->id])$outcomes_achieved[$outcome->id]=$program->achieved_outcome($outcome->id, $selected_semesters);
+	}
+
+	foreach($outcomes as $outcome)
+	{
+		$assessed_courses[$outcome->id]=DB::table('activity_criterion')
+	    	->join('activities', 'activity_criterion.activity_id', '=', 'activities.id')
+	    	->join('courses', 'activities.course_id', '=', 'courses.id')
+	    	->join('programs', 'programs.id', '=', 'courses.program_id')
+	    	->join('criterion_objective_outcome', 'criterion_objective_outcome.criterion_id', '=', 'activity_criterion.criterion_id')
+	    	->where('criterion_objective_outcome.outcome_id','=',$outcome->id)
+	    	->where('programs.id','=',$program->id)
+	    	->where('courses.semester_id','=',$semester)
+	    	->count(DB::raw('DISTINCT courses.id'))
+			;
+	}
+	$assessed_courses_count=array_sum($assessed_courses);
     /**
      * List of grouped courses (grouped sections)
      */
         })
         ->get();
 
+// 	var_dump($outcomes_attempted);
+// 	print "<br>";
+// 	var_dump($outcomes_achieved);
+// 	print "<br>";
     return View::make('local.managers.shared.program', compact('title', 'outcomes', 'outcomes_attempted', 'outcomes_achieved', 'schools', 'program_courses', 'assessed_courses_count', 'grouped_courses', 'program', 'users'));
 
 }
    return View::make('local.managers.shared.program_report', compact('title','programs_info','selected_divulgaciones','selected_semesters','tables_names'));
 }
 
+//   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
    */

app/controllers/RubricsController.php

         return View::make('local.professors.rubrics', compact('title', 'templates', 'outcomes', 'criteria', 'rubrics', 'activity', 'rubric'));
     }
 
+    public function newOtherMethod($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
      *
             $rubric->save();
 
             // Process activity
-            $activity = Activity::find(Input::get('activity_id'));
-            $activity->rubric_id = $rubric->id;
-            $activity->save();
+//             $activity = Activity::find(Input::get('activity_id'));
+//             $activity->rubric_id = $rubric->id;
+//             $activity->save();
 
+			DB::table('new_rubric_activity')->insert(array('activity_id'=>Input::get('activity_id'),'rubric_id'=> $rubric->id));
             DB::commit();
 
             Session::flash('status', 'success');
             Session::flash('message', 'Rubric assigned.');
 
-            return action('ActivitiesController@show', array($activity->id));
-        } catch (Exception $e) {
+            return action('ActivitiesController@show', array(Input::get('activity_id')));
 
             DB::rollBack();
-            echo $e->getMessage();
-            //Session::flash('status', 'danger');
-            //Session::flash('message', 'Error creating Rubric. Try again later.');
+            Session::flash('status', 'danger');
+            Session::flash('message', 'Error creating Rubric. Try again later.'.$e);
         }
     }
 

app/database/migrations/2020_04_22_122910_add_criteria_id_to_assessments_table.php

-<?php
-
-use Illuminate\Database\Migrations\Migration;
-use Illuminate\Database\Schema\Blueprint;
-
-class AddCriteriaIdToAssessmentsTable extends Migration {
-
-	/**
-	 * Run the migrations.
-	 *
-	 * @return void
-	 */
-	public function up()
-	{
-		Schema::table('assessments', function(Blueprint $table)
-		{
-			$table->integer('criterion_id')->unsigned();
-
-			$table
-                ->foreign('criterion_id')
-                ->references('id')
-                ->on('criteria')
-                ->onDelete('cascade')
-                ->onUpdate('cascade');
-		});
-	}
-
-
-	/**
-	 * Reverse the migrations.
-	 *
-	 * @return void
-	 */
-	public function down()
-	{
-		Schema::table('assessments', function(Blueprint $table)
-		{
-		    $table->dropForeign('assessments_criterion_id_foreign');
-		    $table->dropColumn('criterion_id');
-		});
-	}
-
-}

app/models/Activity.php

 
   public function rubric()
   {
-    return $this->belongsTo('Rubric');
+//     return $this->belongsTo('Rubric');
+    return $this->belongsToMany('Rubric','new_rubric_activity');
   }
 
   public function course()

app/models/Course.php

 
   }
 
+  public function outcomes_attempted()
+  {
+	return DB::table('courses')
+	    	->join('activities', 'activities.course_id', '=', 'courses.id')
+	    	->join('activity_criterion', 'activity_criterion.activity_id', '=', 'activities.id')
+	    	->join('new_criteria', 'activity_criterion.criterion_id', '=', 'new_criteria.id')
+	    	->join('criterion_objective_outcome', 'criterion_objective_outcome.criterion_id', '=', 'new_criteria.id')
+	    	->where('courses.id','=',$this->id)
+	    	->select('criterion_objective_outcome.outcome_id')
+	    	->distinct()
+	    	->orderBy('criterion_objective_outcome.outcome_id')
+	    	->get();
+
+//   	SELECT distinct cr.outcome_id FROM  courses c, activities a, activity_criterion ac, criteria cr WHERE c.id=a.course_id and a.id=ac.activity_id and ac.criterion_id=cr.id and c.id=1
+// 	return $this->id;
+  }
+
+  public function outcomes_achieved()
+  {
+		 $criteria=DB::table('new_criteria')
+	    	->join('activity_criterion', 'activity_criterion.criterion_id', '=', 'new_criteria.id')
+	    	->join('activities', 'activity_criterion.activity_id', '=', 'activities.id')
+	    	->join('courses', 'activities.course_id', '=', 'courses.id')
+	    	->join('criterion_objective_outcome', 'criterion_objective_outcome.criterion_id', '=', 'new_criteria.id')
+	    	->where('courses.id','=',$this->id)
+	    	->select('new_criteria.id','expected_percentage_students_achieving','activity_criterion.activity_id')
+	    	->distinct()
+	    	->get()
+			;
+
+		$conteo=0;
+		foreach($criteria as $criterion)
+		{	
+			$students_attempted=Criterion::students_attempted($criterion->id, $criterion->activity_id);
+			$students_achieved=Criterion::students_achieved($criterion->id, $criterion->activity_id);
+		
+			if($students_attempted)
+			{
+				$percentage_students_who_achieved=100.0*$students_achieved/$students_attempted;
+			}
+			else
+			{
+				$percentage_students_who_achieved=0;
+			}
+			if($percentage_students_who_achieved>=$criterion->expected_percentage_students_achieving)
+			{
+				$conteo++;
+			}
+		}		
+		return $conteo;
+  }
+
   public function semester()
   {
     return $this->belongsTo('Semester');

app/models/Criterion.php

 		return $this->belongsTo('Program');
 	}
 
+// 	public function activities()
+// 	{
+// 		return $this->hasManyThrough('Activity','activity_criterion');
+// 	}
+// 
 	public function subcriteria()
 	{
 		return json_decode($this->subcriteria);
 	}
+	
+	public static function students_attempted($criterion_id,$activity_id)	
+	{
+		$students_attempted=0;
+// 		var_dump($criterion_id);
+// 		var_dump($semester);
+// 		exit();
+		$activities_criterions=DB::table('activity_criterion')
+			->join('activities', 'activity_criterion.activity_id', '=', 'activities.id')
+			->join('courses', 'activities.course_id', '=', 'courses.id')
+			->where('activities.id','=',$activity_id)
+			->where('activity_criterion.criterion_id','=',$criterion_id)
+			->select('activity_criterion.id')
+			->distinct()
+			->get();
+			
+		foreach($activities_criterions as $activity_criterion)
+		{
+		
+			 $students_attempted+=DB::table('new_assessments')
+				->join('activity_criterion', 'new_assessments.activity_criterion_id', '=', 'activity_criterion.id')
+				->where('activity_criterion.id',$activity_criterion->id)
+				->count();
+		}
+		return $students_attempted;
+	}
+
+	public static function students_achieved($criterion_id,$activity_id)	
+	{
+		$students_achieved=0;
+		$activities_criterions=DB::table('activity_criterion')
+			->join('activities', 'activity_criterion.activity_id', '=', 'activities.id')
+			->join('courses', 'activities.course_id', '=', 'courses.id')
+			->where('activities.id','=',$activity_id)
+			->where('activity_criterion.criterion_id','=',$criterion_id)
+			->select('activity_criterion.id','expected_student_score')
+			->distinct()
+			->get();
+			
+		foreach($activities_criterions as $activity_criterion)
+		{
+		
+// 			$expected_student_score=DB::table('new_criteria')->where('id',$criterion_id)->select('expected_student_score')->get();
+			 $students_achieved+=DB::table('new_assessments')
+				->join('activity_criterion', 'new_assessments.activity_criterion_id', '=', 'activity_criterion.id')
+				->where('activity_criterion.id',$activity_criterion->id)
+				->where('new_assessments.score','>=',$activity_criterion->expected_student_score)
+				->count();
+		}
+		return $students_achieved;
+	}
 
 }

app/models/Outcome.php

 	    return $this->hasMany('Objective');
 //		return $this->belongsToMany('Objective', 'objective_outcome');
 	}
+// 	public function attempted($semester, $is_grad)
+// 	{
+// 		return DB::table('new_criteria')
+// 	    	->join('activity_criterion', 'activity_criterion.criterion_id', '=', 'new_criteria.id')
+// 	    	->join('activities', 'activity_criterion.activity_id', '=', 'activities.id')
+// 	    	->join('courses', 'activities.course_id', '=', 'courses.id')
+// 	    	->join('programs', 'programs.id', '=', 'courses.program_id')
+// 	    	->join('criterion_objective_outcome', 'criterion_objective_outcome.criterion_id', '=', 'new_criteria.id')
+// 	    	->where('criterion_objective_outcome.outcome_id','=',$this->id)
+// 	    	->where('programs.is_graduate','=',$is_grad)
+// 	    	->where('courses.semester_id','=',$semester)
+// 	    	->count(DB::raw('DISTINCT new_criteria.id,activity_criterion.activity_id'))
+// 			;
+//
+// 	}
+// 	public function attempted($semester, $is_grad)
+// 	{
+// 		 $criteria=DB::table('new_criteria')
+// 	    	->join('activity_criterion', 'activity_criterion.criterion_id', '=', 'new_criteria.id')
+// 	    	->join('activities', 'activity_criterion.activity_id', '=', 'activities.id')
+// 	    	->join('courses', 'activities.course_id', '=', 'courses.id')
+// 	    	->join('programs', 'programs.id', '=', 'courses.program_id')
+// 	    	->join('criterion_objective_outcome', 'criterion_objective_outcome.criterion_id', '=', 'new_criteria.id')
+// 	    	->where('criterion_objective_outcome.outcome_id','=',$this->id)
+// 	    	->where('programs.is_graduate','=',$is_grad)
+// 	    	->where('courses.semester_id','=',$semester)
+// 	    	->select('new_criteria.id','expected_percentage_students_achieving','activity_criterion.activity_id')
+// 	    	->distinct()
+// 	    	->get()
+// 			;
+// 		$conteo=0;
+// 		foreach($criteria as $criterion)
+// 		{
+// 			$students_attempted=Criterion::students_attempted($criterion->id, $criterion->activity_id);
+// 			if($students_attempted)
+// 			{
+// 				$conteo++;
+// 			}
+// 		}
+// 		return $conteo;
+// 	}
+	public function active_by_semesters($selected_semesters, $level)
+	{
+		$min_start="9000-01-01 00:00:00";
+		$max_end="1000-01-01 00:00:00";
+		foreach($selected_semesters as $semester)
+		{
+			if($min_start>$semester->start)
+			{
+				$min_start=$semester->start;
+			}
+			if($max_end<$semester->end)
+			{
+				$max_end=$semester->end;
+			}
+		}
+		$outcomes = Outcome::where(function($query) use ($min_start)
+								   {
+										$query->where('deactivation_date', '>=', $min_start)
+											  ->orWhere('deactivation_date', null);
+								   })
+							->where('activation_date', '<=', $max_end)
+							->where(function($query2) use ($level)
+									{
+										$query2->where("level", $level+1)
+											   ->orWhere("level",3);
+									})
+							->orderBy('name', 'ASC')
+							->get();
+
+// 		return array('outcomes'=>$outcomes,'outcomes_attempted'=>$outcomes_attempted, 'outcomes_achieved'=>$outcomes_achieved, 'attemptedProgramsPerOutcome'=>$attemptedProgramsPerOutcome, 'achievedProgramsPerOutcome'=>$achievedProgramsPerOutcome,'participating_programs'=>$participating_programs);
+		return $outcomes;
+	}
+
+	public function programs_attempted($semesters)
+	{
+		$semesters_array=[];
+		foreach($semesters as $semester)
+		{
+			$semesters_array[]=$semester->id;
+		}
+		 $programs=DB::table('programs')
+	    	->join('courses', 'programs.id', '=', 'courses.program_id')
+	    	->join('activities', 'activities.course_id', '=', 'courses.id')
+	    	->join('activity_criterion', 'activity_criterion.activity_id', '=', 'activities.id')
+	    	->join('new_criteria', 'activity_criterion.criterion_id', '=', 'new_criteria.id')
+	    	->join('criterion_objective_outcome', 'criterion_objective_outcome.criterion_id', '=', 'new_criteria.id')
+	    	->where('criterion_objective_outcome.outcome_id','=',$this->id)
+	    	->whereIn('courses.semester_id',$semesters_array)
+	    	->distinct()
+	    	->select('programs.id')
+	    	->get()
+			;
+
+		return $programs;
+
+	}
+
+	public function attempted($semesters, $is_grad)
+	{
+		$semesters_array=[];
+		foreach($semesters as $semester)
+		{
+			$semesters_array[]=$semester->id;
+		}
+		 $criteria=DB::table('new_criteria')
+	    	->join('activity_criterion', 'activity_criterion.criterion_id', '=', 'new_criteria.id')
+	    	->join('activities', 'activity_criterion.activity_id', '=', 'activities.id')
+	    	->join('courses', 'activities.course_id', '=', 'courses.id')
+	    	->join('programs', 'programs.id', '=', 'courses.program_id')
+	    	->join('criterion_objective_outcome', 'criterion_objective_outcome.criterion_id', '=', 'new_criteria.id')
+	    	->where('criterion_objective_outcome.outcome_id','=',$this->id)
+	    	->where('programs.is_graduate','=',$is_grad)
+	    	->whereIn('courses.semester_id',$semesters_array)
+	    	->select('new_criteria.id','expected_percentage_students_achieving','activity_criterion.activity_id')
+	    	->distinct()
+	    	->get()
+			;
+		$conteo=0;
+		foreach($criteria as $criterion)
+		{
+			$students_attempted=Criterion::students_attempted($criterion->id, $criterion->activity_id);
+			if($students_attempted)
+			{
+				$conteo++;
+			}
+		}
+// 		var_dump($conteo);
+// 		exit();
+		return $conteo;
+	}
+
+	public function courses_attempted($courses)
+	{
+		$courses_array=[];
+		foreach($courses as $course)
+		{
+// 		var_dump($course);
+// 		exit();
+			$courses_array[]=$course->id;
+		}
+		 $criteria=DB::table('new_criteria')
+	    	->join('activity_criterion', 'activity_criterion.criterion_id', '=', 'new_criteria.id')
+	    	->join('activities', 'activity_criterion.activity_id', '=', 'activities.id')
+	    	->join('courses', 'activities.course_id', '=', 'courses.id')
+	    	->join('programs', 'programs.id', '=', 'courses.program_id')
+	    	->join('criterion_objective_outcome', 'criterion_objective_outcome.criterion_id', '=', 'new_criteria.id')
+	    	->where('criterion_objective_outcome.outcome_id','=',$this->id)
+	    	->whereIn('courses.id',$courses_array)
+	    	->select('new_criteria.id','expected_percentage_students_achieving','activity_criterion.activity_id')
+	    	->distinct()
+	    	->get()
+			;
+		$conteo=0;
+		foreach($criteria as $criterion)
+		{
+			$students_attempted=Criterion::students_attempted($criterion->id, $criterion->activity_id);
+			if($students_attempted)
+			{
+				$conteo++;
+			}
+		}
+// 		var_dump($conteo);
+// 		exit();
+		return $conteo;
+	}
+
+	public function courses_achieved($courses)
+	{
+		$courses_array=[];
+		foreach($courses as $course)
+		{
+			$courses_array[]=$course->id;
+		}
+
+		 $criteria=DB::table('new_criteria')
+	    	->join('activity_criterion', 'activity_criterion.criterion_id', '=', 'new_criteria.id')
+	    	->join('activities', 'activity_criterion.activity_id', '=', 'activities.id')
+	    	->join('courses', 'activities.course_id', '=', 'courses.id')
+	    	->join('programs', 'programs.id', '=', 'courses.program_id')
+	    	->join('criterion_objective_outcome', 'criterion_objective_outcome.criterion_id', '=', 'new_criteria.id')
+	    	->where('criterion_objective_outcome.outcome_id','=',$this->id)
+	    	->whereIn('courses.id',$courses_array)
+	    	->select('new_criteria.id','expected_percentage_students_achieving','activity_criterion.activity_id')
+	    	->distinct()
+	    	->get()
+			;
+
+
+		$conteo=0;
+		foreach($criteria as $criterion)
+		{
+			$students_attempted=Criterion::students_attempted($criterion->id, $criterion->activity_id);
+			$students_achieved=Criterion::students_achieved($criterion->id, $criterion->activity_id);
+
+			if($students_attempted)
+			{
+				$percentage_students_who_achieved=100.0*$students_achieved/$students_attempted;
+			}
+			else
+			{
+				$percentage_students_who_achieved=0;
+			}
+			if($percentage_students_who_achieved>=$criterion->expected_percentage_students_achieving)
+			{
+				$conteo++;
+			}
+		}
+		return $conteo;
+	}
+
+	public function achieved($semesters, $is_grad)
+	{
+		$semesters_array=[];
+		foreach($semesters as $semester)
+		{
+			$semesters_array[]=$semester->id;
+		}
+
+//   DB::enableQueryLog();
+		 $criteria=DB::table('new_criteria')
+	    	->join('activity_criterion', 'activity_criterion.criterion_id', '=', 'new_criteria.id')
+	    	->join('activities', 'activity_criterion.activity_id', '=', 'activities.id')
+	    	->join('courses', 'activities.course_id', '=', 'courses.id')
+	    	->join('programs', 'programs.id', '=', 'courses.program_id')
+	    	->join('criterion_objective_outcome', 'criterion_objective_outcome.criterion_id', '=', 'new_criteria.id')
+	    	->where('criterion_objective_outcome.outcome_id','=',$this->id)
+	    	->where('programs.is_graduate','=',$is_grad)
+	    	->whereIn('courses.semester_id',$semesters_array)
+	    	->select('new_criteria.id','expected_percentage_students_achieving','activity_criterion.activity_id')
+	    	->distinct()
+	    	->get()
+			;
+// 		dd(DB::getQueryLog());
+
+		$conteo=0;
+		foreach($criteria as $criterion)
+		{
+			$students_attempted=Criterion::students_attempted($criterion->id, $criterion->activity_id);
+			$students_achieved=Criterion::students_achieved($criterion->id, $criterion->activity_id);
+
+			if($students_attempted)
+			{
+				$percentage_students_who_achieved=100.0*$students_achieved/$students_attempted;
+			}
+			else
+			{
+				$percentage_students_who_achieved=0;
+			}
+			if($percentage_students_who_achieved>=$criterion->expected_percentage_students_achieving)
+			{
+				$conteo++;
+			}
+		}
+		return $conteo;
+	}
+
+
+// 	public function achieved($semester, $is_grad)
+// 	{
+//
+// //   DB::enableQueryLog();
+// 		 $criteria=DB::table('new_criteria')
+// 	    	->join('activity_criterion', 'activity_criterion.criterion_id', '=', 'new_criteria.id')
+// 	    	->join('activities', 'activity_criterion.activity_id', '=', 'activities.id')
+// 	    	->join('courses', 'activities.course_id', '=', 'courses.id')
+// 	    	->join('programs', 'programs.id', '=', 'courses.program_id')
+// 	    	->join('criterion_objective_outcome', 'criterion_objective_outcome.criterion_id', '=', 'new_criteria.id')
+// 	    	->where('criterion_objective_outcome.outcome_id','=',$this->id)
+// 	    	->where('programs.is_graduate','=',$is_grad)
+// 	    	->where('courses.semester_id','=',$semester)
+// 	    	->select('new_criteria.id','expected_percentage_students_achieving','activity_criterion.activity_id')
+// 	    	->distinct()
+// 	    	->get()
+// 			;
+// // 		dd(DB::getQueryLog());
+//
+// 		$conteo=0;
+// 		foreach($criteria as $criterion)
+// 		{
+// 			$outcome_performance=DB::table('outcome_performance')
+// 				->where('outcome_performance.outcome_id','=',$this->id)
+// 				->where('outcome_performance.criterion_id','=',$criterion->id)
+// 				->where('outcome_performance.semester_id','=',$semester)
+// 				->where('outcome_performance.level','=',$is_grad)
+// 				->select('students_attempted','students_achieved')
+// 				->first();
+// 			if(!empty($outcome_performance) and $outcome_performance->students_attempted)
+// 			{
+// 				$percentage_students_who_achieved=100.0*$outcome_performance->students_achieved/$outcome_performance->students_attempted;
+// 			}
+// 			else
+// 			{
+// 				$students_attempted=Criterion::students_attempted($criterion->id, $criterion->activity_id);
+// 				$students_achieved=Criterion::students_achieved($criterion->id, $criterion->activity_id);
+//
+// 				if($students_attempted)
+// 				{
+// 					$percentage_students_who_achieved=100.0*$students_achieved/$students_attempted;
+// 					DB::table('outcome_performance')->insert(array('criterion_id'=>$criterion->id,'outcome_id'=>$this->id,'semester_id'=>$semester,
+// 					'students_attempted' => $students_attempted,'students_achieved' => $students_achieved,'level'=>$is_grad));
+// 				}
+// 				else
+// 				{
+// 					$percentage_students_who_achieved=0;
+// 				}
+// 			}
+// 			if($percentage_students_who_achieved>=$criterion->expected_percentage_students_achieving)
+// 			{
+// 				$conteo++;
+// 			}
+// 		}
+// 		return $conteo;
+// 	}
+//
+
+	public static function active()
+    {
+        //TODO: Check when semester doesnt exist or session is empty
+        $selected_semester = Semester::find(Session::get('semesters_ids')[0]);
+        return Outcome::withTrashed()->where('deactivation_date', '>=', $selected_semester->start)->orWhere('deactivation_date', null)->orderBy('name', 'ASC')->get();
+    }
 }

app/models/Program.php

 		return $this->hasMany('Criterion');
 	}
 
+// 	public function attempted_outcome($outcome_id, $semester)
+// 	{
+// 		$conteo= DB::table('activity_criterion')
+// 	    	->join('activities', 'activity_criterion.activity_id', '=', 'activities.id')
+// 	    	->join('courses', 'activities.course_id', '=', 'courses.id')
+// 	    	->join('programs', 'programs.id', '=', 'courses.program_id')
+// 	    	->join('criterion_objective_outcome', 'criterion_objective_outcome.criterion_id', '=', 'activity_criterion.criterion_id')
+// 	    	->where('criterion_objective_outcome.outcome_id','=',$outcome_id)
+// 	    	->where('programs.id','=',$this->id)
+// 	    	->where('courses.semester_id','=',$semester)
+// 	    	->count(DB::raw('DISTINCT criterion_objective_outcome.outcome_id'))
+// 			;	    	
+// 		return $conteo;		
+// 	}
+
+	public function attempted_criteria_by_outcome($outcome_id, $semesters)
+	{
+		$semesters_array=[];
+		foreach($semesters as $semester)
+		{
+			$semesters_array[]=$semester->id;
+		}
+		
+		$conteo= DB::table('activity_criterion')
+	    	->join('activities', 'activity_criterion.activity_id', '=', 'activities.id')
+	    	->join('courses', 'activities.course_id', '=', 'courses.id')
+	    	->join('programs', 'programs.id', '=', 'courses.program_id')
+	    	->join('criterion_objective_outcome', 'criterion_objective_outcome.criterion_id', '=', 'activity_criterion.criterion_id')
+	    	->where('criterion_objective_outcome.outcome_id','=',$outcome_id)
+	    	->where('programs.id','=',$this->id)
+	    	->whereIn('courses.semester_id',$semesters_array)
+	    	->count(DB::raw('DISTINCT criterion_objective_outcome.criterion_id'))
+			;	    	
+		return $conteo;		
+	}
+
+	public function attempted_outcome($outcome_id, $semesters)
+	{
+		$semesters_array=[];
+		foreach($semesters as $semester)
+		{
+			$semesters_array[]=$semester->id;
+		}
+		
+		$conteo= DB::table('activity_criterion')
+	    	->join('activities', 'activity_criterion.activity_id', '=', 'activities.id')
+	    	->join('courses', 'activities.course_id', '=', 'courses.id')
+	    	->join('programs', 'programs.id', '=', 'courses.program_id')
+	    	->join('criterion_objective_outcome', 'criterion_objective_outcome.criterion_id', '=', 'activity_criterion.criterion_id')
+	    	->where('criterion_objective_outcome.outcome_id','=',$outcome_id)
+	    	->where('programs.id','=',$this->id)
+	    	->whereIn('courses.semester_id',$semesters_array)
+	    	->count(DB::raw('DISTINCT criterion_objective_outcome.outcome_id'))
+			;	    	
+		return $conteo;		
+	}
+	
+	public function achieved_criteria_by_outcome($outcome_id, $semesters)
+	{
+		$semesters_array=[];
+		foreach($semesters as $semester)
+		{
+			$semesters_array[]=$semester->id;
+		}
+		
+//   DB::enableQueryLog();
+// 		dd(DB::getQueryLog());
+		 $criteria=DB::table('new_criteria')
+	    	->join('activity_criterion', 'activity_criterion.criterion_id', '=', 'new_criteria.id')
+	    	->join('activities', 'activity_criterion.activity_id', '=', 'activities.id')
+	    	->join('courses', 'activities.course_id', '=', 'courses.id')
+	    	->join('programs', 'programs.id', '=', 'courses.program_id')
+	    	->join('criterion_objective_outcome', 'criterion_objective_outcome.criterion_id', '=', 'new_criteria.id')
+	    	->where('criterion_objective_outcome.outcome_id','=',$outcome_id)
+	    	->where('programs.id','=',$this->id)
+	    	->whereIn('courses.semester_id',$semesters_array)
+	    	->select('new_criteria.id','expected_percentage_students_achieving','activity_criterion.activity_id')
+	    	->distinct()
+	    	->get()
+			;
+// 		dd(DB::getQueryLog());
+		 
+		$conteo=0;
+		$attempted_criteria_per_program_array=[];
+// 		$students_attempted=0;
+// 		$students_achieved=0;
+		foreach($criteria as $criterion)
+		{	
+			if(!isset($students_attempted[$criterion->id]))$students_attempted[$criterion->id]=0;
+			if(!isset($students_achieved[$criterion->id]))$students_achieved[$criterion->id]=0;
+			$attempted_criteria_per_program_array[$criterion->id]=1;
+			$students_attempted[$criterion->id]+=Criterion::students_attempted($criterion->id, $criterion->activity_id);
+			$students_achieved[$criterion->id]+=Criterion::students_achieved($criterion->id, $criterion->activity_id);
+		}
+// 		var_dump($outcome_id);
+// 		var_dump($this->id);
+// 		if(isset($students_attempted))var_dump($students_attempted);
+// 		else{print "aqui hay algo";}
+// 		print "<br>";
+// 		if(isset($students_achieved))var_dump($students_achieved);
+// 		print "<br>";
+// 		print "<br>";
+// 			exit();
+		if(isset($students_attempted))
+		{
+			foreach($students_attempted as $criteria_id => $students_attempted_n)
+			{
+				if($students_attempted_n)
+				{
+					$percentage_students_who_achieved=100.0*$students_achieved[$criteria_id]/$students_attempted[$criteria_id];
+				}
+				else
+				{
+					$percentage_students_who_achieved=0;
+				}
+				if($percentage_students_who_achieved>=$criterion->expected_percentage_students_achieving)
+				{
+					$conteo++;
+				}
+			}		
+		}
+		$attempted_criteria_per_program=count($attempted_criteria_per_program_array);
+		$achievedProgramOutcome=0;
+		$outcome=Outcome::where('id',$outcome_id)->select('expected_outcome')->first();
+// 		var_dump($outcome->expected_outcome);
+// 		exit();
+		if($attempted_criteria_per_program!=0 && 100.0*$conteo/$attempted_criteria_per_program >= $outcome->expected_outcome)
+		{
+			$achievedProgramOutcome=1;
+			// $output[]= 'END OF PROGRAM: '.$program->name.'-'.json_encode($achievedProgramsPerOutcome);
+		}
+		return $conteo;
+	}
+
+	public function achieved_outcome($outcome_id, $semesters)
+	{
+		$semesters_array=[];
+		foreach($semesters as $semester)
+		{
+			$semesters_array[]=$semester->id;
+		}
+		
+//   DB::enableQueryLog();
+// 		dd(DB::getQueryLog());
+		 $criteria=DB::table('new_criteria')
+	    	->join('activity_criterion', 'activity_criterion.criterion_id', '=', 'new_criteria.id')
+	    	->join('activities', 'activity_criterion.activity_id', '=', 'activities.id')
+	    	->join('courses', 'activities.course_id', '=', 'courses.id')
+	    	->join('programs', 'programs.id', '=', 'courses.program_id')
+	    	->join('criterion_objective_outcome', 'criterion_objective_outcome.criterion_id', '=', 'new_criteria.id')
+	    	->where('criterion_objective_outcome.outcome_id','=',$outcome_id)
+	    	->where('programs.id','=',$this->id)
+	    	->whereIn('courses.semester_id',$semesters_array)
+	    	->select('new_criteria.id','expected_percentage_students_achieving','activity_criterion.activity_id')
+	    	->distinct()
+	    	->get()
+			;
+// 		dd(DB::getQueryLog());
+		 
+		$conteo=0;
+		$attempted_criteria_per_program_array=[];
+// 		$students_attempted=0;
+// 		$students_achieved=0;
+		foreach($criteria as $criterion)
+		{	
+			if(!isset($students_attempted[$criterion->id]))$students_attempted[$criterion->id]=0;
+			if(!isset($students_achieved[$criterion->id]))$students_achieved[$criterion->id]=0;
+			$attempted_criteria_per_program_array[$criterion->id]=1;
+			$students_attempted[$criterion->id]+=Criterion::students_attempted($criterion->id, $criterion->activity_id);
+			$students_achieved[$criterion->id]+=Criterion::students_achieved($criterion->id, $criterion->activity_id);
+		}
+// 		var_dump($outcome_id);
+// 		var_dump($this->id);
+// 		if(isset($students_attempted))var_dump($students_attempted);
+// 		else{print "aqui hay algo";}
+// 		print "<br>";
+// 		if(isset($students_achieved))var_dump($students_achieved);
+// 		print "<br>";
+// 		print "<br>";
+// 			exit();
+		if(isset($students_attempted))
+		{
+			foreach($students_attempted as $criteria_id => $students_attempted_n)
+			{
+				if($students_attempted_n)
+				{
+					$percentage_students_who_achieved=100.0*$students_achieved[$criteria_id]/$students_attempted[$criteria_id];
+				}
+				else
+				{
+					$percentage_students_who_achieved=0;
+				}
+				if($percentage_students_who_achieved>=$criterion->expected_percentage_students_achieving)
+				{
+					$conteo++;
+				}
+			}		
+		}
+		$attempted_criteria_per_program=count($attempted_criteria_per_program_array);
+		$achievedProgramOutcome=0;
+		$outcome=Outcome::where('id',$outcome_id)->select('expected_outcome')->first();
+// 		var_dump($outcome->expected_outcome);
+// 		exit();
+		if($attempted_criteria_per_program!=0 && 100.0*$conteo/$attempted_criteria_per_program >= $outcome->expected_outcome)
+		{
+			$achievedProgramOutcome=1;
+			// $output[]= 'END OF PROGRAM: '.$program->name.'-'.json_encode($achievedProgramsPerOutcome);
+		}
+		return $achievedProgramOutcome;
+	}
 
 	public static function generalComponentPrograms(){
 		return self::whereIn('id', array(123,124,125,126,127,128,129))->get();

app/routes.php

     Route::group(array('prefix' => 'professor', 'before' => 'prof'), function () {
         Route::post('program', array('before' => 'csrf', 'uses' => 'ProfessorsController@program'));
         Route::get('activities/{activity_id}/rubrics', 'RubricsController@newRubric');
+        Route::get('activities/{activity_id}/other_method', 'RubricsController@newOtherMethod');
         Route::get('activities/{activity_id}/rubric', 'RubricsController@show');
         Route::get('activities/{activity_id}/rubric/{rubric_id}/download', 'RubricsController@download');
         Route::get('activities/{activity_id}/rubric/{rubric_id}/print', 'RubricsController@printview');

app/views/local/managers/admins/assessment_report.blade.php

                                                 @foreach($section->activities as $activity_index => $activity)
 
                                                     <!-- If activity has a rubric and the rubric has the outcome being evaluated -->
-                                                    @if(array_key_exists($outcome->id, (array)$activity->o_att_array) && $activity->o_att_array[$outcome->id] >=1)
+                                                    @if(array_key_exists($outcome->id, (array)$activity->o_att_array) && $activity->o_att_array[$outcome->id] >=1 && isset($section)&& isset($activity->rubric))
                                                         <h5>Measure {{ $activity_index + 1 }}</h5>
+                                                        <?php
+                                                        /*
+                                                        var_dump($section->code);
+                                                        var_dump($section->number);
+                                                        var_dump($section->name);
+                                                        var_dump($outcome->name);
+                                                        var_dump(date('M Y', strtotime($activity->date)));
+                                                        var_dump($activity->name);
+                                                        var_dump(count($section->students));
+                                                        print"<br>";
+                                                        print "A rubric was used in the $section->code-$section->number ($section->name) course (". date('M Y', strtotime($activity->date)).") to assess students’ <u>". strtolower($outcome->name) ."</u> in the activity: '<strong>$activity->name </strong>'. N= ". count($section->students);
+                                                        exit();
+                                                        */
+                                                        ?>
+
 
                                                         <p>A rubric was used in the {{ $section->code }}-{{ $section->number }} ({{ $section->name }}) course ({{ date('M Y', strtotime($activity->date))}}) to assess students’ <u>{{ strtolower($outcome->name) }}</u> in the activity: "<strong>{{ $activity->name }}</strong>". N= {{ count($section->students) }}. </p>
                                                         

app/views/local/managers/admins/overview.blade.php

                         <th>Undergraduate Success Rate</th>
                     </thead>
                     <tbody>
-                        @foreach($outcomes as $outcome)
+                        @foreach($outcomes_subgrad as $outcome)
                             <tr>
                                 <td>{{ link_to_action('OutcomesController@show', $outcome->name, array($outcome->id), $attributes = array()) }}</td>
                                 <td>{{{ $attemptedUndergradProgramsPerOutcome[$outcome->id] }}}</td>
                         <th>Graduate Success Rate</th>
                     </thead>
                     <tbody>
-                        @foreach($outcomes as $outcome)
+                        @foreach($outcomes_grad as $outcome)
                             <tr>
                                 <td>{{ link_to_action('OutcomesController@show', $outcome->name, array($outcome->id), $attributes = array()) }}</td>
                                 <td>{{{ $attemptedGradProgramsPerOutcome[$outcome->id] }}}</td>
             },
             xAxis: {
                 categories: [
-                    @foreach($outcomes as $outcome)
+                    @foreach($outcomes_subgrad as $outcome)
                         "{{{ $outcome->name }}}",
                     @endforeach
                 ],
                     y: -1
                 },
                 data: [
-                    @foreach($outcomes as $index => $outcome)
+                    @foreach($outcomes_subgrad as $index => $outcome)
                         @if(
                             is_array($undergrad_outcomes_attempted)
                             && array_key_exists($outcome->id, $undergrad_outcomes_attempted)
                     y:-1
                 },
                 data:[
-                    @foreach($outcomes as $index => $outcome)
+                    @foreach($outcomes_subgrad as $index => $outcome)
                         @if(
                             is_array($undergrad_outcomes_attempted)
                             && array_key_exists($outcome->id, $undergrad_outcomes_attempted)
             },
             xAxis: {
                 categories: [
-                    @foreach($outcomes as $outcome)
+                    @foreach($outcomes_grad as $outcome)
                         "{{{ $outcome->name }}}",
                     @endforeach
                 ],
                     y:-1
                 },
                 data: [
-                    @foreach($outcomes as $index => $outcome)
+                    @foreach($outcomes_grad as $index => $outcome)
                         @if(
                             is_array($grad_outcomes_attempted)
                             && array_key_exists($outcome->id, $grad_outcomes_attempted)
                     y:-1
                 },
                 data:[
-                    @foreach($outcomes as $index => $outcome)
+                    @foreach($outcomes_grad as $index => $outcome)
                         @if(
                             is_array($grad_outcomes_attempted)
                             && array_key_exists($outcome->id, $grad_outcomes_attempted)
             },
             xAxis: {
                 categories: [
-                    @foreach($outcomes as $outcome)
+                    @foreach($outcomes_subgrad as $outcome)
                         "{{{ $outcome->name }}}",
                     @endforeach
                 ],
                     y: -1
                 },
                 data: [
-                    @foreach($outcomes as $index => $outcome)
+                    @foreach($outcomes_subgrad as $index => $outcome)
                         @if(
                             is_array($undergrad_outcomes_attempted)
                             && array_key_exists($outcome->id, $undergrad_outcomes_attempted)
                     y:-1
                 },
                 data:[
-                    @foreach($outcomes as $index => $outcome)
+                    @foreach($outcomes_subgrad as $index => $outcome)
                         @if(
                             is_array($undergrad_outcomes_attempted)
                             && array_key_exists($outcome->id, $undergrad_outcomes_attempted)
         },
         xAxis: {
             categories: [
-                @foreach($outcomes as $outcome)
+                @foreach($outcomes_subgrad as $outcome)
                     "{{{ $outcome->name }}}",
                 @endforeach
             ],
             name: 'Undergraduate',
             color: '#e70033',
             data:[
-                @foreach($outcomes as $outcome)
+                @foreach($outcomes_subgrad as $outcome)
                     {{{ $attemptedUndergradProgramsPerOutcome[$outcome->id] }}},
                 @endforeach
             ],

app/views/local/professors/activity.blade.php

             <!-- If no rubric is assigned and the semester is active -->
             @if($activity->rubric == NULL && in_array($course->semester->id, $active_semesters))
                 {{ HTML::linkAction('RubricsController@newRubric', 'Assign Rubric', array($activity->id), array('class'=>'btn btn-primary btn-sm btn-block')) }}
+                {{ HTML::linkAction('RubricsController@newOtherMethod', 'Assign Other Assessment Method', array($activity->id), array('class'=>'btn btn-primary btn-sm btn-block')) }}
             @else
 
                 {{ HTML::linkAction('RubricsController@show', 'View Rubric', array($activity->id), array('class'=>'btn btn-primary btn-sm btn-block')) }}

composer.json

 		"laravel/framework": "4.2.*",
 		"pda/pheanstalk": "~2.0",
 		"barryvdh/laravel-dompdf": "0.4.*",
-		 "zizaco/entrust": "1.2.*@dev"
-	},
+		 "zizaco/entrust": "1.2.*@dev",
+		"cornford/backup": "1.*"
+},
 	"require-dev": {
 		"way/generators": "~2.0",
 		"fzaninotto/faker": "1.5.*@dev",