internal Termo ObterDadosPDF(int titulo, BancoDeDados banco = null)
{
Termo termo = new Termo();
using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia(banco))
{
#region Título
DadosPDF dados = DaEsp.ObterDadosTitulo(titulo, bancoDeDados);
termo.Titulo = dados.Titulo;
termo.Titulo.SetorEndereco = DaEsp.ObterEndSetor(termo.Titulo.SetorId);
termo.Protocolo = dados.Protocolo;
termo.Empreendimento = dados.Empreendimento;
#endregion
#region Dados da Especificidade
AberturaLivroUnidadeConsolidacao esp = ObterHistorico(titulo, dados.Titulo.SituacaoId, bancoDeDados);
termo.TotalPaginasLivro = esp.TotalPaginasLivro;
termo.PaginaInicial = esp.PaginaInicial;
termo.PaginaFinal = esp.PaginaFinal;
#endregion
termo.Destinatario = DaEsp.ObterDadosPessoa(termo.Destinatario.Id, termo.Empreendimento.Id, bancoDeDados);
termo.UnidadeConsolidacao = new UnidadeConsolidacaoPDF();
termo.UnidadeConsolidacao.ResponsaveisEmpreendimento = DaEsp.ObterEmpreendimentoResponsaveis(termo.Empreendimento.Id.GetValueOrDefault());
}
return(termo);
}
internal Termo ObterDadosPDF(int titulo, BancoDeDados banco = null)
{
Termo termo = new Termo();
using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia(banco))
{
#region Título
DadosPDF dados = DaEsp.ObterDadosTitulo(titulo, bancoDeDados);
termo.Titulo = dados.Titulo;
termo.Titulo.SetorEndereco = DaEsp.ObterEndSetor(termo.Titulo.SetorId);
termo.Protocolo = dados.Protocolo;
termo.Empreendimento = dados.Empreendimento;
#endregion
#region Dados da Especificidade
AberturaLivroUnidadeProducao esp = ObterHistorico(titulo, dados.Titulo.SituacaoId, bancoDeDados);
termo.TotalPaginasLivro = esp.TotalPaginasLivro;
termo.PaginaInicial = esp.PaginaInicial;
termo.PaginaFinal = esp.PaginaFinal;
foreach (var item in esp.Unidades)
{
termo.UnidadeProducao.Unidades.Add(new UnidadeProducaoItemPDF(item));
}
#endregion
termo.Destinatario = DaEsp.ObterDadosPessoa(termo.Destinatario.Id, termo.Empreendimento.Id, bancoDeDados);
}
return(termo);
}
public object ObterDadosPdf(IEspecificidade especificidade, BancoDeDados banco)
{
try
{
AberturaLivroUnidadeConsolidacao esp = especificidade as AberturaLivroUnidadeConsolidacao;
Termo termo = _da.ObterDadosPDF(especificidade.Titulo.Id, banco);
UnidadeConsolidacao caracterizacao = new UnidadeConsolidacaoBus().ObterPorEmpreendimento(especificidade.Titulo.EmpreendimentoId.GetValueOrDefault());
caracterizacao.Cultivares = _da.ObterCultivares(esp.Culturas.Select(x => x.Id).ToList(), esp.ProtocoloReq.Id);
if (caracterizacao != null)
{
termo.UnidadeConsolidacao = new UnidadeConsolidacaoPDF(caracterizacao, termo.UnidadeConsolidacao.ResponsaveisEmpreendimento);
}
else
{
Validacao.Add(Mensagem.UnidadeConsolidacao.Inexistente);
}
DataEmissaoPorExtenso(termo.Titulo);
return(termo);
}
catch (Exception exc)
{
Validacao.AddErro(exc);
}
return(null);
}
public object ObterDadosPdf(IEspecificidade especificidade, BancoDeDados banco)
{
try
{
Termo termo = _da.ObterDadosPDF(especificidade.Titulo.Id, banco);
UnidadeProducao caracterizacao = new UnidadeProducaoBus().ObterPorEmpreendimento(especificidade.Titulo.EmpreendimentoId.GetValueOrDefault());
if (caracterizacao != null)
{
caracterizacao.UnidadesProducao.RemoveAll(x => !termo.UnidadeProducao.Unidades.Any(y => y.CodigoUP == x.CodigoUP));
termo.UnidadeProducao = new UnidadeProducaoPDF(caracterizacao);
}
else
{
Validacao.Add(Mensagem.UnidadeProducao.Inexistente);
}
DataEmissaoPorExtenso(termo.Titulo);
return(termo);
}
catch (Exception exc)
{
Validacao.AddErro(exc);
}
return(null);
}
public override IConfiguradorPdf ObterConfiguradorPdf(IEspecificidade especificidade)
{
ConfiguracaoDefault conf = new ConfiguracaoDefault();
conf.AddLoadAcao((doc, dataSource) =>
{
Termo termo = dataSource as Termo;
conf.CabecalhoRodape = CabecalhoRodapeFactory.Criar(especificidade.Titulo.SetorId);
if (termo.Dominialidade.Matricula.Count <= 0)
{
doc.Last <Row>("«TableStart:Dominialidade.Matricula»").Remove();
}
if (termo.Dominialidade.Posse.Count <= 0)
{
doc.Last <Row>("«TableStart:Dominialidade.Posse»").Remove();
}
if (termo.RLFormacao.Count == 0)
{
doc.Last <Row>("«RLTotalFormacao»").Remove();
}
if (termo.RLPreservada.Count == 0)
{
doc.Last <Row>("«RLTotalPreservada»").Remove();
}
});
return(conf);
}
public VerDetalhesTermo(Termo termo)
{
InitializeComponent();
this.Termo = termo;
this.BindingContext = this;
}
// GET: Dicionario/Delete/5
public async Task <IActionResult> Delete(int?id)
{
if (id == null)
{
return(NotFound());
}
try
{
Termo termo = await dbContext.Dicionario.Where(t => t.CodTermo == id.Value &&
t.Ativo == true).SingleOrDefaultAsync();
if (termo == null)
{
return(NotFound());
}
return(View(termo));
}
catch (Exception ex)
{
TempData["Mensagem"] = "Erro ao excluir termo do dicionário!";
TempData["Exception"] = ex;
TempData["Sucesso"] = false;
}
return(RedirectToAction("Index"));
}
public async Task <IHttpActionResult> PutTermo(int id, Termo termo)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != termo.Id)
{
return(BadRequest());
}
db.Entry(termo).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TermoExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public async Task <Termo> AdicionarAsync(Termo termo)
{
validador.Validar(termo, TermoValidador.AO_ADICIONAR);
await comandoRepositorio.AdicionarAsync(termo);
return(termo);
}
public void Deletar(int Id)
{
Termo termoBuscado = ctx.Termo.Find(Id);
ctx.Termo.Remove(termoBuscado);
ctx.SaveChanges();
}
public Turma()
{
_id = 0;
_termo = new Termo();
_disciplina = new Disciplina();
_professores = new List<Professor>();
_alunos = new List<Aluno>();
}
public Turma(int id, Termo termo, Disciplina disciplina, List<Professor> professores, List<Aluno> alunos)
{
_id = id;
_termo = termo;
_disciplina = disciplina;
_professores = professores;
_alunos = alunos;
}
public async Task <IActionResult> Edit(int?id, TermoViewModel termoVM)
{
using (await dbContext.Database.BeginTransactionAsync())
{
try
{
Termo termo = await dbContext.Dicionario.Where(t => t.CodTermo == id.Value &&
t.Ativo == true).SingleOrDefaultAsync();
if (ModelState.IsValid)
{
termo.Descricao = termoVM.Descricao.Trim();
Termo existTermo = await dbContext.Dicionario.Where(t => t.Descricao == termo.Descricao &&
t.Ativo == true && t.CodTermo != termo.CodTermo).SingleOrDefaultAsync();
if (existTermo == null)
{
termo.CodVideo = termoVM.CodVideo;
termo.Explicacao = termoVM.Explicacao;
dbContext.Dicionario.Update(termo);
await dbContext.SaveChangesAsync();
if (dbContext.Database.CurrentTransaction != null)
{
dbContext.Database.CommitTransaction();
}
TempData["Mensagem"] = "Termo alterado no dicionário com sucesso!";
TempData["Sucesso"] = true;
return(RedirectToAction("Index"));
}
else
{
TempData["Mensagem"] = "Já existe termo com essa descrição!";
}
}
termoVM.CodTermo = termo.CodTermo;
termoVM.CodVideo = termo.CodVideo;
termoVM.Videos = VideoController.GetVideos(dbContext);
termoVM.DescVideo = termoVM.Videos.Where(v => v.CodVideo == termoVM.CodVideo)
.SingleOrDefault().Descricao;
}
catch (Exception ex)
{
TempData["Mensagem"] = "Erro ao alterar termo no dicionário!";
TempData["Exception"] = ex;
TempData["Sucesso"] = false;
if (dbContext.Database.CurrentTransaction != null)
{
dbContext.Database.RollbackTransaction();
}
return(RedirectToAction("Index"));
}
}
return(View(termoVM));
}
public async Task <IActionResult> DeleteConfirmed(int?id)
{
using (await dbContext.Database.BeginTransactionAsync())
{
try
{
Video video = await dbContext.Videos.Where(v => v.CodVideo == id &&
v.Ativo == true).SingleOrDefaultAsync();
Exercicio exercicio = await dbContext.Exercicios.Where(e => e.CodVideo == video.CodVideo &&
e.Ativo == true).FirstOrDefaultAsync();
Termo termo = await dbContext.Dicionario.Where(t => t.CodVideo == video.CodVideo &&
t.Ativo == true).FirstOrDefaultAsync();
if (video == null)
{
return(NotFound());
}
else if (exercicio != null)
{
TempData["Mensagem"] = "Vídeo não pode ser excluído porque está sendo usado por algum exercício!";
return(View(video));
}
else if (termo != null)
{
TempData["Mensagem"] = "Vídeo não pode ser excluído porque está sendo usado por algum termo!";
return(View(video));
}
else
{
video.Ativo = false;
dbContext.Update(video);
await dbContext.SaveChangesAsync();
if (dbContext.Database.CurrentTransaction != null)
{
dbContext.Database.CommitTransaction();
}
TempData["Mensagem"] = "Vídeo excluído com sucesso!";
TempData["Sucesso"] = true;
}
}
catch (Exception ex)
{
TempData["Mensagem"] = "Erro ao excluir vídeo!";
TempData["Exception"] = ex;
TempData["Sucesso"] = false;
if (dbContext.Database.CurrentTransaction != null)
{
dbContext.Database.RollbackTransaction();
}
}
}
return(RedirectToAction("Index"));
}
public KeyValuePair <bool, IList <string> > isValid()
{
var erros = new List <string>();
if (string.IsNullOrEmpty(Termo.Trim()))
{
erros.Add("O termo é necessário ser preenchido!");
}
return(new KeyValuePair <bool, IList <string> >(erros.Count == 0, erros));
}
public async Task <IHttpActionResult> GetTermo(int id)
{
Termo termo = await db.Termos.FindAsync(id);
if (termo == null)
{
return(NotFound());
}
return(Ok(termo));
}
public IActionResult Post(Termo novoTermo)
{
try
{
_termoRepository.Cadastrar(novoTermo);
return(StatusCode(201));
}
catch (Exception e)
{
return(BadRequest(e));
}
}
public async Task <IHttpActionResult> PostTermo(Termo termo)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.Termoes.Add(termo);
await db.SaveChangesAsync();
return(CreatedAtRoute("DefaultApi", new { id = termo.Id }, termo));
}
public IActionResult Put(int Id, Termo termoAtualizado)
{
try
{
_termoRepository.Atualizar(Id, termoAtualizado);
return(StatusCode(204));
}
catch (Exception e)
{
return(BadRequest(e));
}
}
public void Atualizar(int Id, Termo termoAtualizado)
{
Termo termoBuscado = ctx.Termo.Find(Id);
if (termoAtualizado.NumeroTermo != null)
{
termoBuscado.NumeroTermo = termoAtualizado.NumeroTermo;
}
ctx.Termo.Update(termoBuscado);
ctx.SaveChanges();
}
public async Task <IHttpActionResult> DeleteTermo(int id)
{
Termo termo = await db.termos.FindAsync(id);
if (termo == null)
{
return(NotFound());
}
termo.Ativo = false;
await db.SaveChangesAsync();
return(Ok(termo));
}
public Termo IncluirTermo(Termo obj)
{
Termo retorno = new Termo();
if (_repository.ListarTermos().Where(x => x.txt_sigla.Trim() == obj.txt_sigla.Trim()).Count() > 0)
{
retorno.status = Response.ResponseStatus.FALHA.Texto;
retorno.mensagem = Mensagem.MN002.TextoFormatado("TERMO");
return(retorno);
}
return(_repository.IncluirTermo(obj));
}
public ActionResult Edit(Termo obj)
{
if (ModelState.IsValid)
{
Termo retorno = new Termo();
retorno = _regra.AlterarTermo(obj);
if (retorno.status.Equals(ResponseStatus.SUCESSO.Texto))
{
return(RedirectToAction("Index"));
}
ModelState.AddModelError(string.Empty, retorno.mensagem);
}
return(View(obj));
}
internal Termo ObterDadosPDF(int titulo, BancoDeDados banco = null)
{
Termo termo = new Termo();
string compromitente = string.Empty;
using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia(banco))
{
#region Título
DadosPDF dados = DaEsp.ObterDadosTitulo(titulo, bancoDeDados);
termo.Titulo = dados.Titulo;
termo.Protocolo = dados.Protocolo;
termo.Empreendimento = dados.Empreendimento;
#endregion
#region Dados da Especificidade
Comando comando = bancoDeDados.CriarComando(@"
select e.destinatario, e.descricao, num_lar.numero||'/'||num_lar.ano numero_lar,
(case when e.representante is not null then (select p.nome from tab_pessoa p where p.id = e.representante)
else (select p.nome from tab_pessoa p where p.id = e.destinatario) end) compromitente
from esp_termo_compr_amb e, tab_titulo_numero num_lar where e.titulo = :titulo and num_lar.titulo = e.licenca" , EsquemaBanco);
comando.AdicionarParametroEntrada("titulo", titulo, DbType.Int32);
using (IDataReader reader = bancoDeDados.ExecutarReader(comando))
{
if (reader.Read())
{
termo.Destinatario.Id = reader.GetValue <int>("destinatario");
termo.NumeroLAR = reader.GetValue <string>("numero_lar");
termo.Descricao = reader.GetValue <string>("descricao");
compromitente = reader.GetValue <string>("compromitente");
}
reader.Close();
}
#endregion
termo.Destinatario = DaEsp.ObterDadosPessoa(termo.Destinatario.Id, termo.Empreendimento.Id, bancoDeDados);
termo.Titulo.AssinanteSource.Add(new AssinanteDefault {
Cargo = "Compromitente", Nome = compromitente
});
}
return(termo);
}
public object ObterDadosPdf(IEspecificidade especificidade, BancoDeDados banco)
{
try
{
Termo termo = _da.ObterDadosPDF(especificidade.Titulo.Id, banco);
DataEmissaoPorExtenso(termo.Titulo);
return(termo);
}
catch (Exception exc)
{
Validacao.AddErro(exc);
}
return(null);
}
public Termo AlterarTermo(Termo obj)
{
Termo retorno = new Termo();
try
{
var query = "UPDATE tbl_termo SET txt_sigla = @txt_sigla, txt_descricao = @txt_descricao, " +
" txt_observacao = @txt_observacao, cod_ativo = @cod_ativo WHERE cod_termo = " + obj.cod_termo;
_db.Execute(query, obj);
retorno.status = Response.ResponseStatus.SUCESSO.Texto;
} catch (Exception ex)
{
retorno.status = Response.ResponseStatus.FALHA.Texto;
retorno.mensagem = Erro.ErroOperacao(ex);
}
return(retorno);
}
public Termo IncluirTermo(Termo obj)
{
Termo retorno = new Termo();
try
{
var query = "INSERT INTO tbl_termo(txt_sigla, txt_descricao, txt_observacao, cod_ativo) " +
" VALUES(@txt_sigla, @txt_descricao, @txt_observacao, @cod_ativo)";
_db.Execute(query, obj);
retorno.status = Response.ResponseStatus.SUCESSO.Texto;
}
catch (Exception ex)
{
retorno.status = Response.ResponseStatus.FALHA.Texto;
retorno.mensagem = Erro.ErroOperacao(ex);
}
return(retorno);
}
public async Task <IActionResult> DeleteConfirmed(int?id)
{
if (id == null)
{
return(NotFound());
}
using (await dbContext.Database.BeginTransactionAsync())
{
try
{
Termo termo = await dbContext.Dicionario.Where(t => t.CodTermo == id.Value &&
t.Ativo == true).SingleOrDefaultAsync();
if (termo == null)
{
return(NotFound());
}
termo.Ativo = false;
dbContext.Update(termo);
await dbContext.SaveChangesAsync();
if (dbContext.Database.CurrentTransaction != null)
{
dbContext.Database.CommitTransaction();
}
TempData["Mensagem"] = "Termo excluído do dicionário com sucesso!";
TempData["Sucesso"] = true;
}
catch (Exception ex)
{
TempData["Mensagem"] = "Erro ao excluir termo do dicionário!";
TempData["Exception"] = ex;
TempData["Sucesso"] = false;
if (dbContext.Database.CurrentTransaction != null)
{
dbContext.Database.RollbackTransaction();
}
}
}
return(RedirectToAction("Index"));
}
public async Task <IHttpActionResult> PostTermo(Termo termo)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.termos.Add(termo);
await db.SaveChangesAsync();
await db.locacoes.Where(x => x.PeriodoLocacao.DataFinal > DateTime.Now).ForEachAsync(x => x.TermoAceito = false);
await db.SaveChangesAsync();
return(CreatedAtRoute("DefaultApi", new { id = termo.Id }, termo));
}
private string TermoSimples(Termo termo)
{
switch ((eTipoTermo)termo.Tipo)
{
case eTipoTermo.AbreParenteses:
return("(");
case eTipoTermo.FechaParenteses:
return(")");
case eTipoTermo.OperadorE:
return(" and ");
case eTipoTermo.OperadorOu:
return(" or ");
default:
return(string.Empty);
}
}
public async Task <IHttpActionResult> PostTermo(Termo termo)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
foreach (var item in db.Termos)
{
if (item.Ativo)
{
item.Ativo = false;
}
}
db.Termos.Add(termo);
await db.SaveChangesAsync();
return(CreatedAtRoute("DefaultApi", new { id = termo.Id }, termo));
}
public async Task <Termo> AtualizarAsync(Termo termo)
{
validador.Validar(termo, TermoValidador.AO_ATUALIZAR);
var atualizacoes = PropriedadeValorFabrica <Termo> .Iniciar()
.Add(c => c.Nome, termo.Nome)
.Add(c => c.NomeHigienizado, termo.NomeHigienizado)
.Add(c => c.Tags, termo.Tags)
.Add(c => c.TagsHigienizadas, termo.TagsHigienizadas)
.Add(c => c.Tipo, termo.Tipo)
.Add(c => c.Descricao, termo.Descricao)
.Add(c => c.Pontos, termo.Pontos);
var resultado = await comandoRepositorio
.AtualizarUmAsync(t => t.Id == termo.Id, atualizacoes.ObterTodos);
//if (resultado)
// throw new Exception("Não foi possível atualizar. Para mais informações contate o administrador");
return(termo);
}