public IActionResult UpdateEmpresa([FromBody] EmpresaDTO body)
{
try{
Console.WriteLine("[UpdateEmpresa] -> request body: " + body.ToString());
// se validan datos de entrada
if (body == null || body.Id == 0)
{
Console.WriteLine("[UpdateEmpresa] -> falta id de empresa en request body");
RestResponse responseErr = RestUtils.GenerateResponseErrorWith(
new ResponseError(
RestUtils.RESPONSE_BADREQUEST_CODE,
"Falta id de empresa en request body"
)
);
responseErr.Header.Message = RestUtils.RESPONSE_BADREQUEST_MSG;
return(BadRequest(responseErr));
}
// se envia info a modificar
EmpresaDTO result = empresasService.ModifyEmpresa(
body.Id,
ModelMapper.Map(body)
);
// se valida resultado
if (result == null)
{
Console.WriteLine("[UpdateEmpresa] -> operacion fallida");
RestResponse responseErr = RestUtils.GenerateResponseErrorWith(
new ResponseError(
RestUtils.RESPONSE_NOTFOUND_MSG,
"Operacion fallida, no se puede modifica empresa , ya que no hay resultados asociados al id" + body.Id
)
);
responseErr.Header.Message = RestUtils.RESPONSE_ERROR_CODE;
return(NotFound(responseErr));
}
Console.WriteLine("[UpdateEmpresa] -> operacion exitosa");
return(Ok(RestUtils.GenerateResponseOkWithData(result)));
} catch (Exception exception) {
Console.WriteLine("[UpdateEmpresa] -> " + RestUtils.RESPONSE_INTERNAL_ERROR_MSG);
RestResponse response = RestUtils.GenerateResponseErrorWith(
new ResponseError(
exception.Message,
exception.GetType().ToString()
)
);
response.Header.Message = RestUtils.RESPONSE_INTERNAL_ERROR_MSG;
return(StatusCode(
StatusCodes.Status500InternalServerError,
response
));
}
}
public IHttpActionResult verproducto([FromBody] ProductoEmpresaDTO p)
{
try
{
ProductoEmpresa pro = new ProductoEmpresa();
ProductoEmpresaDTO producto = new ProductoEmpresaDTO();
pro = productoempresaservico.Obtenerproducto(p);
ProductoDTO pp = new ProductoDTO()
{
idProducto = pro.idProducto
};
long idc = productoServicio.Obtenerproducto(pp).idCategoria;
CategoriaDTO c = new CategoriaDTO()
{
idCategoria = idc
};
EmpresaDTO e = new EmpresaDTO()
{
idEmpresa = Convert.ToInt64(pro.idEmpresa)
};
ImagenDTO i = new ImagenDTO()
{
idProductoEmpresa = pro.idProductoEmpresa,
principal = true
};
producto.idProductoEmpresa = pro.idProductoEmpresa;
producto.idProducto = pro.idProducto;
producto.precio = Convert.ToDecimal(pro.Precio);
producto.nombre = productoServicio.Obtenerproducto(pp).nombreProducto;
producto.idEmpresa = Convert.ToInt64(pro.idEmpresa);
producto.nombreEmpresa = empresaSevicio.ObtenerEmpresa(e).nombreEmpresa;
producto.idCategoria = categoriaServicio.Obtenercategoria(
new CategoriaDTO()
{
idCategoria = productoServicio.Obtenerproducto(pp).idCategoria
}
).idCategoria;
producto.nombreCategoria = categoriaServicio.Obtenercategoria(
new CategoriaDTO()
{
idCategoria = productoServicio.Obtenerproducto(pp).idCategoria
}
).nombreCategoria;
producto.rutaimagen = imagenService.Obtenerimagen(i);
return(Ok(RespuestaApi <ProductoEmpresaDTO> .createRespuestaSuccess(producto, "success")));
}
catch (Exception ex)
{
return(Ok(RespuestaApi <string> .createRespuestaError(ex.ToString(), "error")));
}
}
public ActionResult CarregaObraPorEmpresa(int empresaId)
{
List <ObraDTO> lista = new List <ObraDTO>();
EmpresaDTO empresa = empresaAppService.ObterEmpresaSemObraPai(empresaId);
if (empresa != null && empresa.ListaObraSemPai != null)
{
lista = empresa.ListaObraSemPai;
}
return(Json(JsonConvert.SerializeObject(lista, Formatting.Indented, new JsonSerializerSettings {
ReferenceLoopHandling = ReferenceLoopHandling.Ignore
})));
}
public IHttpActionResult guardarempresa([FromBody] EmpresaDTO e)
{
try
{
long pk = empresaServicio.GuardarEmpresa(e);
return(Ok(RespuestaApi <long> .createRespuestaSuccess(pk, "success")));
}
catch (Exception ex)
{
return(Ok(RespuestaApi <string> .createRespuestaError(ex.ToString(), "error")));
}
}
public EmpresaViewModel ObterEmpresa(int IdEmpresa)
{
using (HttpClient client = new HttpClient())
{
ServiceBase(client);
HttpResponseMessage response = client.GetAsync("empresa/ObterEmpresa/" + IdEmpresa).Result;
string stringData = response.Content.ReadAsStringAsync().Result;
EmpresaDTO data = JsonConvert.DeserializeObject <EmpresaDTO>(stringData);
var empresaModel = _mapper.Map <EmpresaViewModel>(data);
return(empresaModel);
}
}
public async Task <IActionResult> Update(int id, EmpresaDTO empresa)
{
if (ModelState.IsValid)
{
empresa = await _empresaService.Update(this.Usuario, id, empresa);
return(Ok(empresa));
}
else
{
return(BadRequest(ModelState));
}
}
public EmpresaDTO Salvar(EmpresaDTO dto)
{
if (dto.Codigo == 0)
{
dto = dao.Adicionar(dto);
}
else
{
dto = dao.Alterar(dto);
}
return(dto);
}
private void barButtonItemSelecao_ItemClick(object sender, ItemClickEventArgs e)
{
Cursor = Cursors.WaitCursor;
if (new frmSelecionaEmpresa(this).ShowDialog() != DialogResult.Cancel)
{
if (File.Exists(Global.LocalPath + @"\Sistemas\MechTech\appConfig.xml")) //EXISTE EMPRESA ATIVA.
{
empresa = new EmpresaDTO().Deserializar();
dialogResult = DialogResult.Cancel;
}
}
Cursor = Cursors.Default;
}
public IActionResult Grabar(EmpresaDTO empresa)
{
if (empresa.IdEmp == 0)
{
_empresaService.Insertar(empresa);
}
else
{
_empresaService.Actualizar(empresa);
}
return(RedirectToAction("Index"));
}
public void AlterarEmpresa(EmpresaViewModel empresa)
{
using (HttpClient client = new HttpClient())
{
var empresasDTO = _mapper.Map <EmpresaDTO>(empresa);
ServiceBase(client);
string parametroJSON = JsonConvert.SerializeObject(empresasDTO);
StringContent conteudo = new StringContent(parametroJSON, Encoding.UTF8, "application/json");
HttpResponseMessage response = client.PutAsync("empresa/AlterarEmpresa", conteudo).Result;
string stringData = response.Content.ReadAsStringAsync().Result;
EmpresaDTO data = JsonConvert.DeserializeObject <EmpresaDTO>(stringData);
}
}
public IHttpActionResult eliminarempresa([FromBody] EmpresaDTO e)
{
try
{
empresaServicio.EliminarEmpresa(e);
return(Ok(RespuestaApi <string> .createRespuestaSuccess("Empresa eliminada correctamente", "success")));
}
catch (Exception ex)
{
return(Ok(RespuestaApi <string> .createRespuestaError(ex.ToString(), "error")));
}
}
public async Task <bool> RegistarEmpresa(EmpresaDTO oEmpresa)
{
try
{
UsuarioBl oUsuario = new UsuarioBl();
var response = await oUsuario.RegistarEmpresa(oEmpresa);
return(response);
}
catch (Exception e)
{
throw;
}
}
public EmpresaDTO Insertar(EmpresaDTO empresa)
{
try
{
_contexto.Add(empresa);
_contexto.SaveChanges();
return(empresa);
}
catch (Exception)
{
return(null);
}
}
public EmpresaDTO Actualizar(EmpresaDTO empresa)
{
try
{
_contexto.Update(empresa);
_contexto.SaveChanges();
return(empresa);
}
catch (Exception)
{
return(null);
}
}
public async Task <IActionResult> Post([FromBody] EmpresaDTO empresaDto)
{
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
var empresa = new Empresa(empresaDto.Nome, empresaDto.Cnpj);
_empresaRepository.Adicionar(empresa);
var success = await _empresaRepository.UnitOfWork.Commit();
return(CustomResponse(success));
}
private void CarregarListas(RelOrcamentoListaViewModel model)
{
List <ObraDTO> lista = new List <ObraDTO>();
EmpresaDTO empresa = empresaAppService.ObterEmpresaSemObraPai(model.Filtro.EmpresaId);
if (empresa != null && empresa.ListaObraSemPai != null)
{
lista = empresa.ListaObraSemPai;
}
model.ListaEmpresa = new SelectList(empresaAppService.ListarTodos(), "Id", "NumeroNomeEmpresa", model.Filtro.EmpresaId);
model.ListaObra = new SelectList(lista, "Id", "NumeroDescricao", model.Filtro.ObraId);
model.ListaIndice = new SelectList(indiceFinanceiroAppService.ListarTodos().OrderBy(l => l.Indice), "Id", "Indice", model.Filtro.IndiceId);
}
public List <EmpresaDTO> getListarEmpresa_activa(int COD_EMPRESA)
{
List <EmpresaDTO> ListaEmpresaDTO = new List <EmpresaDTO>();
//ListaUsuarioEmpresaDTO = null;
string cnxString = _appDBContext.Database.GetConnectionString();
SqlConnection cnx = new SqlConnection(cnxString);
try
{
cnx.Open();
using (SqlCommand Sqlcmd = new SqlCommand())
{
Sqlcmd.Connection = cnx;
Sqlcmd.CommandType = CommandType.StoredProcedure;
Sqlcmd.CommandText = "SP_S_Listar_Empresa_activo_21";
SqlDataReader oDataReader = Sqlcmd.ExecuteReader();
while (oDataReader.Read())
{
EmpresaDTO EmpresaDTO = new EmpresaDTO();
EmpresaDTO.cod_empresa = int.Parse(oDataReader["cod_empresa"].ToString());
EmpresaDTO.des_empresa = oDataReader["des_empresa"].ToString();
EmpresaDTO.ruc = oDataReader["ruc"].ToString();
EmpresaDTO.flag_activo = bool.Parse(oDataReader["flag_activo"].ToString());
ListaEmpresaDTO.Add(EmpresaDTO);
}
}
}
catch (SqlException sex)
{
eErrorLog mensajeLogError = new eErrorLog(
sex.Message, "EmpresaRepository/getListarEmpresa_activa(). SQL." + sex, "Error Sql");
mensajeLogError.RegisterLog();
}
catch (Exception ex)
{
eErrorLog mensajeLogError = new eErrorLog(ex.Message, "EmpresaRepository/getListarEmpresa_activa() EX." + ex, "Error");
mensajeLogError.RegisterLog();
}
finally
{
if (cnx.State == System.Data.ConnectionState.Open)
{
cnx.Close();
}
}
return(ListaEmpresaDTO);
}
private List <EmpresaDTO> findByIdUsuario(int usuarioId)
{
var empresas = (from e in _context.Empresa
join ue in _context.UsuarioEmpresa on e.Id equals ue.EmpresaId
join u in _context.Usuario on ue.UsuarioId equals u.Id
where ue.UsuarioId == usuarioId
select new
{
Id = e.Id,
CNPJ = e.CNPJ,
NomeFantasia = e.NomeFantasia,
RazaoSocial = e.RazaoSocial,
Logo = e.Logo,
EmpresaProprietaria = e.EmpresaProprietaria,
QtdUsuarios = e.QtdUsuarios,
UsuarioId = u.Id,
Status = u.Status,
Nome = u.Nome,
Email = u.Email,
PerfilId = ue.PerfilId
}
).ToArray();
var emps = new List <EmpresaDTO>();
foreach (var item in empresas)
{
var emp = new EmpresaDTO();
emp.Id = item.Id;
emp.CNPJ = item.CNPJ;
emp.NomeFantasia = item.NomeFantasia;
emp.RazaoSocial = item.RazaoSocial;
emp.Logo = item.Logo;
emp.EmpresaProprietaria = (int)item.EmpresaProprietaria;
emp.PerfilId = item.PerfilId;
emp.QtdUsuarios = item.QtdUsuarios;
emp.UserDTO = new UserDTO();
emp.UserDTO.Id = item.UsuarioId;
emp.UserDTO.Email = item.Email;
emp.UserDTO.Nome = item.Nome;
emp.UserDTO.PerfilId = item.PerfilId;
emps.Add(emp);
}
return(emps.ToList());
}
public EmpresaDTO GetPk(int i)
{
try
{
EmpresaDTO ud = new EmpresaDTO();
empresa u = db.empresa.Where(t => t.codigo == i).FirstOrDefault();
Mapper.Map(u, ud);
return(ud);
}
catch (Exception ex)
{
throw ex
;
}
}
public void AgregarEmpresa(EmpresaDTO obje)
{
try
{
empresa obj = new empresa();
Mapper.CreateMap <EmpresaDTO, empresa>();
Mapper.Map(obje, obj);
db.empresa.Add(obj);
db.SaveChanges();
}
catch (Exception ex)
{
throw;
}
}
public async Task <bool> Modificar(EmpresaDTO empresa)
{
var dbEmpresa = await _empresaContext.Empresas.Where(u => u.cuit == empresa.Cuit).FirstOrDefaultAsync();
if (dbEmpresa != null)
{
dbEmpresa.direccion = empresa.Direccion ?? dbEmpresa.direccion;
dbEmpresa.nombre = empresa.Nombre ?? dbEmpresa.nombre;
dbEmpresa.razonSocial = empresa.RazonSocial ?? dbEmpresa.razonSocial;
await _empresaContext.SaveChangesAsync();
return(true);
}
return(false);
}
public IHttpActionResult DeleteEmpresa(int id)
{
Empresa empresa = db.Empresa.Find(id);
if (empresa == null)
{
return(NotFound());
}
EmpresaDTO e = new EmpresaDTO(empresa);
db.Empresa.Remove(empresa);
db.SaveChanges();
return(Ok(e));
}
public bool Adicionar(EmpresaDTO dto)
{
_empresa = new Empresa(dto.Nome, dto.Cnpj);
_empresa.AlterarDataFundacao(dto.DataFundacao);
_validador.entidade = _empresa;
_validador.ValidarInclusao();
if (notificationContext.HasNotifications)
{
return(false);
}
_empreaRepository.Add(_empresa);
return(true);
}
public void Update(EmpresaDTO empresadto)
{
var empresa = _repository.GetById(empresadto.Id);
if (empresa == null)
{
Notification.Adicionar("Empresa não encontrada.");
return;
}
empresa.AlteraCNPJ(empresadto.CNPJ);
empresa.AlteraNome(empresadto.Nome);
empresa.AlteraDataFundacao(empresadto.DataFundacao);
Manipulate(empresa, _repository.Update);
}
public void GerarRegistro10()
{
Empresa = new EmpresaDAL(Session).SelectId(IdEmpresa);
ACBrSintegra.Registro10.CNPJ = Empresa.Cnpj;
ACBrSintegra.Registro10.Inscricao = Empresa.InscricaoEstadual;
ACBrSintegra.Registro10.RazaoSocial = Empresa.RazaoSocial;
ACBrSintegra.Registro10.Cidade = Empresa.EnderecoPrincipal.Cidade;
ACBrSintegra.Registro10.Estado = Empresa.EnderecoPrincipal.Uf;
ACBrSintegra.Registro10.Telefone = Empresa.EnderecoPrincipal.Fone;
ACBrSintegra.Registro10.DataInicial = Convert.ToDateTime(DataInicial);
ACBrSintegra.Registro10.DataFinal = Convert.ToDateTime(DataFinal);
ACBrSintegra.Registro10.CodigoConvenio = CodigoConvenio;
ACBrSintegra.Registro10.NaturezaInformacoes = NaturezaInformacao;
ACBrSintegra.Registro10.FinalidadeArquivo = FinalidadeArquivo;
}
public async Task <ActionResult> Alta([FromBody] EmpresaDTO empresaDTO)
{
if (empresaDTO.Cuit == null || empresaDTO.Cuit == "" || empresaDTO.Cuit.Length != 11 || !empresaDTO.Cuit.All(char.IsDigit))
{
return(BadRequest(new ResultJson()
{
Message = "Los valores ingresados no corresponden a un CUIT valido"
}));
}
else
{
if (empresaDTO.Nombre == null || empresaDTO.Nombre == "" || empresaDTO.RazonSocial == null || empresaDTO.RazonSocial == "" ||
empresaDTO.Direccion == null || empresaDTO.Direccion == "")
{
return(BadRequest(new ResultJson()
{
Message = "complete TODOS los campos"
}));
}
else
if (empresaDTO.Nombre.Length < 3 || empresaDTO.RazonSocial.Length < 3 || empresaDTO.Direccion.Length < 3)
{
return(BadRequest(new ResultJson()
{
Message = "ingrese datos VALIDOS"
}));
}
}
var businessCreateDB = await _abmServiceAsync.AltaEmpresa(empresaDTO);
if (businessCreateDB != null)
{
return(Created("", new ResultJson()
{
Message = "Empresa dada de ALTA correctamente"
}));
}
else
{
return(BadRequest(new ResultJson()
{
Message = "Empresa EXISTENTE"
}));
}
}
public ActionResult Post([FromBody] EmpresaDTO empresaDTO)
{
try
{
if (empresaDTO == null)
{
return(NotFound());
}
_applicationService.Add(empresaDTO);
return(Ok("Cadastrado com sucesso"));
}
catch (Exception exc)
{
throw exc;
}
}
public ActionResult Put([FromBody] EmpresaDTO empresaDTO)
{
try
{
if (empresaDTO == null)
{
return(NotFound());
}
_applicationService.Update(empresaDTO);
return(Ok("Atualizado com sucesso"));
}
catch (Exception exc)
{
throw exc;
}
}
public ActionResult Delete([FromBody] EmpresaDTO empresaDTO)
{
try
{
if (empresaDTO == null)
{
return(NotFound());
}
_applicationService.Remove(empresaDTO);
return(Ok("Deletado com sucesso"));
}
catch (Exception exc)
{
throw exc;
}
}
private void Excluir()
{
if (MessageBox.Show("Deseja realmente excluir ?", "Atenção", MessageBoxButtons.YesNo, MessageBoxIcon.Question, MessageBoxDefaultButton.Button2) == DialogResult.Yes)
{
empresaDTO = (EmpresaDTO)EmpresaDTOBindingSource.Current;
try
{
empresaGL.Delete(empresaDTO.Id);
EmpresaDTOBindingSource.RemoveCurrent();
}
catch
{
throw;
}
}
}
public ActionResult AddEmpresa(EmpresaDTO dto)
{
if (!this.currentUser()) { return RedirectToAction("Ingresar"); }
if (!this.isAdministrator()) { return RedirectToAction("Index"); }
if (!this.isSuperAdministrator()) { return RedirectToAction("Index"); }
try
{
EmpresaBL objBL = new EmpresaBL();
if (dto.IdEmpresa == 0)
{
if (objBL.add(dto))
{
createResponseMessage(CONSTANTES.SUCCESS);
return RedirectToAction("GruposTrabajo");
}
else
createResponseMessage(CONSTANTES.ERROR, CONSTANTES.ERROR_UPDATE_MESSAGE);
}
else if (dto.IdEmpresa != 0)
{
if (objBL.update(dto))
{
createResponseMessage(CONSTANTES.SUCCESS);
return RedirectToAction("GruposTrabajo");
}
else
createResponseMessage(CONSTANTES.ERROR, CONSTANTES.ERROR_UPDATE_MESSAGE);
}
else
createResponseMessage(CONSTANTES.ERROR, CONSTANTES.ERROR_UPDATE_MESSAGE);
}
catch
{
if (dto.IdEmpresa != 0) createResponseMessage(CONSTANTES.ERROR, CONSTANTES.ERROR_UPDATE_MESSAGE);
else createResponseMessage(CONSTANTES.ERROR, CONSTANTES.ERROR_INSERT_MESSAGE);
}
TempData["Persona"] = dto;
return RedirectToAction("Personas");
}
