public IList<Dominio.Foto> Pesquisar(Dominio.Foto objeto, int qtde = 0)
{
ICriteria criteria = NHibernate.HttpModule.RecuperarSessao.CreateCriteria(typeof(Dominio.Foto));
criteria.AddOrder(Order.Desc("Codigo"));
if (qtde > 0)
{
criteria.SetMaxResults(qtde);
}
if (objeto == null)
return criteria.List<Dominio.Foto>();
if (objeto.Codigo > 0)
criteria = criteria.Add(Expression.Eq("Codigo", objeto.Codigo));
if (!string.IsNullOrEmpty(objeto.Legenda))
criteria = criteria.Add(Expression.InsensitiveLike("Legenda", string.Format("%{0}%", objeto.Legenda)));
if (!string.IsNullOrEmpty(objeto.Fonte))
criteria = criteria.Add(Expression.Eq("Fonte", objeto.Fonte));
criteria = criteria.Add(Expression.Eq("Galeria", objeto.Galeria));
IList<Dominio.Foto> fotos = criteria.List<Dominio.Foto>();
return fotos;
}
public Dominio.Artigo Cadastrar(Dominio.Artigo objeto)
{
MySQL.ConteudoMySQL conteudoDAO = new MySQL.ConteudoMySQL();
try
{
NHibernate.HttpModule.RecuperarSessao.Transaction.Begin();
objeto.Codigo = (int)NHibernate.HttpModule.RecuperarSessao.Save(objeto);
NHibernate.HttpModule.RecuperarSessao.Transaction.Commit();
conteudoDAO.VincularFotos(objeto);
if (objeto.ListaPalavrasChave != null)
conteudoDAO.VincularPalavraChave(objeto);
return objeto;
}
catch (Exception e)
{
NHibernate.HttpModule.RecuperarSessao.Transaction.Rollback();
return null;
}
}
public List<Dominio.Menu> RetornarMenusPermitidos(Dominio.Usuario usuario)
{
var lista = from p in _contexto.MenusPerfilUsuario.Where(x => x.Perfil.Id == usuario.PerfilUsuario_Id)
select p.MenuPermitido;
return lista.ToList();
}
public Message AtualizarCliente(Dominio.Models.Cliente cliente)
{
Message msg = new Message();
try
{
Integracao.XYZServiceReference.TbCliente tbCliente = new Integracao.XYZServiceReference.TbCliente()
{
Idk__BackingField = cliente.Id,
Nomek__BackingField = cliente.Nome,
Enderecok__BackingField = cliente.Endereco,
TelefoneResidencialk__BackingField = cliente.TelefoneResidencial,
TelefoneCelulark__BackingField = cliente.TelefoneCelular,
DataNascimentok__BackingField = cliente.DataNascimento
};
Integracao.XYZ.XYZClientes.AtualizarCliente(tbCliente);
}
catch (Exception ex)
{
msg.Exception = ex;
}
return msg;
}
protected void Page_Load(object sender, EventArgs e)
{
if (!IsPostBack)
{
try
{
this.id = Int32.Parse(Util.GetCookieValue(cookiesNombre.cookieModelo));
}
catch
{
this.id = 0;
}
lstMarca.Items.Clear();
domModelos = Dominio.obtenerDominios(GlobalEnum.dominios.Marca.ToString());
foreach (Dominio d in domModelos)
{
lstMarca.Items.Add(new ListItem(d.nombre, d.id.ToString()));
}
if (this.id != 0)
{
popularValores();
}
}
}
//----------------------------------------------------------------------
public async Task <Dominio> Update(Dominio model)
{
var dominio = await _context.Dominios.FirstOrDefaultAsync(x => x.dominio_id == model.dominio_id);
if (dominio == null)
{
return(null);
}
if (dominio.descripcion != model.descripcion.Left(100))
{
var reg = await _context.Dominios.FirstOrDefaultAsync(x => x.dominio_id != model.dominio_id && x.descripcion == model.descripcion);
if (reg != null)
{
throw new Exception("El nombre del dominio existe con otro Id");
}
}
dominio.descripcion = model.descripcion.Left(100);
await _context.SaveChangesAsync();
return(dominio);
}
public async Task <Dominio[]> GetDominios(string LugarResidencia)
{
try
{
var client = new HttpClient();
client.BaseAddress = new Uri(GlobalVariables.AcumenUrl);
var contentType = new MediaTypeWithQualityHeaderValue("application/json");
client.DefaultRequestHeaders.Accept.Add(contentType);
client.DefaultRequestHeaders.Authorization =
new AuthenticationHeaderValue("FedAuth", GlobalVariables.TokenAcumen);
var response = client.GetAsync("/api/dominio?valorDominio=" + LugarResidencia).Result;
var stringData = response.Content.ReadAsStringAsync().Result;
var data = JsonConvert.DeserializeObject <List <Dominio> >(await response.Content.ReadAsStringAsync());
if (response.StatusCode == HttpStatusCode.OK)
{
for (var i = 0; i < data.Count; i++)
{
var ent = new Dominio();
ent.Descripcion = data[i].Descripcion;
dm[i] = data[i];
}
}
}
catch (Exception ex)
{
Error = true;
}
return(dm);
}
protected void Page_Load(object sender, EventArgs e)
{
if (!IsPostBack)
{
domCategoriaF = Dominio.obtenerDominios(GlobalEnum.dominios.Categoria.ToString());
lstCategoria.Items.Add(new ListItem("N/A", "0"));
foreach (Dominio d in domCategoriaF)
{
lstCategoria.Items.Add(new ListItem(d.nombre, d.id.ToString()));
}
lstCategoria.SelectedIndex = 0;
lstEstado.Items.Add(new ListItem("N/A", ""));
foreach (String en in Enum.GetNames(typeof(GlobalEnum.estadoMantenimiento)))
{
lstEstado.Items.Add(new ListItem(en, en));
}
lstEstado.SelectedIndex = 2;
this.filtro = " where estado='PENDIENTE' ";
this.complemento = " order by id desc ";
cargarMantenimientos();
}
}
public static void SetarUsuarioAplicacao(Dominio.Usuario usuario)
{
if (_usuario == null)
_usuario = usuario;
else
throw new InvalidOperationException("Você não pode mudar o usuário da aplicação!");
}
public Dominio Buscar(string usuario)
{
try
{
Dominio dominio = null;
DBSession session = new DBSession();
Query quey = session.CreateQuery("SELECT * FROM mailing_dominios WHERE txdominio = @dominio");
quey.SetParameter("txdominio", dominio);
IDataReader reader = quey.ExecuteQuery();
if (reader.Read())
{
dominio = new Dominio(Convert.ToInt32(reader["iddominio"]), Convert.ToString(reader["txdominio"]), Convert.ToString(reader["txsmtp"]), Convert.ToInt32(reader["txporta"]), Convert.ToInt32(reader["flautenticacao"]));
}
reader.Close();
session.Close();
return(dominio);
}
catch (Exception error)
{
throw error;
}
}
protected void btnGuardar_Click(object sender, EventArgs e)
{
Dominio dominio = new Dominio();
String nombre = txtNombre.Text.Trim();
if (!dominio.validarDominio(this.tipoDominio))
{
lblMensaje.Text = Resources.Mensajes.Error_Dominio;
tipoDominio = GlobalEnum.dominios.Estado.ToString();
return;
}
if (!dominio.validarNombreUnico(this.id, nombre, tipoDominio))
{
lblMensaje.Text = Resources.Mensajes.Repetido_Nombre;
return;
}
if (dominio.agregarActualizarDominio(this.id, nombre, tipoDominio))
{
lblMensaje.Text = Resources.Mensajes.Bien_Dominio;
Response.Redirect("Default.aspx");
}
else
{
lblMensaje.Text = Resources.Mensajes.Error_Dominio;
}
}
/// <summary>
/// Metodo para enviar correo notificacion Masivo
/// </summary>
/// <returns></returns>
private void EnviarEmail(string email, string fecha, string hora)
{
try
{
NegocioDominio negocioDominio = new NegocioDominio();
Dominio emaiNotificacionLavadoFormato = negocioDominio.ConsultarPorId(Enums.EnumTablaDominio.notificacionLavado.ToString());
if (emaiNotificacionLavadoFormato.IsNull())
{
throw new ExceptionControlada(string.Format(Mensajes.MsgErrorDominioNoEncontrado, Enums.EnumTablaDominio.sms_formato.ToString()));
}
var message = string.Format(emaiNotificacionLavadoFormato.valor, fecha.Substring(0, 10), hora);
Dominio dominioSMTP = negocioDominio.ConsultarPorId(EnumTablaDominio.configuracionSMTP.ToString());
if (dominioSMTP.IsNull() || string.IsNullOrEmpty(dominioSMTP.valor))
{
throw new ExceptionControlada(Mensajes.MsgConfiguracionSMTPRequerida);
}
CorreoProxy correoProxy = new CorreoProxy(dominioSMTP.valor);
Correo correoEnviar = new Correo();
Dominio dominioRemitentePrincipal = negocioDominio.ConsultarPorId(EnumTablaDominio.correoRemitentePrincipal.ToString());
if (dominioRemitentePrincipal.IsNull() || string.IsNullOrEmpty(dominioRemitentePrincipal.valor))
{
throw new ExceptionControlada(Mensajes.MsgCorreoRemitentePrincipal);
}
Dominio domonioAsuntoCorreo = negocioDominio.ConsultarPorId(EnumTablaDominio.asuntoNotificacionLavado.ToString());
if (domonioAsuntoCorreo.IsNull() || string.IsNullOrEmpty(domonioAsuntoCorreo.valor))
{
throw new ExceptionControlada(Mensajes.MsgAsuntoCorreoRegistroPedido);
}
Dominio plantillaCorreo = negocioDominio.ConsultarPorId(EnumTablaDominio.plantillaCorreoNotificacion.ToString());
if (plantillaCorreo.IsNull() || string.IsNullOrEmpty(plantillaCorreo.valor))
{
throw new ExceptionControlada(Mensajes.MsgTextoInicialCorreoRegistroPedido);
}
var bytes = Convert.FromBase64String(Constantes.IMAGEN_BANNER_NOTI);
var contents = new MemoryStream(bytes);
correoEnviar.De = dominioRemitentePrincipal.valor;
correoEnviar.Asunto = domonioAsuntoCorreo.valor;
correoEnviar.Para = new List <string>()
{
email
};
correoEnviar.Cuerpo = plantillaCorreo.valor.Replace("@MESSAGE", message);
correoEnviar.Adjunto = contents;
correoProxy.EnviarCorreo(correoEnviar, true);
}
catch (Exception ex)
{
Logger log = Logger.Instancia;
log.EscribirLogError($"Error al enviar Correo bono:{10}", ex);
return;
}
}
public ActionResult Dominio(Dominio dominio, int empreendimento)
{
DominioVM vm = new DominioVM(_listaBus.DominialidadeComprovacoes, dominio, dominio.ComprovacaoId);
using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia())
{
#region Select QTD Modulo Fiscal GLOBAL
Comando comando = bancoDeDados.CriarComando(@"SELECT ATP_QTD_MODULO_FISCAL FROM CRT_CAD_AMBIENTAL_RURAL WHERE EMPREENDIMENTO = :empreendimentoID");//, EsquemaBanco);
comando.AdicionarParametroEntrada("empreendimentoID", empreendimento, DbType.Int32);
using (IDataReader reader = bancoDeDados.ExecutarReader(comando))
{
while (reader.Read())
{
//SET VARIAVEL GLOBAL
globalModuloFiscal = Convert.ToDouble(reader["ATP_QTD_MODULO_FISCAL"]);
}
reader.Close();
}
#endregion
}
return(PartialView("DominioPartial", vm));
}
public void Atualizar(Dominio.Entidade.Cliente cliente)
{
var dadosDB = ObterPorID(cliente.ID);
dadosDB.Nome = cliente.Nome;
dadosDB.Nascimento = cliente.Nascimento;
dadosDB.Sexo = cliente.Sexo;
//Atualizando a foto se necessário
if (cliente.Foto != null && cliente.Foto.Binario.Length > 0)
{
if (dadosDB.Foto != null)
{
dadosDB.Foto.NomeArquivo = cliente.Foto.NomeArquivo;
dadosDB.Foto.ExtensaoArquivo = cliente.Foto.ExtensaoArquivo;
dadosDB.Foto.TipoArquivo = cliente.Foto.TipoArquivo;
dadosDB.Foto.Binario = cliente.Foto.Binario;
}
else
{
var novaFoto = new Dominio.Entidade.Foto
{
NomeArquivo = cliente.Foto.NomeArquivo,
ExtensaoArquivo = cliente.Foto.ExtensaoArquivo,
TipoArquivo = cliente.Foto.TipoArquivo,
Binario = cliente.Foto.Binario
};
dadosDB.Foto = novaFoto;
}
}
else if (cliente.Foto != null && cliente.Foto.NomeArquivo != dadosDB.Foto.NomeArquivo)
{
dadosDB.Foto = null;
}
}
public ActionResult ObterPerimetroPosse(int dominio)
{
DominialidadeBus dominialidadeBus = new DominialidadeBus();
Dominio aux = dominialidadeBus.ObterDominio(dominio);
return(Json(new { @EhValido = Validacao.EhValido, @Msg = Validacao.Erros, PerimetroPosse = aux.Perimetro.ToStringTrunc(3) }, JsonRequestBehavior.AllowGet));
}
private void CarregarViewBag(Manutencao item)
{
var idcSituacao = Convert.ToString((Char)Enums.Situacao.Ativo);
var veiculoEmUso = transporteService
.GetAll(x => (!x.DthChegada.HasValue))
.ToList();
// Se for inclusão, o veículo não pode esta em uso
var veiculoEmViagem = veiculoEmUso.Select(x => x.IdeVeiculo).ToList();
#region Veiculo
var veiculo = veiculoService
.GetAll(x => ((x.IdcSituacao == idcSituacao) &&
(x.Manutencao.Where(m => m.DthSaida == null).FirstOrDefault() == null) &&
(!veiculoEmViagem.Contains(x.IdeVeiculo)) ||
(x.IdeVeiculo == item.IdeVeiculo))
)
.ToList();
ViewBag.Veiculo = veiculo
.Select(x => new SelectListItem()
{
Value = x.IdeVeiculo.ToString(), Text = x.DscMarcaModelo
})
.OrderBy(x => x.Text)
.ToList();
#endregion
#region Mecânico
var mecanico = colaboradorService
.GetAll(x => ((x.IdcSituacao == idcSituacao) &&
(x.IdeTipoColaborador == Enums.TipoColaborador.Mecanico.GetHashCode())) ||
(x.IdeColaborador == item.IdeColaborador)
)
.ToList();
ViewBag.mecanico = mecanico
.Select(x => new SelectListItem()
{
Value = x.IdeColaborador.ToString(), Text = x.NomColaborador
})
.OrderBy(x => x.Text)
.ToList();
#endregion
var tipoManutencao = Dominio.BuscarTipoManutencao();
ViewBag.TipoManutencao = tipoManutencao
.Select(x => new SelectListItem()
{
Value = x.Key, Text = x.Value
})
.OrderBy(x => x.Text)
.ToList();
}
public Dominialidade ObterPorEmpreendimento(int empreendimento, bool simplificado = false, BancoDeDados banco = null)
{
Dominialidade caracterizacao = null;
try
{
caracterizacao = _da.ObterPorEmpreendimento(empreendimento, simplificado: simplificado);
foreach (Dominio dominio in caracterizacao.Dominios)
{
foreach (ReservaLegal reserva in dominio.ReservasLegais)
{
if (!string.IsNullOrEmpty(reserva.MatriculaIdentificacao))
{
Dominio dominioAux = caracterizacao.Dominios.SingleOrDefault(x => x.Identificacao == reserva.MatriculaIdentificacao);
if (dominioAux == null)
{
continue;
}
reserva.MatriculaTexto = dominioAux.Matricula + " - " + dominioAux.Folha + " - " + dominioAux.Livro;
}
}
}
}
catch (Exception exc)
{
Validacao.AddErro(exc);
}
return(caracterizacao);
}
protected void grdDominio_RowCommand(object sender, GridViewCommandEventArgs e)
{
if (e.CommandName == "editDominio")
{
Dictionary <string, string> cookieValues = new Dictionary <string, string>();
cookieValues.Add(cookiesNombre.cookieDominioNombre, tipoDominio.ToString());
cookieValues.Add(cookiesNombre.cookieDominioValor, e.CommandArgument.ToString());
Util.AddCookieValues(cookieValues);
this.Page.Response.Redirect("AgregarDominio.aspx");
}
if (e.CommandName == "eliminarDominio")
{
Dominio dominio = new Dominio();
if (!dominio.verificarUsoDominio(e.CommandArgument.ToString(), this.tipoDominio))
{
lblMensaje.Text = Resources.Mensajes.Dominio_Uso;
lblMensaje.ForeColor = System.Drawing.Color.Red;
return;
}
if (!dominio.eliminarDominio(e.CommandArgument.ToString(), this.tipoDominio))
{
lblMensaje.Text = Resources.Mensajes.Error_Dominio_Eliminar;
lblMensaje.ForeColor = System.Drawing.Color.Red;
}
else
{
lblMensaje.Text = Resources.Mensajes.Bien_Eliminar_Dominio;
lblMensaje.ForeColor = System.Drawing.Color.Green;
cargarDominios();
}
}
}
public Dominialidade ObterHistorico(int dominialidadeID, string dominialidadeTID, bool simplificado = false)
{
Dominialidade caracterizacao = null;
try
{
caracterizacao = _da.Obter(dominialidadeID, tid: dominialidadeTID, simplificado: simplificado);
caracterizacao.Dependencias = _busCaracterizacao.ObterDependencias(caracterizacao.Id, eCaracterizacao.Dominialidade, eCaracterizacaoDependenciaTipo.Caracterizacao, caracterizacao.Tid);
foreach (Dominio dominio in caracterizacao.Dominios)
{
foreach (ReservaLegal reserva in dominio.ReservasLegais)
{
if (!string.IsNullOrEmpty(reserva.MatriculaIdentificacao))
{
Dominio dominioAux = caracterizacao.Dominios.SingleOrDefault(x => x.Identificacao == reserva.MatriculaIdentificacao);
if (dominioAux == null)
{
continue;
}
reserva.MatriculaTexto = dominioAux.Matricula + " - " + dominioAux.Folha + " - " + dominioAux.Livro;
}
}
}
}
catch (Exception exc)
{
Validacao.AddErro(exc);
}
return(caracterizacao);
}
public IList<Dominio.Noticia> Pesquisar(Dominio.Noticia objeto, short qtde)
{
ICriteria criteria = NHibernate.HttpModule.RecuperarSessao.CreateCriteria(typeof(Dominio.Noticia));
criteria.SetMaxResults(qtde);
criteria.AddOrder(Order.Desc("Data"));
//criteria.Add(Expression.Between("Data", DateTime.MinValue, DateTime.Now));
if (objeto == null)
return criteria.List<Dominio.Noticia>();
if (objeto.Codigo > 0)
criteria = criteria.Add(Expression.Eq("Codigo", objeto.Codigo));
if (objeto.UsuarioCadastro != null)
criteria = criteria.Add(Expression.Eq("CodUsuario", objeto.UsuarioCadastro.Codigo));
if (objeto.Data > DateTime.MinValue)
criteria = criteria.Add(Expression.Eq("Data", objeto.Data));
if (!string.IsNullOrEmpty(objeto.Titulo))
criteria = criteria.Add(Expression.Eq("Titulo", objeto.Titulo));
if (objeto.AnteTitulo == "UsarDestaque")
criteria = criteria.Add(Expression.Eq("Destaque", objeto.Destaque));
IList<Dominio.Noticia> noticias = criteria.List<Dominio.Noticia>();
return noticias;
}
public ActionResult Dominio(Dominio dominio, int empreendimento)
{
DominioVM vm = new DominioVM(ListaCredenciadoBus.DominialidadeComprovacoes, dominio, dominio.ComprovacaoId);
using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia())
{
#region Select QTD Modulo Fiscal GLOBAL
Comando comando = bancoDeDados.CriarComando(@"SELECT
(round((SELECT (t.croqui_area/10000) FROM CRT_DOMINIALIDADE t WHERE t.empreendimento = D.EMPREENDIMENTO) /
(SELECT m.modulo_ha FROM idaf.CNF_MUNICIPIO_MOD_FISCAL m WHERE m.municipio = (SELECT e.municipio FROM
TAB_EMPREENDIMENTO_ENDERECO e WHERE e.empreendimento = D.EMPREENDIMENTO AND e.correspondencia = 0)),2)) as ATP_QTD_MODULO_FISCAL
FROM CRT_DOMINIALIDADE D
WHERE D.EMPREENDIMENTO = :empreendimentoID");
//Consulta calculo qtd_Modulo_Fiscal
comando.AdicionarParametroEntrada("empreendimentoID", empreendimento, DbType.Int32);
using (IDataReader reader = bancoDeDados.ExecutarReader(comando))
{
while (reader.Read())
{
//SET VARIAVEL GLOBAL
globalModuloFiscal = Convert.ToDouble(reader["ATP_QTD_MODULO_FISCAL"]);
}
reader.Close();
}
#endregion
}
return(PartialView("DominioPartial", vm));
}
/// <summary>
/// Evento que formata os resultados da busca e exibe na tela
/// </summary>
/// <param name="sender">Objeto que disparou esse evento</param>
/// <param name="e">Contém os argumentos fornecidos nesse evento</param>
protected void RptResultadoBusca_ItemDataBound(object sender, RepeaterItemEventArgs e)
{
if (e != null && (e.Item.ItemType == ListItemType.Item || e.Item.ItemType == ListItemType.AlternatingItem))
{
ArquivoSped arquivo = (ArquivoSped)e.Item.DataItem;
HiddenField hfIdResultadoBusca = (HiddenField)e.Item.FindControl("HfIdResultadoBusca");
HtmlGenericControl spnSucesso = (HtmlGenericControl)e.Item.FindControl("SpnSucesso");
HtmlGenericControl spnAdvertencia = (HtmlGenericControl)e.Item.FindControl("SpnAdvertencia");
HtmlGenericControl spnErro = (HtmlGenericControl)e.Item.FindControl("SpnErro");
HtmlGenericControl spnRejeitado = (HtmlGenericControl)e.Item.FindControl("SpnRejeitado");
LinkButton btnPropriedadesArquivo = (LinkButton)e.Item.FindControl("BtnPropriedadesArquivo");
Label lblTipoEscrituracao = (Label)e.Item.FindControl("LblTipoEscrituracao");
Label lblFinalidade = (Label)e.Item.FindControl("LblFinalidade");
Label lblCompetenciaInicio = (Label)e.Item.FindControl("LblCompetenciaInicio");
Label lblCompetenciaFim = (Label)e.Item.FindControl("LblCompetenciaFim");
Label lblDataEntrega = (Label)e.Item.FindControl("LblDataEntrega");
Label lblEntidade = (Label)e.Item.FindControl("LblEntidade");
hfIdResultadoBusca.Value = arquivo.Id.ToString();
spnSucesso.Visible = arquivo.StatusPva.HasValue ? arquivo.StatusPva == StatusPva.ValidadoSucesso : false;
spnAdvertencia.Visible = arquivo.StatusPva.HasValue ? arquivo.StatusPva == StatusPva.ValidadoAdvertencia : false;
spnErro.Visible = arquivo.StatusPva.HasValue ? arquivo.StatusPva == StatusPva.ValidadoErro : false;
spnRejeitado.Visible = arquivo.StatusPva.HasValue ? arquivo.StatusPva == StatusPva.Rejeitado : false;
btnPropriedadesArquivo.CommandArgument = arquivo.Id.ToString();
lblTipoEscrituracao.Text = Dominio.ValorTextoDe(arquivo.TipoEscrituracao);
lblFinalidade.Text = arquivo.FinalidadeArquivo.HasValue ? (byte)arquivo.FinalidadeArquivo + " - " + Dominio.ValorTextoDe(arquivo.FinalidadeArquivo) : string.Empty;
lblCompetenciaInicio.Text = arquivo.Competencia.De.HasValue ? arquivo.Competencia.De.Value.ToString("dd/MM/yyyy") : string.Empty;
lblCompetenciaFim.Text = arquivo.Competencia.Ate.HasValue ? arquivo.Competencia.Ate.Value.ToString("dd/MM/yyyy") : string.Empty;
lblDataEntrega.Text = arquivo.DataTransmissaoSefaz.HasValue ? arquivo.DataTransmissaoSefaz.Value.ToString("dd/MM/yyyy") : TEXTO_NAO_ENTREGUE;
lblEntidade.Text = GerenciamentoEmpresa.MontaTextoParticipante(arquivo.Entidade);
}
}
public void AtualizarCliente(Dominio.TbCliente cliente)
{
try
{
Message msg;
var repo = new Repositorio.Models.Cliente();
msg = repo.EditarClienteService(cliente);
if (msg.Resultado != TipoResultado.Sucesso)
throw msg.Exception;
}
catch (BusinessException be)
{
BusinessFault bf = new BusinessFault();
bf.Titulo = "Erro de negócio";
bf.Mensagem = be.Message;
bf.StackTrace = be.StackTrace;
throw new FaultException<BusinessFault>(bf, bf.Titulo);
}
catch (Exception ex)
{
throw ex;
}
}
public JsonResult Pesquisar(DatatableParm parm, Veiculo item)
{
try
{
SalvarPesquisa(item, parm);
var items = veiculoService.GetAllByPage(item, parm);
var situacao = Dominio.BuscarSituacao();
return(Json(new
{
ok = true,
sEcho = parm.sEcho,
iTotalRecords = items.Count(),
iTotalDisplayRecords = parm.totalRecords,
aaData = items.Select(x => new
{
IdeVeiculo = x.IdeVeiculo,
CodRenavam = x.CodRenavam,
NumPlaca = x.NumPlaca,
NumAnoFab = x.NumAnoFab,
DscMarcaModelo = x.DscMarcaModelo,
IdcSituacao = situacao.Where(s => s.Key == x.IdcSituacao).FirstOrDefault().Value
})
}));
}
catch (Exception ex)
{
return(Json(CreateMessageDatatable(ex)));
}
}
public IHttpActionResult PutDominio(int id, Dominio dominio)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != dominio.IdDominio)
{
return(BadRequest());
}
db.Entry(dominio).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!DominioExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public DominioVM(List <Lista> comprovacoes, Dominio dominio, int comprovacaoId = 0, bool isVisualizar = false)
{
Comprovacoes = ViewModelHelper.CriarSelectList(comprovacoes, isFiltrarAtivo: true, selecionado: comprovacaoId.ToString());
Dominio = dominio;
IsVisualizar = isVisualizar;
}
public ActionResult ObterAreaTotalPosse(int dominio)
{
DominialidadeBus dominialidadeBus = new DominialidadeBus();
Dominio aux = dominialidadeBus.ObterDominio(dominio);
return(Json(new { @EhValido = Validacao.EhValido, @Msg = Validacao.Erros, AreaTotalPosse = aux.AreaCroqui.ToStringTrunc(2) }, JsonRequestBehavior.AllowGet));
}
public ActionResult DeleteConfirmed(int id)
{
Dominio dominio = db.Dominios.Find(id);
db.Dominios.Remove(dominio);
db.SaveChanges();
return(RedirectToAction("Index"));
}
/// <summary>
/// Define os valores inicias dos controles que forem necessários
/// </summary>
private void DefineControles()
{
Dictionary <int, string> unidadesFederativas = (Dictionary <int, string>)Dominio.ObtemListaEnum(typeof(UnidadeFederativa));
unidadesFederativas.Add(0, string.Empty);
this.DefineControleUnidadeFederativa(unidadesFederativas);
}
public static void Configure(IServiceCollection servicios)
{
servicios.AddSingleton <IConfiguration>(CreacionConfiguracion.Inyectar());
//servicios.AddAutoMapper(typeof(DependencyInjector));
//BDConsiguracion.Inyectar(servicios);
Dominio.Inyectar(servicios);
LoggerModuloInyeccion.Inyectar(servicios);
}
public static void Actualizar(Dominio.Dtos.proyectoDTO dto, PersistenciaDatos.proyecto entity)
{
entity.ID_Proyecto = dto.ID_Proyecto;
entity.ID_Usuario = dto.ID_Usuario;
entity.year_ejec = dto.year_ejec;
entity.nombre = dto.nombre;
entity.estado = dto.estado;
}
public void Persistir(Dominio dominio)
{
dominio.DescricaoValor = dominio.DescricaoValor.ToUpper();
dominio.IdValor = _dominioRepository.BuscarDominiosPorTipo(dominio.ValorTipoDominio, false).Count() + 1;
_dominioRepository.Adicionar(dominio);
_unitOfWork.Commit();
}
public CourseModel(Dominio.Matricula matricula)
{
CourseId = matricula.CursoId;
CourseName = matricula.Curso.Nombre;
StartDate = matricula.Curso.FechaInicio.ToShortDateString();
Department = matricula.Curso.Especialidad.Descripcion;
Instructor = matricula.Curso.Profesor.Nombres + " " + matricula.Curso.Profesor.ApellidoPaterno;
}
public override global::System.Data.DataSet Clone()
{
Dominio cln = ((Dominio)(base.Clone()));
cln.InitVars();
cln.SchemaSerializationMode = this.SchemaSerializationMode;
return(cln);
}
public ActionResult AdicionarDominios([FromRoute] int idFuncionario, [FromBody] Dominio dominio, [FromServices] ISession session)
{
Funcionario func = session.Get <Funcionario>(idFuncionario);
func.Dominios.Add(dominio);
session.Save(func);
return(Ok());
}
public Dominio.Usuario Cadastrar(Dominio.Usuario objeto)
{
NHibernate.HttpModule.RecuperarSessao.Transaction.Begin();
objeto.Codigo = (int)NHibernate.HttpModule.RecuperarSessao.Save(objeto);
NHibernate.HttpModule.RecuperarSessao.Transaction.Commit();
return objeto;
}
public static void Actualizar(Dominio.Dtos.requerimiento_detalleDTO dto, PersistenciaDatos.requerimiento_detalle entity)
{
entity.ID_RequerimientoDetalle = dto.ID_RequerimientoDetalle;
entity.ID_Requerimiento = dto.ID_Requerimiento;
entity.ID_Catalogo = dto.ID_Catalogo;
entity.ID_UnidadMedida = dto.ID_UnidadMedida;
entity.cantidad = dto.cantidad;
entity.valor_referencial = dto.valor_referencial;
}
public void AddTrackingNoDominio(Dominio dominio)
{
if (dominio.IdValor == 0)
{
int idValor = _dominioRepository.ObterPeloVlTipoDominio(dominio.ValorTipoDominio)?.LastOrDefault()?.IdValor + 1 ?? 1;
dominio.IdValor = idValor;
}
_dominioRepository.Adicionar(dominio);
}
private int CompilarCMaisMais(Dominio.Submissao submissao)
{
Dominio.Configuracao configuracao = new Dominio.Configuracao();
string arquivo = System.IO.Path.Combine(configuracao.CaminhoSalvarSubmissoes, submissao.Id + ".cpp");
string nome = System.IO.Path.Combine(configuracao.CaminhoSalvarSubmissoes,submissao.Id + ".exe");
string comando = string.Format("/c g++ \"{0}\" -o \"{1}\"", arquivo, nome);
return ExecutarPromptComando(comando, configuracao.CaminhoGmaismais);
}
public void DownloadQuestao(Dominio.Questao questao)
{
Dominio.Configuracao configuracao = new Dominio.Configuracao();
string caminhoEntrada = System.IO.Path.Combine(configuracao.CaminhoSalvarSubmissoes, questao.ArquivoEntrada);
string caminhoSaida = System.IO.Path.Combine(configuracao.CaminhoSalvarSubmissoes, questao.ArquivoSaida);
NpgsqlConnection conexao = new NpgsqlConnection("Server=187.45.196.224;Database=bubblesort9;User ID=bubblesort9;Password=BSboca;");
NpgsqlTransaction transacao = null;
try
{
conexao.Open();
transacao = conexao.BeginTransaction();
LargeObjectManager lbm = new LargeObjectManager(conexao);
LargeObject lo = lbm.Open(questao.IdArquivoEntrada, LargeObjectManager.READ);
FileStream fsout = File.OpenWrite(caminhoEntrada);
byte[] buf = new byte[lo.Size()];
buf = lo.Read(lo.Size());
fsout.Write(buf, 0, (int)lo.Size());
fsout.Flush();
fsout.Close();
lo.Close();
lo = lbm.Open(questao.IdArquivoSaida, LargeObjectManager.READ);
fsout = File.OpenWrite(caminhoSaida);
byte[] buffer = new byte[lo.Size()];
buffer = lo.Read(lo.Size());
fsout.Write(buffer, 0, (int)lo.Size());
fsout.Flush();
fsout.Close();
lo.Close();
transacao.Commit();
}
catch
{
if (transacao != null)
transacao.Rollback();
throw;
}
finally
{
conexao.Close();
}
}
public void Post([FromBody] JObject value)
{
Dominio posted = value.ToObject <Dominio>();
using (DominioDb db = new DominioDb())
{
db.Dominios.Add(posted);
db.SaveChanges();
}
}
public Dominio ConsultarPorId(string dominio)
{
Dominio dominioEntity = new Dominio();
using (UnitOfWork unitOfWork = new UnitOfWork())
{
dominioEntity = unitOfWork.DominioRepositorio.ObtenerPorID(dominio);
}
return(dominioEntity);
}
public ActionResult Edit([Bind(Include = "DominioId,Descricao")] Dominio dominio)
{
if (ModelState.IsValid)
{
db.Entry(dominio).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(dominio));
}
public override int GetHashCode()
{
unchecked
{
int hash = 17;
hash = hash * 31 + Tipo.GetHashCode();
hash = hash * 31 + Dominio.GetHashCode();
return(hash);
}
}
public static void Actualizar(Dominio.Dtos.requerimientoDTO dto, PersistenciaDatos.requerimiento entity)
{
entity.ID_Requerimiento = dto.ID_Requerimiento;
entity.ID_Usuario = dto.ID_Usuario;
entity.ID_Almacen = dto.ID_Almacen;
entity.fecha = dto.fecha;
entity.detalle_requerimiento = dto.detalle_requerimiento;
entity.estado = dto.estado;
entity.observaciones_requerimiento = dto.observaciones_requerimiento;
}
public void Atualizar(Dominio.Entidade.Cliente cliente)
{
var dadosDB = ObterPorID(cliente.ID);
dadosDB.Nome = cliente.Nome;
dadosDB.Nascimento = cliente.Nascimento;
dadosDB.Sexo = cliente.Sexo;
//Atualizando a foto se necessário
AtualizarFoto(cliente, dadosDB);
}
public Dominio.Conteudo DesvincularFotos(Dominio.Conteudo conteudo)
{
string sql = string.Empty;
sql = "delete from tb_conteudofoto where CodConteudo = " + conteudo.Codigo;
this.conexao.ExecutarNonQuery(sql);
return conteudo;
}
public bool ActualizarEntidad(Dominio.Dtos.entidadDTO dto)
{
try
{
return entidadQuerys.ActualizarEntidad(dto);
}
catch (Exception)
{
throw new NotImplementedException();
}
}
public bool InsertarEntidad(Dominio.Dtos.entidadDTO dto)
{
try
{
return entidadLogicaNegocio.InsertarEntidad(dto);
}
catch (Exception)
{
throw new NotImplementedException();
}
}
public int InsertarRequerimientoDetalle(Dominio.Dtos.requerimiento_detalleDTO dto)
{
try
{
return requerimientodetalleLogicaNegocio.InsertarRequerimientoDetalle(dto);
}
catch (Exception)
{
throw new NotImplementedException();
}
}
public int Executar(Dominio.Questao questao, Dominio.Submissao submissao)
{
Dominio.Configuracao configuracao = new Dominio.Configuracao();
string arquivoIn = System.IO.Path.Combine(configuracao.CaminhoSalvarSubmissoes, questao.ArquivoEntrada);
string executavel = System.IO.Path.Combine(configuracao.CaminhoSalvarSubmissoes, submissao.Id + ".exe");
string saida = System.IO.Path.Combine(configuracao.CaminhoSalvarSubmissoes, submissao.Id + ".out");
string comando = string.Format("/c type \"{0}\"|{1} > \"{2}\"",arquivoIn, executavel, saida); //TODO Vou tentar usar o type
return ExecutarPromptComandoComTempo(comando, questao.TimeLimit * 1000, submissao.Id.ToString());
}
public bool ActualizarDepartamento(Dominio.Dtos.departamentoDTO dto)
{
try
{
return departamentoQuerys.ActualizarDepartamento(dto);
}
catch (Exception)
{
throw new NotImplementedException();
}
}
public bool ActualizarAlmacen(Dominio.Dtos.almacenDTO dto)
{
try
{
return almacenLogicaNegocio.ActualizarAlmacen(dto);
}
catch (Exception)
{
throw new NotImplementedException();
}
}
public int InsertarAlmacen(Dominio.Dtos.almacenDTO dto)
{
try
{
return almacenLogicaNegocio.InsertarAlmacen(dto);
}
catch (Exception)
{
throw new NotImplementedException();
}
}
public bool ActualizarProyecto(Dominio.Dtos.proyectoDTO dto)
{
try
{
return proyectoQuerys.ActualizarProyecto(dto);
}
catch (Exception)
{
throw new NotImplementedException();
}
}
public int InsertarProyecto(Dominio.Dtos.proyectoDTO dto)
{
try
{
return proyectoQuerys.InsertarProyecto(dto);
}
catch (Exception)
{
throw new NotImplementedException();
}
}
public int InsertarUsuario(Dominio.Dtos.usuarioDTO dto)
{
try
{
return usuarioQuerys.InsertarUsuario(dto);
}
catch (Exception)
{
throw new NotImplementedException();
}
}
public bool InsertarCatalogo(Dominio.Dtos.catalogoDTO dto)
{
try
{
return catalogoQuerys.InsertarCatalogo(dto);
}
catch (Exception)
{
throw new NotImplementedException();
}
}
public bool InsertarUnidadMedida(Dominio.Dtos.unidad_medidaDTO dto)
{
try
{
return unidadmedidaQuerys.InsertarUnidadMedida(dto);
}
catch (Exception)
{
throw new NotImplementedException();
}
}
public int InsertarDepartamento(Dominio.Dtos.departamentoDTO dto)
{
try
{
return departamentoQuerys.InsertarDepartamento(dto);
}
catch (Exception)
{
throw new NotImplementedException();
}
}
