Merge pull request #2293 from StoDevX/add-course-search

Add basic course search

Author: rye

android/app/src/main/java/com/allaboutolaf/MainActivity.java

@@ -1,5 +1,6 @@
 package com.allaboutolaf;
 
+import com.facebook.react.modules.storage.ReactDatabaseSupplier;
 import com.facebook.react.ReactActivity;
 import com.bugsnag.BugsnagReactNative;
 import com.calendarevents.CalendarEventsPackage;
@@ -23,6 +24,8 @@ public void onCreate(Bundle savedInstanceState) {
         if (!BuildConfig.DEBUG) {
             BugsnagReactNative.start(this);
         }
+        long size = 50L * 1024L * 1024L; // 50 MB
+        ReactDatabaseSupplier.getInstance(getApplicationContext()).setMaximumSize(size);
     }
 
     // Required for react-native-calendar-events

package.json

@@ -114,6 +114,7 @@
     "react-native-restart": "0.0.6",
     "react-native-safari-view": "2.1.0",
     "react-native-search-bar": "3.4.0",
+    "react-native-searchbar": "1.14.0",
     "react-native-tableview-simple": "0.17.2",
     "react-native-typography": "1.3.0",
     "react-native-vector-icons": "4.5.0",
@@ -124,6 +125,7 @@
     "redux-promise": "0.5.3",
     "redux-thunk": "2.2.0",
     "semver": "5.5.0",
+    "sto-sis-time-parser": "2.3.3",
     "stream": "0.0.2",
     "timers": "0.1.1",
     "titlecase": "1.1.2",

source/flux/parts/sis.js

@@ -2,9 +2,17 @@
 
 import {type ReduxState} from '../index'
 import {getBalances, type BalancesShapeType} from '../../lib/financials'
+import {
+	loadCachedCourses,
+	updateStoredCourses,
+	areAnyTermsCached,
+} from '../../lib/course-search'
+import type {CourseType} from '../../lib/course-search'
 
 const UPDATE_BALANCES_SUCCESS = 'sis/UPDATE_BALANCES_SUCCESS'
 const UPDATE_BALANCES_FAILURE = 'sis/UPDATE_BALANCES_FAILURE'
+const LOAD_CACHED_COURSES = 'sis/LOAD_CACHED_COURSES'
+const COURSES_LOADED = 'sis/COURSES_LOADED'
 
 type UpdateBalancesSuccessAction = {|
 	type: 'sis/UPDATE_BALANCES_SUCCESS',
@@ -39,7 +47,51 @@ export function updateBalances(
 	}
 }
 
-type Action = UpdateBalancesActions
+type LoadCachedCoursesAction = {|
+	type: 'sis/LOAD_CACHED_COURSES',
+	payload: Array<CourseType>,
+|}
+type CoursesLoadedAction = {|
+	type: 'sis/COURSES_LOADED',
+|}
+
+export type LoadCourseDataActionType = ThunkAction<
+	LoadCachedCoursesAction | CoursesLoadedAction,
+>
+export type UpdateCourseDataActionType = ThunkAction<
+	LoadCachedCoursesAction | CoursesLoadedAction,
+>
+
+export function loadCourseDataIntoMemory(): LoadCourseDataActionType {
+	return async dispatch => {
+		const areAnyCached = await areAnyTermsCached()
+
+		if (!areAnyCached) {
+			return
+		}
+
+		const cachedCourses = await loadCachedCourses()
+		dispatch({type: LOAD_CACHED_COURSES, payload: cachedCourses})
+		dispatch({type: COURSES_LOADED})
+	}
+}
+
+export function updateCourseData(): UpdateCourseDataActionType {
+	return async dispatch => {
+		const updateNeeded = await updateStoredCourses()
+
+		if (updateNeeded) {
+			const cachedCourses = await loadCachedCourses()
+			dispatch({type: LOAD_CACHED_COURSES, payload: cachedCourses})
+			dispatch({type: COURSES_LOADED})
+		}
+	}
+}
+
+type Action =
+	| UpdateBalancesActions
+	| LoadCachedCoursesAction
+	| CoursesLoadedAction
 
 export type State = {|
 	balancesErrorMessage: ?string,
@@ -49,7 +101,10 @@ export type State = {|
 	mealsRemainingToday: ?string,
 	mealsRemainingThisWeek: ?string,
 	mealPlanDescription: ?string,
+	allCourses: Array<CourseType>,
+	courseDataState: 'not-loaded' | 'ready',
 |}
+
 const initialState = {
 	balancesErrorMessage: null,
 	flexBalance: null,
@@ -58,7 +113,10 @@ const initialState = {
 	mealsRemainingToday: null,
 	mealsRemainingThisWeek: null,
 	mealPlanDescription: null,
+	allCourses: [],
+	courseDataState: 'not-loaded',
 }
+
 export function sis(state: State = initialState, action: Action) {
 	switch (action.type) {
 		case UPDATE_BALANCES_FAILURE:
@@ -77,6 +135,11 @@ export function sis(state: State = initialState, action: Action) {
 			}
 		}
 
+		case LOAD_CACHED_COURSES:
+			return {...state, allCourses: action.payload}
+		case COURSES_LOADED:
+			return {...state, courseDataState: 'ready'}
+
 		default:
 			return state
 	}

source/lib/course-search/index.js

@@ -0,0 +1,6 @@
+// @flow
+
+export {loadCachedCourses} from './load-cached-courses'
+export {updateStoredCourses, areAnyTermsCached} from './update-course-storage'
+export {CourseType, TermType} from './types'
+export {parseTerm} from './parse-term'

source/lib/course-search/load-cached-courses.js

@@ -0,0 +1,12 @@
+// @flow
+
+import type {CourseType, TermType} from './types'
+import flatten from 'lodash/flatten'
+import * as storage from '../storage'
+
+export async function loadCachedCourses(): Promise<Array<CourseType>> {
+	const terms: Array<TermType> = await storage.getTermInfo()
+	const promises = terms.map(term => storage.getTermCourseData(term.term))
+	const coursesByTerm = await Promise.all(promises)
+	return flatten(coursesByTerm)
+}

source/lib/course-search/parse-term.js

@@ -0,0 +1,26 @@
+// @flow
+
+export function parseTerm(term: string) {
+	const semester = term.slice(-1)
+	const year = term.slice(0, -1)
+	const currentYear = parseInt(year)
+	const nextYear = (currentYear + 1).toString().slice(-2)
+	switch (semester) {
+		case '0':
+			return `Abroad ${currentYear}/${nextYear}`
+		case '1':
+			return `Fall ${currentYear}/${nextYear}`
+		case '2':
+			return `Interim ${currentYear}/${nextYear}`
+		case '3':
+			return `Spring ${currentYear}/${nextYear}`
+		case '4':
+			return `Summer Term 1 ${currentYear}/${nextYear}`
+		case '5':
+			return `Summer Term 2 ${currentYear}/${nextYear}`
+		case '9':
+			return `Non-St. Olaf ${currentYear}/${nextYear}`
+		default:
+			return 'Unknown term'
+	}
+}

source/lib/course-search/types.js

@@ -0,0 +1,34 @@
+// @flow
+
+export type CourseType = {
+	clbid: number,
+	credits: number,
+	crsid: number,
+	departments: string[],
+	description?: string[],
+	gereqs?: string[],
+	instructors: string[],
+	level: number,
+	locations?: string[],
+	name: string,
+	notes?: string[],
+	number: number,
+	pn: boolean,
+	prerequisites: false | string,
+	section?: string,
+	semester: number,
+	status: string,
+	term: number,
+	times?: string[],
+	title?: string,
+	type: string,
+	year: number,
+}
+
+export type TermType = {
+	hash: string,
+	path: string,
+	term: number,
+	type: string,
+	year: number,
+}

source/lib/course-search/update-course-storage.js

@@ -0,0 +1,63 @@
+/**
+ * @flow
+ * updateStoredCourses() handles updating the cached course data from the server
+ */
+
+import type {CourseType, TermType} from './types'
+import {COURSE_DATA_PAGE, INFO_PAGE} from './urls'
+import * as storage from '../storage'
+
+type TermInfoType = {
+	files: Array<TermType>,
+	type: string,
+}
+
+export async function areAnyTermsCached(): Promise<boolean> {
+	const localTerms = await storage.getTermInfo()
+	return localTerms.length === 0 ? false : true
+}
+
+export async function updateStoredCourses(): Promise<boolean> {
+	const outdatedTerms: Array<TermType> = await determineOutdatedTerms()
+	await Promise.all(outdatedTerms.map(term => storeTermCoursesFromServer(term)))
+	// returns ``true`` if any terms were updated
+	return outdatedTerms.length === 0 ? false : true
+}
+
+async function determineOutdatedTerms(): Promise<Array<TermType>> {
+	const remoteTerms: Array<TermType> = await loadCurrentTermsFromServer()
+	const localTerms: Array<TermType> = await storage.getTermInfo()
+	if (localTerms.length === 0) {
+		await storage.setTermInfo(remoteTerms)
+		return remoteTerms
+	}
+	let outdatedTerms = localTerms.filter(localTerm => {
+		const match = remoteTerms.find(
+			remoteTerm => remoteTerm.term === localTerm.term,
+		)
+		return match ? match.hash !== localTerm.hash : true
+	})
+	if (outdatedTerms.length !== 0) {
+		storage.setTermInfo(remoteTerms)
+	}
+	return outdatedTerms
+}
+
+async function loadCurrentTermsFromServer(): Promise<Array<TermType>> {
+	const today = new Date()
+	const thisYear = today.getFullYear()
+	const resp: TermInfoType = await fetchJson(INFO_PAGE).catch(() => ({
+		files: [],
+		type: 'error',
+	}))
+	const terms: Array<TermType> = resp.files.filter(
+		file => file.type === 'json' && file.year > thisYear - 5,
+	)
+	return terms
+}
+
+async function storeTermCoursesFromServer(term: TermType) {
+	const url = COURSE_DATA_PAGE + term.path
+	const resp: Array<CourseType> = await fetchJson(url).catch(() => [])
+	storage.setTermCourseData(term.term, resp)
+}

source/lib/course-search/urls.js

@@ -0,0 +1,5 @@
+// @flow
+
+export const COURSE_DATA_PAGE = 'https://stodevx.github.io/course-data/'
+
+export const INFO_PAGE = 'https://stodevx.github.io/course-data/info.json'

source/lib/storage.js

@@ -27,7 +27,7 @@ function removeItem(key: string): Promise<void> {
 async function getItemAsBoolean(key: string): Promise<boolean> {
 	return (await getItem(key)) || false
 }
-async function getItemAsArray(key: string): Promise<Array<*>> {
+async function getItemAsArray<T>(key: string): Promise<Array<T>> {
 	return (await getItem(key)) || []
 }
 
@@ -74,3 +74,23 @@ export function setFavoriteBuildings(buildings: string[]) {
 export function getFavoriteBuildings(): Promise<Array<string>> {
 	return getItemAsArray(favoriteBuildingsKey)
 }
+
+/// MARK: SIS
+import type {CourseType, TermType} from './course-search/types'
+
+const courseDataKey = 'sis:course-data'
+export function setTermCourseData(term: number, courseData: Array<CourseType>) {
+	const key = courseDataKey + `:${term}:courses`
+	return setItem(key, courseData)
+}
+export function getTermCourseData(term: number): Promise<Array<CourseType>> {
+	const key = courseDataKey + `:${term}:courses`
+	return getItemAsArray(key)
+}
+const termInfoKey = courseDataKey + ':term-info'
+export function setTermInfo(termData: Array<TermType>) {
+	return setItem(termInfoKey, termData)
+}
+export function getTermInfo(): Promise<Array<TermType>> {
+	return getItemAsArray(termInfoKey)
+}