catc/inc/catc.php

<?php

class CATC extends Main
{
	
	const GZ_LVL = 4;
	
	/**
	 * Auth Object
	 * @var Auth
	 */
	private $oAuth;	
	
	public function __construct($oClassManagement, $sProcessPage)
	{
		$asClasses = array(
			array('name'=>'auth', 'project'=>true),
			array('name'=>'course', 'project'=>true),
			array('name'=>'note', 'project'=>true),
			array('name'=>'doc', 'project'=>true),
			array('name'=>'definition', 'project'=>true)
		);
		parent::__construct($oClassManagement, $sProcessPage, $asClasses);
		
		//if($this->oDb->sDbState == Db::DB_PEACHY) $this->oAuth = new Auth($this->oDb, Settings::API_KEY);
		$this->oAuth = new Auth($this->oDb, Settings::API_KEY);
	}
	
	protected function install()
	{
		//Install DB
		$this->oDb->install();
		$this->oDb->loadFile('db_build.sql');
	}
	
	protected function getSqlOptions()
	{
		return array
		(
			'tables' 			=>	array
			(
				Auth::USER_TABLE		=> array(Db::getText(Auth::USER_TABLE), 'nickname', 'pass', 'cookie'),
				Course::WS_TABLE		=> array('dates'),
				Course::COURSE_TABLE	=> array(Db::getId(Course::WS_TABLE), 'description', 'timeslot'),
				Note::NOTE_TABLE		=> array(Db::getId(Auth::USER_TABLE), Db::getId(Course::COURSE_TABLE), 'notes'),
				Definition::DEF_TABLE	=> array(Db::getId(Auth::USER_TABLE), 'title', 'description'),
				Doc::DOC_TABLE			=> array(Db::getId(Auth::USER_TABLE), Db::getId(Course::WS_TABLE), 'type', 'filename', 'filehash'),
				'todos'					=> array(Db::getId(Auth::USER_TABLE), Db::getId(Course::COURSE_TABLE), 'description')
			),
			'types' 			=>	array
			(
				Db::getText(Auth::USER_TABLE)	=> "VARCHAR(32) NOT NULL",
				'nickname'						=> "VARCHAR(60) NOT NULL",
				'pass'							=> "VARCHAR(256) NOT NULL",
				'cookie'						=> "VARCHAR(255)",
				'dates'							=> "VARCHAR(50)",
				'title'							=> "VARCHAR(50)",
				'description'					=> "VARCHAR(200)",
				'timeslot'						=> "ENUM('SAT-M', 'SAT-A', 'SUN-M', 'SUN-A')",
				'notes'							=> "LONGTEXT",
				'type'							=> "VARCHAR(10)",
				'filename'						=> "VARCHAR(200)",
				'filehash'						=> "VARCHAR(40)"
			),
			'constraints'		=>	array
			(
				Doc::DOC_TABLE			=> "UNIQUE KEY `uni_file` (`filename`)",
				Definition::DEF_TABLE	=> "UNIQUE KEY `uni_def_title` (`title`)"
			)
		);
	}
	
	private function getVars() {
		return array(
			'id'		=> $this->oAuth->getUserId(),
			'log_in'	=> $this->isLoggedIn()
		);
	}
	
	public function getAppMainPage()
	{
		return self::getMainPage(
			array(
				'consts'	=> array(
					'token_sep'	=> Auth::TOKEN_SEP,
					'error'		=> self::ERROR,
					'success'	=> self::SUCCESS,
					'context'	=> $this->asContext,
					'cookie'	=> Auth::USER_COOKIE_PASS,
					'workshops'	=> (new Course($this->oDb))->getWorkshops(),
					'courses'	=> (new Course($this->oDb))->getCourses(),
					'server'	=> Settings::SERVER_URL
				),
				'vars'		=> $this->getVars()
			),
			'index',
			array(
				'filepath_css'		=> self::addTimestampToFilePath('style/catc.css'),
				'filepath_js_catc'	=> self::addTimestampToFilePath('scripts/catc.js'),
				'filepath_js_common'=> self::addTimestampToFilePath('scripts/common.js'),
			)
		);
	}
	
	/* Authorizations handling */
	
	public function register($sToken, $sNickname)
	{
		$asResult = $this->oAuth->register($sToken, $sNickname);
		
		if($asResult['success']) return $this->logMeIn($sToken);
		else return self::getJsonResult($asResult['success'], $asResult['desc']);
	}
	
	public function isLoggedIn()
	{
		return $this->oAuth->isLoggedIn();
	}
	
	public function logMeIn($sToken)
	{
		$asLogResult = $this->oAuth->logMeIn($sToken);
		return self::getJsonResult($asLogResult['success'], $asLogResult['desc'], $this->getVars());
	}
	
	public function checkApiKey($sApiKey)
	{
		return $this->oAuth->checkApiKey($sApiKey);
	}
	
	/* Notes*/
	
	public function getNote($iCourseId) {
		$oNote = new Note($this->oDb, $this->oAuth->getUserId(), $iCourseId);
		$asNote = $oNote->getNote();
		
		return self::getJsonResult(!empty($asNote), '', $asNote);
	}
	
	public function setNote($iCourseId, $asOps) {
		if(is_string($asOps)) $asOps = json_decode($asOps, true);
		$oNote = new Note($this->oDb, $this->oAuth->getUserId(), $iCourseId);
		$sError = $oNote->setNote($asOps);
		$bSuccess = ($sError=='');
		
		$asData = ($bSuccess)?array('led_time' => $oNote->getNote()['led_time']):array();
		
		return self::getJsonResult($bSuccess, $sError, $asData);
	}
	
	/* Docs */
	
	public function getDocs($iWorkshopId) {
		$oDoc = new Doc($this->oDb, $this->oAuth->getUserId(), $iWorkshopId);
		$asDocList = $oDoc->getList();
		return self::getJsonResult(!empty($asDocList), '', $asDocList);
	}
	
	public function uploadDoc($iWorkshopId) {
		$this->oClassManagement->incClass('uploader', true);
		$oDoc = new Doc($this->oDb, $this->oAuth->getUserId(), $iWorkshopId);
		$oUploader = new Uploader($oDoc);
		
		return $oUploader->sBody;
	}
	
	public function deleteDoc($iDocId) {
		$oDoc = new Doc($this->oDb);
		$oDoc->setDocId($iDocId);
		$asDoc = $oDoc->getDoc();
		$bResult = $oDoc->delete();
		
		return self::getJsonResult($bResult, '', $asDoc);
	}
	
	/* Defs */
	
	public function getDefs() {
		$oDef = new Definition($this->oDb, $this->oAuth->getUserId());
		return self::getJsonResult(true, '', $oDef->getDefinitions());
	}
	
	public function setDef($iDefId, $sTitle, $sDesc) {
		$bNew = ($iDefId == 0);
		$oDef = new Definition($this->oDb, $this->oAuth->getUserId(), $iDefId);
		$bResult = $oDef->setDefinition($sTitle, $sDesc);
		return self::getJsonResult($bResult, '', array('new_def'=>$bNew, 'def'=>$oDef->getDefinition()));
	}
	
	/* Sync */
	
	public function pushToServer() {
		$bSuccess = false;
		$sDesc = '';
		
		if(Settings::SERVER_URL == '') $sDesc = 'No remote server configured';
		else {
			$sBackup = $this->oDb->getBackup();
			if($sBackup === false) $sDesc = 'Error executing mysqldump';
			else {
				//Store backup as a zip file
				$sBackupPath = Doc::DOC_FOLDER.'db/'.uniqid('backup_').'.sql.gz';
				file_put_contents($sBackupPath, gzencode($sBackup, self::GZ_LVL));
				
				//Send backup
				$sResult = self::sendFileToServer('server_update', $sBackupPath);

				//Parse response from server
				$asResult = json_decode($sResult, true);
				$bSuccess = ($asResult['result'] == self::SUCCESS);
				$sDesc = $asResult['desc'];
				unlink($sBackupPath);
				
				//Send missing files
				$asFiles = $asResult['data']['files'];
				foreach($asFiles as $asFile) {
					$this->sendFileToServer('file_update', $asFile['filepath'], $asFile['filename']);
				}
			}
		}
		
		return self::getJsonResult($bSuccess, $sDesc);
	}
	
	public function updateServer() {
		$bSuccess = false;
		$sDesc = '';
		$asMissingFiles = array();

		//Replace DB
		$sBackupPath = Doc::DOC_FOLDER.'db/'.uniqid('backup_').'.sql';
		$sCompressedPath = $sBackupPath.'.gz';
		move_uploaded_file($_FILES['file']['tmp_name'], $sCompressedPath);
		file_put_contents($sBackupPath, gzdecode(file_get_contents($sCompressedPath)));
		unlink($sCompressedPath);
		$sDesc = $this->oDb->restoreBackup($sBackupPath);
		$bSuccess = ($sDesc=='');
		unlink($sBackupPath);
		
		if($bSuccess) {
			//Reset passwords
			$this->oAuth->resetPass();
			
			//Check for missing files
			$asMissingFiles = (new Doc($this->oDb))->getMissingFiles();
		}
		
		//Send list of missing files back
		return self::getJsonResult($bSuccess, $sDesc, array('files'=>$asMissingFiles));
	}
	
	public function updateFile($sPath='') {
		if($sPath=='') $sPath = Doc::DOC_FOLDER.$_FILES['file']['name'];
		move_uploaded_file($_FILES['file']['tmp_name'], $sPath);
		
		//TODO Check data integrity
	}
	
	private static function sendFileToServer($sAction, $sFilePath, $sFileName='file') {
		$asPostData = array('a'=>$sAction, 'api'=>Settings::SERVER_KEY);
		$asPostData['file'] = new CURLFile(realpath($sFilePath), mime_content_type($sFilePath), $sFileName);
		return ToolBox::curl(Settings::SERVER_URL, false, $asPostData);
	}
}