$inc_base = dirname(__FILE__) . DIRECTORY_SEPARATOR . '..' . DIRECTORY_SEPARATOR . 'inc' . DIRECTORY_SEPARATOR;

require_once($inc_base . 'school.inc');

require_once($inc_base . 'school.crawl.inc');

require_once($inc_base . 'class.semester.inc');

  $crawl = TRUE;

  $crawl_semester_year = '2011';

  $crawl_semester_season = Semester::SEASON_SPRING;

      $school = school_load($school_id, TRUE);

      school_crawl($school, $crawl_semester_year, $crawl_semester_season);

  $cache_dir_name = dirname(__FILE__) . DIRECTORY_SEPARATOR . '..'

    . DIRECTORY_SEPARATOR . 'cache' . DIRECTORY_SEPARATOR;

  $cache_auto_dir_name = $cache_dir_name . 'auto' . DIRECTORY_SEPARATOR;

					 'crawled' => $school['crawled'],

      /* autocomplete stuff -- per school */

      if ($school['crawled'])

	{

	  $semester = $school['crawled_semester'];

	  $cache_auto_school_dir_name = $cache_auto_dir_name . $school['id'] . DIRECTORY_SEPARATOR;

	  if (!is_dir($cache_auto_school_dir_name))

	    {

	      if (!mkdir($cache_auto_school_dir_name, 0777, TRUE))

		error_log('Unable to create needed directory: `' . $cache_auto_dir_name . '\'');

	    }

	  $departments = $semester->departments_get();

	  sort($departments);

	  $dept_file = fopen($cache_auto_school_dir_name . '-depts', 'wb');

	  fwrite($dept_file, serialize($departments));

	  fclose($dept_file);

	  /* now per-department autocomplete */

	  foreach ($departments as $department)

	    {

	      $classes = $semester->department_classes_get($department);

	      $classes_file = fopen($cache_auto_school_dir_name . $department . '.sects', 'wb');

	      fwrite($classes_file, serialize($classes));

	      fclose($classes_file);

	      /* now individual section informations, pre-JSON-ized */

	      foreach ($classes as $class)

		{

		  if (!is_dir($cache_auto_school_dir_name . $department))

		    mkdir($cache_auto_school_dir_name . $department);

		  $class_file = fopen($cache_auto_school_dir_name . $department . DIRECTORY_SEPARATOR . $class, 'wb');

		  fwrite($class_file, json_encode($semester->class_get($department, $class)->to_json_array()));

		  fclose($class_file);

		}

	    }

	}

  $cache_file_name =  $cache_dir_name . 'schools';

/**

 * \brief

 *   Invoke a school's registration data crawler.

 *

 * Each school may export registration data on publically accessible

 * websites. Thus, we populate some autocomplete information by

 * crawling these pages and storing the information in a special set

 * of caches.

 *

 * Because crawling code can be non-trivial, it should be separated

 * from a school's main .inc file. Thus, if a school supports

 * crawling, it will have a file called

 * schools.d/<school_id>.crawl.inc. In this file, a function called

 * <school_id>_crawl($semester) must be defined. It must accept one

 * argument, the Semester object which defines the time of year for

 * which courses should be retrieved. It must populate this empty

 * Semester object with Course object and populate those courses with

 * the sections with as much detail as possible.

 *

 * If the crawling is successful, a 'crawl' key is added to the

 * $school handle. school_cache() will use this to help indicate that

 * a school _has_ autocomplete information, which might affect the

 * appearance and JS stuff for the input.php page.

 *

 * \param $school

 *   The school which should be checked for crawl functionality and

 *   crawled.

 * \param $semester_year

 *   The year of the semester for which we should grab data.

 * \param $semester_season

 *   The season of the year of the semester for which we should grab

 *   data.

 */

function school_crawl(&$school, $semester_year, $semester_season, $verbosity = 1)

{

  $school['crawled'] = FALSE;

  $school_crawl_func = $school['id'] . '_crawl';

  if (!function_exists($school_crawl_func))

    return;

  $semester = new Semester($semester_year, $semester_season);

  if ($verbosity > 0)

    fprintf(STDERR, "%s()\n", $school_crawl_func);

  $ret = $school_crawl_func($semester, $verbosity);

  if ($ret)

    {

      fprintf(STDERR, "Crawling %s failed: %s() returned nonzero\n",

	      $school['id'], $school_crawl_func);

      fwrite(STDERR, "\n");

      return;

    }

  $school['crawled'] = TRUE;

  $school['crawled_semester'] = $semester;

  if ($verbosity > 0)

    fwrite(STDERR, "\n");

}

<?php

/*

 * Copyright 2010 Nathan Phillip Brink <ohnobinki@ohnopublishing.net>

 *

 * This file is a part of slate_permutate.

 *

 * slate_permutate is free software: you can redistribute it and/or modify

 * it under the terms of the GNU Affero General Public License as published by

 * the Free Software Foundation, either version 3 of the License, or

 * (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/>.

 */

/**

 * \file

 *   This file's purpose is to autocomplete class names for supporting

 *   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');

require_once('class.class.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'];

$term_parts = Classes::parse($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;

/*

 * autocomplete the list of departments. If the user has already

 * entered a valid department name _and_ delimitted it, however, go on

 * to the next autocompletion step.

 */

$term_strlen = strlen($term);

$dept_strlen = strlen($term_parts['department']);

$dept = $term_parts['department'];

if (!$getsections && count($term_parts) == 1 && $term_strlen == strlen($dept))

  {

    $dept_file = $cache_dir . '-depts';

    if (!file_exists($dept_file))

      clean_empty_exit();

    $deptartments = unserialize(file_get_contents($dept_file));

    foreach ($deptartments as $key => $department)

      {

	if (!strncmp($department, $dept, $term_strlen))

	  $departments[$key] = $department . '-';

	else

	  unset($departments[$key]);

      }

    echo json_encode($departments);

    exit(0);

  }

if ($getsections)

  {

    $section_file = $cache_dir . $dept . DIRECTORY_SEPARATOR . $term_parts['course'];

    if (file_exists($section_file))

      {

	readfile($section_file);

	exit(0);

      }

    /* section not found! */

    header('HTTP/1.1 404: Not found');

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

    echo 'Could not find course ' . implode('-', $term_parts) . "\n";

    exit(0);

  }

/*

 * if a department is fully entered, life gets slightly more

 * complicated. I suppose I only want to autocomplete the first digit

 * of the course/class number. I.e., CS-2 for CS-262 for when the

 * student has entered CS- or 'CS'. But for now we can just dump the entire department at the user ;-).

 */

$classes_file = $cache_dir . $dept . '.sects';

if (file_exists($classes_file))

  {

    $classes = unserialize(file_get_contents($classes_file));

    $class_start = '';

    if (count($term_parts) > 1)

      $class_start = $term_parts['course'];

    $class_start_strlen = strlen($class_start);

    /* reduce/create resultset */

    $json_classes = array();

    foreach ($classes as $class)

      if (!strncmp($class, $class_start, $class_start_strlen))

	{

	  $json_classes[] = $dept . '-' . $class;

	}

    echo json_encode($json_classes);

    exit(0);

  }

/**

 * Nothing caught..

 */

echo '["Oops"]';

exit(0);

/**

 * \brief

 *   Send an empty JSON array and exit.

 */

function clean_empty_exit()

{

  echo '[]';

  exit(0);

}

  /**

   * \brief

   *   Adds an already-instantiated section to this class.

   */

  public function section_add(Section $section)

  {

    $this->sections[$this->nsections] = $section;

    $this->nsections ++;

  }

  /**

   * \brief

   *   Split up a user-friendly course specification into components.

   *

   * This will only return the 'department' and 'course' components of

   * the given course identifier. Otherwise, it acts the same as

   * Section::parse.

   *

   * \see Section::parse()

   *

   * \param $course_spec

   *   A course specifier to parse, such as 'cs262' or 'MATH-156'.

   * \return

   *   An array with normalized output having keys of 'department' and

   *   'course'. If the user's input has less than these two keys of

   *   information, the returned array may have zero or one elements.

   */

  public static function parse($course_spec)

  {

    $section_parts = Section::parse($course_spec);

    if (isset($section_parts['section']))

      unset($section_parts['section']);

    return $section_parts;

  }

  /**

   * \brief

   *   Represent this class as a string.

   */

  public function __toString()

  {

    return $this->getName();

  }

  /**

   * \brief

   *   Represent this class as an array of sections ready to be JSONized.

   */

  public function to_json_array()

  {

    $json_array = array('class' => $this->getName(),

			'sections' => array());

    foreach ($this->sections as $section)

      {

	$json_array['sections'][] = $section->to_json_array();

      }

    return $json_array;

  }

  /**

   * \brief

   *   Splits up a section specifier into dept, course number, and

   *   section.

   *

   * For example, will return array('CS', '262', 'A') for 'CS-262-A'

   * or 'CS262A' or 'cs-262a'. This function is not for dealing with

   * course synonyms.

   *

   * \param $section_spec

   *   A string starting with a section specifier. If only the

   *   department is found, an array of size one is returned. If the

   *   course number is also found, both department and course id are

   *   returned. If all three are found, the array has three elements.

   *

   *   This array is keyed, so the found items may be referred to as

   *   'deptartment', 'course', and 'section'.

   *

   * \return

   *   An array with the department, course number, and section

   *   identifier. This array may be empty or have from one through

   *   three elements depending on the validity and precision of the

   *   $section_spec.

   */

  public static function parse($section_spec)

  {

    $ret = array();

    $section_spec = trim($section_spec);

    if (!preg_match(';([a-zA-Z]+)[^0-9]*;', $section_spec, $dept_matches))

      return $ret;

    /*

     * remove away the already-parsed stuff, including gunk between the

     * dept and the course num.

     */

    $section_spec = trim(substr($section_spec, strlen($dept_matches[0])));

    $ret['department'] = strtoupper($dept_matches[1]);

    if (!preg_match(';([0-9]+)[^a-zA-Z0-9]*;', $section_spec, $course_matches))

      return $ret;

    /* skip gunk */

    $section_spec = trim(substr($section_spec, strlen($course_matches[0])));

    $ret['course'] = $course_matches[1];

    /*

     * we accept _either_ alphabetic section _or_ numeric section (the

     * latter is for cedarville, particulaly)

     */

    if (!preg_match(';([0-9]+|[a-zA-Z]+);', $section_spec, $section_matches))

      return $ret;

    $ret['section'] = strtoupper($section_matches[1]);

    return $ret;

  }

  /**

   * \brief

   *   Get an array of information needed by the AJAX stuff.

   */

  public function to_json_array()

  {

    static $daymap = array(0 => 'm', 1 => 't', 2 => 'w', 3 => 'u', 4 => 'f');

    $json_array = array('section' => $this->letter,

			'prof' => $this->prof,

			'time_start' => $this->start,

			'time_end' => $this->tend,

			'days' => array(),

			);

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

      $json_array['days'][$daymap[$day]] = $this->getDay($day);

    return $json_array;

  }

<?php

/*

 * Copyright 2010 Nathan Phillip Brink <ohnobinki@ohnopublishing.net>

 *

 * This file is a part of slate_permutate.

 *

 * slate_permutate is free software: you can redistribute it and/or modify

 * it under the terms of the GNU Affero General Public License as published by

 * the Free Software Foundation, either version 3 of the License, or

 * (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.class.php');

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.

   */

  const SEASON_FALL = 'fall';

  /**

   * \brief

   *   The Spring season.

   */

  const SEASON_SPRING = 'spring';

  /**

   * \brief

   *   Instantiate an empty Semester.

   *

   * \param $year

   *   The year of this semester. Must be four digits.

   * \param $season

   *   The season of this semester. Currently, only

   *   Semester::SEASON_SPRING and Semester::SEASON_FALL are valid.

   */

  function __construct($year, $season)

  {

    if (!in_array($season, array(self::SEASON_SPRING, self::SEASON_FALL)))

      throw new ErrorException('Attempt to construct a Semester with a $season which is neither Semester::SEASON_SPRING nor Semester::SEASON_FALL. `' . $season . '\' was given.');

    $this->season = $season;

    if (strlen($year) != 4)

      throw new ErrorException('Attempt to construct a Semester with an invalid year. The given year is `' . $year . '\'');

    $this->year = $year;

    $this->departments = array();

  }

  /**

   * \brief

   *   Add a class to this Semester.

   *

   * \param $class

   *   The class/course to add.

   */

  public function class_add(Classes $class)

  {

    $class_parts = Classes::parse($class->getName());

    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

   *   A Classes or NULL if not found.

   */

  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.

   */

  public function departments_get()

  {

    return array_keys($this->departments);

  }

  /**

   * \brief

   *   Gets a list of class/course numbers available for a particular

   *   department.

   */

  public function department_classes_get($dept)

  {

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

      throw new ErrorException('I was asked for a department I don\'t own: ' . $dept);

    return array_keys($this->departments[$dept]);

  }

  /**

   * \brief

   *   Utility function to add a section to the semester,

   *   automatically creating classes as necessary.

   *

   * \param $dept

   *   The department this section belongs to.

   * \param $class

   *   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]))

      {

	$classobj = new Classes($dept . '-' . $class);

	$this->class_add($classobj);

      }

    else

      {

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

      }

    $classobj->section_add($section);

  }

  /**

   * \brief

   *   Get a semester's year.

   */

  public function year_get()

  {

    return $this->year;

  }

  /**

   * \brief

   *   Get a semester's season.

   */

  public function season_get()

  {

    return $this->season;

  }

}

<?php

/*

 * Copyright 2010 Nathan Phillip Brink <ohnobinki@ohnopublishing.net>

 *

 * This file is a part of slate_permutate.

 *

 * slate_permutate is free software: you can redistribute it and/or modify

 * it under the terms of the GNU Affero General Public License as published by

 * the Free Software Foundation, either version 3 of the License, or

 * (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/>.

 */

/**

 * \file

 *   Routines that are only useful when crawling schools' websites for

 *   autofill section data.

 */

/**

 * \brief

 *   Parse a simple time string into slate_permutate's time

 *   representation.

 *

 * \param $time

 *   An array compatible with the return value of strptime(). The only

 *   fields we use are 'tm_hour', which is from 0 through 23, and

 *   'tm_min', which may be from 0 through 50.

 */

function school_crawl_time_format($time)

{

  return sprintf('%02d%02d', $time['tm_hour'], $time['tm_min']);

}

/**

 * \brief

 *   Take an array of day names and assemble them into

 *   slate_permutate's internal (weird) representation of a set of

 *   weekdays.

 *

 * This function is intended to make it easy for one to take the

 * output of an explode() call. For example, to decode $days_str =

 * 'Monday, Tuesday, Friday', one would do

 * school_crawl_days_format(explode(', ', $days_str));

 *

 * \param $days

 *   An array of day names. These may be common abbreviations or

 *   truncations (any truncations must be two chars long for

 *   simplicity. One-char representations are supported, however, but

 *   use 'm', 't', 'w', 'h', 'f' to distinguish thursday and

 *   friday). Case does not matter.

 * \return

 *   slate_permutate's strange internal days representation.

 */

function school_crawl_days_format($days)

{

  static $daymap_1 = array('m' => 1, 't' => 2, 'w' => 3, 'h' => 4, 'f' => 5);

  static $daymap_2 = array('th' => 'h');

  $my_days = array();

  foreach ($days as $day)

    {

      $day_orig = $day;

      $day = strtolower(substr(trim($day), 0, 2));

      /*

       * convert from two-char representation to one-char

       * representation.n

       */

      if (strlen($day) > 1)

	{

	  if (isset($daymap_2[$day]))

	    $day = $daymap_2[$day];

	  else

	    $day = substr($day, 0, 1);

	}

      if (isset($daymap_1[$day]))

	$my_days[$daymap_1[$day]] = TRUE;

      else

	error_log('school_crawl_days_format() got invalid day specifier:'

		  . ' `' . $day_orig . '\' => `' . $day . '\'');

    }

  $day_str = '';

  foreach ($my_days as $day_val => $junk)

    $day_str .= $day_val;

  return $day_str;

}

 * \param $load_all_inc

 *   Asks for a school's extraneous .inc files to be loaded

 *   to. Intended for use by rehash.php only.

function school_load($school_id, $load_all_inc = FALSE)

  $school_file_name_base = dirname(__FILE__) . DIRECTORY_SEPARATOR

    . '..' . DIRECTORY_SEPARATOR . 'school.d' . DIRECTORY_SEPARATOR;

  $school_file_name = $school_file_name_base . $school_id . '.inc';

  if ($load_all_inc)

    {

      $school_crawl_file_name = $school_file_name_base . $school_id . '.crawl.inc';

      if (file_exists($school_crawl_file_name))

	require_once($school_crawl_file_name);

    }

  /*

   * append small amount of info from the cache entry for this school:

   * whether or not it was crawled.

   *

   * Perhaps this stuff should be just moved into the _info function

   * for efficiency.

   */

  $cache = _school_cache_load();

  if ($cache && count($cache['list']))

    $school['crawled'] = $cache['list'][$school['id']]['crawled'];

<?php

/*

 * Copyright 2010 Nathan Phillip Brink <ohnobinki@ohnopublishing.net>

 *

 * This file is a part of slate_permutate.

 *

 * slate_permutate is free software: you can redistribute it and/or modify

 * it under the terms of the GNU Affero General Public License as published by

 * the Free Software Foundation, either version 3 of the License, or

 * (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/>.

 */