コード例 #1
0
        public FileDownloadDTO Exportar(int?id, FormatoExportacaoArquivo formato)
        {
            if (!UsuarioLogado.IsInRole(Funcionalidade.RequisicaoMaterialImprimir))
            {
                messageQueue.Add(Resource.Sigim.ErrorMessages.PrivilegiosInsuficientes, TypeMessage.Error);
                return(null);
            }

            var requisicao = ObterPeloIdEUsuario(id, UsuarioLogado.Id, l => l.ListaItens.Select(o => o.Material.MaterialClasseInsumo));
            relRequisicaoMaterial objRel = new relRequisicaoMaterial();

            objRel.SetDataSource(RequisicaoToDataTable(requisicao));
            objRel.Subreports["requisicaoMaterialItem"].SetDataSource(RequisicaoItemToDataTable(requisicao.ListaItens.ToList()));

            var parametros  = parametrosOrdemCompraRepository.Obter();
            var centroCusto = centroCustoRepository.ObterPeloCodigo(requisicao.CodigoCentroCusto, l => l.ListaCentroCustoEmpresa);

            var caminhoImagem = PrepararIconeRelatorio(centroCusto, parametros);

            objRel.SetParameterValue("caminhoImagem", caminhoImagem);

            var nomeEmpresa = ObterNomeEmpresa(centroCusto, parametros);

            objRel.SetParameterValue("nomeEmpresa", nomeEmpresa);

            FileDownloadDTO arquivo = new FileDownloadDTO(
                "RequisicaoMaterial_" + id.ToString(),
                objRel.ExportToStream((ExportFormatType)formato),
                formato);

            RemoverIconeRelatorio(caminhoImagem);

            return(arquivo);
        }
コード例 #2
0
        public bool Deletar(int?id)
        {
            if (!UsuarioLogado.IsInRole(Funcionalidade.ImpostoFinanceiroDeletar))
            {
                messageQueue.Add(Resource.Sigim.ErrorMessages.PrivilegiosInsuficientes, TypeMessage.Error);
                return(false);
            }

            if (id == null)
            {
                messageQueue.Add(Resource.Sigim.ErrorMessages.NenhumRegistroEncontrado, TypeMessage.Error);
                return(false);
            }

            var impostoFinanceiro = impostoFinanceiroRepository.ObterPeloId(id);

            try
            {
                impostoFinanceiroRepository.Remover(impostoFinanceiro);
                impostoFinanceiroRepository.UnitOfWork.Commit();
                messageQueue.Add(Resource.Sigim.SuccessMessages.ExcluidoComSucesso, TypeMessage.Success);
                return(true);
            }
            catch (Exception)
            {
                messageQueue.Add(string.Format(Resource.Sigim.ErrorMessages.RegistroEmUso, impostoFinanceiro.Descricao), TypeMessage.Error);
                return(false);
            }
        }
コード例 #3
0
        public FileDownloadDTO Exportar(int?id, FormatoExportacaoArquivo formato)
        {
            if (!UsuarioLogado.IsInRole(Funcionalidade.PreRequisicaoMaterialImprimir))
            {
                messageQueue.Add(Resource.Sigim.ErrorMessages.PrivilegiosInsuficientes, TypeMessage.Error);
                return(null);
            }

            var preRequisicao = ObterPeloIdEUsuario(id, UsuarioLogado.Id);
            relPreRequisicaoMaterial objRel = new relPreRequisicaoMaterial();

            objRel.Database.Tables["OrdemCompra_preRequisicaoMaterialRelatorio"].SetDataSource(PreRequisicaoToDataTable(preRequisicao));
            objRel.Database.Tables["OrdemCompra_preRequisicaoMaterialItemRelatorio"].SetDataSource(PreRequisicaoItemToDataTable(preRequisicao.ListaItens.ToList()));

            var parametros = parametrosOrdemCompraRepository.Obter();

            var caminhoImagem = PrepararIconeRelatorio(null, parametros);

            objRel.SetParameterValue("caminhoImagem", caminhoImagem);

            var nomeEmpresa = ObterNomeEmpresa(null, parametros);

            objRel.SetParameterValue("nomeEmpresa", nomeEmpresa);

            FileDownloadDTO arquivo = new FileDownloadDTO(
                "PreRequisicaoMaterial_" + id.ToString(),
                objRel.ExportToStream((ExportFormatType)formato),
                formato);

            RemoverIconeRelatorio(caminhoImagem);

            return(arquivo);
        }
コード例 #4
0
        public bool Aprovar(int?id)
        {
            if (!UsuarioLogado.IsInRole(Funcionalidade.RequisicaoMaterialAprovar))
            {
                messageQueue.Add(Resource.Sigim.ErrorMessages.PrivilegiosInsuficientes, TypeMessage.Error);
                return(false);
            }

            var requisicaoMaterial = ObterPeloIdEUsuario(id, UsuarioLogado.Id);

            if (requisicaoMaterial == null)
            {
                messageQueue.Add(Application.Resource.Sigim.ErrorMessages.NenhumRegistroEncontrado, TypeMessage.Error);
                return(false);
            }

            if (!PodeAprovarNaSituacaoAtual(requisicaoMaterial.Situacao))
            {
                var msg = string.Format(Resource.OrdemCompra.ErrorMessages.RequisicaoSituacaoInvalida, requisicaoMaterial.Situacao.ObterDescricao());
                messageQueue.Add(msg, TypeMessage.Error);
                return(false);
            }

            requisicaoMaterial.Situacao              = SituacaoRequisicaoMaterial.Aprovada;
            requisicaoMaterial.DataAprovacao         = DateTime.Now;
            requisicaoMaterial.LoginUsuarioAprovacao = UsuarioLogado.Login;

            requisicaoMaterialRepository.Alterar(requisicaoMaterial);
            requisicaoMaterialRepository.UnitOfWork.Commit();
            //TODO: Enviar e-mail
            messageQueue.Add(Resource.OrdemCompra.SuccessMessages.AprovacaoRealizadaComSucesso, TypeMessage.Success);
            return(true);
        }
コード例 #5
0
        public bool Deletar(int?id)
        {
            if (!UsuarioLogado.IsInRole(Funcionalidade.FormaRecebimentoDeletar))
            {
                messageQueue.Add(Resource.Sigim.ErrorMessages.PrivilegiosInsuficientes, TypeMessage.Error);
                return(false);
            }

            if (id == null)
            {
                messageQueue.Add(Resource.Sigim.ErrorMessages.NenhumRegistroEncontrado, TypeMessage.Error);
                return(false);
            }

            var formaRecebimento = formaRecebimentoRepository.ObterPeloId(id);

            if (formaRecebimento.Automatico == true)
            {
                messageQueue.Add(Resource.Sigim.ErrorMessages.RegistroProtegido, TypeMessage.Error);
                return(false);
            }

            try
            {
                formaRecebimentoRepository.Remover(formaRecebimento);
                formaRecebimentoRepository.UnitOfWork.Commit();
                messageQueue.Add(Resource.Sigim.SuccessMessages.ExcluidoComSucesso, TypeMessage.Success);
                return(true);
            }
            catch (Exception)
            {
                messageQueue.Add(string.Format(Resource.Sigim.ErrorMessages.RegistroEmUso, formaRecebimento.Descricao), TypeMessage.Error);
                return(false);
            }
        }
コード例 #6
0
        public FileDownloadDTO ExportarRelStatusVenda(RelStatusVendaFiltro filtro,
                                                      int?usuarioId,
                                                      FormatoExportacaoArquivo formato)
        {
            if (!UsuarioLogado.IsInRole(Funcionalidade.RelStatusVendaImprimir))
            {
                messageQueue.Add(Resource.Sigim.ErrorMessages.PrivilegiosInsuficientes, TypeMessage.Error);
                return(null);
            }

            var specification = MontarSpecificationRelStatusVenda(filtro);

            var lista = vendaRepository.ListarPeloFiltro(
                specification,
                l => l.Contrato,
                l => l.Contrato.ListaVendaParticipante.Select(c => c.Cliente),
                l => l.Contrato.Unidade,
                l => l.Contrato.Unidade.Bloco,
                l => l.Contrato.Unidade.Empreendimento,
                l => l.Contrato.Unidade.Empreendimento.Incorporador,
                l => l.TabelaVenda,
                l => l.IndiceFinanceiro
                ).To <List <Venda> >();

            relStatusVenda objRel = new relStatusVenda();

            objRel.SetDataSource(RelStatusVendaToDataTable(lista));

            var   parametros     = parametrosRepository.Obter();
            Moeda moedaPadrao    = new Moeda();
            Moeda moedaConversao = new Moeda();

            if (parametros.MoedaPadraoId.HasValue && parametros.MoedaPadraoId.Value > 0)
            {
                moedaPadrao = moedaRepository.ObterPeloId(parametros.MoedaPadraoId.Value);
            }

            if (filtro.MoedaConversao != 0)
            {
                moedaConversao = moedaRepository.ObterPeloId(filtro.MoedaConversao);
            }

            var caminhoImagem  = PrepararIconeRelatorio(null, parametros);
            var descricaoMoeda = ObterDescricaoMoeda(moedaPadrao, moedaConversao);

            objRel.SetParameterValue("descricaoMoeda", descricaoMoeda);
            objRel.SetParameterValue("caminhoImagem", caminhoImagem);

            FileDownloadDTO arquivo = new FileDownloadDTO(
                "Rel. Status da Venda",
                objRel.ExportToStream((ExportFormatType)formato),
                formato);

            if (System.IO.File.Exists(caminhoImagem))
            {
                System.IO.File.Delete(caminhoImagem);
            }

            return(arquivo);
        }
コード例 #7
0
        public bool Deletar(int?id)
        {
            if (!UsuarioLogado.IsInRole(Funcionalidade.PerfilDeletar))
            {
                messageQueue.Add(Resource.Sigim.ErrorMessages.PrivilegiosInsuficientes, TypeMessage.Error);
                return(false);
            }

            if (id == null)
            {
                messageQueue.Add(Resource.Sigim.ErrorMessages.NenhumRegistroEncontrado, TypeMessage.Error);
                return(false);
            }

            var perfil = perfilRepository.ObterPeloId(id, l => l.ListaFuncionalidade);

            try
            {
                for (int i = perfil.ListaFuncionalidade.Count - 1; i >= 0; i--)
                {
                    perfilFuncionalidadeRepository.Remover(perfil.ListaFuncionalidade.ToList()[i]);
                }

                perfilRepository.Remover(perfil);
                perfilRepository.UnitOfWork.Commit();
                messageQueue.Add(Resource.Sigim.SuccessMessages.ExcluidoComSucesso, TypeMessage.Success);
                return(true);
            }
            catch (Exception)
            {
                messageQueue.Add(string.Format(Resource.Sigim.ErrorMessages.RegistroEmUso, perfil.Descricao), TypeMessage.Error);
                return(false);
            }
        }
コード例 #8
0
        public FileDownloadDTO ExportarRelNotaFiscalLiberada(RelNotaFiscalLiberadaFiltro filtro,
                                                             int?usuarioId,
                                                             FormatoExportacaoArquivo formato)
        {
            if (!UsuarioLogado.IsInRole(Funcionalidade.RelNotasFiscaisLiberadasImprimir))
            {
                messageQueue.Add(Resource.Sigim.ErrorMessages.PrivilegiosInsuficientes, TypeMessage.Error);
                return(null);
            }

            var specification = MontarSpecificationRelNotaFiscalLiberada(filtro, usuarioId);

            var listaMedicao =
                contratoRetificacaoItemMedicaoRepository.ListarPeloFiltro(specification,
                                                                          l => l.Contrato.ContratoDescricao,
                                                                          l => l.Contrato.CentroCusto.ListaUsuarioCentroCusto.Select(u => u.Modulo),
                                                                          l => l.Contrato.Contratado.PessoaFisica,
                                                                          l => l.Contrato.Contratado.PessoaJuridica,
                                                                          l => l.Contrato.Contratante.PessoaFisica,
                                                                          l => l.Contrato.Contratante.PessoaJuridica,
                                                                          l => l.ContratoRetificacao,
                                                                          l => l.ContratoRetificacaoItem.Classe,
                                                                          l => l.ContratoRetificacaoItem.Servico,
                                                                          l => l.ContratoRetificacaoItem.ListaContratoRetificacaoItemImposto.Select(i => i.ImpostoFinanceiro),
                                                                          l => l.MultiFornecedor,
                                                                          l => l.ContratoRetificacaoItemCronograma,
                                                                          l => l.TipoDocumento,
                                                                          l => l.TituloPagar,
                                                                          l => l.TituloReceber).To <List <ContratoRetificacaoItemMedicao> >();

            relNotaFiscalLiberada objRel = new relNotaFiscalLiberada();

            objRel.SetDataSource(RelNotaFiscalLiberadaToDataTable(listaMedicao));

            string periodo = filtro.DataInicial.Value.ToString("dd/MM/yyyy") + "  a  " + filtro.DataFinal.Value.ToString("dd/MM/yyyy");

            var parametros  = parametrosContratoRepository.Obter();
            var centroCusto = centroCustoRepository.ObterPeloCodigo(filtro.CentroCusto.Codigo, l => l.ListaCentroCustoEmpresa);

            var caminhoImagem = PrepararIconeRelatorio(centroCusto, parametros);

            var nomeEmpresa = ObterNomeEmpresa(centroCusto, parametros);

            objRel.SetParameterValue("nomeEmpresa", nomeEmpresa);
            objRel.SetParameterValue("descricaoCentroCusto", centroCusto != null ?  centroCusto.Descricao : "");
            objRel.SetParameterValue("periodo", periodo);
            objRel.SetParameterValue("caminhoImagem", caminhoImagem);

            FileDownloadDTO arquivo = new FileDownloadDTO(
                "Rel. Nota Fiscal Liberada",
                objRel.ExportToStream((ExportFormatType)formato),
                formato);

            if (System.IO.File.Exists(caminhoImagem))
            {
                System.IO.File.Delete(caminhoImagem);
            }
            return(arquivo);
        }
コード例 #9
0
        public bool EhPermitidoImprimirRelStatusVenda()
        {
            if (!UsuarioLogado.IsInRole(Funcionalidade.RelStatusVendaImprimir))
            {
                return(false);
            }

            return(true);
        }
コード例 #10
0
        public bool EhPermitidoDeletar()
        {
            if (!UsuarioLogado.IsInRole(Funcionalidade.UsuarioFuncionalidadeDeletar))
            {
                return(false);
            }

            return(true);
        }
コード例 #11
0
        public bool EhPermitidoImprimir()
        {
            if (!UsuarioLogado.IsInRole(Funcionalidade.RelNotasFiscaisLiberadasImprimir))
            {
                return(false);
            }

            return(true);
        }
コード例 #12
0
        public bool EhPermitidoSalvar()
        {
            if (!UsuarioLogado.IsInRole(Funcionalidade.PerfilGravar))
            {
                return(false);
            }

            return(true);
        }
コード例 #13
0
        public bool EhPermitidoImprimir()
        {
            if (!UsuarioLogado.IsInRole(Funcionalidade.RelatorioItensOrdemCompraImprimir))
            {
                return(false);
            }

            return(true);
        }
コード例 #14
0
        public bool EhPermitidoImprimir()
        {
            if (!UsuarioLogado.IsInRole(Funcionalidade.TipoMovimentoImprimir))
            {
                return(false);
            }

            return(true);
        }
コード例 #15
0
        public bool EhPermitidoSalvar(PreRequisicaoMaterialDTO dto)
        {
            if (!UsuarioLogado.IsInRole(Funcionalidade.PreRequisicaoMaterialGravar))
            {
                return(false);
            }

            return(PodeSerSalvaNaSituacaoAtual(dto.Situacao));
        }
コード例 #16
0
        public bool EhPermitidoSalvar()
        {
            if (!UsuarioLogado.IsInRole(Funcionalidade.ParametroFinanceiroGravar))
            {
                return(false);
            }

            return(true);
        }
コード例 #17
0
        public void Salvar(ParametrosUsuarioFinanceiroDTO dto)
        {
            if (!UsuarioLogado.IsInRole(Funcionalidade.ParametroUsuarioFinanceiroAcessar))
            {
                messageQueue.Add(Resource.Sigim.ErrorMessages.PrivilegiosInsuficientes, TypeMessage.Error);
                return;
            }

            if (dto == null)
            {
                throw new ArgumentNullException("dto");
            }

            bool novoItem = false;

            var parametrosUsuarioFinanceiro = parametrosUsuarioFinanceiroRepository.ObterPeloId(dto.Id);

            if (parametrosUsuarioFinanceiro == null)
            {
                parametrosUsuarioFinanceiro = new ParametrosUsuarioFinanceiro()
                {
                    Id = dto.Id
                };
                novoItem = true;
            }

            parametrosUsuarioFinanceiro.PortaSerial = dto.PortaSerial;

            parametrosUsuarioFinanceiro.TipoImpressora = GIR.Sigim.Application.DTO.Financeiro.TipoImpressoraEnum.Bematech.ToString().ToUpper();
            if (dto.TipoImpressoraEscolhida == GIR.Sigim.Application.DTO.Financeiro.TipoImpressoraEnum.Pertocheck)
            {
                parametrosUsuarioFinanceiro.TipoImpressora = GIR.Sigim.Application.DTO.Financeiro.TipoImpressoraEnum.Pertocheck.ToString().ToUpper();
            }


            if (Validator.IsValid(parametrosUsuarioFinanceiro, out validationErrors))
            {
                if (novoItem)
                {
                    parametrosUsuarioFinanceiroRepository.Inserir(parametrosUsuarioFinanceiro);
                }
                else
                {
                    parametrosUsuarioFinanceiroRepository.Alterar(parametrosUsuarioFinanceiro);
                }

                parametrosUsuarioFinanceiroRepository.UnitOfWork.Commit();

                messageQueue.Add(Resource.Sigim.SuccessMessages.SalvoComSucesso, TypeMessage.Success);
            }
            else
            {
                messageQueue.AddRange(validationErrors, TypeMessage.Error);
            }
        }
コード例 #18
0
        public bool Salvar(ParametrosOrdemCompraDTO dto)
        {
            if (!UsuarioLogado.IsInRole(Funcionalidade.ParametroOrdemCompraGravar))
            {
                messageQueue.Add(Resource.Sigim.ErrorMessages.PrivilegiosInsuficientes, TypeMessage.Error);
                return(false);
            }

            if (dto == null)
            {
                throw new ArgumentNullException("dto");
            }

            var parametros = dto.To <ParametrosOrdemCompra>();
            var entidade   = this.Obter();

            if (entidade != null)
            {
                parametros.Id = entidade.Id;
                if ((dto.IconeRelatorio == null) && (!dto.RemoverImagem) && (entidade.IconeRelatorio.Length > 0))
                {
                    parametros.IconeRelatorio = entidade.IconeRelatorio;
                }
            }

            if (EhValido(parametros))
            {
                if (parametros.Id.HasValue)
                {
                    parametrosRepository.Alterar(parametros);
                }
                else
                {
                    parametrosRepository.Inserir(parametros);
                }

                parametrosOrcamentoAppService.AtualizarMascaraClasseInsumo(parametros.MascaraClasseInsumo);

                parametrosContratoAppService.AtualizarMascaraClasseInsumo(parametros.MascaraClasseInsumo);

                parametrosRepository.UnitOfWork.Commit();

                messageQueue.Add(Resource.Sigim.SuccessMessages.SalvoComSucesso, TypeMessage.Success);
                return(true);
            }
            else
            {
                return(false);
            }
        }
コード例 #19
0
        public bool CancelarRequisicao(int?id, string motivo)
        {
            if (!UsuarioLogado.IsInRole(Funcionalidade.RequisicaoMaterialCancelar))
            {
                messageQueue.Add(Resource.Sigim.ErrorMessages.PrivilegiosInsuficientes, TypeMessage.Error);
                return(false);
            }

            if (string.IsNullOrEmpty(motivo.Trim()))
            {
                messageQueue.Add(Resource.OrdemCompra.ErrorMessages.InformeMotivoCancelamentoRequisicao, TypeMessage.Error);
                return(false);
            }

            var requisicaoMaterial = ObterPeloIdEUsuario(id, UsuarioLogado.Id, l => l.ListaItens.Select(o => o.ListaOrcamentoInsumoRequisitado));

            if (requisicaoMaterial == null)
            {
                messageQueue.Add(Application.Resource.Sigim.ErrorMessages.NenhumRegistroEncontrado, TypeMessage.Error);
                return(false);
            }

            if (!PodeCancelarNaSituacaoAtual(requisicaoMaterial.Situacao))
            {
                var msg = string.Format(Resource.OrdemCompra.ErrorMessages.PreRequisicaoSituacaoInvalida, requisicaoMaterial.Situacao.ObterDescricao());
                messageQueue.Add(msg, TypeMessage.Error);
                return(false);
            }

            if (!PodeCancelarComItensAtuais(requisicaoMaterial.ListaItens.To <List <RequisicaoMaterialItemDTO> >()))
            {
                messageQueue.Add(Resource.OrdemCompra.ErrorMessages.RequisicaoComItensNaoRequisitados, TypeMessage.Error);
                return(false);
            }

            requisicaoMaterial.MotivoCancelamento       = motivo;
            requisicaoMaterial.Situacao                 = SituacaoRequisicaoMaterial.Cancelada;
            requisicaoMaterial.DataCancelamento         = DateTime.Now;
            requisicaoMaterial.LoginUsuarioCancelamento = UsuarioLogado.Login;
            foreach (var item in requisicaoMaterial.ListaItens)
            {
                item.Situacao = SituacaoRequisicaoMaterialItem.Cancelado;
                item.ListaOrcamentoInsumoRequisitado.Clear();
            }

            requisicaoMaterialRepository.Alterar(requisicaoMaterial);
            requisicaoMaterialRepository.UnitOfWork.Commit();
            messageQueue.Add(Resource.OrdemCompra.SuccessMessages.CancelamentoComSucesso, TypeMessage.Success);
            return(true);
        }
コード例 #20
0
        public bool Salvar(MotivoCancelamentoDTO dto)
        {
            if (!UsuarioLogado.IsInRole(Funcionalidade.MotivoCancelamentoGravar))
            {
                messageQueue.Add(Resource.Sigim.ErrorMessages.PrivilegiosInsuficientes, TypeMessage.Error);
                return(false);
            }

            if (dto == null)
            {
                throw new ArgumentNullException("dto");
            }

            bool novoItem = false;

            var motivoCancelamento = motivoCancelamentoRepository.ObterPeloId(dto.Id);

            if (motivoCancelamento == null)
            {
                motivoCancelamento = new MotivoCancelamento();
                novoItem           = true;
            }

            motivoCancelamento.Descricao = dto.Descricao;

            if (Validator.IsValid(motivoCancelamento, out validationErrors))
            {
                if (novoItem)
                {
                    motivoCancelamentoRepository.Inserir(motivoCancelamento);
                }
                else
                {
                    motivoCancelamentoRepository.Alterar(motivoCancelamento);
                }

                motivoCancelamentoRepository.UnitOfWork.Commit();
                messageQueue.Add(Resource.Sigim.SuccessMessages.SalvoComSucesso, TypeMessage.Success);
                return(true);
            }
            else
            {
                messageQueue.AddRange(validationErrors, TypeMessage.Error);
            }

            return(false);
        }
コード例 #21
0
        public bool Cancelar(int?id, string motivo)
        {
            if (!UsuarioLogado.IsInRole(Funcionalidade.PreRequisicaoMaterialCancelar))
            {
                messageQueue.Add(Resource.Sigim.ErrorMessages.PrivilegiosInsuficientes, TypeMessage.Error);
                return(false);
            }

            if (string.IsNullOrEmpty(motivo.Trim()))
            {
                messageQueue.Add(Resource.OrdemCompra.ErrorMessages.InformeMotivoCancelamentoPreRequisicao, TypeMessage.Error);
                return(false);
            }

            var preRequisicaoMaterial = preRequisicaoMaterialRepository.ObterPeloId(id, l => l.ListaItens);

            if (preRequisicaoMaterial == null)
            {
                messageQueue.Add(Application.Resource.Sigim.ErrorMessages.NenhumRegistroEncontrado, TypeMessage.Error);
                return(false);
            }

            if (!PodeCancelarNaSituacaoAtual(preRequisicaoMaterial.Situacao))
            {
                var msg = string.Format(Resource.OrdemCompra.ErrorMessages.PreRequisicaoSituacaoInvalida, preRequisicaoMaterial.Situacao.ObterDescricao());
                messageQueue.Add(msg, TypeMessage.Error);
                return(false);
            }

            if (preRequisicaoMaterial.ListaItens.Any())
            {
                messageQueue.Add(Resource.OrdemCompra.ErrorMessages.PreRequisicaoComItens, TypeMessage.Error);
                return(false);
            }

            preRequisicaoMaterial.MotivoCancelamento       = motivo;
            preRequisicaoMaterial.Situacao                 = SituacaoPreRequisicaoMaterial.Cancelada;
            preRequisicaoMaterial.DataCancelamento         = DateTime.Now;
            preRequisicaoMaterial.LoginUsuarioCancelamento = UsuarioLogado.Login;

            preRequisicaoMaterialRepository.Alterar(preRequisicaoMaterial);
            preRequisicaoMaterialRepository.UnitOfWork.Commit();
            messageQueue.Add(Resource.OrdemCompra.SuccessMessages.CancelamentoComSucesso, TypeMessage.Success);
            return(true);
        }
コード例 #22
0
        public bool SalvarPermissoes(int UsuarioId, int ModuloId, int?PerfilId, List <UsuarioFuncionalidadeDTO> listaFuncionalidadeDTO)
        {
            if (!UsuarioLogado.IsInRole(Funcionalidade.UsuarioFuncionalidadeGravar))
            {
                messageQueue.Add(Resource.Sigim.ErrorMessages.PrivilegiosInsuficientes, TypeMessage.Error);
                return(false);
            }

            if (!ValidaSalvar(UsuarioId, ModuloId, PerfilId, listaFuncionalidadeDTO))
            {
                return(false);
            }

            var objUsuario = usuarioRepository.ObterPeloId(UsuarioId,
                                                           l => l.ListaUsuarioFuncionalidade,
                                                           l => l.ListaUsuarioPerfil);

            RemoverFuncionalidade(objUsuario, ModuloId);
            AdicionarFuncionalidade(objUsuario, ModuloId, listaFuncionalidadeDTO);
            RemoverPerfil(objUsuario, ModuloId);
            AdicionarPerfil(objUsuario, ModuloId, PerfilId);

            if (Validator.IsValid(objUsuario, out validationErrors))
            {
                try
                {
                    usuarioRepository.Alterar(objUsuario);
                    usuarioRepository.UnitOfWork.Commit();
                    messageQueue.Add(Resource.Sigim.SuccessMessages.SalvoComSucesso, TypeMessage.Success);
                    return(true);
                }
                catch (Exception exception)
                {
                    QueueExeptionMessages(exception);
                    return(false);
                }
            }
            else
            {
                messageQueue.AddRange(validationErrors, TypeMessage.Error);
                return(false);
            }
        }
コード例 #23
0
        public bool EhPermitidoAprovarItem(PreRequisicaoMaterialDTO dto)
        {
            if (!UsuarioLogado.IsInRole(Funcionalidade.PreRequisicaoMaterialAprovar))
            {
                return(false);
            }

            if ((dto.Situacao != SituacaoPreRequisicaoMaterial.Requisitada) && (dto.Situacao != SituacaoPreRequisicaoMaterial.ParcialmenteAprovada))
            {
                return(false);
            }

            if (!dto.ListaItens.Any(l => l.Situacao == SituacaoPreRequisicaoMaterialItem.Requisitado))
            {
                return(false);
            }

            return(true);
        }
コード例 #24
0
        public bool EhPermitidoImprimir(PreRequisicaoMaterialDTO dto)
        {
            if (!UsuarioLogado.IsInRole(Funcionalidade.PreRequisicaoMaterialImprimir))
            {
                return(false);
            }

            if (!dto.Id.HasValue)
            {
                return(false);
            }

            if (!dto.ListaItens.Any())
            {
                return(false);
            }

            return(true);
        }
コード例 #25
0
        public void Salvar(ParametrosFinanceiroDTO dto)
        {
            if (!UsuarioLogado.IsInRole(Funcionalidade.ParametroFinanceiroGravar))
            {
                messageQueue.Add(Resource.Sigim.ErrorMessages.PrivilegiosInsuficientes, TypeMessage.Error);
                return;
            }

            if (dto == null)
            {
                throw new ArgumentNullException("dto");
            }

            var parametros = dto.To <ParametrosFinanceiro>();
            var entidade   = Obter();

            if (entidade != null)
            {
                parametros.Id = entidade.Id;
                if ((dto.IconeRelatorio == null) && (!dto.RemoverImagem) && (entidade.IconeRelatorio.Length > 0))
                {
                    parametros.IconeRelatorio = entidade.IconeRelatorio;
                }
            }

            parametros.BloqueioSituacaoLiberado = PreencherStringBloqueioSituacaoLiberado(dto);

            if (EhValido(parametros))
            {
                if (parametros.Id.HasValue)
                {
                    parametrosRepository.Alterar(parametros);
                }
                else
                {
                    parametrosRepository.Inserir(parametros);
                }

                parametrosRepository.UnitOfWork.Commit();

                messageQueue.Add(Resource.Sigim.SuccessMessages.SalvoComSucesso, TypeMessage.Success);
            }
        }
コード例 #26
0
        public bool EhPermitidoCancelar(PreRequisicaoMaterialDTO dto)
        {
            if (!UsuarioLogado.IsInRole(Funcionalidade.PreRequisicaoMaterialCancelar))
            {
                return(false);
            }

            if (!dto.Id.HasValue)
            {
                return(false);
            }

            if (!PodeCancelarNaSituacaoAtual(dto.Situacao))
            {
                return(false);
            }

            if (dto.ListaItens.Any())
            {
                return(false);
            }

            return(true);
        }
コード例 #27
0
        public bool EhPermitidoCancelarAprovacao(RequisicaoMaterialDTO dto)
        {
            if (!UsuarioLogado.IsInRole(Funcionalidade.RequisicaoMaterialCancelarAprovacao))
            {
                return(false);
            }

            if (!dto.Id.HasValue)
            {
                return(false);
            }

            if (!PodeCancelarAprovacaoNaSituacaoAtual(dto.Situacao))
            {
                return(false);
            }

            if (!PodeCancelarComItensAtuais(dto.ListaItens))
            {
                return(false);
            }

            return(true);
        }
コード例 #28
0
        public bool CancelarAprovacao(int?id)
        {
            if (!UsuarioLogado.IsInRole(Funcionalidade.RequisicaoMaterialCancelarAprovacao))
            {
                messageQueue.Add(Resource.Sigim.ErrorMessages.PrivilegiosInsuficientes, TypeMessage.Error);
                return(false);
            }

            var requisicaoMaterial = ObterPeloIdEUsuario(id, UsuarioLogado.Id);

            if (requisicaoMaterial == null)
            {
                messageQueue.Add(Application.Resource.Sigim.ErrorMessages.NenhumRegistroEncontrado, TypeMessage.Error);
                return(false);
            }

            if (!PodeCancelarAprovacaoNaSituacaoAtual(requisicaoMaterial.Situacao))
            {
                var msg = string.Format(Resource.OrdemCompra.ErrorMessages.RequisicaoSituacaoInvalida, requisicaoMaterial.Situacao.ObterDescricao());
                messageQueue.Add(msg, TypeMessage.Error);
                return(false);
            }

            if (!PodeCancelarComItensAtuais(requisicaoMaterial.ListaItens.To <List <RequisicaoMaterialItemDTO> >()))
            {
                messageQueue.Add(Resource.OrdemCompra.ErrorMessages.RequisicaoComItensNaoRequisitados, TypeMessage.Error);
                return(false);
            }

            requisicaoMaterial.Situacao = SituacaoRequisicaoMaterial.Requisitada;

            requisicaoMaterialRepository.Alterar(requisicaoMaterial);
            requisicaoMaterialRepository.UnitOfWork.Commit();
            messageQueue.Add(Resource.OrdemCompra.SuccessMessages.AprovacaoCanceladaComSucesso, TypeMessage.Success);
            return(true);
        }
コード例 #29
0
        public bool Salvar(FormaRecebimentoDTO dto)
        {
            if (!UsuarioLogado.IsInRole(Funcionalidade.FormaRecebimentoGravar))
            {
                messageQueue.Add(Resource.Sigim.ErrorMessages.PrivilegiosInsuficientes, TypeMessage.Error);
                return(false);
            }

            if (dto == null)
            {
                throw new ArgumentNullException("dto");
            }

            if (dto.NumeroDias.HasValue)
            {
                if (dto.NumeroDias.Value < 0)
                {
                    messageQueue.Add("O número de dias não pode ser menor que zero !", TypeMessage.Error);
                    return(false);
                }
            }

            bool novoItem = false;

            var formaRecebimento = formaRecebimentoRepository.ObterPeloId(dto.Id);

            if (formaRecebimento == null)
            {
                formaRecebimento = new FormaRecebimento();
                novoItem         = true;
            }
            if (formaRecebimento.Automatico == true)
            {
                return(false);
            }

            formaRecebimento.Descricao       = dto.Descricao;
            formaRecebimento.Automatico      = dto.Automatico;
            formaRecebimento.TipoRecebimento = dto.TipoRecebimento;
            formaRecebimento.NumeroDias      = dto.NumeroDias;
            if (!dto.NumeroDias.HasValue)
            {
                formaRecebimento.NumeroDias = 0;
            }

            if (Validator.IsValid(formaRecebimento, out validationErrors))
            {
                if (novoItem)
                {
                    formaRecebimentoRepository.Inserir(formaRecebimento);
                }
                else
                {
                    formaRecebimentoRepository.Alterar(formaRecebimento);
                }

                formaRecebimentoRepository.UnitOfWork.Commit();
                messageQueue.Add(Resource.Sigim.SuccessMessages.SalvoComSucesso, TypeMessage.Success);
                return(true);
            }
            else
            {
                messageQueue.AddRange(validationErrors, TypeMessage.Error);
                return(false);
            }
        }
コード例 #30
0
 public bool EhPermitidoImprimir()
 {
     return(UsuarioLogado.IsInRole(Funcionalidade.FormaRecebimentoImprimir));
 }