private async Task Stampa(List <EmendamentiDto> listaEMendamenti, string path,
                                  PersonaDto utenteRichiedente)
        {
            try
            {
                var atto = await apiGateway.Atti.Get(_stampa.UIDAtto);

                if (_stampa.Da > 0 && _stampa.A > 0)
                {
                    listaEMendamenti = listaEMendamenti.GetRange(_stampa.Da - 1, _stampa.A - (_stampa.Da - 1));
                }

                var bodyCopertina = await apiGateway.Emendamento.GetCopertina(new CopertinaModel
                {
                    Atto        = atto,
                    TotaleEM    = listaEMendamenti.Count,
                    Ordinamento = _stampa.Ordine.HasValue
                        ? (OrdinamentoEnum)_stampa.Ordine.Value
                        : OrdinamentoEnum.Presentazione
                });

                var nameFilePDFCopertina = $"COPERTINAEM_{DateTime.Now:ddMMyyyy_hhmmss}.pdf";
                var DirCopertina         = Path.Combine(path, nameFilePDFCopertina);
                PdfStamper.CreaPDFCopertina(bodyCopertina, DirCopertina);
                await apiGateway.Stampe.AddInfo(_stampa.UIDStampa, "Copertina generata");

                var listaPdfEmendamentiGenerati =
                    await GeneraPDFEmendamenti(listaEMendamenti, path);

                var countNonGenerati = listaPdfEmendamentiGenerati.Count(item => !File.Exists(item.Value.Path));
                await apiGateway.Stampe.AddInfo(_stampa.UIDStampa, $"PDF NON GENERATI [{countNonGenerati}]");

                //Funzione che fascicola i PDF creati prima
                var nameFileTarget = $"Fascicolo_{DateTime.Now:ddMMyyyy_hhmmss}.pdf";
                var FilePathTarget = Path.Combine(path, nameFileTarget);
                PdfStamper.CreateMergedPDF(FilePathTarget, DirCopertina,
                                           listaPdfEmendamentiGenerati.ToDictionary(item => item.Key, item => item.Value.Path));
                await apiGateway.Stampe.AddInfo(_stampa.UIDStampa, "FASCICOLAZIONE COMPLETATA");

                var _pathStampe = Path.Combine(_model.CartellaLavoroStampe, nameFileTarget);
                Log.Debug($"[{_stampa.UIDStampa}] Percorso stampe {_pathStampe}");
                SpostaFascicolo(FilePathTarget, _pathStampe);

                var URLDownload = Path.Combine(_model.UrlCLIENT, $"stampe/{_stampa.UIDStampa}");
                _stampa.PathFile = nameFileTarget;
                await apiGateway.Stampe.JobUpdateFileStampa(_stampa);

                if (_stampa.Scadenza.HasValue)
                {
                    try
                    {
                        var bodyMail    = $"Gentile {utenteRichiedente.DisplayName},<br>la stampa richiesta sulla piattaforma PEM è disponibile al seguente link:<br><a href='{URLDownload}' target='_blank'>{URLDownload}</a>";
                        var resultInvio = await BaseGateway.SendMail(new MailModel
                        {
                            DA        = _model.EmailFrom,
                            A         = utenteRichiedente.email,
                            OGGETTO   = "Link download fascicolo",
                            MESSAGGIO = bodyMail
                        },
                                                                     _auth.jwt);

                        if (resultInvio)
                        {
                            await apiGateway.Stampe.JobSetInvioStampa(_stampa);
                        }
                    }
                    catch (Exception e)
                    {
                        Log.Debug($"[{_stampa.UIDStampa}] Invio mail", e);
                        await apiGateway.Stampe.AddInfo(_stampa.UIDStampa, $"Invio mail ERRORE. Motivo: {e.Message}");
                    }
                }
                else
                {
                    if (_stampa.Ordine.HasValue)
                    {
                        if ((OrdinamentoEnum)_stampa.Ordine.Value == OrdinamentoEnum.Presentazione)
                        {
                            atto.LinkFascicoloPresentazione = URLDownload;
                        }
                        if ((OrdinamentoEnum)_stampa.Ordine.Value == OrdinamentoEnum.Votazione)
                        {
                            atto.LinkFascicoloVotazione = URLDownload;
                        }
                        await apiGateway.Atti.ModificaFiles(atto);
                    }
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                throw e;
            }
        }
Exemplo n.º 2
0
        private async void DoWork()
        {
            var utenteRichiedente = await ApiGateway.GetPersona(stampa.UIDUtenteRichiesta);

            try
            {
                Log.Debug(
                    $"[{stampa.UIDStampa}] Utente Richiedente [{utenteRichiedente.DisplayName}], EMAIL [{utenteRichiedente.email}]");
                if (stampa.Tentativi < Convert.ToInt16(model.NumMaxTentativi))
                {
                    var dirFascicolo = $"Fascicolo_{stampa.UIDStampa}_{DateTime.Now:ddMMyyyy_hhmmss}";
                    var _pathTemp    = Path.Combine(model.CartellaLavoroTemporanea, dirFascicolo);
                    if (!Directory.Exists(_pathTemp))
                    {
                        Directory.CreateDirectory(_pathTemp);
                    }

                    var resultEmendamenti = await ApiGateway.JobGetEmendamenti(stampa.QueryEM, 1);

                    var has_next         = resultEmendamenti.Paging.Has_Next;
                    var listaEMendamenti = resultEmendamenti.Results.ToList();
                    while (has_next)
                    {
                        resultEmendamenti =
                            await ApiGateway.JobGetEmendamenti(stampa.QueryEM, resultEmendamenti.Paging.Page + 1);

                        has_next = resultEmendamenti.Paging.Has_Next;
                        listaEMendamenti.AddRange(resultEmendamenti.Results);
                    }

                    Log.Debug($"[{stampa.UIDStampa}] Totale EM [{listaEMendamenti.Count}]");

                    var atto = stampa.ATTI;

                    if (stampa.NotificaDepositoEM)
                    {
                        //STAMPA PDF DEPOSITATO (BACKGROUND MODE)
                        Log.Debug($"[{stampa.UIDStampa}] BACKGROUND MODE - Genera PDF Depositato");

                        var listaPdfEmendamentiGenerati =
                            await GeneraPDFEmendamenti(listaEMendamenti, stampa.Da, stampa.A, _pathTemp);

                        Log.Debug($"[{stampa.UIDStampa}] BACKGROUND MODE - Salva EM nel repository");

                        var em             = listaEMendamenti.First();
                        var dirSeduta      = $"Seduta_{atto.SEDUTE.Data_seduta:yyyyMMdd}";
                        var dirPDL         = Regex.Replace($"{atto.TIPI_ATTO.Tipo_Atto} {atto.NAtto}", @"[^0-9a-zA-Z]+", "_");
                        var pathRepository = $"{model.RootRepository}/{dirSeduta}/{dirPDL}";

                        if (!Directory.Exists(pathRepository))
                        {
                            Directory.CreateDirectory(pathRepository);
                        }

                        var destinazioneDeposito = Path.Combine(pathRepository,
                                                                Path.GetFileName(listaPdfEmendamentiGenerati.First().Value.Path));
                        SpostaFascicolo(listaPdfEmendamentiGenerati.First().Value.Path, destinazioneDeposito);
                        stampa.PathFile = Path.Combine($"{dirSeduta}/{dirPDL}",
                                                       Path.GetFileName(listaPdfEmendamentiGenerati.First().Value.Path));
                        stampa.UIDEM = em.UIDEM;
                        await ApiGateway.JobUpdateFileStampa(stampa);

                        var bodyMail = await ApiGateway.GetBodyEM(em.UIDEM, TemplateTypeEnum.MAIL, true);

                        if (atto.SEDUTE.Data_effettiva_inizio.HasValue)
                        {
                            var ruoloSegreteriaAssempblea =
                                await ApiGateway.GetRuolo(RuoliIntEnum.Segreteria_Assemblea);

                            Log.Debug(
                                $"[{stampa.UIDStampa}] BACKGROUND MODE - EM depositato il {listaEMendamenti.First().DataDeposito}");
                            if (Convert.ToDateTime(listaEMendamenti.First().DataDeposito) >
                                atto.SEDUTE.Data_effettiva_inizio.Value)
                            {
                                Log.Debug($"[{stampa.UIDStampa}] BACKGROUND MODE - Seduta già iniziata");

                                await ApiGateway.SendMail(new MailModel
                                {
                                    DA      = model.EmailFrom,
                                    A       = $"{ruoloSegreteriaAssempblea.ADGroupShort}@consiglio.regione.lombardia.it",
                                    OGGETTO =
                                        $"[TRATTAZIONE AULA] {atto.TIPI_ATTO.Tipo_Atto} {atto.NAtto}: Depositato {listaEMendamenti.First().DisplayTitle}",
                                    MESSAGGIO = bodyMail
                                });
                            }
                        }
                        else
                        {
                            Log.Debug($"[{stampa.UIDStampa}] BACKGROUND MODE - Seduta non è ancora iniziata");
                        }

                        var email_destinatari       = $"{utenteRichiedente.email};[email protected]";
                        var email_destinatariGruppo = string.Empty;
                        var email_destinatariGiunta = string.Empty;

                        if (em.id_gruppo > 10000)
                        {
                            Log.Debug(
                                $"[{stampa.UIDStampa}] BACKGROUND MODE - Invio mail a Capo Gruppo e Segreteria Politica");
                            var capoGruppo = await ApiGateway.GetCapoGruppo(em.id_gruppo);

                            var segreteriaPolitica = await ApiGateway.GetSegreteriaPolitica(em.id_gruppo, false, true);

                            if (segreteriaPolitica.Any())
                            {
                                email_destinatariGruppo = segreteriaPolitica.Select(u => u.email)
                                                          .Aggregate((i, j) => $"{i};{j}");
                            }
                            if (capoGruppo != null)
                            {
                                email_destinatariGruppo += $";{capoGruppo.email}";
                            }
                        }
                        else
                        {
                            Log.Debug($"[{stampa.UIDStampa}] BACKGROUND MODE - Invio mail a Giunta Regionale");
                            var giuntaRegionale = await ApiGateway.GetGiuntaRegionale();

                            var segreteriaGiuntaRegionale = await ApiGateway.GetSegreteriaGiuntaRegionale(false, true);

                            if (segreteriaGiuntaRegionale.Any())
                            {
                                email_destinatariGiunta += segreteriaGiuntaRegionale.Select(u => u.email)
                                                           .Aggregate((i, j) => $"{i};{j}");
                            }
                            if (giuntaRegionale.Any())
                            {
                                email_destinatariGiunta +=
                                    giuntaRegionale.Select(u => u.email).Aggregate((i, j) => $"{i};{j}");
                            }
                        }

                        if (!string.IsNullOrEmpty(email_destinatariGruppo))
                        {
                            email_destinatari += ";" + email_destinatariGruppo;
                        }
                        if (!string.IsNullOrEmpty(email_destinatariGiunta))
                        {
                            email_destinatari += ";" + email_destinatariGiunta;
                        }

                        var resultInvio = await ApiGateway.SendMail(new MailModel
                        {
                            DA      = model.EmailFrom,
                            A       = email_destinatari,
                            OGGETTO =
                                $"{atto.TIPI_ATTO.Tipo_Atto} {atto.NAtto}: Depositato {listaEMendamenti.First().DisplayTitle}",
                            MESSAGGIO      = bodyMail,
                            pathAttachment = destinazioneDeposito,
                            IsDeposito     = true
                        });

                        if (resultInvio)
                        {
                            await ApiGateway.JobSetInvioStampa(stampa);
                        }
                    }
                    else
                    {
                        //STAMPA - STANDARD MODE
                        Log.Debug($"[{stampa.UIDStampa}] STANDARD MODE - Genera PDF");

                        var bodyCopertina = await ApiGateway.GetCopertina(new CopertinaModel
                        {
                            Atto        = atto,
                            TotaleEM    = listaEMendamenti.Count,
                            Ordinamento = stampa.Ordine.HasValue
                                ? (OrdinamentoEnum)stampa.Ordine.Value
                                : OrdinamentoEnum.Presentazione
                        });

                        var nameFilePDFCopertina = $"COPERTINAEM_{DateTime.Now:ddMMyyyy_hhmmss}.pdf";
                        var DirCopertina         = Path.Combine(_pathTemp, nameFilePDFCopertina);
                        PdfStamper.CreaPDFCopertina(bodyCopertina, DirCopertina);

                        var listaPdfEmendamentiGenerati =
                            await GeneraPDFEmendamenti(listaEMendamenti, stampa.Da, stampa.A, _pathTemp);

                        var countNonGenerati = listaPdfEmendamentiGenerati.Count(item => !File.Exists(item.Value.Path));
                        Log.Debug($"PDF NON GENERATI [{countNonGenerati}]");

                        //Funzione che fascicola i PDF creati prima
                        var nameFileTarget = $"Fascicolo_{DateTime.Now:ddMMyyyy_hhmmss}.pdf";
                        var FilePathTarget = Path.Combine(_pathTemp, nameFileTarget);
                        PdfStamper.CreateMergedPDF(FilePathTarget, DirCopertina,
                                                   listaPdfEmendamentiGenerati.ToDictionary(item => item.Key, item => item.Value.Path));
                        var _pathStampe = Path.Combine(model.CartellaLavoroStampe, nameFileTarget);
                        Log.Debug($"[{stampa.UIDStampa}] Percorso stampe {_pathStampe}");
                        SpostaFascicolo(FilePathTarget, _pathStampe);

                        var LinkFile = Path.Combine(model.CartellaStampeLink, nameFileTarget);
                        //Funzione che genera il LINK per il download del documento appena creato
                        var URLDownload = Path.Combine(model.urlCLIENT, LinkFile);
                        //Funzione che genera il LINK per il download del documento appena creato
                        stampa.PathFile = nameFileTarget;
                        await ApiGateway.JobUpdateFileStampa(stampa);

                        if (stampa.Scadenza.HasValue)
                        {
                            var resultInvio = await ApiGateway.SendMail(new MailModel
                            {
                                DA        = model.EmailFrom,
                                A         = utenteRichiedente.email,
                                OGGETTO   = "Link download fascicolo",
                                MESSAGGIO = URLDownload
                            });

                            if (resultInvio)
                            {
                                await ApiGateway.JobSetInvioStampa(stampa);
                            }
                        }
                        else
                        {
                            if (stampa.Ordine.HasValue)
                            {
                                if ((OrdinamentoEnum)stampa.Ordine.Value == OrdinamentoEnum.Presentazione)
                                {
                                    atto.LinkFascicoloPresentazione = URLDownload;
                                }
                                if ((OrdinamentoEnum)stampa.Ordine.Value == OrdinamentoEnum.Votazione)
                                {
                                    atto.LinkFascicoloVotazione = URLDownload;
                                }
                                await ApiGateway.ModificaFilesAtto(atto);
                            }
                        }
                    }

                    PulisciCartellaLavoroTemporanea(_pathTemp);
                }
                else
                {
                    await ApiGateway.SendMail(new MailModel
                    {
                        DA        = model.EmailFrom,
                        A         = utenteRichiedente.email,
                        OGGETTO   = "Errore generazione stampa",
                        MESSAGGIO = $"ID stampa: [{stampa.UIDStampa}], per l'atto: [{stampa.UIDAtto}]"
                    });
                }
            }
            catch (Exception ex)
            {
                Log.Error($"[{stampa.UIDStampa}] ERROR", ex);
                try
                {
                    await ApiGateway.JobErrorStampa(stampa.UIDStampa, ex.Message);

                    await ApiGateway.JobUnLockStampa(stampa.UIDStampa);
                }
                catch (Exception ex2)
                {
                    Log.Error($"[{stampa.UIDStampa}] ERROR", ex2);
                    try
                    {
                        await ApiGateway.SendMail(new MailModel
                        {
                            DA        = model.EmailFrom,
                            A         = utenteRichiedente.email,
                            OGGETTO   = "Errore generazione fascicolo",
                            MESSAGGIO = ex.Message
                        });
                    }
                    catch (Exception exMail)
                    {
                        Log.Error($"[{stampa.UIDStampa}] ERROR", exMail);
                        await ApiGateway.JobErrorStampa(stampa.UIDStampa, exMail.Message);
                    }
                }
            }
        }