*/

function test()

{

  $ideal = array('department' => 'CS',

		 'course' => '262',

		 'section' => 'A');

  $ideal_c = $ideal;

  unset($ideal_c['section']);

  $n = 0;

  $t1 = 'CS-262-A';

  $n += assert_equal($t1, Section::parse($t1), $ideal);

  $t2 = 'cs262 a';

  $n += assert_equal($t2, Section::parse($t2), $ideal);

  $t3 = 'cs 262 a';

  $n += assert_equal($t3, Section::parse($t2), $ideal);

  $ideal['course'] .= 'L';

  $ideal_c['course'] = $ideal['course'];

  $t1 = 'CS-262L-A';

  $n += assert_equal($t1, Section::parse($t1), $ideal);

  $t2 = 'cs262l a';

  $n += assert_equal($t2, Section::parse($t2), $ideal);

  $t3 = 'cs 262l a';

  $n += assert_equal($t3, Section::parse($t2), $ideal);

  return $n;

}

/**

 * \brief

 *   A reimplementation of a standard testsuite utility.

 *

 * \return

 *   TRUE if the test failed.

 */

function assert_equal($name, $a, $b)

 *   the autocomplete JS based off of crawling schools' registration

 *   websites. This shall only perform the autocompletion of class

 *   names.

 *

 *   Since we output JSON, no special Page classes and stuff

 *   :-p. Except we still call the Page class's session_start()

 *   function because we apparently need sessions.... oh yeah, for

 *   school profile supports ;-).

 */

require_once('inc/school.inc');

require_once('inc/class.page.php');

Page::session_start();

if (isset($_REQUEST['txt'])) {

  header('Content-Type: text/plain; encoding=utf-8');

}

else {

  header('Content-Type: application/json; encoding=utf-8');

}

if (!isset($_REQUEST['term'])) {

  clean_empty_exit();

}

$getsections = FALSE;

if (isset($_REQUEST['getsections'])) {

  $getsections = TRUE;

}

$term = $_REQUEST['term'];

if (!count($term_parts)) {

  clean_empty_exit();

}

$school = school_load_guess();

if (!$school['crawled']) {

  clean_empty_exit();

}

$cache_dir = dirname(__FILE__) . DIRECTORY_SEPARATOR . 'cache' . DIRECTORY_SEPARATOR . 'auto' . DIRECTORY_SEPARATOR . $school['id'] . DIRECTORY_SEPARATOR;

/*

 * You should have received a copy of the GNU Affero General Public License

 * along with SlatePermutate.  If not, see <http://www.gnu.org/licenses/>.

 */

//**************************************************

// class.schedule.php	Author: Nathan Gelderloos

//

// Represents a schedule of a week. Stores the

// classes that are part of that week and calculates

// all the possible permutations.

//**************************************************

include_once 'class.section.php';

include_once 'inc/class.page.php';

class Schedule

{

  private $nclasses;				// Integer number of classes

  private $nPermutations = 0;		// Integer number of real permutations

  private $possiblePermutations;	// Integer number of possible permutations

  private $scheduleName;			// String name of schedule

  private $storage;				// Integer array of valid schedules

  private $title;

  /**

   * \brief

   *   My global identification number. Not defined until the schedule

   *   is processed and first saved.

   */

  private $id;

   * The input format of the sections. Only used for the UI. Valid

   * values are 'numerous' for custom, 'numbered' for numeric, and 'lettered' for

   * alphabetical.

   */

  public $section_format;

  /**

   * \brief

   *   Create a schedule with the given name.

   */

  function __construct($name)

  {

    $this->scheduleName = $name;

    $this->storage = array();

    $this->title = "SlatePermutate - Scheduler";

    $this->section_format = 'numerous';

  }

  //--------------------------------------------------

  // Mutators and Accessors

  //--------------------------------------------------

  public function getName()

  {

    return $this->scheduleName;

  }    

  //--------------------------------------------------

  // Adds a new class to the schedule.

  //--------------------------------------------------

  {

  }

  //--------------------------------------------------

  // Adds a section to the desired class.

  //--------------------------------------------------

  function addSection($course_name, $letter, $time_start, $time_end, $days, $synonym = NULL, $faculty = NULL, $location = NULL, $type = 'lecture')

  {

    $found = false;

    $counter = 0;

	  {

      if (!$section)

	{

	  $section = new Section($letter, array(), $synonym, $faculty);

	}

      $section->meeting_add(new SectionMeeting($days, $time_start, $time_end, $location, $type));

    }

  }

  //--------------------------------------------------

  // Finds all of the possible permutations and stores

  // the results in the storage array.

  //--------------------------------------------------

	function findPossibilities()

	{

		$this->possiblePermutations = 1;

		/* special case: there is nothing entered into the schedule and thus there is one, NULL permutation */

		{

			/* have an empty schedule */

			$this->nPermutations = 1;

			return;

		}

		$position = 0;

		$counter = 0;

		{

			$cs[$i] = 0;	// Sets the counter array to all zeroes.

		}

		// Checks for conflicts in given classes, stores if none found

		do

		{

			$conflict = false;

			// Get first class to compare

			{

				{

				    {

				      $conflict = TRUE;

				      break;

				    }

				}

			}

	// Store to storage if no conflict is found.

	if(!$conflict)

	  {

	      {

		$this->storage[$this->nPermutations][$i] = $cs[$i];

	      }

	    $this->nPermutations++;

	  }

	// Increase the counter by one to get the next combination of class sections.

	$cs[$position] = $cs[$position] + 1;

	// Check to make sure the counter is still valid.

	$valid = false;

	while(!$valid)

	  {

	      {

		$cs[$position] = 0;

		$position++;

		// This is for the very last permutation. Even 

		// though the combination is not actually true

		// the larger while loop will end before any 

		// new combinations are performed.

		  {

		    $valid = true;

		  } else {

		  $cs[$position]++;

		}

	      } else {

	      $valid = true;

	      $position = 0;

	    }

	  }

	$counter++;

	    $rowspan = array(0, 0, 0, 0, 0);

	    for($r = 0; $r < (count($time)-1); $r++)

	      {

		echo "          <tr>\n"

		  . "            <td class=\"time\">" . $this->prettyTime($time[$r]) . "</td>\n";

		for($dayLoop = 0; $dayLoop < 5; $dayLoop++)

		{

		  /* Makes sure there is not a class already in progress */

		  if($rowspan[$dayLoop] <= 0)

		    {

			{

			  $section_index = $this->storage[$i][$j];

			  $section = $class->getSection($section_index);

				  /* iterate through all of a class's meeting times */

				  $meetings = $section->getMeetings();

				  /* find any meeting which are going on at this time */

				  $current_meeting = NULL;

				  foreach ($meetings as $meeting)

				    {

				      if ($meeting->getDay($dayLoop)

					  && $meeting->getStartTime() >= $time[$r]

					  && $meeting->getStartTime() < $time[$r+1])

	return substr($t, 0, strlen($t)-2) . ":" . substr($t, strlen($t)-2, strlen($t)) . " PM";

      } else {

      return substr($t, 0, strlen($t)-2) . ":" . substr($t, strlen($t)-2, strlen($t)) . " AM";

    }

  }

  /**

   * \brief

   *   fetch the number of classes

   */

  function nclasses_get()

  {

  }

   * \brief

   *   fetch a specified class by its key

   */

  function class_get($class_key)

  {

  }

  /**

   * \brief

   *   Set my global ID.

   *

   * Only to be called by schedule_store_store().

   */

  function id_set($id)

  { 

    $this->id = $id;

  }

      $id = $this->id;

    $url .= (int)$id;

    if ($clean_urls)

      $url .= '?';

    else

      $url .= '&';

    if ($page)

      $url .= 'page=' . (int)$page . '&';

    return $url;

  }

}

 * You should have received a copy of the GNU Affero General Public License

 * along with SlatePermutate.  If not, see <http://www.gnu.org/licenses/>.

 */

/**

 * \file

 *    This file represents a course (formerly class). It stores

 *    the section associated with the course.

 */

include_once 'class.section.php';

{

  private $name;	// String

  private $sections;	// Array of sections

  private $nsections;	// int

  /**

   * \brief

   *    Creates a class with the given name.

   * \param $n

   *    The name of the class.

   */

  function __construct($n)

 * (at your option) any later version.

 *

 * slate_permutate is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU Affero General Public License for more details.

 *

 * You should have received a copy of the GNU Affero General Public License

 * along with slate_permutate.  If not, see <http://www.gnu.org/licenses/>.

 */

$root_dir = dirname(__FILE__) . DIRECTORY_SEPARATOR . '..' . DIRECTORY_SEPARATOR;

require_once($root_dir . 'class.section.php');

/**

 * \brief

 *   Identifies a school semester and acts as a container for courses

 *   offered in a semester.

 */

class Semester

{

  /**

   * \brief

   *   The Fall season.

    $this->year = $year;

    $this->departments = array();

  }

  /**

   * \brief

   *   Add a class to this Semester.

   *

   * \param $class

   *   The class/course to add.

   */

  {

    if (!isset($class_parts['course']))

      throw ErrorException('I was given a class with an invalid name: `' . $class->getName() . '\'');

    if (!isset($this->departments[$class_parts['department']]))

      $this->departments[$class_parts['department']] = array();

    $department =& $this->departments[$class_parts['department']];

    $department[$class_parts['course']] = $class;

  }

  /**

   * \brief

   *   Retrieve a class.

   *

   * \param $dept

   *   The class's department. 'CS' for 'CS-262'.

   * \param $class

   *   The course/class number. '262' for 'cs-262'.

   * \return

   */

  public function class_get($dept, $class)

  {

    if (!isset($this->departments[$dept][$class]))

      return NULL;

    return $this->departments[$dept][$class];

  }

  /**

   * \brief

   *   Gets a list of departments available in this semester.

   *   The class this section belongs to.

   * \param $section

   *   The section itself.

   */

  public function section_add($dept, $class, Section $section)

  {

    $dept = strtoupper($dept);

    $class = strtoupper($class);

    if (!isset($this->departments[$dept])

	|| !isset($this->departments[$dept][$class]))

      {

	$this->class_add($classobj);

      }

    else

      {

	$classobj = $this->departments[$dept][$class];

      }

    $classobj->section_add($section);

  }

  /**

   * \brief

}

/**

 * \brief

 *   Obtains a lock on the /lastid file in the schedule_store.

 *

 * \see _schedule_store_flock_release().

 *

 * \param $schedule_store

 *   The schedule_store instance we're working with.

 * \param $operation

 *   Which flock() operation to perform: valid are LOCK_SH and LOCK_EX.

 */

function _schedule_store_flock_grab(&$schedule_store, $operation)

{

  $schedule_store['lastid_flock_file'] = fopen($schedule_store['dir'] . DIRECTORY_SEPARATOR . 'lastid.flock', 'c');

  return flock($schedule_store['lastid_flock_file'], $operation);

}

/**

 * \brief

 *   Release a lock grabbed with _schedule_store_flock_grab().

 */

function _schedule_store_flock_release(&$schedule_store)

/**

 * \brief

 *   Return an array of default classes for a particular school.

 *

 * \param $school

 *   The school's handle.

 */

function school_default_classes($school)

{

  $school_default_classes = $school['id'] . '_default_classes';

  if (function_exists($school_default_classes))

    {

      return $school_default_classes();

    }

  return array();

}

/**

 * \brief

 *   Used to load the school cache.

 *

 * \return

 *   The cache array or NULL if the cache couldn't be loaded.

 * (at your option) any later version.

 *

 * SlatePermutate is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU Affero General Public License for more details.

 *

 * You should have received a copy of the GNU Affero General Public License

 * along with SlatePermutate.  If not, see <http://www.gnu.org/licenses/>.

 */

include_once 'class.schedule.php';

include_once 'class.section.php';

include_once 'inc/class.page.php';

require_once('inc/schedule_store.inc');

$scripts = array('jQuery', 'jQueryUI', 'jValidate','qTip','schedInput');

$inputPage = new page('Scheduler', $scripts, FALSE);

$schedule_store = FALSE;

$sch = FALSE;

$school = $inputPage->get_school();

</div>

</form>

<p>&nbsp;<br /><br /><br /></p>

<?php 

/* Show/hide Advanced Options: <p><span id="showadvanced" style="margin-left: 1em;"><a href="#">Advanced</a></span></p> */ 

$inputPage->showSchoolInstructions();

$inputPage->foot();

{

  $js = $whitespace . 'class_last = add_class_n(\'' . htmlentities($class->getName(), ENT_QUOTES) . "');\n";

  $nsections  = $class->getnsections();

  for ($section_key = $nsections - 1; $section_key >= 0; $section_key --)

    {

      $section = $class->getSection($section_key);

      $meetings = $section->getMeetings();

      foreach ($meetings as $meeting)

	{

	  $js .= $whitespace . 'add_section_n(class_last, \'' . htmlentities($section->getLetter(), ENT_QUOTES) . '\', \''

	    . htmlentities($section->getSynonym(), ENT_QUOTES) . '\', \''

 * SlatePermutate is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU Affero General Public License for more details.

 *

 * You should have received a copy of the GNU Affero General Public License

 * along with SlatePermutate.  If not, see <http://www.gnu.org/licenses/>.

 */

require_once('inc/schedule_store.inc');

require_once('inc/class.page.php');

include_once 'class.schedule.php';

include_once 'class.section.php';

// Converts a 5-element day array into a string.

// Supports multiple modes, prettiness, and searching for different indicators

function arrayToDays($array, $mode = 'num', $pretty = false, $key = 1) {

	$outString = '';

	switch($mode)

	  {

		case 'short':

			$days = array('Mon','Tue','Wed','Thur','Fri');

			break;

		case 'long':

		$allClasses = new Schedule($_POST['postData']['name']);

		foreach($_POST['postData'] as $class)

		{

		  /*

		   * Only add classes if the user added at least one

		   * section to the class. We know that $class['name']

		   * is not a section, so count() needs to be > 1 and

		   * we need to skip over 'name' in our loop.

		   */

			if(is_array($class) && count($class) > 1)

			{

				foreach($class as $section)

				  /* Skip the section name, which isn't a section */

					if(is_array($section))

					{

					  $allClasses->addSection($class['name'], $section['letter'], $section['start'], $section['end'], arrayToDays($section['days'], 'alpha'), $section['synonym'], $section['professor'], $section['location'], $section['type']);

					}

			}

		}

		$allClasses->findPossibilities();

		if (!isset($_SESSION['saved']))

		  $_SESSION['saved'] = array();

 * (at your option) any later version.

 *

 * SlatePermutate is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU Affero General Public License for more details.

 *

 * You should have received a copy of the GNU Affero General Public License

 * along with SlatePermutate.  If not, see <http://www.gnu.org/licenses/>.

 */