/**
         * Processo reale di trasferimento immagini
         */
        protected override void Work()
        {
            int      conta     = 0;
            DateTime oraInizio = DateTime.Now;

            _giornale.Debug("Inizio a clonare le foto");

            _esitoScarico = new EsitoScarico();

            // trasferisco tutti i files elencati
            foreach (Fotografia foto in fotografie)
            {
                if (clonaAsincronoUnFile(foto.nomeFile, foto.nomeFile))
                {
                    ++conta;
                }
            }


            // Nel log scrivo anche il tempo che ci ho messo a scaricare le foto. Mi servirà per profilare
            TimeSpan tempoImpiegato = DateTime.Now.Subtract(oraInizio);

            _giornale.Info("Terminato trasferimento di " + conta + " foto. Tempo impiegato = " + tempoImpiegato);


            // Deve essere già aperto
            using (new UnitOfWorkScope(true)) {
                // ::: Ultima fase eleboro le foto memorizzando nel db e creando le dovute cache
                _elaboraImmaginiAcquisiteCallback.Invoke(_esitoScarico);
            }
        }
Exemple #2
0
        private void elaboraFotoAcquisite(EsitoScarico esitoScarico)
        {
            _giornale.Debug("Inizio elaboraFotoAcquisite()");

            StringBuilder msg = new StringBuilder();

            if (esitoScarico.riscontratiErrori)
            {
                msg.AppendFormat("Errore in acquisizione {0} foto. Verificare!", esitoScarico.totFotoCopiateOk);
            }
            else
            {
                msg.AppendFormat("Scaricate OK {0} foto.", +esitoScarico.totFotoCopiateOk);
            }
            msg.Append(" Togliere la card");

            ScaricoFotoMsg scaricoFotoMsg = new ScaricoFotoMsg(this, msg.ToString());

            scaricoFotoMsg.esitoScarico = esitoScarico;
            scaricoFotoMsg.esito        = esitoScarico.riscontratiErrori ? Esito.Errore : Esito.Ok;
            // Finito: genero un evento per notificare che l'utente può togliere la flash card.
            scaricoFotoMsg.fase            = FaseScaricoFoto.FineScarico;
            scaricoFotoMsg.sorgente        = _paramScarica.cartellaSorgente != null ? _paramScarica.cartellaSorgente : _paramScarica.nomeFileSingolo;
            scaricoFotoMsg.showInStatusBar = true;

            // battezzo la flashcard al fotografo corrente
            battezzaFlashCard(_paramScarica);

            // Se il drive che ho appena scaricato è rimovibile, allora lo smonto
            // Richiesta di Ciccio del 29-03-2018 non smontiamo piu la card
            // smontaSeRimovibile();



            // Rendo pubblico l'esito dello scarico in modo che la UI possa notificare l'utente di togliere
            // la flash card.

            /*
             * per l'onride mi serve che lanci il msg anche su un solo file
             * però mi pare che nessuno utilizzi il modo singolo. quindi lo pubblico sempre
             *
             * if( _paramScarica.nomeFileSingolo == null && _paramScarica.cartellaSorgente != null )
             */
            pubblicaMessaggio(scaricoFotoMsg);

            _giornale.Debug("Scaricate " + esitoScarico.totFotoCopiateOk + " foto. Si può togliere la card");

            // -- inizio elaborazione

            ElaboratoreFotoAcquisite elab = new ElaboratoreFotoAcquisite(esitoScarico.fotoDaLavorare, _paramScarica);

            statoScarica = StatoScarica.Provinatura;
            elab.elabora(esitoScarico.tempo);

            _giornale.Debug("Elaborazione terminata. Inserite " + elab.contaAggiunteDb + " foto nel database");

            statoScarica = StatoScarica.Idle;

            // Rendo pubblico l'esito dell'elaborazione così che si può aggiornare la libreria.
            scaricoFotoMsg.esitoScarico.totFotoProvinate = elab.contaAggiunteDb;
            if (scaricoFotoMsg.esitoScarico.totFotoProvinate != scaricoFotoMsg.esitoScarico.totFotoScaricate)
            {
                scaricoFotoMsg.esitoScarico.riscontratiErrori = true;
            }

            scaricoFotoMsg.fase            = FaseScaricoFoto.FineLavora;
            scaricoFotoMsg.descrizione     = "Provinatura foto terminata. Inserite " + elab.contaAggiunteDb + " foto nel database";
            scaricoFotoMsg.showInStatusBar = true;
            pubblicaMessaggio(scaricoFotoMsg);

            // Chiudo il worker che ha finito il suo lavoro
            // _copiaImmaginiWorker.Stop();


            // Faccio un controllo: Se le foto scaricate non coincidono con quelle elaborate (ovvero scritte nel db e provinate)
            // Allora c'è stato un problema. Devo avvisare l'utente di ricostruire il database
            bool problemiInVista = (esitoScarico.riscontratiErrori || esitoScarico.totFotoCopiateOk != elab.contaAggiunteDb);

            if (problemiInVista)
            {
                // TODO stampare nel log tutto l'oggetto EsitoScarico
                _giornale.Warn(String.Format("Riscontrata incongruenza database. copiate={0} elab={1}", esitoScarico.totFotoCopiateOk, elab.contaAggiunteDb));

                RilevataInconsistenzaDatabaseMsg inconsistenzaMsg = new RilevataInconsistenzaDatabaseMsg(this);
                inconsistenzaMsg.descrizione          = "Inconsistenza database. Lanciare ricostruzione!";
                inconsistenzaMsg.showInStatusBar      = true;
                inconsistenzaMsg.giornataDaVerificare = LumenApplication.Instance.stato.giornataLavorativa;
                pubblicaMessaggio(inconsistenzaMsg);
            }
        }
Exemple #3
0
        /**
         * Processo reale di trasferimento immagini
         */
        protected override void Work()
        {
            int conta = 0;



            _giornale.Debug("Inizio a trasferire le foto da " + _paramScarica.cartellaSorgente);



            string nomeDirDest = calcolaCartellaDestinazione();

            // Creo la cartella che conterrà le foto
            Directory.CreateDirectory(nomeDirDest);

            // Creo la cartella che conterrà i provini
            PathUtil.creaCartellaProvini(new FileInfo(nomeDirDest));

            _esitoScarico = new EsitoScarico();

            ScaricoFotoMsg scaricoFotoMsg = new ScaricoFotoMsg(this, "Notifica progresso");

            scaricoFotoMsg.fase            = FaseScaricoFoto.Scaricamento;
            scaricoFotoMsg.esitoScarico    = _esitoScarico;
            scaricoFotoMsg.sorgente        = _paramScarica.cartellaSorgente != null ? _paramScarica.cartellaSorgente : _paramScarica.nomeFileSingolo;
            scaricoFotoMsg.showInStatusBar = false;

            try {
                if (_paramScarica.nomeFileSingolo != null)
                {
                    // Lavoro un solo file che mi è stato indicato. Serve per creare una maschera quando lavoro con le cornici.
                    if (scaricaAsincronoUnFile(_paramScarica.nomeFileSingolo, nomeDirDest))
                    {
                        ++conta;
                        if (conta % 20 == 0)
                        {
                            scaricoFotoMsg.esitoScarico.totFotoScaricateProg = conta;
                            LumenApplication.Instance.bus.Publish(scaricoFotoMsg);
                        }
                    }
                    else
                    {
                        // La copia di questo file non è andata a buon fine
                        _esitoScarico.riscontratiErrori = true;
                    }
                }
                else
                {
                    // Faccio giri diversi per i vari formati grafici che sono indicati nella configurazione (jpg, tif)
                    string[] estensioni = Configurazione.UserConfigLumen.estensioniGrafiche.Split(';');
                    foreach (string estensione in estensioni)
                    {
                        string[] files = Directory.GetFiles(_paramScarica.cartellaSorgente, searchPattern: "*" + estensione, searchOption: SearchOption.AllDirectories);

                        // trasferisco tutti i files elencati
                        foreach (string nomeFileSrc in files)
                        {
                            if (scaricaAsincronoUnFile(nomeFileSrc, nomeDirDest))
                            {
                                ++conta;
                                if (conta % 20 == 0)
                                {
                                    scaricoFotoMsg.esitoScarico.totFotoScaricateProg = conta;
                                    LumenApplication.Instance.bus.Publish(scaricoFotoMsg);
                                }
                            }
                            else
                            {
                                // La copia di questo file non è andata a buon fine
                                _esitoScarico.riscontratiErrori = true;
                            }
                        }
                    }
                }
            } catch (Exception qq) {
                // Se casco qui, probabilmente è perché è stata sfilata la memorycard prima che sia completato lo scarico.
                _esitoScarico.riscontratiErrori = true;
                _giornale.Error("Errore imprevisto durante scarico card", qq);
            }

            if (conta != 0)
            {
                scaricoFotoMsg.esitoScarico.totFotoScaricate     = conta;
                scaricoFotoMsg.esitoScarico.totFotoScaricateProg = conta;
                LumenApplication.Instance.bus.Publish(scaricoFotoMsg);
            }

            // Nel log scrivo anche il tempo che ci ho messo a scaricare le foto. Mi servirà per profilare
            TimeSpan tempoImpiegato = DateTime.Now.Subtract(_esitoScarico.tempo);

            _giornale.Info("Terminato trasferimento di " + conta + " foto. Tempo impiegato = " + tempoImpiegato);


            // Deve essere già aperto
            using (new UnitOfWorkScope(true)) {
                // ::: Ultima fase eleboro le foto memorizzando nel db e creando le dovute cache
                _elaboraImmaginiAcquisiteCallback.Invoke(_esitoScarico);
            }

            _giornale.Debug("Terminato background worker per copia files");
        }