public object ObterDadosPdf(IEspecificidade especificidade, BancoDeDados banco)
{
try
{
Autorizacao autorizacao = _da.ObterDadosPDF(especificidade.Titulo.Id, banco);
DataEmissaoPorExtenso(autorizacao.Titulo);
autorizacao.QueimaControlada = new QueimaControladaPDF(new QueimaControladaBus().ObterPorEmpreendimento(especificidade.Titulo.EmpreendimentoId.GetValueOrDefault()));
List <ArquivoProjeto> arquivosProj = new ProjetoGeograficoBus().ObterArquivos(especificidade.Titulo.EmpreendimentoId.GetValueOrDefault(0), eCaracterizacao.QueimaControlada, true).Where(x => x.Tipo == (int)eProjetoGeograficoArquivoTipo.Croqui).ToList();
autorizacao.AnexosPdfs = arquivosProj.Cast <Arquivo>().ToList();
//Obtendo Arquivos
ArquivoBus _busArquivo = new ArquivoBus(eExecutorTipo.Interno);
for (int i = 0; i < autorizacao.AnexosPdfs.Count; i++)
{
autorizacao.AnexosPdfs[i] = _busArquivo.ObterDados(autorizacao.AnexosPdfs[i].Id.GetValueOrDefault(0));
}
return(autorizacao);
}
catch (Exception exc)
{
Validacao.AddErro(exc);
}
return(null);
}
/// <summary>
/// Evento do botão de editar a autorização
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void btn_editarAutorizacao_Click(object sender, EventArgs e)
{
try
{
foreach (Form mdiChild in principalUi.MdiChildren)
{
if (mdiChild.GetType() == typeof(SolicitarAutorizacao))
{
mdiChild.Close();
}
}
funcionario = CriaFuncionario();
autorizacao = CriaAutorizacao();
if (!funcionario.Equals(null))
{
SolicitarAutorizacao frmSolicitarautorizacao = new SolicitarAutorizacao(funcionario, autorizacao, principalUi);
frmSolicitarautorizacao.MdiParent = principalUi;
frmSolicitarautorizacao.Show();
//this.Close();
}
}
catch (Exception ex)
{
Mensageiro.MensagemErro(ex, principalUi);
}
}
} // CopiarAutorizações
#region Métodos privados
private AutorizarUsuarioViewModel PreencheModel(AutorizarUsuarioViewModel model)
{
string copia = model.UsuarioCopia;
Autorizacao auth = new Autorizacao();
auth.Usuario = new Profissional();
auth.Usuario.Codigo = model.NomeUsuario;
auth.UsuarioAutorizando = usuario;
auth.OrgaoAutorizado = new Orgao();
if (auth.UsuarioAutorizando.Perfil != Perfil.GERENTE)
{
auth.OrgaoAutorizado.Sigla = usuario.OrgaoAtual.Sigla;
}
IList <Autorizacao> autorizacoes = new List <Autorizacao>();
autorizacoes.Add(auth);
model.PreencherDadosView(autorizacoes);
model.UsuarioLiberacao = usuario;
model = new FachadaAdmWeb <AutorizarUsuarioViewModel>().Consultar(model)[0];
model.UsuarioCopia = copia;
return(model);
}
public override IConfiguradorPdf ObterConfiguradorPdf(IEspecificidade especificidade)
{
ConfiguracaoDefault conf = new ConfiguracaoDefault();
conf.AddLoadAcao((doc, dataSource) =>
{
Autorizacao autorizacao = dataSource as Autorizacao;
List <Table> itenRemover = new List <Table>();
conf.CabecalhoRodape = CabecalhoRodapeFactory.Criar(especificidade.Titulo.SetorId);
if (autorizacao.ExploracaoFlorestal.Count <= 0)
{
itenRemover.Add(doc.LastTable("«TableStart:ExploracaoFlorestal»"));
}
if (autorizacao.Anexos.Count <= 0)
{
doc.FindTable("«TableStart:Anexos»").RemovePageBreakAnterior();
itenRemover.Add(doc.FindTable("«TableStart:Anexos»"));
}
AsposeExtensoes.RemoveTables(itenRemover);
});
return(conf);
}
/// <summary>
/// Evento do botão autorizar
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void btn_autorizar_Click(object sender, EventArgs e)
{
try
{
if (!VericaCamposObrigatorios())
{
throw new Exception("Existem campos vazios!");
}
controleFuncionario = new FuncionarioControl();
bool salvouFuncionario = controleFuncionario.Salvar(CriaFuncionario(), true);
Autorizacao autorizar = CriaAutorizacao();
controleAutorizacao = new AutorizacaoControl();
bool salvouAutorizacao = controleAutorizacao.Salvar(autorizar, true);
if (salvouAutorizacao && salvouFuncionario)
{
Mensageiro.MensagemAviso($"Salvo com sucesso!!!{Environment.NewLine}O número da autorização é: {autorizar.numeroautorizacao}", PrincipalUi);
LimpaCampos();
lbl_ultimaautoriz.Text = $@"0{controleAutorizacao.RetornaUltimaAutorizacao()}/{DateTime.Now.Year}";
}
else
{
throw new Exception("Não foi possível salvar no banco o funcionário ou a autorização.");
}
}
catch (Exception ex)
{
Mensageiro.MensagemErro(ex, this);
}
}
/// <summary>
/// Cria o objeto Autorização
/// </summary>
/// <returns></returns>
private Autorizacao CriaAutorizacao()
{
DeterminaTipoAutorizacao();
var autoriz = new Autorizacao(idinstituicao: (int)cbo_instituicao.SelectedValue, codigorequerente: (int)controleFuncionario.PesquisaID(cpf: msk_cpf.Text), dataExpedicao: DateTime.Now, tipoAutoriz: tipoAutoriz);
controleFuncionario = new FuncionarioControl();
controleAutorizacao = new AutorizacaoControl();
autoriz.Tipoautorizacao = this.tipoAutoriz;
autoriz.Idfuncionario = (int)controleFuncionario.PesquisaID(cpf: msk_cpf.Text);
autoriz.nivelensino = this.cbo_nivelensino.Text.ToUpper();
autoriz.usuario = PrincipalUi.user.nomeusuario.ToUpper(); //Get nome do usuario
autoriz.IdInstituicao = (int)cbo_instituicao.SelectedValue;
if (cbo_disciplina.SelectedValue != null)
{
autoriz.Disciplina = Convert.ToInt16(value: this.cbo_disciplina.SelectedValue);
}
autoriz.Dataexpedicao = DateTime.Now;
autoriz.Datapossecargo = DateTime.Now;
string num = controleAutorizacao.RetornaUltimaAutorizacao();
var data = DateTime.Now.Year.ToString(); //get ano atual
autoriz.numeroautorizacao = $"0{num}/{data}"; //acrescenta o zero na frente do número da autorização
return(autoriz);
}
public async Task <IHttpActionResult> PutAutorizacao(long id, Autorizacao autorizacao)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != autorizacao.id)
{
return(BadRequest());
}
db.Entry(autorizacao).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!AutorizacaoExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public override string Executar(object entidade)
{
if (entidade is CopiaDeAutorizacao)
{
CopiaDeAutorizacao copia = entidade as CopiaDeAutorizacao;
string msg = this.Executar(copia.AutorizacaoOrigem);
if (msg == null)
{
msg = this.Executar(copia.AutorizacaoDestino);
}
return(msg);
}
Autorizacao auth = entidade as Autorizacao;
IFachada <Profissional> fachada = new FachadaAdmWeb <Profissional>();
fachada.SalvaConexaoAtiva(this.conexao); // Manter conexão anterior
fachada.SalvaTransacaoAtiva(this.transacao); // Manter transação anterior
fachada.DefineTemQueFecharConexao(false); // Não fechar ao finalizar
Orgao aux = auth.Usuario.OrgaoAtual;
auth.Usuario.OrgaoAtual = null;
IList <Profissional> retorno = fachada.Consultar(auth.Usuario);
auth.Usuario.OrgaoAtual = aux;
if (retorno == null)
{
return("O Usuário informado não existe!");
}
return(null);
}
/// <summary>
/// Repassa aos controles os dados da autorização
/// </summary>
/// <param name="autorizacao1"></param>
private void RepassaAutorizacao(Autorizacao autorizacao1)
{
cbo_tipoautoriz.Text = autorizacao1.Tipoautorizacao.ToString().ToUpper();
cbo_nivelensino.Text = autorizacao1.nivelensino;
txt_outrosdocs.Text = autorizacao1.outrosdocs;
dtp_datapossecargo.Value = autorizacao1.Datapossecargo;
dtp_data_expedicao.Value = autorizacao1.Dataexpedicao;
lbl_numautoriz.Text = autorizacao1.numeroautorizacao;
lbl_idsolicitacao.Text = autorizacao1.IdAutorizacao.ToString();
if (!string.IsNullOrEmpty(autorizacao1.Disciplina.ToString()))
{
foreach (DataRowView item in cbo_disciplina.Items)
{
if (item["idDisciplinas"].ToString() == autorizacao1.Disciplina.ToString())
{
cbo_disciplina.SelectedIndex = cbo_disciplina.Items.IndexOf(item);
}
}
}
if (autorizacao1.anosdeensino.Equals("Anos Iniciais e Anos Finais"))
{
chk_anosiniciais.Checked = true;
chk_anosfinais.Checked = true;
}
if (autorizacao1.anosdeensino.Equals("Anos Iniciais"))
{
chk_anosiniciais.Checked = true;
}
else
{
chk_anosfinais.Checked = true;
}
autorizacao1.Documentos.Replace(" ", string.Empty); //retira os espaços em branco
List <String> listaDeDocumentos = autorizacao1.Documentos.ToString().Split(',').ToList(); //cria uma lista de documentos
foreach (string str in listaDeDocumentos)
{
foreach (Control control in listacheks)
{
if (control.Tag.Equals(str))
{
((CheckBox)control).Checked = true;
}
}
}
foreach (DataRowView item in cbo_instituicao.Items)
{
if (item["idInstituicoes"].ToString() == autorizacao1.IdInstituicao.ToString())
{
cbo_instituicao.SelectedItem = item;
}
}
}
public void EditarAutorizacao(Autorizacao autorizacao)
{
using (MyDatabaseContext db = new MyDatabaseContext())
{
db.Entry(autorizacao).State = System.Data.Entity.EntityState.Modified;
db.SaveChanges();
}
}
public Autorizacao VerificaAutorizacao(int idAluno)
{
Autorizacao autorizacaoModel = new Autorizacao();
autorizacaoModel = new AutorizacaoDAO().BuscarPorAlunoId(idAluno);
return(autorizacaoModel);
}
public void Inserir(Autorizacao autorizacao)
{
using (MyDatabaseContext db = new MyDatabaseContext())
{
db.Autorizacao.Add(autorizacao);
db.SaveChanges();
}
}
/// <summary>
/// Método responsável por cumprir o requisito de Autorizar Usuários Cadastrados em Aplicativos
/// previamente cadastrados.
/// Quando chamado em GET - Retorna a tela de Autorizar Usuário
/// Quando chamado em POST - Retorna a tela de Cadastrar
/// </summary>
/// <returns>A tela de Cadastrar Aplicativo (GET) ou A tela de Index
/// podendo ou não conter uma mensamge de erro (Post)</returns>
public ActionResult AutorizarUsuario(AutorizarUsuarioViewModel dados)
{
#region Decidir se deve proseguir com a requisição
AutorizarUsuarioViewModel model = new AutorizarUsuarioViewModel();
ActionResult urlRetorno = DecideUrlFormulários("/Autorizacao/AutorizarUsuario", model);
if (urlRetorno != null)
{
if (usuario != null) // Usuario preenchido com os dados da seção na superclasse
{
model = PreencheModel(model);
}
return(urlRetorno); // ação que deve ser retornada para o browser
}
#endregion
IList <Autorizacao> autorizacoes = new List <Autorizacao>();
dados.UsuarioLiberacao = usuario;
autorizacoes = dados.CriarModelo();
IFachada <Autorizacao> fachada = new FachadaAdmWeb <Autorizacao>();
string retorno;
if (Request["Salvar"] != null)
{
retorno = fachada.SalvarTodos(autorizacoes);
}
else if (Request["Alterar"] != null)
{
retorno = fachada.AlterarTodos(autorizacoes);
}
else if (Request["Inativar"] != null)
{
Autorizacao auxiliar = new Autorizacao();
auxiliar.OrgaoAutorizado = autorizacoes[0].OrgaoAutorizado;
auxiliar.Usuario = autorizacoes[0].Usuario;
retorno = fachada.Excluir(autorizacoes[0]);
}
else
{
retorno = "Opção Inválida";
}
if (retorno != null) // se retornar null, é porque ocorreu tudo bem
{
ViewBag.Mensagem = retorno;
model = PreencheModel(autorizacoes, model);
return(View(model));
}
ViewBag.Mensagem = "Autorizado com sucesso!";
return(View("../Home/Index"));
} // AutorizarUsuario
public override IList <object> Consultar(object entidade)
{
Autorizacao autorizacao = (Autorizacao)entidade;
IList <object> retorno = new List <object>();
string sql;
if (autorizacao.Aplicativo == null)
{
return(BuscaAutorizacoesDoUsuario(autorizacao, retorno));
}
sql = "select nom_aplica " +
"from sis_rel_usuario_submenu " +
"where lower(cod_usuari) = lower(?) " +
"AND cod_orgao = ? " +
"AND nom_aplica = ? " +
"AND nom_menu = ? " +
"AND nom_submen = ? " +
"AND (dat_inicio_libera is null " +
"OR Date('Now') > dat_inicio_libera) " +
"AND (dat_fim_libera is null " +
"OR Date('Now') < dat_fim_libera) ";
comando = new SqlCommand(sql, conexao, transacao);
Aplicativo app = autorizacao.Aplicativo;
// colocar parâmetros na consulta
comando.Parameters.Add(new SqlParameter("cod_usuari", autorizacao.Usuario.Codigo));
comando.Parameters.Add(new SqlParameter("cod_orgao",
autorizacao.OrgaoAutorizado.Codigo));
comando.Parameters.Add(new SqlParameter("nom_aplica",
app.Nome));
comando.Parameters.Add(new SqlParameter("nom_menu",
app.Menus[0].Nome));
comando.Parameters.Add(new SqlParameter("nom_submen",
app.Menus[0].SubMenus[0].Nome));
dataReader = comando.ExecuteReader();
if (dataReader.Read())
{
retorno.Add(autorizacao);
} // if
dataReader.Close();
if (retorno.Count == 0)
{
retorno = null;
}
return(retorno);
}
public async Task <IHttpActionResult> GetAutorizacao(long id)
{
Autorizacao autorizacao = await db.Autorizacaos.FindAsync(id);
if (autorizacao == null)
{
return(NotFound());
}
return(Ok(autorizacao));
}
public string login([FromBody] UsuarioInsert usuario)
{
UsuarioDTO user = new UsuarioDTO();
user.Nome = usuario.Login;
user.TipoUsuario = UsuarioDTO.Tipo.Usuario;
Autorizacao.Autorizar(contexto, user);
return("Usuario/Perfil");
}
public IActionResult Perfil()
{
if (Autorizacao.EhAutorizado(contexto))
{
ViewData["Nome"] = Autorizacao.getUsuario(contexto).Nome;
return(View());
}
else
{
return(RedirectToAction("Login", "Usuario"));
}
}
public async Task <IHttpActionResult> PostAutorizacao(Autorizacao autorizacao)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.Autorizacaos.Add(autorizacao);
await db.SaveChangesAsync();
return(CreatedAtRoute("DefaultApi", new { id = autorizacao.id }, autorizacao));
}
public ActionResult CadastrarAutorizacao(Autorizacao autorizacaoModel)
{
AutorizacaoDAO autorizacaoDAO = new AutorizacaoDAO();
autorizacaoDAO.Inserir(autorizacaoModel);
Aluno alunoModel = new AlunoDAO().BuscarAlunoId(autorizacaoModel.IdAluno);
TempData["Mensagem"] = "Autorização Cadastrada Com Sucesso, agora você pode escolher um passeio";
return(RedirectToAction("IndexAluno", "Aluno", alunoModel));
}
public object ObterDadosPdf(IEspecificidade especificidade, BancoDeDados banco)
{
try
{
Autorizacao autorizacao = _da.ObterDadosPDF(especificidade.Titulo.Id, banco);
DataEmissaoPorExtenso(autorizacao.Titulo);
#region Anexos
autorizacao.AnexosPdfs = autorizacao.Anexos
.Select(x => x.Arquivo)
.Where(x => (!String.IsNullOrEmpty(x.Nome) && new FileInfo(x.Nome).Extension.ToLower().IndexOf("pdf") > -1)).ToList();
autorizacao.Anexos.RemoveAll(anexo =>
String.IsNullOrEmpty(anexo.Arquivo.Extensao) ||
!((new[] { ".jpg", ".gif", ".png", ".bmp" }).Any(x => anexo.Arquivo.Extensao.ToLower() == x)));
if (autorizacao.Anexos != null && autorizacao.Anexos.Count > 0)
{
foreach (AnexoPDF anexo in autorizacao.Anexos)
{
anexo.Arquivo.Conteudo = AsposeImage.RedimensionarImagem(
File.ReadAllBytes(anexo.Arquivo.Caminho),
11, eAsposeImageDimensao.Ambos);
}
}
#endregion
autorizacao.Dominialidade = new DominialidadePDF(new DominialidadeBus().ObterPorEmpreendimento(especificidade.Titulo.EmpreendimentoId.GetValueOrDefault()));
var exploracoes = new ExploracaoFlorestalBus().ObterExploracoes(especificidade.Titulo.Id, (int)eTituloModeloCodigo.AutorizacaoExploracaoFlorestal);
autorizacao.ExploracaoFlorestal = exploracoes.Select(x => new ExploracaoFlorestalAutorizacaoPDF(x)).ToList();
decimal areaAutorizada = exploracoes.SelectMany(x => x.Exploracoes).Sum(x => x.AreaCroqui);
autorizacao.VegetacaoNativaRemanescente = (autorizacao.Dominialidade.VegetacaoNativaTotalDecimal - areaAutorizada).ToStringTrunc(2);
var produtos = exploracoes.SelectMany(x => x.Exploracoes).SelectMany(x => x.Produtos).Select(x => new ExploracaoFlorestalExploracaoProdutoPDF(x)).ToList();
autorizacao.Produtos = produtos.GroupBy(x => new { x.Nome, x.Especie, x.UnidadeMedida }, x => x.Quantidade, (key, g) => new ExploracaoFlorestalAutorizacaoProdutoPDF()
{
Nome = key.Nome,
Especie = key.Especie,
UnidadeMedida = string.IsNullOrWhiteSpace(key.UnidadeMedida) ? "" : String.Concat("(", key.UnidadeMedida, ")"),
Quantidade = g.Sum(x => x)
}).ToList();
return(autorizacao);
}
catch (Exception exc)
{
Validacao.AddErro(exc);
}
return(null);
}
public async Task <IHttpActionResult> DeleteAutorizacao(long id)
{
Autorizacao autorizacao = await db.Autorizacaos.FindAsync(id);
if (autorizacao == null)
{
return(NotFound());
}
db.Autorizacaos.Remove(autorizacao);
await db.SaveChangesAsync();
return(Ok(autorizacao));
}
/// <summary>
/// Repassa os dados da autorização salva no banco para um objeto
/// </summary>
/// <param name="dt"></param>
/// <returns></returns>
private Autorizacao RepassaAutorizacao(DataTable dt)
{
try
{
Autorizacao autoriz = new Autorizacao
{
Idfuncionario = (int)dt.Rows[0]["idFuncionario"],
IdAutorizacao = (int)dt.Rows[0]["idAutorizacao"],
IdInstituicao = (int)dt.Rows[0]["idInstituicao"],
numeroautorizacao = dt.Rows[0]["numeroAutorizacao"].ToString(),
Dataexpedicao = Convert.ToDateTime(dt.Rows[0]["dataExpedicao"]),
Datavalidade = Convert.ToDateTime(dt.Rows[0]["dataValidadeAutorizacao"]),
anosdeensino = dt.Rows[0]["anosdeensino"].ToString(),
Datapossecargo = Convert.ToDateTime(dt.Rows[0]["dataPosseCargo"]),
Documentos = new StringBuilder(dt.Rows[0]["documentos"].ToString()),
nivelensino = dt.Rows[0]["nivelensino"].ToString(),
outrosdocs = dt.Rows[0]["outrosdocs"].ToString(),
usuario = dt.Rows[0]["usuario"].ToString(),
datacriacao = Convert.ToDateTime(dt.Rows[0]["datacriacao"])
};
if (dt.Rows[0]["disciplina"] != DBNull.Value)
{
autoriz.Disciplina = Convert.ToInt16(dt.Rows[0]["disciplina"]);
}
switch (dt.Rows[0]["tipoAutorizacao"].ToString())
{
case "dirigir":
autoriz.Tipoautorizacao = Tipoautorizacao.Dirigir;
break;
case "lecionar":
autoriz.Tipoautorizacao = Tipoautorizacao.Lecionar;
break;
case "secretariar":
autoriz.Tipoautorizacao = Tipoautorizacao.Secretariar;
break;
}
return(autoriz);
}
catch (SqlException exception)
{
throw exception;
}
}
/// <summary>
/// Construtor da classe com parâmetros
/// </summary>
/// <param name="funcionario2">Objeto funcionário</param>
/// <param name="autorizacao">Objeto autorização</param>
/// <param name="principalUi"></param>
public SolicitarAutorizacao(Funcionario funcionario2, Autorizacao autorizacao, Principal_UI principalUi)
{
PrincipalUi = principalUi;
this.InitializeComponent();
this.CamposObrigatorios();
this.ListadeControles();
this.instituicoesTableAdapter.FillByMunicipioCreche(this.siescDataSet.instituicoes);
this.disciplinasTableAdapter.Fill(this.siescDataSet.disciplinas);
CarregaCombosCargos();
navegacao = Navegando.Editando;
this.RepassaFuncionario(funcionario2);
this.RepassaAutorizacao(autorizacao);
}
public ActionResult VerificaAutorizacao(int idPasseio, int idAluno)
{
Autorizacao autorizacao = new Autorizacao();
autorizacao = new AutorizacaoBusiness().VerificaAutorizacao(idAluno);
if (autorizacao != null)
{
return(RedirectToAction("ConfirmarPasseio", "Resultado", new { autorizacao.IdAutorizacao, idPasseio }));
}
else
{
TempData["Mensagem"] = "É necessário enviar uma autorização para os passeios!!";
TempData["IdAluno"] = idAluno;
return(RedirectToAction("AutorizacaoPasseio", "Aluno", new Autorizacao()));
}
}
/// <summary>
/// Retorna uma autorização diretamento do banco
/// </summary>
/// <param name="numeroautorizacao"></param>
/// <returns></returns>
public Autorizacao RetornaAutorizacao(string numeroautorizacao)
{
try
{
autorizacoes_TA = new autorizacoesTableAdapter();
DataTable dt = autorizacoes_TA.GetDataByNumeroAutorizacao(numeroautorizacao);
autorizacao = RepassaAutorizacao(dt);
return(autorizacao);
}
catch (SqlException exception)
{
throw exception;
}
}
public override void Excluir(object entidade)
{
Autorizacao auth = (Autorizacao)entidade;
string sql;
// desautorizar todas as autorizações do órgão informado
sql = "update sis_rel_usuario_submenu " +
"set dat_fim_libera = Date('Now') " +
"where cod_usuari = ? and " +
"cod_orgao = ? ";
comando = new SqlCommand(sql, conexao, transacao);
comando.Parameters.Add(new SqlParameter("cod_usuari", auth.Usuario.Codigo));
comando.Parameters.Add(new SqlParameter("cod_orgao", auth.OrgaoAutorizado.Codigo));
comando.ExecuteNonQuery();
}
public ActionResult AutorizacaoAluno(int idAluno)
{
Autorizacao autorizacao = new Autorizacao();
autorizacao = new AutorizacaoDAO().BuscarPorAlunoId(idAluno);
Aluno aluno = new AlunoDAO().BuscarAlunoId(idAluno);
if (autorizacao == null)
{
TempData["Mensagem"] = "Envie uma autorização preenchida para participar dos passeios";
ViewData["AlunoModel"] = aluno;
return(View("CadastrarAutorizacao", new Autorizacao()));
}
else
{
return(View(autorizacao));
}
}
internal Autorizacao ObterDadosPDF(int titulo, BancoDeDados banco = null)
{
Autorizacao autorizacao = new Autorizacao();
using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia(banco))
{
#region Dados do Titulo
DadosPDF dados = DaEsp.ObterDadosTitulo(titulo, bancoDeDados);
autorizacao.Titulo = dados.Titulo;
autorizacao.Titulo.SetorEndereco = DaEsp.ObterEndSetor(autorizacao.Titulo.SetorId);
autorizacao.Protocolo = dados.Protocolo;
autorizacao.Empreendimento = dados.Empreendimento;
#endregion
#region Dados da Especificidade
Comando comando = bancoDeDados.CriarComando(@"select e.destinatario, e.observacao from {0}esp_auto_exploracao_florestal e where titulo = :id", EsquemaBanco);
comando.AdicionarParametroEntrada("id", titulo, DbType.Int32);
using (IDataReader reader = bancoDeDados.ExecutarReader(comando))
{
if (reader.Read())
{
autorizacao.Destinatario.Id = Convert.ToInt32(reader["destinatario"]);
autorizacao.Observacao = reader["observacao"].ToString();
}
reader.Close();
}
#endregion
autorizacao.Destinatario = DaEsp.ObterDadosPessoa(autorizacao.Destinatario.Id, autorizacao.Empreendimento.Id, bancoDeDados);
autorizacao.Anexos = DaEsp.ObterAnexos(titulo, bancoDeDados);
}
return(autorizacao);
}
public override string Executar(object entidade)
{
Autorizacao auth = (Autorizacao)entidade;
// Verificar se preencheu o código do usuário a se desautorizar
if (auth.Usuario == null || auth.Usuario.Codigo == null ||
auth.Usuario.Codigo.Trim() == "")
{
return("O usuário é um campo obrigatório para fazer a inativação");
}
// Verificar se preencheu o orgão a se desautorizar
if (auth.OrgaoAutorizado == null || auth.OrgaoAutorizado.Codigo == null ||
auth.OrgaoAutorizado.Codigo.Trim() == "")
{
return("Preencha o órgão para fazer a inativação");
}
return(null); // campos validados
}
public object ObterDadosPdf(IEspecificidade especificidade, BancoDeDados banco)
{
try
{
Autorizacao autorizacao = _da.ObterDadosPDF(especificidade.Titulo.Id, banco);
DataEmissaoPorExtenso(autorizacao.Titulo);
#region Anexos
autorizacao.AnexosPdfs = autorizacao.Anexos
.Select(x => x.Arquivo)
.Where(x => (!String.IsNullOrEmpty(x.Extensao) && x.Extensao.ToLower().IndexOf("pdf") > -1)).ToList();
autorizacao.Anexos.RemoveAll(anexo =>
String.IsNullOrEmpty(anexo.Arquivo.Extensao) ||
!((new[] { ".jpg", ".gif", ".png", ".bmp" }).Any(x => anexo.Arquivo.Extensao.ToLower() == x)));
if (autorizacao.Anexos != null && autorizacao.Anexos.Count > 0)
{
foreach (AnexoPDF anexo in autorizacao.Anexos)
{
anexo.Arquivo.Conteudo = AsposeImage.RedimensionarImagem(
File.ReadAllBytes(anexo.Arquivo.Caminho),
11, eAsposeImageDimensao.Ambos);
}
}
#endregion
autorizacao.Dominialidade = new DominialidadePDF(new DominialidadeBus().ObterPorEmpreendimento(especificidade.Titulo.EmpreendimentoId.GetValueOrDefault()));
autorizacao.ExploracaoFlorestal = new ExploracaoFlorestalPDF(new ExploracaoFlorestalBus().ObterPorEmpreendimento(especificidade.Titulo.EmpreendimentoId.GetValueOrDefault()));
return(autorizacao);
}
catch (Exception exc)
{
Validacao.AddErro(exc);
}
return(null);
}
/// <summary>
/// Atualiza a participacão de um usuário
/// </summary>
/// <param name="IdParticipacao">Id da Participação</param>
/// <param name="participacao">participação do usuário (Autorizado ou Não Autorizado)</param>
public static void AtualizarParticipacaoUsuario(int IdParticipacao, Autorizacao autorizacao)
{
AtualizarParticipacaoUsuario(IdParticipacao, autorizacao, "");
}
/// <summary>
/// Atualiza a participacão de um usuário
/// </summary>
/// <param name="IdParticipacao">Id da Participação</param>
/// <param name="participacao">participação do usuário (Autorizado ou Não Autorizado)</param>
public static void AtualizarParticipacaoUsuario(int IdParticipacao, Autorizacao autorizacao, string Mensagem)
{
using (Escopo escopo = new Escopo(OpcaoTransacao.Requerido))
{
string sql = @"UPDATE CadeiaAutorizacao.UsuarioParticipacao
SET Usp_Autorizacao = @Autorizacao,
Usp_Mensagem = @Mensagem
WHERE Usp_Id = @IdParticipacao";
BdUtil bd = new BdUtil(sql);
bd.AdicionarParametro("@IdParticipacao", DbType.Int32, IdParticipacao);
bd.AdicionarParametro("@Autorizacao", DbType.Int16, autorizacao);
bd.AdicionarParametro("@Mensagem", DbType.String, Mensagem);
bd.ExecuteNonQuery();
// Verificando se a participacao do usuário finalizou a instância da cadeia
// Aprovando ou Não aprovando
int IdInstacia = ObterIDInstaciaPelaParticipacao(IdParticipacao);
int respAutorizacao = VerificarAutorizacao(IdInstacia, IdParticipacao);
AtualizarStatusInstancia(IdInstacia, respAutorizacao);
if (respAutorizacao == 1 || respAutorizacao == 2)
{
//Executando o método do sistema indicando o resultado da autorização
ExecutarMetodoSistema(IdParticipacao, autorizacao, Mensagem);
}
escopo.Terminar();
}
}
/// <summary>
/// Altera a situação de uma cadeia de autorização.
/// </summary>
/// <param name="IdInstancia">Id da Instância</param>
/// <param name="IdUsuario">Id do usuário.</param>
/// <param name="Sitaucao">Nova situação.</param>
/// <param name="Mensagem">Mensagem ou observação do usuário.</param>
/// <returns>o "Usp_ID"</returns>
public static int AtualizarParticipacaoUsuario(int IdInstancia, int IdUsuario, Autorizacao Autorizacao, string Mensagem)
{
string sql = @"
SELECT Usp_Id
FROM CadeiaAutorizacao.UsuarioParticipacao
WHERE Usu_Id = @Usu_Id
AND Cai_Id = @Cai_Id
";
BdUtil bd = new BdUtil(sql);
bd.AdicionarParametro("@Usu_Id", DbType.Int32, IdUsuario);
bd.AdicionarParametro("@Cai_Id", DbType.Int32, IdInstancia);
int uspId = bd.ExecuteScalar<int>();
AtualizarParticipacaoUsuario(uspId, Autorizacao, Mensagem);
return uspId;
}
/// <summary>
/// Executa o método do sistema fornecendo o Id da participação
/// </summary>
/// <param name="IdParticipacao">Id da participação</param>
private static void ExecutarMetodoSistema(int IdParticipacao, Autorizacao Autorizacao, string Mensagem)
{
string sql = @"SELECT cau.Cau_ClasseRetorno, cau.Cau_MetodoRetorno, cai.Cai_Id, usp.Usu_ID
FROM CadeiaAutorizacao.UsuarioParticipacao usp
INNER JOIN CadeiaAutorizacao.CadeiaInstancia cai on cai.Cai_Id = usp.Cai_Id
INNER JOIN CadeiaAutorizacao.Cadeia cau on cau.Cau_Id = cai.Cau_Id
WHERE usp.Usp_Id = @IdParticipacao";
BdUtil bd = new BdUtil(sql);
bd.AdicionarParametro("@IdParticipacao", DbType.Int32, IdParticipacao);
DataTable dt = bd.ObterDataTable();
if (dt.Rows.Count == 0)
{
throw new SecvException("Erro ao obter o método do sistema e id da instância");
}
string nomeClasse = dt.Rows[0]["Cau_ClasseRetorno"].ToString();
string nomeMetodo = dt.Rows[0]["Cau_MetodoRetorno"].ToString();
int IdInstancia = Convert.ToInt32(dt.Rows[0]["Cai_Id"]);
Type tipo = Type.GetType(nomeClasse);
if (tipo == null)
{
throw new SecvException("Classe não encontrada.");
}
MethodInfo metodo = tipo.GetMethod(nomeMetodo);
if (metodo == null)
{
throw new SecvException("Método não encontrado.");
}
int i = 0;
List<object> parametros = new List<object>();
parametros.Add(IdInstancia);
parametros.Add(Autorizacao);
foreach (ParameterInfo parametro in metodo.GetParameters())
{
switch (i)
{
case 0:
{
if (parametro.ParameterType != typeof(int))
{
throw new SecvException("A ordem dos parâmetros tem que ser System.Int32, Autorizacao.");
}
i++;
}
break;
case 1:
{
if (parametro.ParameterType != typeof(Autorizacao))
{
throw new SecvException("A ordem dos parâmetros tem que ser System.Int32, Autorizacao.");
}
i++;
}
break;
case 2:
{
if (parametro.ParameterType == typeof(String))
{
parametros.Add(Mensagem);
}
else if (parametro.ParameterType == typeof(int))
{
parametros.Add(Convert.ToInt32(dt.Rows[0]["Usu_ID"]));
}
else
{
throw new SecvException("A ordem dos parâmetros tem que ser [System.Int32 cai_ID, Autorizacao autorizacao, System.String mensagem] ou [System.Int32 cai_ID, Autorizacao autorizacao, System.Int32 UsuarioAprovador].");
}
i++;
}
break;
}
}
if ( i < 2 && i > 3)
throw new SecvException("Quantidade de parametros inválida");
metodo.Invoke(null, parametros.ToArray());
}
