コード例 #1
0
        public async Task PubblicaFascicolo(ATTI attoInDb, PubblicaFascicoloModel model, PersonaDto currentUser)
        {
            try
            {
                switch (model.Ordinamento)
                {
                case OrdinamentoEnum.Default:
                case OrdinamentoEnum.Presentazione:
                    attoInDb.OrdinePresentazione        = model.Abilita;
                    attoInDb.LinkFascicoloPresentazione = string.Empty;
                    break;

                case OrdinamentoEnum.Votazione:
                    attoInDb.OrdineVotazione        = model.Abilita;
                    attoInDb.LinkFascicoloVotazione = string.Empty;
                    break;

                default:
                    throw new ArgumentOutOfRangeException(nameof(model.Ordinamento), model.Ordinamento, null);
                }

                attoInDb.UIDPersonaModifica = currentUser.UID_persona;
                attoInDb.DataModifica       = DateTime.Now;

                await _unitOfWork.CompleteAsync();
            }
            catch (Exception e)
            {
                Log.Error("Pubblica Fascicolo", e);
                throw;
            }
        }
コード例 #2
0
        public async Task <ATTI> SalvaAtto(ATTI attoInDb, AttiFormUpdateModel attoModel, PersonaDto currentUser)
        {
            try
            {
                attoInDb.UIDPersonaModifica = currentUser.UID_persona;
                attoInDb.DataModifica       = DateTime.Now;
                Mapper.Map(attoModel, attoInDb);
                if (!attoModel.Data_chiusura.HasValue)
                {
                    attoInDb.Data_chiusura = null;
                }

                await _unitOfWork.CompleteAsync();

                if (attoModel.DocAtto_Stream != null)
                {
                    var path = ByteArrayToFile(attoModel.DocAtto_Stream);
                    attoInDb.Path_Testo_Atto = Path.Combine(AppSettingsConfiguration.PrefissoCompatibilitaDocumenti, path);
                    await _unitOfWork.CompleteAsync();
                }

                return(attoInDb);
            }
            catch (Exception e)
            {
                Log.Error("Salva Atto", e);
                throw e;
            }
        }
コード例 #3
0
 public async Task DeleteAtto(ATTI attoInDb)
 {
     try
     {
         attoInDb.Eliminato = true;
         await _unitOfWork.CompleteAsync();
     }
     catch (Exception e)
     {
         Log.Error("Elimina Atto", e);
         throw e;
     }
 }
コード例 #4
0
        public async Task <ATTI> NuovoAtto(ATTI atto, PersonaDto currentUser)
        {
            try
            {
                atto.UIDAtto             = Guid.NewGuid();
                atto.Eliminato           = false;
                atto.UIDPersonaCreazione = currentUser.UID_persona;
                atto.DataCreazione       = DateTime.Now;
                atto.OrdinePresentazione = false;
                atto.OrdineVotazione     = false;
                atto.Priorita            = await _unitOfWork.Atti.PrioritaAtto(atto.UIDSeduta.Value);

                _unitOfWork.Atti.Add(atto);
                await _unitOfWork.CompleteAsync();

                return(atto);
            }
            catch (Exception e)
            {
                Log.Error("Nuovo Atto", e);
                throw e;
            }
        }
コード例 #5
0
        public async Task ModificaFascicoli(ATTI attoInDb, AttiDto attiDto)
        {
            try
            {
                if (!string.IsNullOrEmpty(attiDto.LinkFascicoloPresentazione))
                {
                    attoInDb.LinkFascicoloPresentazione = attiDto.LinkFascicoloPresentazione;
                    attoInDb.DataCreazionePresentazione = DateTime.Now;
                }

                if (!string.IsNullOrEmpty(attiDto.LinkFascicoloVotazione))
                {
                    attoInDb.LinkFascicoloVotazione = attiDto.LinkFascicoloVotazione;
                    attoInDb.DataCreazioneVotazione = DateTime.Now;
                }

                await _unitOfWork.CompleteAsync();
            }
            catch (Exception e)
            {
                Log.Error("Modifica Fascicoli Atto", e);
                throw e;
            }
        }
コード例 #6
0
        public async Task <ATTI> SalvaAtto(ATTI attoInDb, AttiFormUpdateModel attoModel, PersonaDto currentUser)
        {
            try
            {
                attoInDb.UIDPersonaModifica = currentUser.UID_persona;
                attoInDb.DataModifica       = DateTime.Now;
                Mapper.Map(attoModel, attoInDb);
                await _unitOfWork.CompleteAsync();

                if (attoModel.DocAtto_Stream != null)
                {
                    var path = ByteArrayToFile(attoModel.DocAtto_Stream, DocTypeEnum.ATTO);
                    attoInDb.Path_Testo_Atto = path;
                    await _unitOfWork.CompleteAsync();
                }

                return(attoInDb);
            }
            catch (Exception e)
            {
                Log.Error("Salva Atto", e);
                throw e;
            }
        }