Beispiel #1
0
        public List <MD_GRUPPOModel> CreaNuovoGruppo(string Gruppo)
        {
            List <MD_GRUPPOModel> gruppi = new List <MD_GRUPPOModel>();
            MailDispatcherDS      ds     = new MailDispatcherDS();

            using (MailDispatcherBusiness bMD = new MailDispatcherBusiness())
            {
                bMD.FillMD_GRUPPI(ds);
                if (!ds.MD_GRUPPI.Any(x => x.NOME.Trim() == Gruppo.Trim()))
                {
                    MailDispatcherDS.MD_GRUPPIRow gruppoRow = ds.MD_GRUPPI.NewMD_GRUPPIRow();
                    gruppoRow.NOME = Gruppo;
                    ds.MD_GRUPPI.AddMD_GRUPPIRow(gruppoRow);
                    bMD.UpdateMailDispatcherDSTable(ds.MD_GRUPPI.TableName, ds);
                }

                ds.Clear();
                bMD.FillMD_GRUPPI(ds);
                bMD.FillMD_GRUPPI_DESTINATARI(ds);
                bMD.FillMD_GRUPPI_RICHIEDENTI(ds);
                bMD.FillMD_RICHIEDENTI(ds);

                foreach (MailDispatcherDS.MD_GRUPPIRow gruppo in ds.MD_GRUPPI)
                {
                    MD_GRUPPOModel gr = CreaGruppoModel(ds, gruppo.IDGRUPPO);
                    gruppi.Add(gr);
                }
            }

            return(gruppi);
        }
Beispiel #2
0
        public List <MD_RICHIEDENTEModel> RimuoviGruppoRichiedente(decimal IDGRRICH)
        {
            List <MD_RICHIEDENTEModel> richiedenti = new List <MD_RICHIEDENTEModel>();
            MailDispatcherDS           ds          = new MailDispatcherDS();

            using (MailDispatcherBusiness bMD = new MailDispatcherBusiness())
            {
                bMD.FillMD_GRUPPI_RICHIEDENTI(ds);
                foreach (MailDispatcherDS.MD_GRUPPI_RICHIEDENTIRow row in ds.MD_GRUPPI_RICHIEDENTI.Where(x => x.IDGRRICH == IDGRRICH))
                {
                    row.Delete();
                }

                bMD.UpdateMailDispatcherDSTable(ds.MD_GRUPPI_RICHIEDENTI.TableName, ds);
                ds.MD_GRUPPI_RICHIEDENTI.Clear();

                bMD.FillMD_GRUPPI(ds);
                bMD.FillMD_GRUPPI_DESTINATARI(ds);
                bMD.FillMD_GRUPPI_RICHIEDENTI(ds);
                bMD.FillMD_RICHIEDENTI(ds);

                foreach (MailDispatcherDS.MD_RICHIEDENTIRow richiedente in ds.MD_RICHIEDENTI)
                {
                    MD_RICHIEDENTEModel ri = CreaRichiedenteModel(ds, richiedente.IDRICHIEDENTE);
                    richiedenti.Add(ri);
                }
            }

            return(richiedenti);
        }
Beispiel #3
0
        public List <MD_RICHIEDENTEModel> AggiungiGruppoRichiedente(decimal IDRICHIEDENTE, decimal IDGRUPPO, bool CC)
        {
            List <MD_RICHIEDENTEModel> richiedenti = new List <MD_RICHIEDENTEModel>();
            MailDispatcherDS           ds          = new MailDispatcherDS();

            using (MailDispatcherBusiness bMD = new MailDispatcherBusiness())
            {
                bMD.FillMD_GRUPPI_RICHIEDENTI(ds);
                if (!ds.MD_GRUPPI_RICHIEDENTI.Any(x => x.IDRICHIEDENTE == IDRICHIEDENTE && x.IDGRUPPO == IDGRUPPO))
                {
                    MailDispatcherDS.MD_GRUPPI_RICHIEDENTIRow grRow = ds.MD_GRUPPI_RICHIEDENTI.NewMD_GRUPPI_RICHIEDENTIRow();
                    grRow.IDGRUPPO      = IDGRUPPO;
                    grRow.IDRICHIEDENTE = IDRICHIEDENTE;
                    grRow.A_CC          = CC ? "1" : "0";
                    ds.MD_GRUPPI_RICHIEDENTI.AddMD_GRUPPI_RICHIEDENTIRow(grRow);
                }

                bMD.UpdateMailDispatcherDSTable(ds.MD_GRUPPI_RICHIEDENTI.TableName, ds);
                ds.MD_GRUPPI_RICHIEDENTI.Clear();

                bMD.FillMD_GRUPPI(ds);
                bMD.FillMD_GRUPPI_DESTINATARI(ds);
                bMD.FillMD_GRUPPI_RICHIEDENTI(ds);
                bMD.FillMD_RICHIEDENTI(ds);

                foreach (MailDispatcherDS.MD_RICHIEDENTIRow richiedente in ds.MD_RICHIEDENTI)
                {
                    MD_RICHIEDENTEModel ri = CreaRichiedenteModel(ds, richiedente.IDRICHIEDENTE);
                    richiedenti.Add(ri);
                }
            }

            return(richiedenti);
        }
Beispiel #4
0
        public List <MD_GRUPPO_DESTINATARIOModel> AggiungiDestinatario(decimal IDGRUPPO, string Destinatario)
        {
            MailDispatcherDS ds = new MailDispatcherDS();

            using (MailDispatcherBusiness bMD = new MailDispatcherBusiness())
            {
                bMD.FillMD_GRUPPI_DESTINATARI(ds);
                if (!ds.MD_GRUPPI_DESTINATARI.Any(x => x.IDGRUPPO == IDGRUPPO && x.DESTINATARIO == Destinatario.Trim()))
                {
                    MailDispatcherDS.MD_GRUPPI_DESTINATARIRow destinatario = ds.MD_GRUPPI_DESTINATARI.NewMD_GRUPPI_DESTINATARIRow();
                    destinatario.IDGRUPPO     = IDGRUPPO;
                    destinatario.DESTINATARIO = Destinatario;
                    ds.MD_GRUPPI_DESTINATARI.AddMD_GRUPPI_DESTINATARIRow(destinatario);

                    bMD.UpdateMailDispatcherDSTable(ds.MD_GRUPPI_DESTINATARI.TableName, ds);
                }

                ds.Clear();
                bMD.FillMD_GRUPPI(ds);
                bMD.FillMD_GRUPPI_DESTINATARI(ds);
                bMD.FillMD_GRUPPI_RICHIEDENTI(ds);
                bMD.FillMD_RICHIEDENTI(ds);

                bMD.UpdateMailDispatcherDSTable(ds.MD_GRUPPI_DESTINATARI.TableName, ds);
                ds.MD_GRUPPI_DESTINATARI.AcceptChanges();

                MailDispatcherDS.MD_GRUPPIRow gruppo = ds.MD_GRUPPI.Where(x => x.IDGRUPPO == IDGRUPPO).FirstOrDefault();
                MD_GRUPPOModel gr = CreaGruppoModel(ds, IDGRUPPO);

                return(gr.Destinatari);
            }
        }
Beispiel #5
0
        public List <MD_RICHIEDENTEModel> CreaNuovoRichiedente(string Richiedente)
        {
            List <MD_RICHIEDENTEModel> richiedenti = new List <MD_RICHIEDENTEModel>();
            MailDispatcherDS           ds          = new MailDispatcherDS();

            using (MailDispatcherBusiness bMD = new MailDispatcherBusiness())
            {
                bMD.FillMD_RICHIEDENTI(ds);
                if (!ds.MD_RICHIEDENTI.Any(x => x.RICHIEDENTE.Trim() == Richiedente.Trim()))
                {
                    MailDispatcherDS.MD_RICHIEDENTIRow row = ds.MD_RICHIEDENTI.NewMD_RICHIEDENTIRow();
                    row.RICHIEDENTE = Richiedente;
                    ds.MD_RICHIEDENTI.AddMD_RICHIEDENTIRow(row);
                    bMD.UpdateMailDispatcherDSTable(ds.MD_RICHIEDENTI.TableName, ds);
                }

                ds.Clear();
                bMD.FillMD_GRUPPI(ds);
                bMD.FillMD_GRUPPI_DESTINATARI(ds);
                bMD.FillMD_GRUPPI_RICHIEDENTI(ds);
                bMD.FillMD_RICHIEDENTI(ds);

                foreach (MailDispatcherDS.MD_RICHIEDENTIRow richiedente in ds.MD_RICHIEDENTI)
                {
                    MD_RICHIEDENTEModel ri = CreaRichiedenteModel(ds, richiedente.IDRICHIEDENTE);
                    richiedenti.Add(ri);
                }
            }

            return(richiedenti);
        }
Beispiel #6
0
        public List <MD_GRUPPOModel> RimuoviGruppo(decimal IDGRUPPO)
        {
            List <MD_GRUPPOModel> gruppi = new List <MD_GRUPPOModel>();
            MailDispatcherDS      ds     = new MailDispatcherDS();

            using (MailDispatcherBusiness bMD = new MailDispatcherBusiness())
            {
                bMD.FillMD_GRUPPI(ds);
                bMD.FillMD_GRUPPI_DESTINATARI(ds);
                bMD.FillMD_GRUPPI_RICHIEDENTI(ds);
                bMD.FillMD_RICHIEDENTI(ds);

                foreach (MailDispatcherDS.MD_GRUPPI_RICHIEDENTIRow gra in ds.MD_GRUPPI_RICHIEDENTI.Where(x => x.IDGRUPPO == IDGRUPPO))
                {
                    gra.Delete();
                }

                foreach (MailDispatcherDS.MD_GRUPPI_DESTINATARIRow grd in ds.MD_GRUPPI_DESTINATARI.Where(x => x.IDGRUPPO == IDGRUPPO))
                {
                    grd.Delete();
                }

                foreach (MailDispatcherDS.MD_GRUPPIRow gr in ds.MD_GRUPPI.Where(x => x.IDGRUPPO == IDGRUPPO))
                {
                    gr.Delete();
                }

                bMD.UpdateMailDispatcherDSTable(ds.MD_GRUPPI_RICHIEDENTI.TableName, ds);
                bMD.UpdateMailDispatcherDSTable(ds.MD_GRUPPI_DESTINATARI.TableName, ds);
                bMD.UpdateMailDispatcherDSTable(ds.MD_GRUPPI.TableName, ds);

                ds.Clear();
                bMD.FillMD_GRUPPI(ds);
                bMD.FillMD_GRUPPI_DESTINATARI(ds);
                bMD.FillMD_GRUPPI_RICHIEDENTI(ds);
                bMD.FillMD_RICHIEDENTI(ds);

                foreach (MailDispatcherDS.MD_GRUPPIRow gruppo in ds.MD_GRUPPI)
                {
                    MD_GRUPPOModel gr = CreaGruppoModel(ds, gruppo.IDGRUPPO);
                    gruppi.Add(gr);
                }
            }

            return(gruppi);
        }
Beispiel #7
0
        public List <MD_GRUPPOModel> LeggiGruppi()
        {
            List <MD_GRUPPOModel> gruppi = new List <MD_GRUPPOModel>();
            MailDispatcherDS      ds     = new MailDispatcherDS();

            using (MailDispatcherBusiness bMD = new MailDispatcherBusiness())
            {
                bMD.FillMD_GRUPPI(ds);
                bMD.FillMD_GRUPPI_DESTINATARI(ds);
                bMD.FillMD_GRUPPI_RICHIEDENTI(ds);
                bMD.FillMD_RICHIEDENTI(ds);

                foreach (MailDispatcherDS.MD_GRUPPIRow gruppo in ds.MD_GRUPPI)
                {
                    MD_GRUPPOModel gr = CreaGruppoModel(ds, gruppo.IDGRUPPO);
                    gruppi.Add(gr);
                }
            }

            return(gruppi);
        }
Beispiel #8
0
        public List <MD_RICHIEDENTEModel> LeggiRichiedenti()
        {
            List <MD_RICHIEDENTEModel> richiedenti = new List <MD_RICHIEDENTEModel>();
            MailDispatcherDS           ds          = new MailDispatcherDS();

            using (MailDispatcherBusiness bMD = new MailDispatcherBusiness())
            {
                bMD.FillMD_GRUPPI(ds);
                bMD.FillMD_GRUPPI_DESTINATARI(ds);
                bMD.FillMD_GRUPPI_RICHIEDENTI(ds);
                bMD.FillMD_RICHIEDENTI(ds);

                foreach (MailDispatcherDS.MD_RICHIEDENTIRow richiedente in ds.MD_RICHIEDENTI)
                {
                    MD_RICHIEDENTEModel r = CreaRichiedenteModel(ds, richiedente.IDRICHIEDENTE);
                    richiedenti.Add(r);
                }
            }

            return(richiedenti);
        }
Beispiel #9
0
        public List <MD_GRUPPO_DESTINATARIOModel> RimuoviDestinatario(decimal IDDESTINATARIO)
        {
            MailDispatcherDS ds = new MailDispatcherDS();

            using (MailDispatcherBusiness bMD = new MailDispatcherBusiness())
            {
                bMD.FillMD_GRUPPI(ds);
                bMD.FillMD_GRUPPI_DESTINATARI(ds);
                bMD.FillMD_GRUPPI_RICHIEDENTI(ds);
                bMD.FillMD_RICHIEDENTI(ds);

                MailDispatcherDS.MD_GRUPPI_DESTINATARIRow grd = ds.MD_GRUPPI_DESTINATARI.Where(x => x.IDDESTINATARIO == IDDESTINATARIO).FirstOrDefault();
                decimal IDGRUPPO = grd.IDGRUPPO;
                grd.Delete();

                bMD.UpdateMailDispatcherDSTable(ds.MD_GRUPPI_DESTINATARI.TableName, ds);
                ds.MD_GRUPPI_DESTINATARI.AcceptChanges();

                MailDispatcherDS.MD_GRUPPIRow gruppo = ds.MD_GRUPPI.Where(x => x.IDGRUPPO == IDGRUPPO).FirstOrDefault();
                MD_GRUPPOModel gr = CreaGruppoModel(ds, IDGRUPPO);

                return(gr.Destinatari);
            }
        }
        public void SendMail()
        {
            MailDispatcherDS ds = new MailDispatcherDS();

            using (MailDispatcherBusiness bMD = new MailDispatcherBusiness())
            {
                bMD.FillMD_EMAILByStato(MD_EMAIL_STATO.DA_INVIARE, ds);
                bMD.InsertMD_LOG(string.Format("Ci sono {0} mail da inviare", ds.MD_EMAIL.Rows.Count));

                if (ds.MD_EMAIL.Rows.Count == 0)
                {
                    return;
                }

                bMD.FillMD_GRUPPI(ds);
                bMD.FillMD_RICHIEDENTI(ds);
                bMD.FillMD_GRUPPI_RICHIEDENTI(ds);
                bMD.FillMD_GRUPPI_DESTINATARI(ds);

                List <decimal> idmail = ds.MD_EMAIL.Select(x => x.IDMAIL).Distinct().ToList();

                foreach (MailDispatcherDS.MD_EMAILRow mail in ds.MD_EMAIL)
                {
                    try
                    {
                        ds.MD_ALLEGATI.Clear();
                        bMD.FillMD_ALLEGATI(ds, mail.IDMAIL);
                        decimal idRichiedente = mail.IDRICHIEDENTE;

                        if (mail.TENTATIVO == 3)
                        {
                            bMD.InsertMD_LOG(mail.IDMAIL, "MAIL BLOCCATA", "SUPERATO IL NUMERO DI TENTATIVI AMMESSI");
                            mail.STATO = MD_EMAIL_STATO.BLOCCATA;
                            bMD.UpdateMailDispatcherDSTable(ds.MD_EMAIL.TableName, ds);
                            continue;
                        }

                        MailDispatcherDS.MD_RICHIEDENTIRow richiedente = ds.MD_RICHIEDENTI.Where(x => x.IDRICHIEDENTE == idRichiedente).FirstOrDefault();
                        if (richiedente == null)
                        {
                            bMD.InsertMD_LOG(mail.IDMAIL, "RICERCA RICHIEDENTE", string.Format("RICHIEDENTE {0} INESISTENTE", idRichiedente));
                            mail.STATO     = MD_EMAIL_STATO.DA_INVIARE;
                            mail.TENTATIVO = mail.TENTATIVO + 1;
                            bMD.UpdateMailDispatcherDSTable(ds.MD_EMAIL.TableName, ds);
                            continue;
                        }

                        List <string> destintinatariMail = (from destinatari in ds.MD_GRUPPI_DESTINATARI
                                                            join richiedenti in ds.MD_GRUPPI_RICHIEDENTI on destinatari.IDGRUPPO equals richiedenti.IDGRUPPO
                                                            where richiedenti.IDRICHIEDENTE == idRichiedente
                                                            select destinatari.DESTINATARIO).ToList();
                        if (destintinatariMail.Count == 0)
                        {
                            bMD.InsertMD_LOG(mail.IDMAIL, "RICERCA DESTINATARI", string.Format("NESSUN DESTINATARIO PER RICHIEDENTE {0}", idRichiedente));
                            mail.STATO     = MD_EMAIL_STATO.DA_INVIARE;
                            mail.TENTATIVO = mail.TENTATIVO + 1;
                            bMD.UpdateMailDispatcherDSTable(ds.MD_EMAIL.TableName, ds);
                            continue;
                        }

                        MailSender sender  = new MailSender();
                        string     oggetto = string.Format("MAIL:{0} - {1}", mail.IDMAIL, mail.OGGETTO);
                        sender.CreaEmail(destintinatariMail, oggetto);

                        StringBuilder sb = new StringBuilder();
                        sb.AppendLine("MAIL AUTOMATICA DA MAIL DISPATCHER - NON RISPONDERE");
                        sb.AppendLine(string.Format("MAIL: {0}", mail.IDMAIL));
                        sb.AppendLine();
                        sb.AppendLine(mail.CORPO);

                        sender.AggiungiCorpoAllaMail(sb.ToString());

                        foreach (MailDispatcherDS.MD_ALLEGATIRow allegato in ds.MD_ALLEGATI)
                        {
                            MemoryStream ms = new MemoryStream(allegato.FILECONTENT);
                            sender.AggiungiAllegato(ms, allegato.FILENAME);
                        }


                        sender.InviaMail();

                        mail.STATO     = MD_EMAIL_STATO.INVIATA;
                        mail.DATAINVIO = DateTime.Now;
                        bMD.UpdateMailDispatcherDSTable(ds.MD_EMAIL.TableName, ds);
                        bMD.InsertMD_LOG(mail.IDMAIL, "INVIATA", string.Empty);
                    }
                    catch (Exception ex)
                    {
                        decimal tentativo = mail.IsTENTATIVONull() ? 0 : mail.TENTATIVO;
                        if (tentativo < 3)
                        {
                            mail.STATO     = MD_EMAIL_STATO.DA_INVIARE;
                            mail.TENTATIVO = tentativo + 1;
                            bMD.UpdateMailDispatcherDSTable(ds.MD_EMAIL.TableName, ds);
                        }
                        else
                        {
                            mail.STATO     = MD_EMAIL_STATO.DA_INVIARE;
                            mail.TENTATIVO = tentativo + 1;
                            bMD.UpdateMailDispatcherDSTable(ds.MD_EMAIL.TableName, ds);
                        }

                        StringBuilder exstr = new StringBuilder();
                        exstr.AppendLine(string.Format("Eccezione {0}", ex.Message));
                        exstr.AppendLine(string.Format("Stack {0}", ex.StackTrace));
                        while (ex.InnerException != null)
                        {
                            exstr.AppendLine(string.Format("Eccezione {0}", ex.InnerException.Message));
                            exstr.AppendLine(string.Format("Stack {0}", ex.InnerException.StackTrace));
                            ex = ex.InnerException;
                        }
                        if (exstr.Length > 200)
                        {
                            exstr.Remove(199, (exstr.Length - 200));
                        }

                        bMD.InsertMD_LOG(mail.IDMAIL, "ERRORE", exstr.ToString());
                    }
                }
            }
        }