hackpoint/plugin/export/action.php

<?php
global $_,$conf;
switch($_['action']){
	/** TEMPLATE **/
	
	//Récuperation d'une liste de exportmodel
	case 'export_exportmodel_search':
		Action::write(function(&$response){
			global $myUser,$_;
			if(!$myUser->can('export','read')) throw new Exception("Permissions insuffisantes",403);
			require_once(__DIR__.SLASH.'ExportModel.class.php');

			if(isset($_['params']) && !empty($_['params'])){
				//Récupération export modèle avec paramètres 
				//du plugin et jeu de données depuis le composant
				//d'export modèle
				$params = $_['params'];
				if(not_set_empty($params['plugin'])) throw new Exception("Il faut préciser le plugin ciblé");
				if(not_set_empty($params['dataset'])) throw new Exception("Il faut préciser le jeu de données à récupérer");

				$query = 'SELECT * FROM '.ExportModel::tableName().' WHERE plugin = ? AND dataset = ? AND (privacy = "'.ExportModel::PRIVACY_PUBLIC.'" OR (privacy = "'.ExportModel::PRIVACY_PRIVATE.'" AND creator = "'.$myUser->login.'"))';
				$data = array($params['plugin'], $params['dataset']);

				foreach(ExportModel::staticQuery($query, $data,true) as $exportmodel)
					$response['rows'][] = $exportmodel;
			} else {
				//Suppression de tous les exports modèles non conformes
				foreach(ExportModel::staticQuery('SELECT * FROM '.ExportModel::tableName().' WHERE dataset IS NULL', array(), true) as $exMdl) {
					ExportModel::deleteById($exMdl->id);
					foreach ($exMdl->documents() as $doc) {
						$path = (strtoupper(substr(PHP_OS, 0, 3)) === 'WIN') ? utf8_decode($doc['path']) : $doc['path'];
						unlink(File::dir().$path);
					}
				}

				//Récupération des exports modèles pour
				//vue liste des exports modèle dans les 
				//paramètres.

				//Récupération liste des plugins
				foreach (Plugin::getAll() as $plugin)
					$allPlug[$plugin->folder] = $plugin;

				//Récupération jeux de données
				$datasets = array();
				Plugin::callHook('export_model_data', array(&$datasets, array('description'=>true)));

				$query = 'SELECT * FROM '.ExportModel::tableName().' WHERE 1 AND (privacy = "'.ExportModel::PRIVACY_PUBLIC.'" OR (privacy = "'.ExportModel::PRIVACY_PRIVATE.'" AND creator = "'.$myUser->login.'")) ';
				$data = array();

				//Recherche simple
				if(!empty($_['filters']['keyword'])){
					$query .= ' AND (';
					foreach (array('filename', 'label', 'description') as $column) {
						$query .= $column.' LIKE ? OR ';
						$data[] = '%'.$_['filters']['keyword'].'%';
					}
					$query = rtrim($query, 'OR ');
					$query .= ')';
				}

				//Recherche avancée
				if(isset($_['filters']['advanced'])) filter_secure_query($_['filters']['advanced'],array('label','description','filename','plugin','privacy'),$query,$data);

				//Tri des colonnes
				if(isset($_['sort']))
					sort_secure_query($_['sort'],array('label','description','filename','plugin'),$query,$data);
				else 
					$query .= ' ORDER BY plugin ASC, created DESC';

				//Pagination
				$response['pagination'] = ExportModel::paginate(10,(!empty($_['page'])?$_['page']:0),$query,$data);
				
				//Mise en forme des résultats
				foreach(ExportModel::staticQuery($query,$data,true) as $exportmodel){
					$row = $exportmodel->toArray(true);
					$row['pluginName'] = $allPlug[$exportmodel->plugin]->name;
					$row['datasetName'] = $datasets[$exportmodel->dataset]['label'];
					$row['class'] = $exportmodel->privacy==ExportModel::PRIVACY_PRIVATE ? 'private' : 'public';
					$row['privacy'] = $exportmodel->privacy();
					$response['rows'][] = $row;
				}
			}
		});
	break;
	
	//Ajout ou modification d'élément exportmodel
	case 'export_exportmodel_save':
		Action::write(function(&$response){
			global $myUser,$_;
			if(!$myUser->can('export','edit')) throw new Exception("Permissions insuffisantes",403);
			require_once(__DIR__.SLASH.'ExportModel.class.php');

			if(not_set_empty($_['label'])) throw new Exception('Champ "Libellé" obligatoire');
			// if(not_set_empty($_['description'])) throw new Exception('Champ "Description" obligatoire');
			if(not_set_empty($_['plugin'])) throw new Exception('Champ "Plugin" obligatoire');
			if(not_set_empty($_['dataset'])) throw new Exception('Champ "Jeu de données" obligatoire');

			$item = ExportModel::provide();
			$newItem = isset($item->id) && !empty($item->id) ? false : true;
			$docs = $item->documents();
			//Ajout des fichiers joints
			if(not_set_empty($_['document_temporary']) && empty($docs)) throw new Exception("Un fichier de modèle est requis");

			$item->label = $_['label'];
			$item->description = $_['description'];
			$item->plugin = $_['plugin'];
			$item->dataset = $_['dataset'];
			$item->privacy = $_['privacy']==1 ? ExportModel::PRIVACY_PRIVATE : ExportModel::PRIVACY_PUBLIC;
			$item->save();

			if(!empty($_['document_temporary'])){
				$files = json_decode($_['document_temporary'],true);

				if(count($files)>1) {
					if($newItem) ExportModel::deleteById($item->id);
					throw new Exception("1 seul fichier est nécessaire par export modèle");
				}
				if(count($docs)==1) {
					if($newItem) ExportModel::deleteById($item->id);
					throw new Exception("Un fichier est déjà présent pour ce modèle d'export");
				}

				foreach($files as $file){
					$item->filename = $file['name'];
					$from = (strtoupper(substr(PHP_OS, 0, 3)) === 'WIN') ? File::temp().utf8_decode($file['path']) : File::temp().$file['path'];
					$to = (strtoupper(substr(PHP_OS, 0, 3)) === 'WIN') ? utf8_decode($file['name']) : $file['name'];
					$fileReturn = File::move($from, 'export'.SLASH.'documents'.SLASH.$item->plugin.SLASH.$item->id.SLASH.$to);
					$response['relativePath'] = $fileReturn['relative'];
					$response['filePath'] = 'action.php?action=export_exportmodel_download_document&path='.rawurlencode($item->plugin.SLASH.$item->id.SLASH.$to);
				}
			}
			if(count($docs)==1) {
				if(empty($item->export_format)) {
					$ext = getExt($docs[0]['path']);
					$item->export_format = $ext;
				}
				$item->filename = $docs[0]['name'];
			}
			$item->export_format = !isset($_['export_format']) || empty($_['export_format']) || $_['export_format']=='none' ? $item->export_format : $_['export_format'];
			$item->save();
			$response['id'] = $item->id;

			Log::put("Création/Mofdification d'export modèle ".$item->toText(), "Export Modèle");
		});
	break;
	
	//Récuperation ou edition d'élément exportmodel
	case 'export_exportmodel_edit':
		Action::write(function(&$response){
			global $myUser,$_;
			if(!$myUser->can('export','edit')) throw new Exception("Permissions insuffisantes",403);
			require_once(__DIR__.SLASH.'ExportModel.class.php');
			$response = ExportModel::getById($_['id']);
		});
	break;

	//Suppression d'élement exportmodel
	case 'export_exportmodel_delete':
		Action::write(function(&$response){
			global $myUser,$_;
			if(!$myUser->can('export','delete')) throw new Exception("Permissions insuffisantes",403);
			require_once(__DIR__.SLASH.'ExportModel.class.php');
			
			$item = ExportModel::getById($_['id']);
			ExportModel::deleteById($item->id);

			$docsProps = $item->documents();
			foreach ($docsProps as $doc) {
				$path = (strtoupper(substr(PHP_OS, 0, 3)) === 'WIN') ? utf8_decode($doc['path']) : $doc['path'];
				unlink(File::dir().$path);
			}

			// Décommenter pour une supression logique
			// $item = ExportModel::getById($_['id']);
			// $item->state = ExportModel::INACTIVE;
			// $item->save();
			
			Log::put("Suppression d'export modèle ".$item->toText(), "Export Modèle");
		});
	break;

	//Ajout document automatique à l'upload
	case 'export_exportmodel_add_document':
		Action::write(function(&$response){
			global $myUser,$_;
			if(!$myUser->can('export','edit')) throw new Exception("Permissions insuffisantes",403);
			require_once(__DIR__.SLASH.'ExportModel.class.php');

			$exportmodel = ExportModel::provide();
			if((!isset($_['plugin']) || empty($_['plugin'])) && (!isset($exportmodel->plugin) || empty($exportmodel->plugin))) throw new Exception("Vous devez d'abord définir un plugin pour importer un fichier modèle");

			$newItem = isset($exportmodel->id) && !empty($exportmodel->id) ? false : true;
			$exportmodel->plugin = $_['plugin'];
			$exportmodel->save();

			if(count($_['files'])>1) {
				if($newItem) ExportModel::deleteById($exportmodel->id);
				throw new Exception("1 seul fichier est nécessaire par export modèle");
			}
			if(count($exportmodel->documents())==1) {
				if($newItem) ExportModel::deleteById($exportmodel->id);
				throw new Exception("Un fichier est déjà présent pour ce modèle d'export");
			}
			foreach ($_['files'] as $file) {
				$ext = getExt($file['name']);
				$exportmodel->export_format = $ext;

				$name = (strtoupper(substr(PHP_OS, 0, 3)) === 'WIN') ? utf8_decode($file['name']) : $file['name'];
				$exportmodel->filename = $file['name'];
				$row = File::move(File::temp().$file['path'],'export'.SLASH.'documents'.SLASH.$exportmodel->plugin.SLASH.$exportmodel->id.SLASH.$name);
				$row['url'] = 'action.php?action=export_exportmodel_download_document&path='.SLASH.$exportmodel->plugin.SLASH.$exportmodel->id.SLASH.rawurlencode($file['name']);
				$row['oldPath'] = $file['path'];
				$response['files'][] = $row;
			}
			$exportmodel->save();

			$response['ext'] = $ext;
			$response['id'] = $exportmodel->id;
		});
	break;

	//Suppression document
	case 'export_exportmodel_delete_document':
		Action::write(function(&$response){
			global $myUser,$_;
			if(!$myUser->can('export','delete')) throw new Exception("Permissions insuffisantes",403);
			require_once(__DIR__.SLASH.'ExportModel.class.php');
			if(!isset($_['path']) ) throw new Exception("Chemin non spécifié ou non numerique");
			$path = (strtoupper(substr(PHP_OS, 0, 3)) === 'WIN') ? utf8_decode($_['path']) : $_['path'];
			//Le premier argument est un namespace de sécurité 
			//et assure que le fichier sera toujours cloisoné dans un contexte file/export/documents
			File::delete('export'.SLASH.'documents',$path);

			$regex = "@\\".SLASH."(\d+)\\".SLASH."@i";
			preg_match($regex, $path, $matches);
			if(isset($matches[1])) ExportModel::change(array('export_format'=>NULL, 'filename'=>NULL), array('id'=>$matches[1]));

			Log::put("Suppression de fichier modèle : ".$_['path'], "Export Modèle");
		});
	break;

	//Téléchargement des documents
	case 'export_exportmodel_download_document':
		global $myUser,$_;
		if(!$myUser->can('export','read')) throw new Exception("Permissions insuffisantes",403);
		$path = (strtoupper(substr(PHP_OS, 0, 3)) === 'WIN') ? utf8_decode($_['path']) : $_['path'];
		File::downloadFile(File::dir().'export'.SLASH.'documents'.SLASH.$path);

		Log::put("Téléchargement du fichier modèle : ".$path, "Export Modèle");
	break;

	//Téléchargement des templates d'exemple
	case 'export_exportmodel_download_template':
		global $myUser,$_;
		if(!$myUser->can('export','read')) throw new Exception("Permissions insuffisantes",403);
		if(!isset($_['extension']) || empty($_['extension'])) throw new Exception("Extension non précisée");
		
		$template = ExportModel::templates($_['extension']);
		$dataset = ExportModel::dataset($_['plugin'],$_['dataset']);
		$className =  $template['handler'];
		$stream = $className::sample($dataset['values']);

		File::downloadStream($stream, $_['filename'].'.'.$template['extension'],$template['mime']);

		Log::put("Téléchargement d'un fichier modèle d'exemple : ".$_['filename'].'.'.$template['extension'], "Export Modèle");
	break;

	//Récupération des jeux de données en fct de params
	case 'export_exportmodel_list_dataset':
		Action::write(function(&$response){
			global $myUser,$_;
			if(!$myUser->can('export','read')) throw new Exception("Permissions insuffisantes",403);
			require_once(__DIR__.SLASH.'ExportModel.class.php');
	
			$params = isset($_['params']) ? $_['params'] : array();
			$datasets = array();
			Plugin::callHook('export_model_data', array(&$datasets, $params));
		
			$response['rows'] = $datasets;
		});
	break;


	//Récupération du détail d'un jeu de donnée
	case 'export_exportmodel_get_dataset':
		Action::write(function(&$response){
			global $myUser,$_;
			if(!$myUser->can('export','read')) throw new Exception("Permissions insuffisantes",403);
			require_once(__DIR__.SLASH.'ExportModel.class.php');
	
			$params = isset($_['params']) ? $_['params'] : array();
			if(empty($params)) throw new Exception("Aucun paramètre spécifié pour récupérer le informations du jeu de données");

			$plugin = $_['params']['plugin'];
			$dataset = $_['params']['dataset'];
			$params['description'] = true;
			$set = ExportModel::dataset($plugin, $dataset, $params);
			$response['dataset'] = $set['values'];

			foreach(ExportModel::templates() as $extension => $template){
				$response['files'][] = array(
					'path'=>'action.php?action=export_exportmodel_download_template&plugin='.rawurlencode($plugin).'&dataset='.rawurlencode($dataset).'&extension='.$template['extension'].'&filename='.$set['label'],
					'icon'=>getExtIcon($template['extension']),
					'ext'=>$template['extension'],
					'label'=> $set['label'].'.'.$template['extension']
				);
			}

		});
	break;


	//Choix du exportmodel pour export modèle
	case 'export_exportmodel_export':
		try{
			ob_start();
			global $myUser,$_;
			if(!$myUser->can('export','read')) throw new Exception("Permissions insuffisantes",403);
			require_once(__DIR__.SLASH.'ExportModel.class.php');

			if(!isset($_['exportmodel']) || empty($_['exportmodel']) || base64_decode($_['exportmodel']) == 'none') throw new Exception("Il faut choisir un modèle d'export");

			$params = isset($_['params']) ? json_decode(base64_decode($_['params']), true) : array();
			$params['description'] = false;
			$return = isset($params['destination']) && !empty($params['destination']) ? $params['destination'] : 'stream';

			if($exportmodel = ExportModel::getById(base64_decode($_['exportmodel']))){
				$plugin = $exportmodel->plugin;
				$dataset = $exportmodel->dataset;
			} else {
				throw new Exception("Impossible de récupérer le modèle d'export");
			}
			//Tableau de jeu de données
			$datasets = array();

			//On alimente notre tableau de jeu de données en 
			//appelant un hook qui sera défini pour remplir le tableau
			Plugin::callHook('export_model_data', array(&$datasets, $params));
	
			//On a notre tableau de jeu de données rempli et on 
			//récupère la partie de notre jeu de donnée qui nous 
			//intéresse et on execute la fonction associée
			if(!isset($datasets[$dataset])) throw new Exception("Jeu de données spécifié inexistant");
			$currentDataset = $datasets[$dataset];
			$plgLines = $currentDataset['function']($params);
			$stdLines = ExportModel::get_standard_dataset($params);
			$lines = array_merge($stdLines, $plgLines);
	
			//On génère le fichier à exporter en utilisant le jeu de données 
			//+ le fichier associé à l'exportmodel (le fichier mis en dropzone)
			$docsProps = $exportmodel->documents();
			if(empty($docsProps)) throw new Exception("Aucun fichier modèle pour le modèle d'export : ".$exportmodel->label);

			foreach ($docsProps as $document) {
				$docInfos['document'] = $document;
				$docInfos['format'] = $exportmodel->export_format;
				$ext = getExt($document['name']);
				$tplType = ExportModel::templates($docInfos['format']);
				$filename = basename($document['name'], $ext).$docInfos['format'];

				$fileReturn = ExportModel::merge_data_template($filename, $docInfos, $lines,$return);

				if($return == 'stream') {
					File::downloadStream($fileReturn, $filename, $tplType['mime']);
				} else {
					$filename = (strtoupper(substr(PHP_OS, 0, 3)) === 'WIN') ? utf8_decode($filename) : $filename;
					$filename = autoincrement_filename($docInfos['format'], $return, $filename);
					$fileInfo = File::move($fileReturn, $return.$filename);
					$previousUrl = base64_decode($_['url']);
					header('location: '.$previousUrl.'&success=Export modèle correctement généré');
				}
			}
			Log::put("Exportation de modèle, plugin : ".$plugin.", jeu de données : ".$dataset.".", "Export Modèle");
		} catch(Exception $e){
			$previousUrl = base64_decode($_['url']);
			header('location: '.$previousUrl.'&error='.$e->getMessage());
			exit();
		}
	break;
}




?>