First Smart Contract

//run me at https://ethereum.github.io/browser-solidity/#GIST_ID=abb4967f9a5fa3229b5bb2b65fa24562

contract signatureManagement {
    
    address[] signatureAllocatorPartner;
    mapping (address => uint) signatureAllocatorPartnerId;
    
    Mandate[] mandates;
    
    authorizedSigningPartnerForMandate[] authorisationsGranted;

    
    enum Frequence { Annual, SemiAnnual, Quarterly }

    event signatureAllocatorPartnerAdded(address newCommer);
    event signatureAllocatorPartnerDeleted(address leaver);
    event signatureAllocatorPartnerError(string Description);
    event mandatesError(string Description);
    
    //associé signataire pour un dossier 
    struct authorizedSigningPartnerForMandate{
        uint    startSigningPeriod;
        uint    endSigningPertiod;
        address signingPartnerAddress;
        uint    endTaintingPertiod;
    }
    
    //dossier d'audit
    struct Mandate {
        // dates in Solidity are Unix dates: seconds since 01/01/1970
        uint      ID;
        string    mandateName;
        uint      mandateStartDate;
        uint      mandateEndDate;
        Frequence mandateFrequence;
        bool      hasGrantedAuthorization;
        authorizedSigningPartnerForMandate grantedAuthorization;
    }
    
    function isSignatureAllocatorPartner(address Candidat) returns (bool result) {
        result = (signatureAllocatorPartner[signatureAllocatorPartnerId[Candidat]] == Candidat);
    }
    
    modifier onlySignatureAllocatorPartner { 
        if(!isSignatureAllocatorPartner(msg.sender))
            throw;
        _ 
    }
    
    // Créer le gestionnaire de signatures.
    function signatureManagement() {
        //la première personne à pouvoir autoriser des signatures est le
        //créateur du contrat.
        //Obligé de le faire à la main car sinon onlySignatureAllocatorPartner dit non !
        signatureAllocatorPartnerId[msg.sender] = signatureAllocatorPartner.length++;
        signatureAllocatorPartner[signatureAllocatorPartnerId[msg.sender]] = msg.sender;
    }
    
    //Désignation d'un membre du congrès
    function registerSignatureAllocatorPartner(address newCommer) 
    onlySignatureAllocatorPartner 
    {
        if(isSignatureAllocatorPartner(newCommer)){
            signatureAllocatorPartnerError("Signataire déjà enregistré.");
            return;
        }
        signatureAllocatorPartnerId[newCommer] = signatureAllocatorPartner.length++;
        signatureAllocatorPartner[signatureAllocatorPartnerId[newCommer]] = newCommer;
        // on lance un event ajout
        signatureAllocatorPartnerAdded(newCommer);
    }
    
    //Résiliation d'un membre du congrès
    function unRegisterSignatureAllocatorPartner(address leaver)
    onlySignatureAllocatorPartner
    {
        //a protéger je pense
        delete signatureAllocatorPartner[signatureAllocatorPartnerId[leaver]];
        delete signatureAllocatorPartnerId[leaver];
        signatureAllocatorPartnerDeleted(leaver);
    }
    
    function createMandate(string name, uint startDate, uint endDate) 
    onlySignatureAllocatorPartner 
    returns (uint ID) 
    {
        ID = mandates.length++;
        mandates[ID].mandateName = name;
        mandates[ID].mandateStartDate = startDate;
        mandates[ID].mandateEndDate = endDate;
        mandates[ID].hasGrantedAuthorization = false;
    }
    
    /*modification de la "base de données" descriptive des mandats
    function updateMandateDescription(uint ID, string name, uint startDate, uint endDate){
    
    }*/
    
    function GrantAuthorization(uint mandateID, address _signingPartnerAddress) 
    onlySignatureAllocatorPartner 
    {
        uint AuthorizationID = authorisationsGranted.length++;
        authorisationsGranted[AuthorizationID].signingPartnerAddress = _signingPartnerAddress;
        mandates[mandateID].grantedAuthorization = authorisationsGranted[AuthorizationID];
        mandates[mandateID].hasGrantedAuthorization = true; 
    }
    
    /*modification des associés signataires
    function updateMandatesSigningPartners(uint ID, address main, address Second){
    
    }*/

    //fonction appelée par un Signataire pour s'assurer qu'il a le droit de signer 
    //le dossier [ID] à la date [signatureDate]
    function claimSignatureRight(uint ID) returns (bool okToSign) {
        if(ID>mandates.length){
            mandatesError("Mandat non existant");
            return false;
        }
        if(!mandates[ID].hasGrantedAuthorization){
            mandatesError("Aucune authorisation affectée"); // information protégér, ne devrait pas être révélée
            return false;
        }
        return (mandates[ID].grantedAuthorization.signingPartnerAddress == msg.sender);
    }
    
    //triggers events on mandates with no signingPartners or with
    // signingPartners.endSigningPeriod <= now 
    function identifyOrphanMandates(){
        
    }
    
    function whoAmI() returns (address msgSender){
        msgSender = msg.sender;
    }
    
}