<?php
require_once __DIR__ . '/Types.php';

class Account extends Scores_Ws_Server
{
    /**
     * Authentication
     * @param string $app
     *  Application name (extranet | odea | starlinks)
     * @param string $ip
     *  IPv4 ou IPv6
     * @param string $browser
     *  User agent string
     */
    public function loginAuthenticate($app, $ip = null, $browser = null)
    {
        switch ($app) {
            case 'extranet':
                $this->authApp = 'extranet';
                $this->authIp = $ip;
                break;
            case 'odea':
                $this->authApp = 'odea';
                $this->authIp = $ip;
                break;
            case 'starlinks':
                $this->authApp = 'starlinks';
                $this->authIp = $ip;
                break;
        }

    	// --- Authentification des applications par login
    	$this->authenticate();

		// --- Enregistrement authentification OK
    	try {
    		$authLogM = new Application_Model_Sdv1UtilisateursAuthLog();
    		$authLogM->insert(array(
				'login' => $login,
				'authenticate' => 'OK',
				'ip' => $ip,
    		    'dateInsert' => date('YmdHis'),
    		));
    	} catch (Zend_Db_Exception $e) {}


    	// --- Check App authorization - Find Service parameters
        $serviceM = new Application_Model_Sdv1ClientsServices();
        $sql = $serviceM->select()
            ->where('IdClient=?', $this->User->idClient)
            ->where('Code=?', $this->User->serviceCode);
        $serviceParams = $serviceM->fetchRow($sql);

        // --- Enregistrement informations navigateur uniquement si bien identifié
        if ($browser !== null) {
        	try {
        		$browserLogM = new Application_Model_Sdv1UtilisateursBrowserLog();
        		$browserLogM->insert(array(
    				'clientId' => $this->User->idClient,
    				'userId' => $this->User->id,
    				'service' => $this->User->serviceCode,
    				'login' => $this->User->login,
                    'userAgent' => $browser,
        		));
        	} catch (Zend_Db_Exception $e) {
        	    if ($this->User->idClient==1) {
        	        throw new SoapFault('ERR', $e->getMessage());
        	    } else {
        	        throw new SoapFault('ERR', "Application error");
        	    }
        	}
        }

    	//Retourne un minimum d'information pour les applications
        //login
        //civilite
        //nom
        //prenom
        //email
        //profil
        //pref
        //droits
        //typeScore
        //acceptationCGU

    }

    /**
     * Authentication by key
     * @param string $app
     */
    protected function keyAuthenticate($app)
    {
        //Authentification par clé - @define
        $this->authApp = 'extranet';

        //Reception du login

        //Reception de la clé (key:md5(login + '|' + key))

        //Vérification nécessaire : application - enable - date debut - date fin


    }

    /**
     * Authentication by SSO
     * @param int $client
     * @param string $login
     * @param string $token
     * @param AuthParam[] $params
     * @throws SoapFault
     * @return mixed
     *  Retourne FALSE or HASH to connect
     */
    public function ssoAuthenticate($client, $login, $token, $params)
    {
        /**
         * login ?
         * nom@mon.tld => extract nom
         */
        $part = strstr($login, '@', true);
        if ($part !== false) {
            $login = $part;
        }

		/**
         * Extract login from database
         */
        try {
            $userM = new Application_Model_Sdv1Utilisateurs();
            $sql = $userM->select()
                ->setIntegrityCheck(false)
                ->from(array('u'=>'utilisateurs'), array('u.id', 'u.login', 'u.idClient', 'u.actif',))
                ->join(array('c'=>'clients'), 'u.idClient = c.id', array('c.actif AS clientActif'))
                ->joinLeft(array('s'=>'sdv1.utilisateurs_service'), 'u.login=s.login', array('Service AS serviceCode'))
                ->where('u.login=?', $login)
                ->where('c.id=?', $client);
            $result = $userM->fetchRow($sql);
        } catch (Zend_Db_Exception $e) {
            if ($this->User->idClient==1) {
                throw new SoapFault('ERR', $e->getMessage());
            } else {
                throw new SoapFault('ERR', "Application error");
            }
        }

        /**
         * Client disable
         */
        if ( $result !== null && $result->clientActif == 'Non') {
            throw new SoapFault('SSO', 'Compte client inactif'); //Client désactivé
        }

        /**
         * No user
         */
        if ( null === $result ) {
            return false; //Utilisateur inexistant
        }

        /**
         * User not activated
         */
        if ( $result->actif == 0) {
            throw new SoapFault('SSO', 'Utilisateur non activé'); //Utilisateur non activé
        }

        /**
         * Process token - uniquement compatible In Extenso
         */
        $key = 'rh5s4z';
        $maxTime = time() + (15 * 60);
        $time = 0;
        $user = '';
        if (count($params->item) > 0) {
            foreach ($params->item as $k => $param) {
                if ($param->label == 'time') {
                    $time = $param->value;
                }
                if ($param->label == 'mail') {
                    $user = $param->value;
                }
            }
        }

        /**
         * Limite de temps
         */
        if ($time > $maxTime) {
            throw new SoapFault('SSO', 'Délai dépassé pour la connexion'); //Limite de temps dépassé pour la connexion
        }

        /**
         * Check token
         */
        $data = $user . '/' . $time . '/' . $key;
        $internalToken = hash('sha256', $data);
        //file_get_contents('inextenso.log', $internalToken .' = '. $token."\n", FILE_APPEND);
        if ($internalToken == $token) {
            //Generate random password
            $hash = password_hash ( uniqid() , PASSWORD_BCRYPT );
            try {
        		$userM->update(array('password' => $hash), 'id='.$result->id);
            } catch (Zend_Db_Exception $e) {
            	throw new SoapFault('SSO', "Activation de l'utilisateur impossible");
            }
            return $hash;
        }

        throw new SoapFault('SSO', 'Token invalide'); //Token invalide
    }

    /**
     * Liste des clients
     * @throws SoapFault
     * @return Client[]
     */
    public function getClients()
    {
        $this->authenticate();

        if ( $this->User->idClient != 1 ) {
            throw new SoapFault('ERR', 'Accès non authorisé');
        }

        $clientM = new Application_Model_Sdv1Clients();
        $sql = $clientM->select(true)->columns(array(
                'nom AS Nom',
                'LPAD(siren,9,0) AS Siren',
                'LPAD(nic,5,0) AS Nic',
                'IF(actif="Oui",1,0) AS Actif',
                'IF(test="Oui",1,0) AS Test'
            ))->where('actif=?', 'Oui');
        $result = $clientM->fetchAll($sql);

        if ( count($result) > 0 ) {
            foreach ( $result as $item ) {
                $client = new Client();
                $client->Nom = $item->Nom;
                $client->Siren = $item->Siren;
                $client->Nic = $item->Nic;
                $client->Actif = $item->Actif;
                $client->Test = $item->Test;

                $clients[] = $client;
            }
        }

        return $clients;
    }

    /**
     * Information client
     * @param int $id
     *  ID du client
     * @throws SoapFault
     * @return Client
     */
    public function getClient($id = null)
    {
        $this->authenticate();

        if ( $id === null || $this->User->idClient != 1 ) {
            $id = $this->User->idClient;
        }

        $clientM = new Application_Model_Sdv1Clients();
        $sql = $clientM->select(true)->columns(array(
                    'nom AS Nom',
                    'LPAD(siren,9,0) AS Siren',
                    'LPAD(nic,5,0) AS Nic',
                    'IF(actif="Oui",1,0) AS Actif',
                    'IF(test="Oui",1,0) AS Test'
                ))->where('id=?', $id);
        $result = $clientM->fetchRow($sql);

        if ( $result === null ) {
            throw new SoapFault('ERR', 'Information client introuvable.');
        }

        $client = new Client();
        $client->Nom = $result->Nom;
        $client->Siren = $result->Siren;
        $client->Nic = $result->Nic;
        $client->Actif = $result->Actif;
        $client->Test = $result->Test;

        return $client;
    }

    /**
     * Information client avec la liste des services
     * @param int $id
     *  ID du client
     * @throws SoapFault
     * @return ClientServices
     */
    public function getClientServices($id = null)
    {
        $this->authenticate();

        if ( $id === null || $this->User->idClient != 1 ) {
            $id = $this->User->idClient;
        }

        $clientM = new Application_Model_Sdv1Clients();
        $sql = $clientM->select()->from($clientM, array(
            'nom AS Nom',
            'LPAD(siren,9,0) AS Siren',
            'LPAD(nic,5,0) AS Nic',
            'IF(actif="Oui",1,0) AS Actif',
            'IF(test="Oui",1,0) AS Test'
        ))->where('id=?', $id);
        $result = $clientM->fetchRow($sql);

        if ( $result === null ) {
            throw new SoapFault('ERR', 'Information client introuvable.');
        }

        $client = new ClientServices();
        $client->Nom = $result->Nom;
        $client->Siren = $result->Siren;
        $client->Nic = $result->Nic;
        $client->Actif = $result->Actif;
        $client->Test = $result->Test;

        //Get Services
        $serviceM = new Application_Model_Sdv1ClientsServices();
        $sql = $serviceM->select()
                    ->from($serviceM, array('id', 'Code', 'Label', 'Editable', 'Active'))
                    ->where('Deleted=?', 0)
                    ->where('Active=?', 1)
                    ->where('IdClient=?', $id);
        $result = $serviceM->fetchAll($sql);
        $services = array();
        if (count($result) > 0) {
            foreach ($result as $item) {
                $clientService = new ClientServicesList();
                $clientService->id = $item->id;
                $clientService->Code = $item->Code;
                $clientService->Label = $item->Label;
                $clientService->Editable = $item->Editable;
                $clientService->Active = $item->Active;
                $services[] = $clientService;
            }
        }
        $client->Services = $services;

        return $client;
    }

    protected function getContratList()
    {
    	//Liste des contrats, par service résumé

        //Vérification des droits d'utilisation
        if ( $this->User->profil != 'Administrateur' ) {
            throw new SoapFault('ERR', 'Accès non authorisé');
        }

    }

    protected function getContrat($id)
    {
        //Détail d'un contrat

        //Vérification des droits d'utilisation
        if ( $this->User->profil != 'Administrateur' ) {
            throw new SoapFault('ERR', 'Accès non authorisé');
        }

    }

    /**
     * Liste des services
     * @param string $client
     *  Id client
     * @return ServiceList[]
     */
    public function getServiceList($client = null)
    {
        //Liste des services
        $this->authenticate();

        if ( $client === null ) {
            $client = $this->User->idClient;
        }

        // Uniquement si l'utilisateur est administrateur et dans le service DEFAULT
        if ( !in_array($this->User->profil, array('Administrateur', 'SuperAdministrateur')) ) {
            throw new SoapFault('ERR', 'Accès non authorisé');
        }

        $serviceM = new Application_Model_Sdv1ClientsServices();
        try {
            $serviceSql = $serviceM->select()->where('IdClient=?', $client) ->where('Deleted=?', 0);
            $serviceResult = $serviceM->fetchAll($serviceSql);
        } catch (Zend_Db_Exception $e) {
            if ($this->User->idClient == 1) {
                throw new SoapFault('ERR', $e->getMessage());
            } else {
                throw new SoapFault('ERR', "Application error");
            }
        }
        $services = array();
        if ( count($serviceResult) > 0 ) {
            foreach ($serviceResult as $item) {
                $service = new ServiceList();
                $service->id = $item->id;
                $service->IdClient = $item->IdClient;
                $service->Code = $item->Code;
                $service->Label = $item->Label;
                $service->TypeCompte = $item->TypeCompte;
                $service->TypeAcces = $item->TypeAcces;
                $service->TypeScore = $item->TypeScore;
                $service->Timeout = $item->Timeout;
                $service->Editable = $item->Editable;
                $service->Active = $item->Active;
                $service->DateInsert = $item->DateInsert;
                $service->DateUpdate = $item->DateUpdate;

                $services[] = $service;
            }
        }

        return $services;
    }

    /**
     * Détail d'un service
     * @param string $code
     * @throws SoapFault
     * @return Service
     */
    public function getService($code)
    {
    	$this->authenticate();

    	$client = $this->User->idClient;

    	// Détail d'un service
        $serviceM = new Application_Model_Sdv1ClientsServices();
        try {
            $sql = $serviceM->select()->where('IdClient=?', $client)->where('Deleted=?', 0)->where('Code=?', $code);
            $result = $serviceM->fetchRow($sql);
        } catch (Zend_Db_Exception $e) {
            if ($this->User->idClient == 1) {
                throw new SoapFault('ERR', $e->getMessage());
            } else {
                throw new SoapFault('ERR', "Application error");
            }
        }

        if ( $result === null ) {
            throw new SoapFault('ERR', 'Service introuvable.');
        }

        $output = new Service();
        $output->id = $result->id;
        $output->IdClient = $client;
        $output->Code = $result->Code;
        $output->Label = $result->Label;
        $output->TypeCompte = $result->TypeCompte;
        $output->TypeAcces = $result->TypeAcces;
        $output->TypeScore = $result->TypeScore;
        $output->Timeout =  $result->Timeout;
        $output->Editable =  $result->Editable;
        $output->Active = $result->Active;
        $output->DateInsert = $result->DateInsert;
        $output->DateUpdate = $result->DateUpdate;

        $serviceCode = $result->Code;

    	// Droits
        $output->Acces = array();
        $serviceDroitsM = new Application_Model_Sdv1ClientsServicesDroits();
    	try {
        	$sql = $serviceDroitsM->select()->where('IdClient=?', $client)->where('Service=?', $serviceCode);
            $result = $serviceDroitsM->fetchAll($sql);
        } catch (Zend_Db_Exception $e) {
            if ($this->User->idClient == 1) {
                throw new SoapFault('ERR', $e->getMessage());
            } else {
                throw new SoapFault('ERR', "Application error");
            }
        }
        if (count($result) > 0) {
        	foreach ($result as $item) {
        	    $acces = new Acces();
        	    $acces->Code = strtoupper($item->Acces);
        	    $acces->Label = $this->listeDroits[strtoupper($item->Acces)];
        	    $output->Acces[] = $acces;
        	}
        }

    	// IP
        $output->IP = array();
        $serviceIPM = new Application_Model_Sdv1ClientsServicesIP();
        try {
            $sql = $serviceIPM->select()->where('IdClient=?', $client)->where('Service=?', $serviceCode);
            $result = $serviceIPM->fetchAll($sql);
        } catch (Zend_Db_Exception $e) {
            if ($this->User->idClient == 1) {
                throw new SoapFault('ERR', $e->getMessage());
            } else {
                throw new SoapFault('ERR', "Application error");
            }
        }
        if (count($result) > 0) {
            foreach ($result as $item) {
                $output->IP[] = $item->IP;
            }
        }

        return $output;
    }

    protected function getServiceConso($id){}

    protected function getServiceLogByFile(){}

    /**
     * Modification des éléments d'un service par un administrateur
     * @param string $code Element à modifier (label | active | delete)
     * @param mixed $value Valeur
     * @param string $id Id du service
     * @throws SoapFault
     * @return boolean
     */
    public function setService($code, $value, $id)
    {
    	$this->authenticate();

    	// --- Vérification des droits d'utilisation
    	if ( !in_array($this->User->profil, array('Administrateur', 'SuperAdministrateur')) ) {
    	    throw new SoapFault('ERR', "Accès non authorisé");
    	}

    	$client = $this->User->idClient;

    	// --- Définir les éléments du service
        $serviceM = new Application_Model_Sdv1ClientsServices();
        $sql = $serviceM->select()
                    ->where('IdClient=?', $client)
                    ->where('Deleted=?', 0)
                    ->where('id=?', $id);
        $result = $serviceM->fetchRow($sql);

        if ( $result === null ) {
            throw new SoapFault('ERR', "Service introuvable.");
        }

        if ( $result->Editable == 0) {
            throw new SoapFault('MSG', "Impossible d'éditer le service");
        }

        $data = json_decode($data);
        $dataToUpdate = array();

        // --- Suppression d'un service
        if ( $code == 'delete' && $value == 1 ) {
            $dataToUpdate = array('Deleted' => 1);
        }

        if ( $code == 'active' && in_array($value, array(0,1)) ) {
            $dataToUpdate = array('Active' => $value);
        }

        if ( $code == 'label' && is_string($value) ) {
            $dataToUpdate = array('Label' => $value);
        }

        if ( count($dataToUpdate) > 0 ) {
            $dataToUpdate['DateUpdate'] = date('YmdHis');
            try {
                $serviceM->update($dataToUpdate, 'id='.$id);
                return true;
            } catch (Zend_Db_Exception $e) {
                if ($this->User->idClient == 1) {
                    throw new SoapFault('ERR', $e->getMessage());
                } else {
                    throw new SoapFault('ERR', "Application error");
                }
            }
        }

        return false;
    }

    /**
     * Définit les paramètres d'un service
     * @param string $type
     * @param string $value
     * @param string $id
     * @param boolean $delete
     * @throws SoapFault
     * @return boolean
     */
    public function setServiceParam($type, $value, $id, $delete = false)
    {
    	// --- Définir un paramètre du service
        $this->authenticate();

        // --- Vérification des droits d'utilisation
        if ( !in_array($this->User->profil, array('Administrateur', 'SuperAdministrateur')) ) {
            throw new SoapFault('ERR', "Accès non authorisé");
        }

        $client = $this->User->idClient;

        $serviceM = new Application_Model_Sdv1ClientsServices();
        $sql = $serviceM->select()
                ->where('IdClient=?', $client)
                ->where('Deleted=?', 0)
                ->where('id=?', $id);
        $result = $serviceM->fetchRow($sql);

        if ( $result === null ) {
            throw new SoapFault('ERR', "Service introuvable.");
        }

        if ( $result->Editable == 0) {
            throw new SoapFault('MSG', "Impossible d'éditer le service");
        }

        // --- Acces
        if ( $type == 'acces' ) {
            if ( in_array($value, $this->listeDroits) ) {
            	$accessM = new Application_Model_Sdv1ClientsServicesDroits();
            	if ( $delete ) {
            		$row = $accessM->delete('id='.$id);
            	} else {            		            		
            		$row = $accessM->insert(array(
            			'IdClient' => $result->IdClient,
            			'Service' => $result->Code,
            			'Access' => $value,
            			'DateAdded' => date('YmdHis'),
            		));
            	}
            }
            
        	if ($row) {
            	return true;
            }
        }

        // --- IP
        if ( $type == 'ip' ) {
			$ipM = new Application_Model_Sdv1ClientsServicesIP();
            if ( $delete ) {
				$row = $ipM->delete('id='.$id);
            } else {
                //Control de la plage IP ou de l'IP
                $validate = new Zend_Validate_Ip();
                if ( $validate->isValid($value) ) {
                	$row = $accessM->insert(array(
						'IdClient' => $result->IdClient,
                		'Service' => $result->Code,
                		'IP' => $value,
                		'DateAdded' => date('YmdHis'),
                	));
                }
            }
            
            if ($row) {
            	return true;
            }
        }

        return false;
    }

    /**
     * Liste des utilisateurs
     * @param int $actif (0|1)
     * @param string $service Code du service
     * @param string $client Id du client
     * @return UserList[]
     */
    public function getUserList($actif = null, $service = null, $client = null)
    {
    	// Liste des utilisateurs - filtre au service
    	$this->authenticate();

    	if ( $client === null ) {
    	    $client = $this->User->idClient;
    	}

    	// Administrateur
    	if ( !in_array($this->User->profil, array('Administrateur', 'SuperAdministrateur')) ) {
    	    throw new SoapFault('ERR', 'Accès non authorisé');
    	}

    	// Administrateur d'un service
    	if ( $this->User->Service != '' && $this->User->Service !== null && $this->User->Service !== 'DEFAULT' ) {
            $service = $this->User->Service;
    	}

    	try {
            $userM = new Application_Model_Sdv1Utilisateurs();
            $sql = $userM->select()
                ->setIntegrityCheck(false)
                ->from(array('u'=>'sdv1.utilisateurs'), array('id','idClient','login','email','civilite','nom','prenom','actif','deleted'))
                ->joinLeft(array('s'=>'sdv1.utilisateurs_service'), 'u.login=s.login', array('Service'))
                ->joinLeft(array('sd'=>'sdv1.clients_services'), 'sd.Code=s.Service', array('Label'))
                ->where('u.idClient=?', $client);

            if ( $actif !== null && in_array($actif, array(0,1)) ) {
                $sql->where('u.actif=?', $actif);
            }
            $sql->where('u.deleted=?', 0);

            if ($service == 'DEFAULT') {
                $sql->where('(s.Service IS NULL) OR (s.Service="DEFAULT" AND sd.idClient='.$client.')');
            } else {
                $sql->where('sd.Code=?', $service);
            }
            $result = $userM->fetchAll($sql);
    	} catch (Zend_Db_Exception $e) {
    	    if ($this->User->idClient == 1) {
    	        throw new SoapFault('ERR', $e->getMessage());
    	    } else {
    	        throw new SoapFault('ERR', "Application error");
    	    }
    	}

        $users = array();
        if (count($result) > 0) {
        	foreach ($result as $item) {
                $user = new UserList();
                $user->id = $item->id;
                $user->IdClient = $item->idClient;
                $user->ServiceCode = $item->Service;
                $user->ServiceLabel = $item->Label;
                $user->Login = $item->login;
                $user->Email = $item->email;
                $user->Civilite = $item->civilite;
                $user->Nom = $item->nom;
                $user->Prenom = $item->prenom;
                $user->Enable = $item->actif;
                $user->Delete = $item->deleted;

                $users[] = $user;

        	}
        }

        return $users;
    }

    protected function getUsersFile($actif = null, $service = null, $client = null)
    {

    }

    /**
     * Information Utilisateur
     * @param string $id
     *  ID de l'utilisateur
     * @throws SoapFault
     * @return User
     */
    public function getUser($id = null)
    {
    	//Détail d'un utilisateur
        $this->authenticate();

        $idClient = $this->User->idClient;

        if ( $id === null ) {
        	$id = $this->User->id;
        }

        // Get Data
        try {
            $userM = new Application_Model_Sdv1Utilisateurs();
            $sql = $userM->select()->from(array('u'=>'utilisateurs'))
                    ->setIntegrityCheck(false)
                    ->joinLeft(array('s'=>'sdv1.utilisateurs_service'), 'u.login=s.login', array('Service'))
                    ->joinLeft(array('sd'=>'sdv1.clients_services'), 'sd.Code=s.Service', array('Label AS ServiceLabel'))
                    ->where('u.id=?', $id);

            $user = $userM->fetchRow($sql);
        } catch (Zend_Db_Exception $e) {
            if ($this->User->idClient == 1) {
                throw new SoapFault('ERR', $e->getMessage());
            } else {
                throw new SoapFault('ERR', "Application error");
            }
        }

        if ( $user === null ) {
        	throw new SoapFault('ERR', 'Utilisateur inexistant !');
        }

        // Service
        $serviceCode = 'DEFAULT';
        $serviceLabel = 'Standard';
        if ( $user->Service !== null ) {
            $serviceCode = $user->Service;
            $serviceLabel = $user->ServiceLabel;
        }

        $output = new User();
        $output->id = $user->id;
        $output->IdClient = $user->idClient;
        $output->ServiceCode = $serviceCode;
        $output->ServiceLabel = $serviceLabel;
        $output->Login = $user->login;
        $output->Email = $user->email;
        $output->Civilite = $user->civilite;
        $output->Nom = $user->nom;
        $output->Prenom = $user->prenom;
        $output->Enable = $user->actif;
        $output->Delete = $user->deleted;

        // Service - Droits
        $acces = array();
        try {
            $droitsM = new Application_Model_Sdv1ClientsServicesDroits();
            $sql = $droitsM->select()->where('IdClient=?', $idClient)->where('Service=?', $serviceCode);
            $droits = $droitsM->fetchAll($sql);
        } catch (Zend_Db_Exception $e) {
            if ($this->User->idClient == 1) {
                throw new SoapFault('ERR', $e->getMessage());
            } else {
                throw new SoapFault('ERR', "Application error");
            }
        }
        if ( count($droits) > 0 ) {
            foreach ($droits as $item) {
                $acces = new Acces();
                $acces->Code = strtoupper($item->Acces);
                $acces->Label = $this->listeDroits[strtoupper($item->Acces)];
                $output->Acces[] = $acces;
            }
        }

        // Si l'utilisateur a pour Service = DEFAULT et pas de service DEFAULT alors droits de l'utilisateur
        if ( count($droits) == 0 ) {
            $droits = explode(' ', $user->droits);
            foreach ($droits as $item) {
                $acces = new Acces();
                $acces->Code = strtoupper($item);
                $acces->Label = $this->listeDroits[strtoupper($item)];
                $output->Acces[] = $acces;
            }
        }

        // Service - IP
        try {
            $ipM = new Application_Model_Sdv1ClientsServicesIP();
            $sql = $ipM->select()->where('IdClient=?', $idClient)->where('Service=?', $serviceCode);
            $ips = $ipM->fetchAll($sql);
        } catch (Zend_Db_Exception $e) {
            if ($this->User->idClient == 1) {
                throw new SoapFault('ERR', $e->getMessage());
            } else {
                throw new SoapFault('ERR', "Application error");
            }
        }
        if ( count($ips) > 0 ) {
            foreach ($ips as $item) {
                $output->IP[] = $item;
            }
        }

        return $output;
    }

    protected function getUserActivity($id = null)
    {
    	//Retourner la liste des dernières connexions
    }

    /**
     * Emails secondaires
     * @param int $id
     * @throws SoapFault
     * @return string[]
     */
    public function getUserEmail($id)
    {
        $this->authenticate();

        $idClient = $this->User->idClient;

        try {
            $emailsM = new Application_Model_Sdv1UtilisateursEmails();
            $sql = $emailsM->select()
                ->where('id=?', $id)
                ->where('idClient=?', $idClient);
            $result = $emailsM->fetchAll($sql);
        } catch (Zend_Db_Exception $e) {
            if ($this->User->idClient==1) {
                throw new SoapFault('ERR', $e->getMessage());
            } else {
                throw new SoapFault('ERR', "Application error");
            }
        }

        $emails = array();
        if ( count($result)>0 ) {
            foreach ( $result as $item ) {
                $email = new Email();
                $email->id = $item->id;
                $email->value = $item->email;

                $emails[] = $email;
            }
        }

        return $emails;
    }

    /**
     * Log des consultations
     * @param string $month AAAAMM
     * @param string $item
     *  Code de l'élément
     * @param integer $p
     * @param integer $limit
     */
    public function getUserLog($month, $item, $p=0, $limit=50)
    {
        $this->authenticate();

        $selectedYear = date('Y');
        $selectedMonth = date('m');

        $item = 'identite';

        // --- Generate SQL
        $logM = new Application_Model_Sdv1Logs();
        $logSql = $logM->select()
            ->where('login=?', $this->User->login)
            ->where('page=?', $item)
            ->where('dateHeure BETWEEN "'.$selectedYear.'-'.$selectedMonth.'-00 00:00:00" AND "'.
                $selectedYear.'-'.$selectedMonth.'-31 23:59:59"');

        // --- Get total
        $cols = new Zend_Db_Expr("COUNT(*) AS NB");
        $logSql->columns($cols);
        $totalResult = $logM->fetchRow($logSql);

        $output = new UserLog();
        $output->Total = $totalResult->NB;
        $output->List = array();

        if ($totalResult->NB > 0) {
            // --- Get Row
            $logSql->columns(array('LPAD(siren,9,0) AS siren', 'LPAD(nic,5,0) AS nic', 'raisonSociale'));
            $logSql->order('dateHeure DESC')->limitPage($p, $limit);
            $logResult = $logM->fetchAll($logSql);
            foreach ($logResult as $l) {
                $struct = new UserLogItem();
                $companyId = $l->siren;
                if (intval($l->nic) > 0) {
                    $companyId.= $l->nic;
                }
                $struct->CompanyId = $companyId;
                $struct->CompanyType = 'SIREN';
                $struct->CompanyName = $l->raisonSociale;
                $struct->Date = $l->dateHeure;
                $output->List[] = $struct;
            }
        }

        return $output;
    }

    protected function getUserLogFile($id){}

    /**
     * Company User History (10 last)
     * @param int $id
     * @param int $limit
     * @return UserLogItem[]
     */
    public function getUserHistory($id=null, $limit=10)
    {
        $this->authenticate();

        $selectedYear = date('Y');
        $selectedMonth = date('m');

        $output = array();

        // --- Generate SQL
        try {
            $logSubquery = "SELECT siren, MAX(dateHeure) AS MaxDateHeure FROM logs WHERE login='".$this->User->login."' AND page='identite' GROUP BY siren";
            $logSql = "SELECT LPAD(x.siren,9,0) AS siren, LPAD(x.nic,5,0) AS nic, x.raisonSociale, x.dateHeure FROM logs x ".
                "JOIN (".$logSubquery.") y ON y.siren = x.siren AND y.MaxDateHeure = x.dateHeure ".
                "ORDER BY x.dateHeure DESC LIMIT 0,".$limit;
            $db = Zend_Db_Table_Abstract::getDefaultAdapter();
            $db->setFetchMode(Zend_Db::FETCH_OBJ);
            $logResult = $db->fetchAll($logSql);
            foreach ($logResult as $l) {
                $struct = new UserLogItem();
                $companyId = $l->siren;
                if (intval($l->nic) > 0) {
                    $companyId.= $l->nic;
                }
                $struct->CompanyId = $companyId;
                $struct->CompanyType = 'SIREN';
                $struct->CompanyName = $l->raisonSociale;
                $struct->Date = $l->dateHeure;
                $output[] = $struct;
            }
        } catch (Zend_Db_Exception $e) {
            if ($this->User->idClient == 1) {
                throw new SoapFault('ERR', $e->getMessage());
            } else {
                throw new SoapFault('ERR', 'Application Error.');
            }
        }

        return $output;
    }

    /**
     * Log d'authentification
     * @param string $month Date (AAAAMM)
     * @param string $type (OK, KO)
     * @param integer $p
     * @param integer $limit
     * @return AuthLog
     */
    public function getAuthLog($month, $type, $p=0, $limit=20)
    {
        $this->authenticate();
        
        $limit = ($limit > 0) ? $limit : 20;
        $p     = ($p > 0)     ? $p     : 0;
        
        if ($month === null) {
        	$month = date('Y-m');
        }
        $dateStart = $month.'-01 00:00:00';
        $dateEnd = $month.'-31 23:59:59';

        // --- Generate SQL
        $logM = new Application_Model_Sdv1UtilisateursAuthLog();        
        // --- Get total
        $logSql = $logM->select()->from($logM, array())
	        ->where('login=?', $this->User->login)
	        ->where('authenticate=?', 'OK')
	        ->where('dateInsert BETWEEN "'.$dateStart.'" AND "'.$dateEnd.'"');
        $cols = new Zend_Db_Expr("COUNT(*) AS NB");
        $logSql->columns($cols);
        try {
        	$totalResult = $logM->fetchRow($logSql);
        } catch (Zend_Db_Exception $e) {
        	if ($this->User->idClient == 1) {
        		throw new SoapFault('ERR', $e->getMessage());
        	} else {
        		throw new SoapFault('ERR', 'Application Error.');
        	}
        }

        $output = new AuthLog();
        $output->Total = $totalResult->NB;
        $output->List = array();

        if ($totalResult->NB > 0) {
            // --- Get Row
        	$logSql = $logM->select()->from($logM, array())
	        	->where('login=?', $this->User->login)
	        	->where('authenticate=?', 'OK')
	        	->where('dateInsert BETWEEN "'.$dateStart.'" AND "'.$dateEnd.'"');
            $logSql->columns(array('IP', 'dateInsert AS Date'));
            $logSql->order('dateInsert DESC')->limit($limit, $limit * $p);
            file_put_contents('test.log', print_r($logSql->__toString(),1));            
            try {
            	$logResult = $logM->fetchAll($logSql);
            } catch (Zend_Db_Exception $e) {
            	if ($this->User->idClient == 1) {
            		throw new SoapFault('ERR', $e->getMessage());
            	} else {
            		throw new SoapFault('ERR', 'Application Error.');
            	}
            }
            foreach ($logResult as $item) {
                $struct = new AuthLogItem();
                $struct->IP = $item->IP;
                $struct->Date = $item->Date;
                $output->List[] = $struct;
            }
        }

        return $output;
    }

    /**
     * Paramétrage d'un utilisateur
     * @param string $data
     * @param int $id
     * @throws SoapFault
     * @return boolean
     */
    public function setUser($data, $id = null)
    {
        $this->authenticate();

        // --- Vérification des droits de création d'utilisateur
        if ( $this->User->id != $id || !in_array($this->User->profil, array('SuperAdministrateur', 'Administrateur')) ) {
            throw new SoapFault('ERR', 'Accès non authorisé');
        }

        $values = json_decode($data);

        $userM = new Application_Model_Sdv1Utilisateurs();

        $userData = array(
            'idClient' => $values['idClient'],
            'login' => trim($values['login']),
            'email' => strtolower(trim($values['email'])),
            'password' => '',
            'actif' => 1,
            'deleted' => 0,
            'typeCompte' => 'PROD',
            'civilite' => $values['civilite'],
            'nom' => trim($values['nom']),
            'prenom' => trim($values['prenom']),
            'profil' => 'Utilisateur',
            'droits' => '',
            'referenceParDefaut' => '',
            'nbReponses' => 10,
            'lang' => 'fr',
            'formatMail' => 'txt2',
            'lienExtranetMail' => 0,
            'lienSurvFic' => 0,
            'idSurvFic' => '',
            'loginCptSurvFic' => '',
            'listeEven' => '',
        );

        // --- Création
        if ( $id === null ) {

            $sql = $userM->select()->where('login=?', $values['login']);
            $row = $userM->fetchRow($sql);
            // --- Utilisateur existant
            if ( null !== $row ) {
                throw new SoapFault('ERR', "User exist");
            }
            // --- Prepare data to insert
            foreach ($values as $key => $value) {
                if (array_key_exists($key, $userData)) {
                    $userData[$key] = trim($value);
                }
            }
            $userData['dateInsert'] = date('YmdHis');

            try {
                $userM->insert($userData);
            } catch (Zend_Db_Exception $e) {
                return false;
            }

            //Définition du service
            $serviceM = new Application_Model_Sdv1UtilisateursService();
            try {
                $serviceM->insert(array(
                    'login' => $infos->login,
                    'idClient'=> $infos->idClient,
                    'Service'=> $infos->Service
                ));
            } catch (Zend_Db_Exception $e) {
                return false;
            }

            return true;

        }
        // --- Modification
        else {

            $sql = $userM->select()->where('id=?', $id);
            $row = $userM->fetchRow($sql);
            if ( null === $row ) {
                throw new SoapFault('ERR', "User doesn't exist");
            }
            // --- Prepare data to update
            foreach ($row as $key => $value) {
                if (array_key_exists($key, $userData)) {
                    $userData[$key] = trim($value);
                }
            }
            foreach ($values as $key => $value) {
                if (array_key_exists($key, $userData)) {
                    $userData[$key] = trim($value);
                }
            }

            try {
                $userM->update($userData, 'id='.$id);
            } catch (Zend_Db_Exception $e) {
                return false;
            }

            return true;
        }
    }

    /**
     * Création de compte client partenaire
     * @param string $data
     * @return boolean
     */
    public function setUserSSO ( $data )
    {
        //Check IP application
        /*$ip = $_SERVER['REMOTE_ADDR'];
        if ( !in_array($ip, $this->listApplicationIp) ) {
            $this->sendError('0901');
        }*/

        //Decodage
        $infos = json_decode($data);

        $userData = array(
            'idClient' => null,
            'login' => null,
            'email' => '',
            'password' => '',
            'actif' => 0,
            'deleted' => 0,
            'typeCompte' => 'PROD',
            'filtre_ip' => '',
            'civilite' => 'M',
            'nom' => '',
            'prenom' => '',
            'raisonSociale' => '',
            'siret' => '000000000',
            'adrNum' => null,
            'adrIndRep' => null,
            'adrTypeVoie' => null,
            'adrLibVoie' => '',
            'adrCp' => null,
            'adrVille' => null,
            'adrComp' => '',
            'tel' => '',
            'fax' => null,
            'mobile' => null,
            'pref' => '',
            'profil' => 'Utilisateur',
            'dateInscription' => '0000-00-00 00:00:00',
            'dateValidation' => '0000-00-00 00:00:00',
            'nombreConnexions' => '0',
            'dateDerniereConnexion' => '0000-00-00 00:00:00',
            'droits' => '',
            'referenceParDefaut' => '',
            'nbReponses' => '020',
            'lang' => null,
            'formatMail' => 'txt1',
            'lienExtranetMail' => 0,
            'lienSurvFic' => 0,
            'idSurvFic' => '',
            'loginCptSurvFic' => '',
            'listeEven' => '',
            'dateDebutCompte' => null,
            'dateFinCompte' => null,
            'maxFicheId' => null,
            'accesWS' => '0',
            'rechRefType' => 'UTI',
            'acceptationCGU' => null,
        );

        //Définition du service
        $serviceM = new Application_Model_Sdv1UtilisateursService();
        try {
        	$serviceM->insert(array(
				'login' => $infos->login,
				'idClient'=> $infos->idClient,
				'Service'=> $infos->Service
        	));
        } catch ( Zend_Db_Exception $e ) {
        	return false;
        }

        //Prepare data to insert
        foreach ($infos as $key => $value) {
            if (array_key_exists($key, $userData)) {
                $userData[$key] = $value;
            }
        }
        $userData['password'] = password_hash ( uniqid() , PASSWORD_BCRYPT );
        $userData['dateInsert'] = date('YmdHis');
        $userData['dateDebutCompte'] = date('YmdHis');

        //Insertion dans la base de données
        try {
            $userM = new Application_Model_Sdv1Utilisateurs();
            $userM->insert($userData);
        } catch ( Zend_Db_Exception $e ) {
            return false;
        }

        return true;
    }

    protected function setUserService($service, $id)
    {
    	//Déplacer un utilisateur de service - ne pas activer tout de suite

    }

    public function setUserEmail($id, $email, $op = null)
    {
        //Which operation
        switch ( $op ) {
            //Ajouter un email secondaire
            case null:
            case 'add':
                break;
            //Supprimer un email secondaire
            case 'del':
                break;
        }


    }

    /**
     * Change password
     * @param string $password
     * @param int $id
     * @throws SoapFault
     * @return boolean
     */
    public function setUserPassword($password, $id = null)
    {
        $this->authenticate();

        if ( $id === null ) {
            $id = $this->User->id;
        } elseif ( $id !== null && $this->User->profil != 'Administrateur' ) {
            throw new SoapFault('ERR', 'Accès non authorisé');
        }

        //@todo : Prise en compte de la version

        //Changer le mot de passe
        $userM = new Application_Model_Sdv1Utilisateurs();
        $result = $userM->update(array('password'=>$password), 'id='.$id);
        if ( $result == 1 ) {
            return true;
        }
        return false;
    }

    /**
     * Catégorie et Accès
     * @return AccesCategory[]
     */
    public function getCategory()
    {
        $output = array();
        foreach ($this->listeCategory as $code => $desc) {
            $c = new AccesCategory();
            $c->Code = $code;
            $c->Label = $desc['label'];
            $c->Acces = $desc['droits'];
            $output[] = $c;
        }
        return $output;
    }

    /**
     * Liste des acces
     * @return Acces[]
     */
    public function getAccess()
    {
    	$droits = $this->listeDroits;
    	$list = array();
        foreach ($droits as $k => $v) {
            $acces = new Acces();
            $acces->Code = $k;
            $acces->Label = $v;
            $list[] = $acces;
        }

        return $list;
    }

    protected function getPref()
    {
    	//Liste des préférences - Code, Label, Description, Values
    }

    protected function setPref(){}

    /**
     * Acceptation des CGUs
     * @param string $app
     * @throws SoapFault
     * @return boolean
     */
    public function setCGU($app = null)
    {
        $this->authenticate();

        $id = $this->User->id;

        try {
            $userM = new Application_Model_Sdv1Utilisateurs();
            $data = array('acceptationCGU' => date('YmdHis'));
            $result = $userM->update($data, 'id='.$idUser);
        } catch (Zend_Db_Exception $e) {
            throw new SoapFault('Erreur', $e->getMessage());
        } catch (Zend_Exception $e) {
            throw new SoapFault('Erreur', $e->getMessage());
        }
        if ( 1 == $result ) {
            return true;
        }
        return false;
    }

    protected function setUserEnable($id)
    {
        //Un administrateur force l'activation d'un utilisateur ?
        $userM = new Application_Model_Sdv1Utilisateurs();
        //actif = 1

        /**
         * L'utilisateur n'a pas reçu ou a perdu l'email avec son mot de passe, vous pouvez activez sont compte
         * (attention son email ne sera pas validé, et certaines prestations nécessitant un email valide ne peuvent fonctionner)
         */

    }

    protected function setLinkValidation()
    {
        //Génération d'un hash pour la validation email
        //Database : utilisateurs_validationh [id, ]

        //utilisateurs_email => dateValidation + surveillance

        //Envoi email avec lien de validation
    }

    protected function setUserValidation($id)
    {
        //Un utilisateur valide son compte pour la première connexion et déclenche l'envoi de validation de l'email
        //Doit-on demander un nouveau mot de passe ? Est ce que le mot de passe a été générer et envoyé par email .
        $userM = new Application_Model_Sdv1Utilisateurs();
        //actif = 0
        //dateValidation pour email

        //Envoi email de validation
        //lien + email + login + date + hash ('sha256', string ) => string {idClient}{login}{email}{AAAAMMJJ}
    }

    protected function setUserEmailValidation($id)
    {
        //Validation d'un email
        //Email secondaire ajouté marqueur dateValidation
    }

    /**
     * Un SuperAdministrateur devenir un utilisateur (pour les tests)
     * @param int $id
     * @throws SoapFault
     */
    protected function setAdminAs($id)
    {
    	$this->authenticate();

    	//Vérification des droits d'utilisation
    	if ( $this->User->profil != 'SuperAdministrateur' ) {
            throw new SoapFault('ERR', 'Accès non authorisé');
    	}

    	// Pour les SuperAdministrateur, voir l'application comme un login (id)

    }
}