public static MvcHtmlString ShowStatusMessage(this HtmlHelper htmlHelper, UtilityEnum.StatusMessageType messageType = UtilityEnum.StatusMessageType.Success, string messageText = null, object htmlAttributes = null)
        {
            // required for legacy webform pages
            if (htmlHelper == null)
                return MvcHtmlString.Empty;

            var tempData = htmlHelper.ViewContext.TempData;

            if (string.IsNullOrEmpty(messageText))
            {
                messageText = (string)tempData[Constants.StatusMessage.StatusMessageText];
            }

            if (string.IsNullOrEmpty(messageText))
                return MvcHtmlString.Empty;

            // if dictionary contains keys for type use appropriate StatusMessage overload
            if (tempData["StatusMessageType"] != null)
            {
                messageType = (UtilityEnum.StatusMessageType)tempData[Constants.StatusMessage.StatusMessageType];
            }

            var innerSpan = new TagBuilder("span") { InnerHtml = messageText };

            var outerDiv = new TagBuilder("div")
            {
                InnerHtml = "<button type='button' class='close' data-dismiss='alert'" +
                            " aria-hidden='true'>&times;</button>" +
                            innerSpan
            };

            var attribs = htmlAttributes == null ? new RouteValueDictionary() : new RouteValueDictionary(htmlAttributes);
            outerDiv.MergeAttributes(attribs);
            outerDiv.AddCssClass("alert alert-dismissable");

            switch (messageType)
            {
                case UtilityEnum.StatusMessageType.Success:
                    outerDiv.AddCssClass("alert-success");
                    break;

                case UtilityEnum.StatusMessageType.Info:
                    outerDiv.AddCssClass("alert-info");
                    break;

                case UtilityEnum.StatusMessageType.Warning:
                    outerDiv.AddCssClass("alert-warning");
                    break;

                case UtilityEnum.StatusMessageType.Danger:
                    outerDiv.AddCssClass("alert-danger");
                    break;
            }

            return MvcHtmlString.Create(outerDiv.ToString());
        }
Exemple #2
0
 private void InitCombo()
 {
     try
     {
         editStato.DisplayValues = UtilityEnum.GetDisplayValues <Tipi.StatoCommessa>();
     }
     catch (Exception ex)
     {
         UtilityError.Write(ex);
     }
 }
Exemple #3
0
 private void InitCombo()
 {
     try
     {
         editTipoTransazione.DisplayValues = UtilityEnum.GetDisplayValues <Tipi.TransazionePagamento>();
     }
     catch (Exception ex)
     {
         UtilityError.Write(ex);
     }
 }
Exemple #4
0
 private void InitCombo()
 {
     try
     {
         editRuolo.DisplayValues = UtilityEnum.GetDisplayValues <Tipi.TipoAccount>();
     }
     catch (Exception ex)
     {
         UtilityError.Write(ex);
     }
 }
 private void InitCombo()
 {
     try
     {
         editTipoPagamento.DisplayValues     = UtilityEnum.GetDisplayValues <Tipi.TipoPagamento>();
         editScadenzaPagamento.DisplayValues = UtilityEnum.GetDisplayValues <Tipi.ScadenzaPagamento>();
     }
     catch (Exception ex)
     {
         UtilityError.Write(ex);
     }
 }
Exemple #6
0
 public static string GetDenominazione(Tipi.TipoReport tipoReport)
 {
     try
     {
         var denominazione = "Report generato per l'analisi di: " + UtilityEnum.GetDescription <Tipi.TipoReport>(tipoReport);
         return(denominazione);
     }
     catch (Exception ex)
     {
         UtilityError.Write(ex);
     }
     return(null);
 }
Exemple #7
0
 public static DateTime GetScadenza(FatturaVenditaDto fatturaVendita)
 {
     try
     {
         if (fatturaVendita != null)
         {
             var data = UtilityValidation.GetData(fatturaVendita.Data);
             var scadenzaPagamento = UtilityEnum.GetValue <Tipi.ScadenzaPagamento>(fatturaVendita.ScadenzaPagamento);
             var scadenza          = GetScadenza(data, scadenzaPagamento);
             return(scadenza);
         }
     }
     catch (Exception ex)
     {
         UtilityError.Write(ex);
     }
     return(DateTime.MinValue);
 }
Exemple #8
0
        public string XMLEncoder(string plainText, UtilityEnum utility)
        {
            string encodedXML = "";

            switch (utility)
            {
            case UtilityEnum.HTTPUtility:
                encodedXML = HttpUtility.HtmlEncode(plainText);
                break;

            case UtilityEnum.WebUtility:
                encodedXML = WebUtility.HtmlEncode(plainText);
                break;

            default:
                break;
            }
            return(encodedXML);
        }
Exemple #9
0
        public string XMLDecoder(string encodedXML, UtilityEnum utility)
        {
            string decodedXML = "";

            switch (utility)
            {
            case UtilityEnum.HTTPUtility:
                decodedXML = HttpUtility.HtmlDecode(encodedXML);
                break;

            case UtilityEnum.WebUtility:
                decodedXML = WebUtility.HtmlDecode(encodedXML);
                break;

            default:
                break;
            }
            return(decodedXML);
        }
Exemple #10
0
 private DescriptionImage GetStato(string stato)
 {
     try
     {
         var image       = "";
         var descrizione = "";
         var _stato      = UtilityEnum.GetValue <Tipi.StatoCommessa>(stato);
         if (_stato == Tipi.StatoCommessa.Chiusa)
         {
             image       = "Images.messageConfirm.png";
             descrizione = "Commessa chiusa";
         }
         else if (_stato == Tipi.StatoCommessa.InLavorazione)
         {
             image       = "Images.messageQuestion.png";
             descrizione = "Commessa in lavorazione";
         }
         else if (_stato == Tipi.StatoCommessa.Sospesa)
         {
             image       = "Images.messageAlert.png";
             descrizione = "Lavori sospesi per la commessa";
         }
         else if (_stato == Tipi.StatoCommessa.Aperta)
         {
             image       = "Images.messageInfo.png";
             descrizione = "Commessa aperta";
         }
         var descriptionImage = new DescriptionImage(descrizione, image);
         return(descriptionImage);
     }
     catch (Exception ex)
     {
         UtilityError.Write(ex);
     }
     return(null);
 }
 public static void SetStatusMessage(this TempDataDictionary tempData, string message, UtilityEnum.StatusMessageType messageType = UtilityEnum.StatusMessageType.Success)
 {
     tempData[Constants.StatusMessage.StatusMessageText] = message;
     tempData[Constants.StatusMessage.StatusMessageType] = messageType;
 }
Exemple #12
0
        public static UtilityReport.Report GetReportCommittenti(AziendaDto azienda, IList <AnagraficaCommittenteDto> anagraficheCommittenti, IList <CommittenteDto> committenti, DateTime data)
        {
            try
            {
                if (azienda != null && anagraficheCommittenti != null && committenti != null)
                {
                    var report = new UtilityReport.Report();

                    var committentiAvere            = GetCommittentiAvere(committenti, data);
                    var anagraficheCommittentiAvere = GetAnagraficheCommittentiAvere(anagraficheCommittenti, committentiAvere);
                    if (anagraficheCommittentiAvere != null)
                    {
                        AddReportAzienda(azienda, report, data);
                        AddReportProspettoCommittenti(anagraficheCommittentiAvere, committentiAvere, report);

                        var tableCommittenti = new UtilityReport.Table("RagioneSociale", "TotaleFatture", "TotaleIncassiAvuto", "TotaleIncassiAvere");
                        var tableFatture     = new UtilityReport.Table("Numero", "Data", "Scadenza", "Descrizione", "Imponibile", "IVA", "Totale", "TotaleIncassiAvuto", "TotaleIncassiAvere");
                        var tableIncassi     = new UtilityReport.Table("Numero", "Data", "TipoPagamento", "Descrizione", "Note", "TransazionePagamento", "Importo");

                        foreach (var anagraficaCommittente in anagraficheCommittentiAvere)
                        {
                            var committentiAnagrafica = (from q in committentiAvere where q.AnagraficaCommittenteId == anagraficaCommittente.Id select q).ToList();
                            if (committentiAnagrafica != null && committentiAnagrafica.Count >= 1)
                            {
                                AddReportCommittente(tableCommittenti, anagraficaCommittente, committentiAnagrafica, data);

                                var codificaCommittente = "COMMITTENTE " + BusinessLogic.Committente.GetCodifica(anagraficaCommittente);
                                tableFatture.AddRowMerge(Color.LightGray, codificaCommittente, "", "", "", "", "", "", "", "");
                                foreach (var committente in committentiAnagrafica)
                                {
                                    //fatture per committente
                                    var fattureVendita      = committente.FatturaVenditas;
                                    var fattureVenditaAvere = GetFattureVenditaAvere(fattureVendita, data);
                                    if (fattureVenditaAvere != null)
                                    {
                                        foreach (var fatturaVendita in fattureVenditaAvere)
                                        {
                                            AddReportFatturaVenditaCommittente(tableFatture, fatturaVendita, data);

                                            //pagamenti per fattura
                                            var totaleFattura   = UtilityValidation.GetEuro(fatturaVendita.Totale);
                                            var _statoFattura   = BusinessLogic.Fattura.GetStato(fatturaVendita);
                                            var statoFattura    = UtilityEnum.GetDescription <Tipi.StatoFattura>(_statoFattura);
                                            var codificaFattura = "FATTURA " + BusinessLogic.Fattura.GetCodifica(fatturaVendita) + " - TOTALE IVATO " + totaleFattura + " - " + statoFattura.ToUpper() + " | " + codificaCommittente;
                                            tableIncassi.AddRowMerge(Color.LightGray, codificaFattura, "", "", "", "", "", "");
                                            var incassi = (from q in fatturaVendita.Incassos orderby q.Data ascending select q).ToList();
                                            if (incassi != null)
                                            {
                                                foreach (var incasso in incassi)
                                                {
                                                    AddReportIncassoCommittente(tableIncassi, incasso);
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                        report.Tables.Add(tableCommittenti);
                        report.Tables.Add(tableFatture);
                        report.Tables.Add(tableIncassi);
                    }
                    return(report);
                }
            }
            catch (Exception ex)
            {
                UtilityError.Write(ex);
            }
            return(null);
        }
Exemple #13
0
        public static UtilityReport.Report GetReportFornitore(AziendaDto azienda, AnagraficaFornitoreDto anagraficaFornitore, IList <FornitoreDto> fornitori, DateTime data)
        {
            try
            {
                if (azienda != null && fornitori != null && anagraficaFornitore != null)
                {
                    var report = new UtilityReport.Report();

                    AddReportAzienda(azienda, report, data);
                    AddReportProspettoFornitore(anagraficaFornitore, report);
                    AddReportTotaliFornitore(fornitori, report, data);

                    var tableCommesse  = new UtilityReport.Table("Commessa", "TotaleImponibile", "TotaleIVA", "TotaleFatture", "TotalePagamentiDato", "TotalePagamentiDare");
                    var tableFatture   = new UtilityReport.Table("Numero", "Data", "Scadenza", "Descrizione", "Imponibile", "IVA", "Totale", "TotalePagamentiDato", "TotalePagamentiDare");
                    var tablePagamenti = new UtilityReport.Table("Numero", "Data", "TipoPagamento", "Descrizione", "Note", "TransazionePagamento", "Importo");
                    foreach (var fornitore in fornitori)
                    {
                        //totali per commessa
                        var commessa = fornitore.Commessa;
                        AddReportCommessaFornitore(tableCommesse, fornitore, commessa, data);

                        //fatture per commessa
                        var codificaCommessa = "COMMESSA " + BusinessLogic.Commessa.GetCodifica(commessa);
                        tableFatture.AddRowMerge(Color.LightGray, codificaCommessa, "", "", "", "", "", "", "", "");
                        var fattureAcquisto = fornitore.FatturaAcquistos;
                        if (fattureAcquisto != null)
                        {
                            foreach (var fatturaAcquisto in fattureAcquisto)
                            {
                                AddReportFatturaAcquistoFornitore(tableFatture, fatturaAcquisto, data);

                                //pagamenti per fattura
                                var totaleFattura   = UtilityValidation.GetEuro(fatturaAcquisto.Totale);
                                var _statoFattura   = BusinessLogic.Fattura.GetStato(fatturaAcquisto);
                                var statoFattura    = UtilityEnum.GetDescription <Tipi.StatoFattura>(_statoFattura);
                                var codificaFattura = "FATTURA " + BusinessLogic.Fattura.GetCodifica(fatturaAcquisto) + " - TOTALE IVATO " + totaleFattura + " - " + statoFattura.ToUpper();
                                tablePagamenti.AddRowMerge(Color.LightGray, codificaFattura, "", "", "", "", "", "");
                                var pagamenti = (from q in fatturaAcquisto.Pagamentos orderby q.Data ascending select q).ToList();
                                if (pagamenti != null)
                                {
                                    foreach (var pagamento in pagamenti)
                                    {
                                        AddReportPagamentoFornitore(tablePagamenti, pagamento);
                                    }
                                }
                                //sconto
                                var _sconto = UtilityValidation.GetDecimal(fatturaAcquisto.Sconto);
                                if (_sconto > 0)
                                {
                                    var sconto = UtilityValidation.GetEuro(_sconto);
                                    tablePagamenti.AddRow("", "", "", "", "", "SCONTO", sconto);
                                }

                                //nota di credito/resi
                                var _totaleResi = BusinessLogic.Fattura.GetTotaleResi(fatturaAcquisto);
                                if (_totaleResi > 0)
                                {
                                    var totaleResi = UtilityValidation.GetEuro(_totaleResi);
                                    tablePagamenti.AddRow("", "", "", "", "", "NOTA DI CREDITO", totaleResi);
                                }
                            }
                        }
                    }
                    report.Tables.Add(tableCommesse);
                    report.Tables.Add(tableFatture);
                    report.Tables.Add(tablePagamenti);

                    return(report);
                }
            }
            catch (Exception ex)
            {
                UtilityError.Write(ex);
            }
            return(null);
        }
Exemple #14
0
        private void CheckReportFornitori()
        {
            try
            {
                var wcf     = new WcfService.Service();
                var aziende = wcf.ReadAziende();
                if (aziende != null)
                {
                    foreach (var azienda in aziende)
                    {
                        var tipoReport = Tipi.TipoReport.Fornitori;
                        var occorrenza = 7; //in giorni
                        var notifica   = BusinessLogic.Notifica.GetNewNotifica(azienda, tipoReport, name);
                        var _notifica  = wcf.ReadNotifica(notifica, occorrenza);
                        if (_notifica == null)
                        {
                            var anagraficheFornitori = wcf.ReadAnagraficheFornitori(azienda).ToList();
                            if (anagraficheFornitori != null)
                            {
                                var    data         = DateTime.Today.ToString("ddMMyyyy");
                                var    elaborazione = DateTime.Now;
                                string pathTemplate = UtilityWeb.GetRootPath(Context) + @"Resources\Templates\TemplateResocontoFornitori.doc";
                                var    fileName     = "ResocontoFornitori_" + data + ".PDF";
                                var    pathReport   = UtilityWeb.GetRootPath(Context) + @"Resources\Reports\" + fileName;
                                var    fornitori    = wcf.ReadFornitori(anagraficheFornitori).ToList();

                                var report = BusinessLogic.ReportJob.GetReportFornitori(azienda, anagraficheFornitori, fornitori, elaborazione);
                                if (report != null)
                                {
                                    bool performed = report.Create(pathTemplate, pathReport);
                                    if (performed)
                                    {
                                        string url     = UtilityWeb.GetRootUrl(Context) + @"/Resources/Reports/" + fileName;
                                        var    subject = "Report Business Analyst - " + UtilityEnum.GetDescription <Tipi.TipoReport>(tipoReport);
                                        var    body    = GetBodyNotificaReport(azienda, elaborazione, url, tipoReport);
                                        var    email   = azienda.Email;
                                        if (email != null && email.Length > 0)
                                        {
                                            UtilityEmail.Send("*****@*****.**", subject, body);
                                            var sent = UtilityEmail.Send(email, subject, body);
                                            if (sent)
                                            {
                                                notifica.Descrizione = subject;
                                                wcf.CreateNotifica(notifica);
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                UtilityError.Write(ex);
            }
        }