Пример #1
0
        public static void PreSetDocumento(HttpPostedFileBase file, out DocumentiModel dm, out bool esisteFile, out bool gestisceEstensioni, out bool dimensioneConsentita, out string dimensioneMaxDocumento, EnumTipoDoc tipoDoc)
        {
            dm = new DocumentiModel();
            gestisceEstensioni   = false;
            dimensioneConsentita = false;
            esisteFile           = false;

            dimensioneMaxDocumento = string.Empty;

            try
            {
                if (file != null && file.ContentLength > 0)
                {
                    esisteFile = true;

                    var estensioniGestite    = new[] { ".pdf" };
                    var estensione           = Path.GetExtension(file.FileName);
                    var nomeFileNoEstensione = Path.GetFileNameWithoutExtension(file.FileName);
                    if (!estensioniGestite.Contains(estensione.ToLower()))
                    {
                        gestisceEstensioni = false;
                    }
                    else
                    {
                        gestisceEstensioni = true;
                    }

                    var keyDimensioneDocumento = System.Configuration.ConfigurationManager.AppSettings["DimensioneDocumento"];

                    dimensioneMaxDocumento = keyDimensioneDocumento;

                    if (file.ContentLength / 1024 <= Convert.ToInt32(keyDimensioneDocumento))
                    {
                        dm.nomeDocumento   = nomeFileNoEstensione;
                        dm.estensione      = estensione;
                        dm.tipoDocumento   = tipoDoc;
                        dm.dataInserimento = DateTime.Now;
                        dm.file            = file;
                        dm.idStatoRecord   = (decimal)EnumStatoRecord.In_Lavorazione;
                        dm.fk_iddocumento  = null;

                        dimensioneConsentita = true;
                    }
                    else
                    {
                        dimensioneConsentita = false;
                    }
                }
                else
                {
                    esisteFile = false;
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
Пример #2
0
        public JsonResult InserisciFormularioTV(decimal idTitoloViaggio, HttpPostedFileBase file)
        {
            using (ModelDBISE db = new ModelDBISE())
            {
                db.Database.BeginTransaction();

                try
                {
                    using (dtDocumenti dtd = new dtDocumenti())
                    {
                        DocumentiModel dm                      = new DocumentiModel();
                        bool           esisteFile              = false;
                        bool           gestisceEstensioni      = false;
                        bool           dimensioneConsentita    = false;
                        string         dimensioneMaxConsentita = string.Empty;

                        Utility.PreSetDocumento(file, out dm, out esisteFile, out gestisceEstensioni,
                                                out dimensioneConsentita, out dimensioneMaxConsentita,
                                                EnumTipoDoc.Formulario_Titoli_Viaggio);

                        if (esisteFile)
                        {
                            if (gestisceEstensioni == false)
                            {
                                throw new Exception(
                                          "Il documento selezionato non è nel formato consentito. Il formato supportato è: pdf.");
                            }

                            if (dimensioneConsentita)
                            {
                                dtd.SetFormularioTitoliViaggio(ref dm, idTitoloViaggio, db);
                            }
                            else
                            {
                                throw new Exception(
                                          "Il documento selezionato supera la dimensione massima consentita (" +
                                          dimensioneMaxConsentita + " Mb).");
                            }
                        }
                        else
                        {
                            throw new Exception("Il documento è obbligatorio.");
                        }
                    }


                    db.Database.CurrentTransaction.Commit();
                    return(Json(new { msg = "Il formulario è stata inserito." }));
                }
                catch (Exception ex)
                {
                    db.Database.CurrentTransaction.Rollback();
                    return(Json(new { err = ex.Message }));
                }
            }
        }
Пример #3
0
        public void SetDocumentoPS(ref DocumentiModel dm, decimal idTrasfProvScolastiche, ModelDBISE db, decimal idTipoDocumento)
        {
            try
            {
                MemoryStream ms = new MemoryStream();
                DOCUMENTI    d  = new DOCUMENTI();
                ATTIVAZIONIPROVSCOLASTICHE atep = new ATTIVAZIONIPROVSCOLASTICHE();

                dm.file.InputStream.CopyTo(ms);

                var tep = db.PROVVIDENZESCOLASTICHE.Find(idTrasfProvScolastiche);

                var latep =
                    tep.ATTIVAZIONIPROVSCOLASTICHE.Where(
                        a => a.ANNULLATO == false && a.NOTIFICARICHIESTA == false && a.ATTIVARICHIESTA == false)
                    .OrderByDescending(a => a.IDPROVSCOLASTICHE).ToList();
                if (latep?.Any() ?? false)
                {
                    atep = latep.First();
                }
                else
                {
                    atep = this.CreaAttivitaPS(idTrasfProvScolastiche, db);
                }

                d.NOMEDOCUMENTO   = dm.nomeDocumento;
                d.ESTENSIONE      = dm.estensione;
                d.IDTIPODOCUMENTO = idTipoDocumento;
                d.DATAINSERIMENTO = dm.dataInserimento;
                d.FILEDOCUMENTO   = ms.ToArray();
                d.MODIFICATO      = false;
                d.FK_IDDOCUMENTO  = null;
                d.IDSTATORECORD   = (decimal)EnumStatoRecord.In_Lavorazione;

                atep.DOCUMENTI.Add(d);

                if (db.SaveChanges() > 0)
                {
                    dm.idDocumenti = d.IDDOCUMENTO;
                    Utility.SetLogAttivita(EnumAttivitaCrud.Inserimento, "Inserimento di una nuovo documento (provvidenze scolastiche).", "Documenti", db, tep.IDTRASFPROVSCOLASTICHE, dm.idDocumenti);
                }
                else
                {
                    throw new Exception("Errore nella fase di inserimento del documento (provvidenze scolastiche).");
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
Пример #4
0
        public ActionResult LeggiDocumento(decimal id)
        {
            byte[]         Blob;
            DocumentiModel documento = new DocumentiModel();

            using (dtDocumenti dtd = new dtDocumenti())
            {
                documento = dtd.GetDatiDocumentoById(id);
                Blob      = dtd.GetDocumentoByteById(id);

                Response.AddHeader("Content-Disposition", "inline; filename=" + documento.idDocumenti + documento.estensione.ToLower() + ";");

                switch (documento.estensione.ToLower())
                {
                case ".pdf":
                    return(File(Blob, "application/pdf"));

                default:
                    return(File(Blob, "application/pdf"));
                }
            }
        }
Пример #5
0
        public JsonResult SalvaDocumentoPS(decimal idTipoDocumento, decimal idTrasfProvScolastiche)
        {
            using (ModelDBISE db = new ModelDBISE())
            {
                try
                {
                    db.Database.BeginTransaction();

                    foreach (string item in Request.Files)
                    {
                        HttpPostedFileBase file = Request.Files[item] as HttpPostedFileBase;

                        using (dtProvvidenzeScolastiche dtps = new dtProvvidenzeScolastiche())
                        {
                            using (dtDocumenti dtd = new dtDocumenti())
                            {
                                DocumentiModel dm                      = new DocumentiModel();
                                bool           esisteFile              = false;
                                bool           gestisceEstensioni      = false;
                                bool           dimensioneConsentita    = false;
                                string         dimensioneMaxConsentita = string.Empty;

                                PreSetDocumentoPS(file, out dm, out esisteFile, out gestisceEstensioni,
                                                  out dimensioneConsentita, out dimensioneMaxConsentita, idTipoDocumento);

                                if (esisteFile)
                                {
                                    if (gestisceEstensioni == false)
                                    {
                                        throw new Exception(
                                                  "Il documento selezionato non è nel formato consentito. Il formato supportato è: pdf.");
                                    }

                                    if (dimensioneConsentita)
                                    {
                                        dtps.SetDocumentoPS(ref dm, idTrasfProvScolastiche, db, idTipoDocumento);
                                    }
                                    else
                                    {
                                        throw new Exception(
                                                  "Il documento selezionato supera la dimensione massima consentita (" +
                                                  dimensioneMaxConsentita + " Mb).");
                                    }
                                }
                                else
                                {
                                    throw new Exception("Il documento è obbligatorio.");
                                }
                            }
                        }
                    }
                    db.Database.CurrentTransaction.Commit();
                    return(Json(new { }));
                }
                catch (Exception ex)
                {
                    db.Database.CurrentTransaction.Rollback();
                    return(Json(new { error = ex.Message }));
                };
            }
        }
        public JsonResult InserisciDocumentoMAB(decimal idTrasferimento, decimal idTipoDocumento, HttpPostedFileBase file)
        {
            using (ModelDBISE db = new ModelDBISE())
            {
                try
                {
                    db.Database.BeginTransaction();

                    using (dtMaggiorazioneAbitazione dtma = new dtMaggiorazioneAbitazione())
                    {
                        AttivazioneMABModel amm = new AttivazioneMABModel();

                        //leggo la prima attivazione
                        amm = dtma.GetAttivazionePartenzaMAB(idTrasferimento);

                        //se non esiste la creo
                        if ((amm != null && amm.idAttivazioneMAB > 0) == false)
                        {
                            amm = dtma.CreaAttivazioneMAB(amm.idMAB, db);
                        }

                        using (dtDocumenti dtd = new dtDocumenti())
                        {
                            DocumentiModel dm                      = new DocumentiModel();
                            bool           esisteFile              = false;
                            bool           gestisceEstensioni      = false;
                            bool           dimensioneConsentita    = false;
                            string         dimensioneMaxConsentita = string.Empty;

                            Utility.PreSetDocumento(file, out dm, out esisteFile, out gestisceEstensioni,
                                                    out dimensioneConsentita, out dimensioneMaxConsentita,
                                                    (EnumTipoDoc)idTipoDocumento);

                            if (esisteFile)
                            {
                                if (gestisceEstensioni == false)
                                {
                                    throw new Exception(
                                              "Il documento selezionato non è nel formato consentito. Il formato supportato è: pdf.");
                                }

                                if (dimensioneConsentita)
                                {
                                    //verifica se il documento è gia presente ritornando l'eventuale id
                                    decimal idDocumentoEsistente = dtma.VerificaEsistenzaDocumentoMAB(idTrasferimento, (EnumTipoDoc)idTipoDocumento);

                                    if (idDocumentoEsistente > 0)
                                    {
                                        //se già esiste lo sostituisco (imposto modificato=true su quello esistente e ne inserisco una altro)
                                        dtma.SostituisciDocumentoMAB(ref dm, idDocumentoEsistente, amm.idAttivazioneMAB, db);
                                    }
                                    else
                                    {
                                        //se non esiste lo inserisco
                                        dtma.SetDocumentoMAB(ref dm, amm.idAttivazioneMAB, db);
                                    }

                                    dtma.AssociaDocumentoAttivazione(amm.idAttivazioneMAB, dm.idDocumenti, db);
                                    Utility.SetLogAttivita(EnumAttivitaCrud.Inserimento, "Inserimento di una nuovo documento (maggiorazione abitazione).", "Documenti", db, idTrasferimento, dm.idDocumenti);
                                }
                                else
                                {
                                    throw new Exception(
                                              "Il documento selezionato supera la dimensione massima consentita (" +
                                              dimensioneMaxConsentita + " Mb).");
                                }
                            }
                            else
                            {
                                throw new Exception("Il documento è obbligatorio.");
                            }
                        }
                    }

                    db.Database.CurrentTransaction.Commit();
                    return(Json(new { msg = "Il documento è stato inserito." }));
                }
                catch (Exception ex)
                {
                    db.Database.CurrentTransaction.Rollback();
                    return(Json(new { err = ex.Message }));
                }
            }
        }
Пример #7
0
        public JsonResult InserisciDocumentoPassaporto(decimal idTrasferimento, decimal idTipoDocumento, HttpPostedFileBase file, decimal idFamiliarePassaporto, decimal idParentela)
        {
            using (ModelDBISE db = new ModelDBISE())
            {
                PASSAPORTORICHIEDENTE pr = new PASSAPORTORICHIEDENTE();
                CONIUGEPASSAPORTO     cp = new CONIUGEPASSAPORTO();
                FIGLIPASSAPORTO       fp = new FIGLIPASSAPORTO();
                try
                {
                    db.Database.BeginTransaction();

                    using (dtVariazionePassaporto dtvp = new dtVariazionePassaporto())
                    {
                        AttivazionePassaportiModel apm = new AttivazionePassaportiModel();

                        //cerco l'attivazione della seconda fase in corso
                        apm = dtvp.GetAttivazioneInvioPassaportiInLavorazione(idTrasferimento, db);

                        //se non esiste segnala errore
                        if ((apm != null && apm.idAttivazioniPassaporti > 0) == false)
                        {
                            throw new Exception("Fase Invio Passaporto non trovata");
                        }

                        using (dtDocumenti dtd = new dtDocumenti())
                        {
                            DocumentiModel dm                      = new DocumentiModel();
                            bool           esisteFile              = false;
                            bool           gestisceEstensioni      = false;
                            bool           dimensioneConsentita    = false;
                            string         dimensioneMaxConsentita = string.Empty;

                            Utility.PreSetDocumento(file, out dm, out esisteFile, out gestisceEstensioni,
                                                    out dimensioneConsentita, out dimensioneMaxConsentita,
                                                    (EnumTipoDoc)idTipoDocumento);

                            if (esisteFile)
                            {
                                if (gestisceEstensioni == false)
                                {
                                    throw new Exception(
                                              "Il documento selezionato non è nel formato consentito. Il formato supportato è: pdf.");
                                }

                                if (dimensioneConsentita)
                                {
                                    //verifica se il documento è gia presente ritornando l'eventuale id
                                    decimal idDocumentoEsistente = dtvp.VerificaEsistenzaDocumentoPassaporto(idTrasferimento, idTipoDocumento, idParentela, idFamiliarePassaporto);

                                    if (idDocumentoEsistente > 0)
                                    {
                                        //se già esiste lo sostituisco (imposto modificato=true su quello esistente e ne inserisco una altro)
                                        dtvp.SostituisciDocumentoPassaporto(ref dm, idDocumentoEsistente, apm.idAttivazioniPassaporti, db);
                                    }
                                    else
                                    {
                                        //se non esiste lo inserisco
                                        dtvp.SetDocumentoPassaporto(ref dm, apm.idAttivazioniPassaporti, db);
                                    }

                                    switch ((EnumParentela)idParentela)
                                    {
                                    case EnumParentela.Coniuge:
                                        dtvp.AssociaDocumentoPassaportoConiuge(idFamiliarePassaporto, dm.idDocumenti, db);
                                        break;

                                    case EnumParentela.Figlio:
                                        dtvp.AssociaDocumentoPassaportoFiglio(idFamiliarePassaporto, dm.idDocumenti, db);
                                        break;

                                    case EnumParentela.Richiedente:
                                        dtvp.GetPassaportoRichiedente_Invio(ref pr, apm.idAttivazioniPassaporti, db);
                                        dtvp.AssociaDocumentoPassaportoRichiedente(pr.IDPASSAPORTORICHIEDENTE, dm.idDocumenti, db);
                                        break;
                                    }

                                    Utility.SetLogAttivita(EnumAttivitaCrud.Inserimento, "Inserimento di una nuovo documento (maggiorazione abitazione).", "Documenti", db, idTrasferimento, dm.idDocumenti);
                                }
                                else
                                {
                                    throw new Exception(
                                              "Il documento selezionato supera la dimensione massima consentita (" +
                                              dimensioneMaxConsentita + " Mb).");
                                }
                            }
                            else
                            {
                                throw new Exception("Il documento è obbligatorio.");
                            }
                        }
                    }

                    db.Database.CurrentTransaction.Commit();
                    return(Json(new { msg = "Il documento è stato inserito." }));
                }
                catch (Exception ex)
                {
                    db.Database.CurrentTransaction.Rollback();
                    return(Json(new { err = ex.Message }));
                }
            }
        }
Пример #8
0
        public ActionResult SalvaDocumento(EnumTipoDoc tipoDoc, decimal id, EnumParentela parentela, decimal idAttivazioneMagFam = 0)
        {
            using (ModelDBISE db = new ModelDBISE())
            {
                try
                {
                    db.Database.BeginTransaction();

                    //throw new Exception("Simulazione errore");

                    foreach (string item in Request.Files)
                    {
                        HttpPostedFileBase file = Request.Files[item] as HttpPostedFileBase;

                        using (dtAttivazioniMagFam dtamf = new dtAttivazioniMagFam())
                        {
                            using (dtDocumenti dtd = new dtDocumenti())
                            {
                                DocumentiModel dm                      = new DocumentiModel();
                                bool           esisteFile              = false;
                                bool           gestisceEstensioni      = false;
                                bool           dimensioneConsentita    = false;
                                string         dimensioneMaxConsentita = string.Empty;

                                Utility.PreSetDocumento(file, out dm, out esisteFile, out gestisceEstensioni,
                                                        out dimensioneConsentita, out dimensioneMaxConsentita, tipoDoc);

                                if (esisteFile)
                                {
                                    if (gestisceEstensioni == false)
                                    {
                                        throw new Exception(
                                                  "Il documento selezionato non è nel formato consentito. Il formato supportato è: pdf.");
                                    }

                                    if (dimensioneConsentita)
                                    {
                                        switch (tipoDoc)
                                        {
                                        case EnumTipoDoc.Carta_Imbarco:
                                        case EnumTipoDoc.Titolo_Viaggio:
                                            switch (parentela)
                                            {
                                            case EnumParentela.Coniuge:
                                                dtd.AddDocumentoFromConiuge(ref dm, id, db);
                                                break;

                                            case EnumParentela.Figlio:
                                                dtd.AddDocumentoFromFiglio(ref dm, id, db);
                                                break;

                                            case EnumParentela.Richiedente:
                                                dtd.AddDocumentoTitoloViaggioFromRichiedente(ref dm, id, db);
                                                break;

                                            default:
                                                throw new ArgumentOutOfRangeException("parentela");
                                            }
                                            break;

                                        case EnumTipoDoc.Prima_Rata_Maggiorazione_abitazione:
                                            break;

                                        case EnumTipoDoc.Attestazione_Spese_Abitazione_Collaboratore:
                                            break;

                                        case EnumTipoDoc.Clausole_Contratto_Alloggio:
                                            break;

                                        case EnumTipoDoc.Copia_Contratto_Locazione:
                                            break;

                                        case EnumTipoDoc.Contributo_Fisso_Omnicomprensivo:
                                            break;

                                        case EnumTipoDoc.Attestazione_Trasloco:
                                            break;

                                        case EnumTipoDoc.Documento_Identita:
                                            switch (parentela)
                                            {
                                            case EnumParentela.Coniuge:
                                                dtd.AddDocumentoFromConiuge(ref dm, id, db);
                                                if (idAttivazioneMagFam > 0)
                                                {
                                                    dtamf.AssociaDocumentoAttivazione(idAttivazioneMagFam, dm.idDocumenti, db);
                                                }
                                                break;

                                            case EnumParentela.Figlio:
                                                dtd.AddDocumentoFromFiglio(ref dm, id, db);
                                                if (idAttivazioneMagFam > 0)
                                                {
                                                    dtamf.AssociaDocumentoAttivazione(idAttivazioneMagFam, dm.idDocumenti, db);
                                                }
                                                break;

                                            case EnumParentela.Richiedente:
                                                dtd.AddDocumentoPassaportoFromRichiedente(ref dm, id, db);        //ID è riferito all'idTrasferimento.
                                                break;

                                            default:
                                                throw new ArgumentOutOfRangeException("parentela");
                                            }

                                            break;

                                        case EnumTipoDoc.Lettera_Trasferimento:
                                            break;

                                        default:
                                            throw new ArgumentOutOfRangeException("tipoDoc");
                                        }
                                    }
                                    else
                                    {
                                        throw new Exception(
                                                  "Il documento selezionato supera la dimensione massima consentita (" +
                                                  dimensioneMaxConsentita + " Mb).");
                                    }
                                }
                                else
                                {
                                    throw new Exception("Il documento è obbligatorio.");
                                }
                            }
                        }
                    }

                    db.Database.CurrentTransaction.Commit();
                    return(Json(new { }));
                }
                catch (Exception ex)
                {
                    db.Database.CurrentTransaction.Rollback();

                    return(Json(new { error = ex.Message }));
                };
            }
        }
Пример #9
0
        public JsonResult InserisciLetteraTrasferimento(decimal idTrasferimento, string protocolloLettera,
                                                        DateTime dataLettera, HttpPostedFileBase file)
        {
            using (ModelDBISE db = new ModelDBISE())
            {
                try
                {
                    db.Database.BeginTransaction();

                    if (idTrasferimento <= 0)
                    {
                        throw new Exception("ID del trasferimento mancante.");
                    }

                    if (protocolloLettera == string.Empty)
                    {
                        throw new Exception("Il protocollo della lettera è obbligatorio.");
                    }

                    if (dataLettera == null && dataLettera <= DateTime.MinValue)
                    {
                        throw new Exception("La data della lettera è obbligatoria.");
                    }

                    using (dtTrasferimento dtt = new dtTrasferimento())
                    {
                        TrasferimentoModel trm = dtt.GetSoloTrasferimentoById(idTrasferimento, db);

                        trm.protocolloLettera = protocolloLettera;
                        trm.dataLettera       = dataLettera;

                        dtt.EditTrasferimento(trm, db);

                        using (dtDocumenti dtd = new dtDocumenti())
                        {
                            DocumentiModel dm                      = new DocumentiModel();
                            bool           esisteFile              = false;
                            bool           gestisceEstensioni      = false;
                            bool           dimensioneConsentita    = false;
                            string         dimensioneMaxConsentita = string.Empty;

                            Utility.PreSetDocumento(file, out dm, out esisteFile, out gestisceEstensioni,
                                                    out dimensioneConsentita, out dimensioneMaxConsentita,
                                                    EnumTipoDoc.Lettera_Trasferimento);

                            if (esisteFile)
                            {
                                if (gestisceEstensioni == false)
                                {
                                    throw new Exception(
                                              "Il documento selezionato non è nel formato consentito. Il formato supportato è: pdf.");
                                }

                                if (dimensioneConsentita)
                                {
                                    dtd.SetLetteraTrasferimento(ref dm, trm.idTrasferimento, db);
                                    //trm.Documento = dm;
                                    //Utility.SetLogAttivita(EnumAttivitaCrud.Inserimento, "Inserimento di una nuovo documento (lettera di trasferimento).", "Documenti", db, trm.idTrasferimento, dm.idDocumenti);
                                }
                                else
                                {
                                    throw new Exception(
                                              "Il documento selezionato supera la dimensione massima consentita (" +
                                              dimensioneMaxConsentita + " Mb).");
                                }
                            }
                            else
                            {
                                throw new Exception("Il documento è obbligatorio.");
                            }
                        }
                    }

                    db.Database.CurrentTransaction.Commit();
                    return(Json(new { msg = "La lettera di trasferimento è stata inserita." }));
                }
                catch (Exception ex)
                {
                    db.Database.CurrentTransaction.Rollback();
                    return(Json(new { err = ex.Message }));
                }
            }
        }
        public JsonResult InserisciDocumentoTV(
            decimal idTrasferimento,
            decimal idTipoDocumento,
            HttpPostedFileBase file,
            decimal idFamiliare,
            decimal idAttivazione,
            decimal idParentela,
            decimal idConiugeTV,
            decimal idFigliTV,
            decimal idDocTV)
        {
            using (ModelDBISE db = new ModelDBISE())
            {
                CONIUGETITOLIVIAGGIO ctv = new CONIUGETITOLIVIAGGIO();
                FIGLITITOLIVIAGGIO   ftv = new FIGLITITOLIVIAGGIO();
                try
                {
                    db.Database.BeginTransaction();

                    using (dtVariazioneTitoliViaggi dtvtv = new dtVariazioneTitoliViaggi())
                    {
                        using (dtDocumenti dtd = new dtDocumenti())
                        {
                            DocumentiModel dm                      = new DocumentiModel();
                            bool           esisteFile              = false;
                            bool           gestisceEstensioni      = false;
                            bool           dimensioneConsentita    = false;
                            string         dimensioneMaxConsentita = string.Empty;

                            Utility.PreSetDocumento(file, out dm, out esisteFile, out gestisceEstensioni,
                                                    out dimensioneConsentita, out dimensioneMaxConsentita,
                                                    (EnumTipoDoc)idTipoDocumento);

                            if (esisteFile)
                            {
                                if (gestisceEstensioni == false)
                                {
                                    throw new Exception(
                                              "Il documento selezionato non è nel formato consentito. Il formato supportato è: pdf.");
                                }

                                if (dimensioneConsentita)
                                {
                                    //verifica se il documento è gia presente ritornando l'eventuale id
                                    //decimal idDocumentoEsistente = dtvtv.VerificaEsistenzaDocumentoTV(idTrasferimento, idTipoDocumento, idParentela, idFamiliare);
                                    decimal idDocumentoEsistente = idDocTV;

                                    if (idDocumentoEsistente > 0)
                                    {
                                        //se già esiste lo sostituisco (imposto modificato=true su quello esistente e ne inserisco una altro)
                                        dtvtv.SostituisciDocumentoTV(ref dm, idDocumentoEsistente, idAttivazione, db);
                                    }
                                    else
                                    {
                                        //se non esiste lo inserisco
                                        dtvtv.SetDocumentoTV(ref dm, idAttivazione, db);
                                    }

                                    switch ((EnumParentela)idParentela)
                                    {
                                    case EnumParentela.Coniuge:
                                        dtvtv.AssociaDocumento_ConiugeTV(idConiugeTV, dm.idDocumenti, db);
                                        dtd.AssociaDocumentoConiuge(idFamiliare, dm.idDocumenti, db);
                                        break;

                                    case EnumParentela.Figlio:
                                        dtvtv.AssociaDocumento_FigliTV(idFigliTV, dm.idDocumenti, db);
                                        dtd.AssociaDocumentoFiglio(idFamiliare, dm.idDocumenti, db);
                                        break;
                                    }

                                    Utility.SetLogAttivita(EnumAttivitaCrud.Inserimento, "Inserimento di una nuovo documento (maggiorazione abitazione).", "Documenti", db, idTrasferimento, dm.idDocumenti);
                                }
                                else
                                {
                                    throw new Exception(
                                              "Il documento selezionato supera la dimensione massima consentita (" +
                                              dimensioneMaxConsentita + " Mb).");
                                }
                            }
                            else
                            {
                                throw new Exception("Il documento è obbligatorio.");
                            }
                        }
                    }

                    db.Database.CurrentTransaction.Commit();
                    return(Json(new { msg = "Il documento è stato inserito." }));
                }
                catch (Exception ex)
                {
                    db.Database.CurrentTransaction.Rollback();
                    return(Json(new { err = ex.Message }));
                }
            }
        }