Exemple #1
0
 public GetHashDocumentoResponse GetHashDocumento(GetHashDocumentoRequest request)
 {
     object[] results = this.Invoke("GetHashDocumento", new object[] {
         request
     });
     return((GetHashDocumentoResponse)(results[0]));
 }
Exemple #2
0
 /// <remarks/>
 public void GetHashDocumentoAsync(GetHashDocumentoRequest request, object userState)
 {
     if ((this.GetHashDocumentoOperationCompleted == null))
     {
         this.GetHashDocumentoOperationCompleted = new System.Threading.SendOrPostCallback(this.OnGetHashDocumentoOperationCompleted);
     }
     this.InvokeAsync("GetHashDocumento", new object[] {
         request
     }, this.GetHashDocumentoOperationCompleted, userState);
 }
Exemple #3
0
 /// <remarks/>
 public void GetHashDocumentoAsync(GetHashDocumentoRequest request)
 {
     this.GetHashDocumentoAsync(request, null);
 }
Exemple #4
0
        /// <summary>
        ///
        /// </summary>
        /// <returns></returns>
        private void Verifica()
        {
            this.CheckIstanzaConservazione();

            // TODO: Verifica validità firma del file di chiusura

            // TODO: Verifica validità marca del file di chiusura

            Double percentuale;

            Double.TryParse(this.PercentualeVerifica, out percentuale);


            this.UpdateProgress(0, "Individuazione file di chiusura istanza in corso...");
            Application.DoEvents();

            XmlDocument xmlFile = new XmlDocument();

            xmlFile.Load(this.PathFileChiusuraXML);

            // Per la conservazione l'url del file xml da leggere deve essere quello in cui ha fatto download dell'istanza
            string idIstanzaFileChiusura = this.GetIdIstanza(xmlFile);

            if (idIstanzaFileChiusura != this.IdIstanza)
            {
                throw new ApplicationException("Il file di chiusura non corrisponde all'istanza richiesta. Il supporto non è valido.");
            }

            // Reperimento nodi relativi ai files
            XmlNode[] nodiDocumento = this.GetNodiDocumento(xmlFile);


            this.UpdateProgress(0, "Connessione al servizio per la verifica di integrità dei documenti in corso...");
            Application.DoEvents();

            using (Proxy.IntegritaServices services = new Proxy.IntegritaServices())
            {
                services.Url = this.ServiceUrl;

                // Numero totali di documenti che fanno parte dell'istanza
                int numeroDocumenti = nodiDocumento.Length;

                // Numero di documenti di cui voglio verificare l'impronta
                int n = 0;

                if (percentuale < 100)
                {
                    n = ((int)percentuale * numeroDocumenti / 100);

                    if (n == 0)
                    {
                        n = n + 1;
                    }
                }
                else
                {
                    n = numeroDocumenti;
                }

                // Genero una sequenza di numeri casuali senza ripetizione compresi tra 0 e numeroDocumenti-1
                int[] numeriCasuali = this.EseguiEstrazioneRandom(numeroDocumenti);

                // Verifico l'impronta di n documenti tra quelli presenti nel supporto e calcolo la percentuale di quelli che nn sono stati corrotti
                int contatore = 0;

                int countValidDocuments = 0;

                for (int i = 0; i < n; i++)
                {
                    this.UpdateProgress((contatore * 100 / numeroDocumenti), string.Format("Verifica integrità documento {0} di {1} in corso...", (i + 1), n));

                    if (this._interrompi)
                    {
                        if (MessageBox.Show("Interrompere la verifica del supporto?", this.Text, MessageBoxButtons.OKCancel, MessageBoxIcon.Question, MessageBoxDefaultButton.Button2) == System.Windows.Forms.DialogResult.OK)
                        {
                            throw new ApplicationException(string.Format("Verifica interrotta dall'utente. Analizzati {0} documenti su {1}.", i, n));
                        }
                        else
                        {
                            this._interrompi = false;
                        }
                    }

                    //prendo l'impronta del nodo con posizione tra quelli generati in maniera casuale
                    int         indiceNodo = numeriCasuali[i];
                    XmlNode     nodoDoc    = ((XmlNode)nodiDocumento[indiceNodo]);
                    XmlNodeList childList  = (XmlNodeList)nodoDoc.ChildNodes;

                    //verifico che l'impronta del documento e dei suoi allegati corrisponda a quella originale
                    string improntaCalcolata;
                    string idDocumento;

                    this.UpdateProgress((contatore * 100 / numeroDocumenti),
                                        string.Format("Verifica impronta documento {0} di {1} su supporto fisico in corso...", (i + 1), n));

                    bool verifyImpronta = this.VerificaImprontaFile(childList, out improntaCalcolata, out idDocumento);

                    if (verifyImpronta)
                    {
                        Proxy.GetHashDocumentoRequest request = new Proxy.GetHashDocumentoRequest
                        {
                            IdDocumento = idDocumento,
                            IdPeople    = this.IdPeople
                        };

                        this.UpdateProgress((contatore * 100 / numeroDocumenti),
                                            string.Format("Verifica impronta documento {0} di {1} su repository in corso...", (i + 1), n));

                        Proxy.GetHashDocumentoResponse resp = services.GetHashDocumento(request);

                        if (resp.Success)
                        {
                            if (resp.HashDatabase == resp.HashRepository)
                            {
                                if (improntaCalcolata == resp.HashDatabase)
                                {
                                    countValidDocuments++;
                                }
                            }
                        }
                    }

                    contatore = contatore + 1;

                    this.UpdateProgress((contatore * 100 / numeroDocumenti),
                                        string.Format("Verifica integrità documento {0} di {1} effettuata.", (i + 1), n));

                    Application.DoEvents();
                }

                if (countValidDocuments == n)
                {
                    this.Success      = true;
                    this.ErrorMessage = string.Empty;
                }
                else
                {
                    this.Success = false;

                    int invalidDocuments = (contatore - countValidDocuments);

                    string msg = string.Empty;

                    if (invalidDocuments > 1)
                    {
                        msg = "Individuati {0} documenti corrotti. Il supporto risulta danneggiato.";
                    }
                    else
                    {
                        msg = "Individuato {0} documento corrotto. Il supporto risulta danneggiato.";
                    }

                    this.ErrorMessage = string.Format(msg, invalidDocuments);
                }

                if (!this._interrompi)
                {
                    this.btnAnnulla.Text = "&Chiudi";
                    this._finito         = true;
                }
            }

            this._interrompi = false;
        }