setMessage('Pas implémenté');
return $this->KO;
}
protected function modifier($data, $msg_OK = null, $msg_KO = null) {
$this->setMessage('Pas implémenté');
return $this->KO;
}
protected function supprimer(&$data, $msg_OK, $msg_KO) {
$this->setMessage('Pas implémenté');
return $this->KO;
}
/**
* Renvoie le nom de la classe du 'processeur' permettant de traiter la tâche spécifiée.
*
* @param $tache La tâche à traiter.
*
* @return Array & Callable Une fonction appelable, pour traiter la tâche
*
* @throw InvalidArgumentException Lorsque que le type de tâche n'est pas supporté/invalide
*/
protected function _getProcessorFromTache($tache) {
switch($tache->getVal('type')) {
case 'create_DI_for_consultation': return array($this, 'create_DI_for_consultation');
case 'add_piece': return array($this, 'add_piece');
}
throw new InvalidArgumentException(sprintf(
__("Type de tâche '%s' non supporté"), $tache->getVal('type')));
}
/**
* Traite toutes les tâches, éventuellement seulement celles spécifiées par un type.
*
* @param string $statut Un statut de tâche à traiter
* @param string $type Un type de tâche à traiter
*
* @return Array Un tableau contenant le récapitulatif des traitements
*
* @throw RuntimeException Lorsqu'il y a un échec pendant le traitement d'une tâche
*/
public function traitement(array $requestData) {
try {
$this->addToLog(__METHOD__.'(): request data = '.var_export($requestData, true), VERBOSE_MODE);
$statut = isset($requestData['statut']) ? $requestData['statut'] : task::STATUS_NEW;
$type = isset($requestData['type']) ? $requestData['type'] : '';
$this->addToLog(__METHOD__.'(): statut = '.var_export($statut, true).', '.
'type = '.var_export($type, true), VERBOSE_MODE);
// construit le filtre SQL (clause WHERE)
$filtreSQL = "stream = 'input' AND json_payload <> '{}'";
$filtreSQL .= sprintf(" AND state = '%s'", $this->f->db->escapeSimple($statut));;
if (! empty($type)) {
$filtreSQL .= sprintf(" AND type = '%s'", $this->f->db->escapeSimple($type));
}
// stocke le résultat et les succès/échecs
$success = array();
$failures = array();
// pour chaque tâche
foreach($this->f->getAllObjects('task', $filtreSQL) as $tache) {
$desc = $this->_getTacheDesc($tache);
$type = $tache->getVal('type');
// selon le type de la tâche invoquer un "processeur"
// qui réalisera le traitement de cette tâche
// stocker les succès et les échecs
if (empty($type)) {
$this->_setTaskState($tache, 'invalide');
$failures[$desc] = "Attribut 'type' vide";
}
else {
$processorCallable = $this->_getProcessorFromTache($tache);
if (isset($processorCallable[0]) != $this) {
$processorClass = $processorCallable[0].'.class.php';
$processorClassPath = PROJECT_ROOT.'/obj/'.$processorClass;
if (file_exists($processorClassPath)) {
require_once $processorClassPath;
$processor = new $processorName($this->f, $this->APILogger);
$processorMethod = isset($processorCallable[1]) ? $processorCallable[1] : 'process';
$processorCallable = array($processor, $processorMethod);
}
}
if (is_callable($processorCallable)) {
$this->_setTaskState($tache, task::STATUS_PENDING);
$result = array();
try {
$result = call_user_func_array($processorCallable, array($tache));
}
catch(Exception $exception) {
$result['error'] = get_class($exception).' : '.$exception->getMessage();
}
if (isset($result['error']) && ! empty($result['error'])) {
$this->_setTaskState($tache, task::STATUS_ERROR);
$failures[$desc] = $result['error'];
}
elseif ($result === false) {
$this->_setTaskState($tache, task::STATUS_ERROR);
$failures[$desc] = 'erreur';
}
else {
$this->_setTaskState($tache, task::STATUS_DONE);
$success_message = 'succès';
if (is_array($result) && isset($result['message'])) {
$success_message = $result['message'];
}
$success[$desc] = $success_message;
}
}
else {
$this->_setTaskState($tache, 'invalide');
$failures[$desc] = "Processeur '".var_export($processorCallable, true)."' invalide pour la tâche '$desc'";
}
}
}
// s'il y a eu des échecs de traitements
if (! empty($failures)) {
$this->addToLog(__METHOD__."(): il y a eu des échecs de traitements", DEBUG_MODE);
// renvoyer un code HTTP adapté ainsi que les erreurs rencontrées
$errorMsg = "Les tâches suivantes ont rencontrées un échec pendant leur traitement :\n";
foreach($failures as $tacheDesc => $error) {
$this->addToLog(__METHOD__."(): * $tacheDesc => $error", DEBUG_MODE);
$errorMsg .= " - $tacheDesc: $error\n";
}
if(! empty($success)) {
$errorMsg .= "\nLes tâches suivantes ont été traitées avec succès :\n";
foreach($success as $tacheDesc => $msg) {
$this->addToLog(__METHOD__."(): * $tacheDesc => $msg", DEBUG_MODE);
$errorMsg .= " - $tacheDesc: $msg\n";
}
}
throw new RuntimeException($errorMsg);
}
// si tout s'est bien passé :
// renvoyer un code HTTP adapté et le résultat obtenu (un tableau)
$this->addToLog(__METHOD__."(): succès des traitements", VERBOSE_MODE);
if (! empty($success)) {
$this->setMessage(implode('\n', array_map(
function($desc, $msg) { return $desc.' : '.$msg; },
array_keys($success), $success)));
}
return $this->OK;
}
catch(InvalidArgumentException $exc) {
$this->setMessage($exc->getMessage());
return $this->BAD_DATA;
}
catch(Exception $exc) {
$this->setMessage($exc->getMessage());
return $this->KO;
}
}
/**
* Renvoie une description textuelle d'une tâche (composée de son ID, son type et le dossier).
*
* @param $tache La tâche concernée
*
* @return string la description textuelle de la tâche
*/
protected function _getTacheDesc($tache) {
return '['.$tache->getVal('task').'] '.$tache->getVal('type').' '.$tache->getVal('dossier');
}
/**
* Met à jours l'état d'une tâche.
*
* @param $tache La tâche concernée
*
* @return taskProcessorDemande
*/
protected function _setTaskState($tache, string $statut) {
$tache->update_task(array('val' => array('state' => $statut)));
return $this;
}
/**
* Traite les tâches de type 'creation_DI'.
*
* @param $tache La tâche à traiter
*
* @return Array|false Un tableau contenant le résultat du traitement, false en cas d'erreur
*
* @throw InvalidArgumentException En cas de donnée utilisateur invalide ou manquante
* @throw RuntimeException En cas d'erreur BDD
*/
protected function create_DI_for_consultation($tache) {
global $_POST;
$this->addToLog(__METHOD__."(): Décode le json", VERBOSE_MODE);
$request_data = json_decode($tache->getVal('json_payload'), true);
if (json_last_error() !== JSON_ERROR_NONE) {
throw new InvalidArgumentException(sprintf(
__("échec du décodage JSON (%s)"),
json_last_error_msg()));
}
// TODO gérer l'ajout de demande sur existant
// (on ne connait pas le format des données arrivant)
// ajout d'une nouvelle demande
// retraitement spécifique des données de la nouvelle demande
$this->addToLog(__METHOD__."(): Prépare les données de la nouvelle demande", VERBOSE_MODE);
$demande_values = $this->prepare_new_demande_data($request_data);
// retraitement commun des données de la demande
$this->addToLog(__METHOD__."(): Prépare les données de la demande", VERBOSE_MODE);
$demande_values = $this->prepare_demande_data($request_data, $demande_values);
// vérification des externals UUIDs
if (! isset($request_data['external_uids']) || empty($request_data['external_uids'])) {
throw new InvalidArgumentException(sprintf(
__("Aucune valeur pour le paramètre '%s'"),
'external_uids'));
}
// utilisation d'un faux $_POST pour stocker les demandeurs de la demande
$_POST = array();
// ajout des demandeurs
$this->addToLog(__METHOD__."(): Créé les demandeurs", VERBOSE_MODE);
if (! isset($request_data['demandeur']) && ! empty($request_data['demandeur'])) {
throw new InvalidArgumentException(sprintf(
__("Aucune valeur pour le paramètre '%s'"),
'demandeur'));
}
foreach ($request_data["demandeur"] as $d_index => $demandeur_valeurs) {
if (! isset($demandeur_valeurs['type_demandeur']) ||
empty($demandeur_valeurs['type_demandeur'])) {
throw new InvalidArgumentException(sprintf(
__("Aucun type pour le demandeur '%s'"), $d_index));
}
$demandeur_type = $demandeur_valeurs['type_demandeur'];
if (isset($demandeur_valeurs["${demandeur_type}_principal"]) &&
$demandeur_valeurs["${demandeur_type}_principal"] === 't') {
$demandeur_type = "${demandeur_type}_principal";
$demandeur_valeurs['type_demandeur'] = $demandeur_type;
}
$demandeur_id = $this->creation_demandeur(
$demandeur_type, $demandeur_valeurs, $demande_values['om_collectivite']);
if (isset($_POST[$demandeur_type]) === false) {
$_POST[$demandeur_type] = array();
}
$_POST[$demandeur_type][] = $demandeur_id;
}
// création de l'objet demande
$demande = $this->f->get_inst__om_dbform(array(
"obj" => "demande",
"idx" => "]",
));
// Prise en compte des faux POST
$this->f->set_submitted_value();
$demande->getPostedValues();
$this->addToLog(__METHOD__."(): Ajoute la demande", VERBOSE_MODE);
if ($demande->ajouter($demande_values) === false) {
throw new RuntimeException(__("Erreur lors de la création de la demande."));
}
elseif ($demande->correct === false) {
throw new RuntimeException(__("Erreur lors de la création de la demande.").' '.
sprintf(__("Détail: %s"), strip_tags(str_replace('
', '. ', $demande->msg))));
}
$dossier_instruction_id = $demande->getVal('dossier_instruction');
$this->addToLog(__METHOD__."(): DI créé: '$dossier_instruction_id'", VERBOSE_MODE);
// caractères supplémentaires en fin de numéro de dossier autorisé
// si option des entités
$extra_chars = '';
$collectiviteId = $demande_values['om_collectivite'];
if ($this->f->is_option_om_collectivite_entity_enabled($collectiviteId)) {
$extra_chars = '([a-zA-Z0-9_-]*)?';
}
// vérifie le numéro de dossier obtenu
$match = array();
if (! preg_match(
"|^([A-Z]{2,3})\s{0,1}(\d{6})\s{0,1}(\d{2})\s{0,1}".
"([[:alnum:]]{5}[A-Z]{0,5}\d{0,2})${extra_chars}$|",
$dossier_instruction_id, $match)) {
/*throw new InvalidArgumentException(sprintf(__(
"Erreur lors de la création de la demande. ".
"Le format du numéro de dossier créé n'est pas correct ".
"(ID: '%s')."), $dossier_instruction_id));*/
$dossier_libelle = $dossier_instruction_id;
}
else {
$dossier_libelle = $match[1].' '.$match[2].' '.$match[3].' '.$match[4];
if (! empty($extra_chars)) {
$dossier_libelle .= ' '.$match[5];
}
}
$this->addToLog(__METHOD__."(): Libellé: '$dossier_libelle'", VERBOSE_MODE);
//
if (is_array($request_data['external_uids']) === true) {
//
foreach ($request_data['external_uids'] as $object => $external_uid) {
//
if (in_array($object, array('dossier', 'dossier_consultation', )) === true) {
//
$inst_lien = $this->f->get_inst__om_dbform(array(
"obj" => "lien_id_interne_uid_externe",
"idx" => ']',
));
if ($inst_lien->is_exists($object, $dossier_instruction_id, $external_uid, $dossier_instruction_id) === false) {
//
$valF = array(
'lien_id_interne_uid_externe' => '',
'object' => $object,
'object_id' => $dossier_instruction_id,
'external_uid' => $external_uid,
'dossier' => $dossier_instruction_id,
);
$add = $inst_lien->ajouter($valF);
$message = $inst_lien->msg;
if ($add === false) {
throw new RuntimeException(__("Erreur lors de la création de la demande.").' '.
sprintf(__("Détail: %s"), strip_tags(str_replace('
', '. ', $message))));
}
}
}
}
}
//
if (isset($request_data['consultation']) === true
&& is_array($request_data['consultation']) === true
&& count($request_data['consultation']) > 0) {
//
$valF = $request_data['consultation'];
$inst_ce = $this->f->get_inst__om_dbform(array(
"obj" => "consultation_entrante",
"idx" => ']',
));
$valF['consultation_entrante'] = '';
$valF['dossier'] = $dossier_instruction_id;
$add = $inst_ce->ajouter($valF);
$message = $inst_lien->msg;
if ($add === false) {
throw new RuntimeException(__("Erreur lors de la création de la consultation entrante.").' '.
sprintf(__("Détail: %s"), strip_tags(str_replace('
', '. ', $message))));
}
}
return array(
"message" => sprintf(
__("dossier instruction '%s' créé"),
$dossier_libelle
),
);
}
/**
* Traite les tâches de type 'add_piece'.
*
* @param $tache La tâche à traiter
*
* @return Array|false Un tableau contenant le résultat du traitement, false en cas d'erreur
*
* @throw InvalidArgumentException Si le DA existe déjà ou si le numéro dossier est invalide
* @throw RuntimeException En cas d'erreur BDD
*/
protected function add_piece($tache) {
$this->addToLog(__METHOD__."(): Décode le json", VERBOSE_MODE);
$request_data = json_decode($tache->getVal('json_payload'), true);
if (json_last_error() !== JSON_ERROR_NONE) {
throw new InvalidArgumentException("échec du décodage JSON (".json_last_error_msg().')');
}
// vérification de la présence des externals UUIDs
if (! isset($request_data['external_uids']) || empty($request_data['external_uids'])) {
throw new InvalidArgumentException(__(
"Aucune valeur pour l'external_uids"));
}
// vérification de la présence du numéro de dossier
if(! isset($request_data['external_uids']['dossier']) ||
empty($request_data['external_uids']['dossier'])) {
throw new InvalidArgumentException(__("L'attribut external_uids.dossier n'est pas présent."));
}
// récupération de l'identifiant de collectivité
$collectiviteId = $this->get_collectivite_id_from_acteur_or_collectivite($request_data, 'external_uids');
// il faut que le dossier existe pour qu'on puis ajouter la pièce
$this->addToLog(__METHOD__."(): Vérification de l'existance du dossier", VERBOSE_MODE);
// Comme la numérotation du dossier peut être différente entre le numéro de dossier openads et le numéro
// de dossier envoyé par Plat'AU on se base sur l'external uid pour vérifier si le dossier existe
// On instancie l'objet lien_id_interne_uid_externe
$inst_lien = $this->f->get_inst__om_dbform(array(
"obj" => "lien_id_interne_uid_externe",
"idx" => 0,
));
// instanciation d'un document numérisé "vide"
$this->addToLog(__METHOD__."(): \tInitialise une instance de 'document_numerise'", VERBOSE_MODE);
$document_numerise = $this->f->get_inst__om_dbform(array(
"obj" => "document_numerise",
"idx" => "]",
));
// retraitement spécifique des données de la nouvelle pièce
$this->addToLog(__METHOD__."(): Prépare les données de la nouvelle piece", VERBOSE_MODE);
$attachment_values = $this->prepare_attachment_data(
$request_data, $document_numerise, $inst_lien, $collectiviteId);
$this->addToLog(__METHOD__."(): Ajoute la pièce", VERBOSE_MODE);
$this->addToLog(__METHOD__."(): Valeurs:\n---\n".var_export($attachment_values, true)."\n---\n", VERBOSE_MODE);
if ($document_numerise->ajouter($attachment_values) === false) {
throw new RuntimeException(
__("Erreur lors de la création de la pièce.").' '.
sprintf(__("Détail: %s"), strip_tags(str_replace('
', '. ', $document_numerise->msg))));
}
elseif ($document_numerise->correct === false) {
throw new RuntimeException(__("Erreur lors de la création de la pièce.").' '.
sprintf(__("Détail: %s"), strip_tags(str_replace('
', '. ', $document_numerise->msg))));
}
$document_numerise_id = $document_numerise->getVal('document_numerise');
$this->addToLog(__METHOD__."(): pièce créée: '$document_numerise_id'", VERBOSE_MODE);
//
if (is_array($request_data['external_uids']) === true) {
//
foreach ($request_data['external_uids'] as $object => $external_uid) {
//
if (in_array($object, array('piece', )) === true) {
//
$inst_lien = $this->f->get_inst__om_dbform(array(
"obj" => "lien_id_interne_uid_externe",
"idx" => ']',
));
if ($inst_lien->is_exists($object, $document_numerise_id, $external_uid, $attachment_values['dossier']) === false) {
//
$valF = array(
'lien_id_interne_uid_externe' => '',
'object' => $object,
'object_id' => $document_numerise_id,
'external_uid' => $external_uid,
'dossier' => $attachment_values['dossier'],
);
$add = $inst_lien->ajouter($valF);
$message = $inst_lien->msg;
if ($add === false) {
throw new RuntimeException(__("Erreur lors de la création de la pièce.").' '.
sprintf(__("Détail: %s"), strip_tags(str_replace('
', '. ', $message))));
}
}
}
}
}
return array(
"message" => sprintf(
__("pièce : '%s' créée sur le dossier d'instruction '%s'"),
$document_numerise_id,
$attachment_values['dossier']
),
);
}
/**
* Ré-organise les données reçues pour qu'elles puissent être utilisées en tant que
* paramètre de la méthode document_numerise::ajouter().
*
* @param array $request_data données reçues
* @param object $inst_doc_num instance de document_numerise
* @param object $inst_lien instance de lien_id_interne_uid_externe
* @param int $collectiviteId identifiant de la collectivité du dossier de la pièce
*
* @return array données ré-organisées
*/
protected function prepare_attachment_data(array $request_data, $inst_doc_num, $inst_lien,
int $collectiviteId) {
$this->addToLog(__METHOD__."(): \tRempli une instance de 'document_numerise'", VERBOSE_MODE);
$attachment_values = array();
$this->addToLog(__METHOD__."(): \tRempli un tableau qui contiendra les données ".
"de la piece", VERBOSE_MODE);
foreach ($inst_doc_num->champs as $value) {
$attachment_values[$value] = null;
if (isset($request_data['document_numerise'][$value])) {
$attachment_values[$value] = $request_data['document_numerise'][$value];
}
if($value == 'document_numerise_type' &&
isset($request_data['document_numerise']['document_numerise_type_code'])) {
$attachment_values["document_numerise_type"] =
$request_data['document_numerise']['document_numerise_type_code'];
}
}
// sélectionne la référence externe la plus pertinente
// - dossier_consultation: si spécifiée
// - dossier: sinon
$ref_external_uid = $request_data['external_uids']['dossier'];
$type_external_uid = 'dossier';
$err_external_uid = __("Le dossier %s n'existe pas.");
if(isset($request_data['external_uids']['dossier_consultation']) &&
! empty($request_data['external_uids']['dossier_consultation'])) {
$ref_external_uid = $request_data['external_uids']['dossier_consultation'];
$type_external_uid = 'dossier_consultation';
$err_external_uid = __("La consultation %s n'existe pas.");
}
// récupération de l'id dossier openADS à partir de l'uid externe
$attachment_values['dossier'] = $inst_lien->get_id_dossier_from_external_uid(
$ref_external_uid, $collectiviteId, $type_external_uid);
if(empty($attachment_values['dossier'])) {
throw new InvalidArgumentException(sprintf($err_external_uid, $ref_external_uid));
}
return $attachment_values;
}
/**
* Ré-organise les données reçues pour qu'elles puissent être utilisées en tant que
* paramètre de la méthode demander::ajouter().
* Les données traitées dans cette méthode ne concernent que les données spécifiques
* lors d'une nouvelle demande.
* Celle-ci est complétée par la méthode 'prepare_demande_data()'.
*
* @param Array $request_data données reçues
*
* @return Array données ré-organisées
*/
protected function prepare_new_demande_data(array $request_data) {
$this->addToLog(__METHOD__."(): \tInitialise une instance de 'demande'", VERBOSE_MODE);
$demande_values = array();
$demande = $this->f->get_inst__om_dbform(array(
"obj" => "demande",
"idx" => "]",
));
$this->addToLog(__METHOD__."(): \tRempli un tableau qui contiendra les données ".
"de la demande", VERBOSE_MODE);
foreach ($demande->champs as $value) {
$demande_values[$value] = null;
if (isset($request_data['dossier'][$value])) {
$demande_values[$value] = $request_data['dossier'][$value];
}
}
// si le DA est spécifié, mais que la version est 0, alors on supprime le DA
// sinon cela va faire boguer la création du dossier (recherchant le DA inexistant)
//if(! $this->f->is_option_dossier_saisie_numero_complet_enabled()) {
if (isset($demande_values['dossier_autorisation']) && (
! isset($demande_values['version']) || $demande_values['version'] == '0')) {
$demande_values['dossier_autorisation'] = null;
}
//}
$this->addToLog(__METHOD__."(): \tObtient le DAtd à partir de la valeur fournie ".
"'".$request_data['dossier']["dossier_autorisation_type_detaille_code"]."'",
VERBOSE_MODE);
$demande_values['dossier_autorisation_type_detaille'] = (
$this->get_dossier_autorisation_type_detaille(
$request_data['dossier']["dossier_autorisation_type_detaille_code"]));
// si l'option de saisie du numéro complet est activée
if($this->f->is_option_dossier_saisie_numero_complet_enabled() &&
isset($request_data['dossier']['dossier'])) {
$demande_values['num_doss_complet'] = $request_data['dossier']['dossier'];
$demande_values['num_doss_manuel'] = 'Oui';
$this->f->addToLog(__METHOD__."(): num_doss_complet = '".$demande_values['num_doss_complet']."'", VERBOSE_MODE);
}
return $demande_values;
}
/**
* Ré-organise les données reçues pour qu'elles puissent être utilisées en tant que
* paramètre de la méthode demander::ajouter().
* Les données traitées dans cette méthode ne concernent que les données "communes"
* lors d'une nouvelle demande ou d'une demande sur existant.
* Celle-ci est complétée par la méthode 'prepare_new_demande_data()'.
*
* @param Array $request_data données reçues
*
* @return Array données ré-organisées
*
* @throw InvalidArgumentException En cas de donnée utilisateur invalide ou manquante
*/
protected function prepare_demande_data(array $request_data, array $demande_values) {
// numéro de dossier
$this->ensure_numero_dossier($request_data);
// références cadastrales
if (isset($request_data["dossier"]['terrain_references_cadastrales']) &&
! empty($request_data["dossier"]['terrain_references_cadastrales'])) {
// TODO vérifier le format
$demande_values['terrain_references_cadastrales'] = strtoupper(
$request_data["dossier"]['terrain_references_cadastrales']);
}
// date demande
$demande_values['date_demande'] = (new DateTime())->format('d/m/Y');
if (isset($request_data['dossier']['date_demande']) &&
! empty($request_data['dossier']['date_demande'])) {
// TODO vérifier le format
$demande_values['date_demande'] = $request_data['dossier']['date_demande'];
}
// collectivité
$collectiviteId = $this->get_collectivite_id_from_acteur_or_collectivite($request_data);
$demande_values['om_collectivite'] = $collectiviteId;
// commune
if ($this->f->is_option_dossier_commune_enabled()) {
// si le code insee n'est pas fourni
if (! isset($request_data['dossier']['insee']) ||
empty($request_data['dossier']['insee'])) {
throw new InvalidArgumentException(sprintf(__(
"Le paramètre '%s' est obligatoire"), 'dossier/insee'));
}
$insee = $request_data['dossier']['insee'];
$this->addToLog(__METHOD__."(): code INSEE '$insee'", VERBOSE_MODE);
// récupère la commune à partir du code insee
$commune = $this->get_commune_from_insee($insee);
if (empty($commune)) {
throw new InvalidArgumentException(sprintf(__(
"Impossible de trouver la commune pour le code INSEE '%s'"), $insee));
}
$this->addToLog(__METHOD__."(): commune '$commune'", VERBOSE_MODE);
$demande_values['commune'] = $commune;
}
// demande type
$demande_values['demande_type'] = $this->get_demande_type(
$demande_values,
intval($demande_values['dossier_autorisation_type_detaille']),
$collectiviteId);
// version
$demande_values['version'] = '0';
if (isset($request_data['dossier']['version']) &&
! empty($request_data['dossier']['version'])) {
$demande_values['version'] = $request_data['dossier']['version'];
}
// dépôt électronique
$demande_values['depot_electronique'] = (
isset($request_data['dossier']['depot_electronique']) &&
$request_data['dossier']['depot_electronique'] === 't');
// parcelle temporaire
$demande_values['parcelle_temporaire'] = (
isset($request_data['dossier']['parcelle_temporaire']) &&
$request_data['dossier']['parcelle_temporaire'] === 't');
return $demande_values;
}
/**
* Récupère l'identifiant d'une collectivité à partir d'un acteur ou d'un libellé.
*
* @param array $request_data donnée utilisateurs reçues
*
* @return int L'identifiant de la collectivité
*
* @throw InvalidArgumentException lorsqu'aucune collectivité ne correspond à un acteur
* @throw InvalidArgumentException lorsque ni l'acteur ni la collectivité n'ont été spécifiés
*/
protected function get_collectivite_id_from_acteur_or_collectivite(array $request_data) {
$collectiviteId = null;
if (isset($request_data['external_uids']['acteur']) &&
! empty($request_data['external_uids']['acteur'])) {
$acteurId = $request_data['external_uids']['acteur'];
$collectiviteId = $this->get_collectivite_id_from_acteur($acteurId);
if (empty($collectiviteId)) {
throw new InvalidArgumentException(sprintf(__(
"Impossible de trouver le service correspondant à l'acteur '%s'"), $acteurId));
}
$this->addToLog(__METHOD__."(): acteur: '$acteurId' => collectivite '$collectiviteId'",
VERBOSE_MODE);
}
elseif (isset($request_data['dossier']['om_collectivite']) &&
! empty($request_data['dossier']['om_collectivite'])) {
$collectiviteId = $this->get_collectivite_id(intval($request_data['dossier']["om_collectivite"]));
$this->addToLog(__METHOD__."(): collectivite '$collectiviteId'", VERBOSE_MODE);
}
if (empty($collectiviteId)) {
throw new InvalidArgumentException(sprintf(__(
"Le paramètre %s est obligatoire."), "'acteur' (ou 'om_collectivite')"));
}
return $collectiviteId;
}
/**
* Cette methode prend le type de demandeur et ces valeurs pour le créer
* et renvoie l'identifiant du demandeur créé ou false en cas d'erreur
*
* @param string $demandeur_type Le type de demandeur
* @param array $demandeur_valeur Les valeurs renseignés du demandeur
* @param int $collectiviteId L'identifiant de la collectivité
*
* @return int L'identifiant du demandeur
*
* @throw InvalidArgumentException Lorsque 'om_collectivite' est manquant
* @throw RuntimeException En cas d'échec lors de l'ajout du demandeur
*/
protected function creation_demandeur(string $demandeur_type, array $demandeur_valeur,
int $collectiviteId) {
// récupère une instance "vide"
$demandeur = $this->f->get_inst__om_dbform(array(
"obj" => "demandeur",
"idx" => "]",
));
// stocke les valeurs du demandeur, ré-organisées pour qu'elles puissent être fournies
// en tant qu'argument à la méthode demandeur::ajouter().
$valAuto = array();
// initialisation des valeurs à null
foreach($demandeur->champs as $value) {
$valAuto[$value] = null;
}
// récupération des valeurs
foreach ($demandeur_valeur as $colonne => $valeur) {
$valAuto[$colonne] = $valeur;
}
// traitement spécifique pour la civilité
if (isset($demandeur_valeur['particulier_civilite']) &&
! empty($demandeur_valeur['particulier_civilite'])) {
$valAuto['particulier_civilite'] = $this->get_civilite($demandeur_valeur['particulier_civilite']);
}
if (isset($demandeur_valeur['personne_morale_civilite']) &&
! empty($demandeur_valeur['personne_morale_civilite'])) {
$valAuto['personne_morale_civilite'] = $this->get_civilite($demandeur_valeur['personne_morale_civilite']);
}
// collectivité
if (empty($collectiviteId)) {
throw new InvalidArgumentException(sprintf(
__("Le paramètre %s est obligatoire pour les données du demandeur."),
"'acteur' (ou 'om_collectivite')"));
}
$valAuto['om_collectivite'] = $collectiviteId;
// traitement spécifique pour la fréquence
if (isset($demandeur_valeur['frequent']) && ! empty($demandeur_valeur['frequent'])) {
$valAuto['frequent'] = $demandeur_valeur["frequent"] == 'f';
}
// traitement spécifique pour la qualité
$valAuto['qualite'] = 'particulier';
if (isset($demandeur_valeur['qualite']) && ! empty($demandeur_valeur['qualite'])) {
$valAuto['qualite'] = str_replace(' ', '_', $demandeur_valeur['qualite']);
}
// traitement spécifique pour le type ==> TODO WHY ???
$valAuto['type_demandeur'] = str_replace("_principal", "", $demandeur_type);
// ajout du demandeur en BDD
if ($demandeur->ajouter($valAuto) === false) {
throw new RuntimeException(__("Échec lors de l'ajout du demandeur"));
}
// renvoie l'identifiant technique en BDD du demandeur créé
return $demandeur->valF['demandeur'];
}
/**
* Renvoie l'identifiant en BDD d'une collectivité à partir de son libellé ou de son ID.
* Stocke l'info en cache et l'utilise ensuite si elle existe.
*
* @param string|int $collectivite Libellé ou ID de la collectivité
*
* @return int L'identifiant de la collectivité en BDD
*/
protected function get_collectivite_id(string $collectivite) {
if (! isset($this->cacheCollectivites[$collectivite])) {
$om_collectivite = $this->f->getSingleSqlValue(
'om_collectivite', 'om_collectivite', 'om_collectivite.libelle', $collectivite);
$this->cacheCollectivites[$collectivite] = $om_collectivite;
}
return $this->cacheCollectivites[$collectivite];
}
/**
* Renvoi l'identifiant d'une collectivité à partir de la valeur de l'acteur (om_parametre).
*
* @param $acteurId string L'identifiant de l'acteur (valeur de om_parametre)
*
* @return int|null L'identifiant de la collectivité correspondante, ou null si non trouvée
*
* @throw RuntimeException En cas d'erreur BDD
*/
protected function get_collectivite_id_from_acteur(string $acteurId) {
$om_collectivite = null;
foreach(array(
'acteur_service_consulte',
'acteur_guichet_unique',
'acteur_service_instructeur',
'acteur_autorite_competente'
) as $acteur_key) {
$om_collectivite = $this->f->db->getOne(sprintf("
SELECT
om_collectivite
FROM
".DB_PREFIXE."om_parametre
WHERE
libelle = '%s'
AND valeur = '%s'
",
"platau_$acteur_key", $this->f->db->escapeSimple($acteurId)));
if ($this->f->isDatabaseError($om_collectivite, true)) {
throw new RuntimeException(sprintf(
__("Échec à l'exécution de la requête SQL de sélection d'un service ".
"pour l'acteur '%s'"), $acteurId));
}
if (! empty($om_collectivite)) {
break;
}
}
return $om_collectivite;
}
/**
* Renvoi le code INSEE d'une collectivité.
*
* @param $collectiviteId int L'identifiant de la collectivite
*
* @return int|null Le code INSEE de la collectivité, ou null si non trouvé
*
* @throw RuntimeException En cas d'erreur BDD
*/
protected function get_code_insee_for_collectivite(int $collectiviteId) {
$code_insee = $this->f->db->getOne(sprintf("
SELECT
valeur
FROM
".DB_PREFIXE."om_parametre
WHERE
libelle = '%s'
AND om_collectivie = '%d'
",
'insee', $collectiviteId));
if ($this->f->isDatabaseError($code_insee, true)) {
throw new RuntimeException(sprintf(
__("Échec à l'exécution de la requête SQL de sélection du code INSEE ".
"de la collectivité '%s'"), $collectiviteId));
}
return $code_insee;
}
/**
* Renvoi le code commune à partir d'un code INSEE
*
* @param $insee int Le code INSEE
*
* @return string|null Le code de la commune, ou null si non trouvé
*
* @throw RuntimeException En cas d'erreur BDD
*/
protected function get_commune_from_insee(string $insee) {
$today = (new Datetime())->format('Y-m-d');
$communeId = $this->f->db->getOne(sprintf("
SELECT
commune
FROM
".DB_PREFIXE."commune
WHERE
com = '%s'
AND (
om_validite_debut IS NULL
OR om_validite_debut <= TO_DATE('%s', 'YYYY-MM-DD')
)
AND (
commune.om_validite_fin IS NULL
OR om_validite_fin > TO_DATE('%s', 'YYYY-MM-DD')
)
ORDER BY
om_validite_fin DESC NULLS FIRST,
om_validite_debut DESC NULLS FIRST
LIMIT 1
",
$insee, $today, $today));
if ($this->f->isDatabaseError($communeId, true)) {
throw new RuntimeException(sprintf(
__("Échec à l'exécution de la requête SQL de sélection d'idenfiant commune ".
"à partir du code INSEE '%s'"), $insee));
}
return $communeId;
}
/**
* Renvoie l'identifiant en BDD d'une civilité à partir de son libellé ou de son ID.
*
* @param string|int $civilite Libellé ou ID de la civilité
*
* @return int L'identifiant de la civilité en BDD
*/
protected function get_civilite(string $civilite) {
return $this->f->getSingleSqlValue(
'civilite', 'civilite', 'civilite.libelle', $civilite);
}
/**
* Vérifie que le numéro de dossier est défini et conforme à la réglementation
*
* @param array Tableau des valeurs courantes de la demande
*
* @return array Tableau contenant les clés 'di' et 'da' avec le numéro de dossier correspondant
*
* @throw InvalidArgumentException Lorsque une donnée utilisateur est invalide ou manquante
*/
protected function ensure_numero_dossier(array $demande_values) {
$num_matches = array('di' => null, 'da' => null);
// s'il manque la clé 'dossier' alors que l'option
// 'saisie complète numéro dossier' est activée
if($this->f->is_option_dossier_saisie_numero_complet_enabled() &&
(! isset($demande_values['dossier']['dossier']) ||
empty($demande_values['dossier']['dossier']))) {
throw new InvalidArgumentException(sprintf(
__("Le paramètre '%s' est obligatoire"), 'dossier/dossier'));
}
// sinon, si on a la clé 'dossier' qui est bien définie
elseif(isset($demande_values['dossier']['dossier']) &&
! empty($demande_values['dossier']['dossier'])) {
/*
* On relache cette contrainte pour le cas ou les DA/DI sont non-règlementaires
*
// si le numéro de dossier n'est pas conforme à la numérotation
$num_matches = $this->f->numerotation_urbanisme($demande_values['dossier']['dossier']);
if (empty($num_matches['da']) || empty($num_matches['di'])) {
throw new InvalidArgumentException(sprintf(
__("La valeur '%s' du paramètre '%s' n'est pas valide"),
$demande_values['dossier']['dossier'], 'dossier/dossier'));
}*/
}
return $num_matches;
}
/**
* [get_datd_values_by_id description]
* @param int $datd_id [description]
* @return [type] [description]
*/
protected function get_datd_values_by_id(int $datd_id) {
//
$inst_datd = $this->f->get_inst__om_dbform(array(
"obj" => "dossier_autorisation_type_detaille",
"idx" => $datd_id,
));
$val = array();
$val = array_combine($inst_datd->champs, $inst_datd->val);
foreach ($val as $key => $value) {
$val[$key] = strip_tags($value);
}
return $val;
}
/**
* Renvoie l'identifiant en BDD d'une demande type à partir de son libellé ou de son ID.
*
* @param array $demande_values Tableau des valeurs courantes de la demande
* @param int $datd_id Identifiant du type de dossier d'autorisation détaillé.
* @param int $collectiviteId Identifiant de la collectivité courante
*
* @return int L'identifiant de la demande type en BDD
*
* @throw InvalidArgumentException Lorsque le paramètrage des types de demande n'est pas défini
*/
protected function get_demande_type(array $demande_values, int $datd_id, int $collectiviteId) {
// nom du paramèrte permettant de récupérer le type de demande
$type_demande_param = 'platau_type_demande_initial';
// si on a la clé 'dossier' qui est bien définie
if(isset($demande_values['dossier']['dossier']) &&
! empty($demande_values['dossier']['dossier'])) {
// récupère le suffixe du numéro de dossier
$matches = array();
if (preg_match('([A-Z])[0-9]\+$', $demande_values['dossier']['dossier'], $matches)) {
// en fonction du suffixe on définit le nom du paramètre du type de demande
switch($matches[1]) {
case 'P': break ;
case 'M': $type_demande_param = 'platau_type_demande_modificatif'; break ;
case 'T': $type_demande_param = 'platau_type_demande_transfert'; break ;
}
}
}
// Complète le libellé du paramètre à récupérer avec le code du type de dossier
// d'autorisation détaillé
$get_datd_values_by_id = array();
$get_datd_values_by_id = $this->get_datd_values_by_id($datd_id);
$datd_code = $get_datd_values_by_id['code'];
$type_demande_param = sprintf('%s_%s', $type_demande_param, $datd_code);
//
$param_collectivite = $this->f->getCollectivite($collectiviteId);
$type_demande_code = null;
if (is_array($param_collectivite) && isset($param_collectivite[$type_demande_param])) {
$type_demande_code = $param_collectivite[$type_demande_param];
}
if (empty($type_demande_code)) {
throw new InvalidArgumentException(sprintf(
__("Le paramètre '%s' n'est pas défini pour la collectivité/le service dont l'identifiant est %d"),
$type_demande_param, $param_collectivite['om_collectivite_idx']));
}
// récupère le type de demande à partir du code du type de demande
return $this->f->getSingleSqlValue(
'demande_type', 'demande_type', 'demande_type.code', $type_demande_code,
'demande_type', 'demande_type.dossier_autorisation_type_detaille', strval($datd_id));
}
/**
* Renvoie l'identifiant en BDD du DAtd à partir de son code.
*
* @param string $datd_code Code du type de dossier d'autorisation detaillé
*
* @return int L'identifiant du DAtd en BDD
*/
protected function get_dossier_autorisation_type_detaille(string $datd_code) {
return $this->f->getSingleSqlValue(
'dossier_autorisation_type_detaille', 'dossier_autorisation_type_detaille',
'dossier_autorisation_type_detaille.code', $datd_code);
}
}