public async Task ActualizaHistorialPuestosContacto(UnidadOrganizacionalEmpresas model)
{
try
{
var contacto = await _db.Contacto.Where(x => x.ContactoId == model.ContactoId).AsNoTracking().FirstOrDefaultAsync();
if (contacto != null) //Cuando se agrega un contacto a una UO (casos cuando se agrega un nuevo titular a la unidad)
{
if (model.oldValueTitular != null)
{
//Actualizamos la informacion del ultimo puesto del contacto ACTUAL de la UO
await new ContactoPuestoHistoricoRepository().ModificaPuestoContacto(Convert.ToInt32(model.oldValueTitular), model.EmpresaId, null, null, "actualizar");
}
if (model.ContactoId != contacto.ContactoId) //Con esto evitamos que con cada actualizacion de datos en una UO se agregue un puesto para el contacto
{
//Actualizamos la informacion del ultimo puesto del contacto NUEVO de la UO
await new ContactoPuestoHistoricoRepository().ModificaPuestoContacto(Convert.ToInt32(model.ContactoId), model.EmpresaId, model.ClaveUnidad, model.Puesto, "agregar");
}
}
else
{
if (model.oldValueTitular != null)
{
//Actualizamos la informacion del ultimo puesto del contacto ACTUAL de la UO (Casos en donde se quita a un titular de unidad)
await new ContactoPuestoHistoricoRepository().ModificaPuestoContacto(Convert.ToInt32(model.oldValueTitular), model.EmpresaId, null, null, "actualizar");
}
}
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
/// <summary>
/// Crea un registro en el historial de cambios de unidades organizacionales de empresas
/// </summary>
/// <param name="_param">La unidad a la cual se le va a crear el registro</param>
/// <param name="_accion">La accion que origina la actualizacion de la informacion</param>
/// <returns></returns>
public async Task Create(UnidadOrganizacionalEmpresas _param, string _accion)
{
try
{
HistorialUnidadesOrganizacionalesEmpresas model = new HistorialUnidadesOrganizacionalesEmpresas
{
nombreActualUnidad = _param.NombreUnidad,
nombreAnteriorUnidad = _param.oldValueUnidad,
nombreAnteriorUnidadPadre = _param.nombrePadre,
autor = _param.autor,
contactoId = _param.ContactoId,
empresaId = _param.EmpresaId,
claveUnidad = _param.ClaveUnidad,
accion = _accion,
claveUnidadPadre = _param.padre,
comentarios = _param.comentarios,
fecha = DateTime.Now
};
_db.HistorialUnidadesOrganizacionalesEmpresas.Add(model);
await _db.SaveChangesAsync();
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
/// <summary>
/// Actualiza una entidad de tipo UnidadOrganizacionalEmpresas
/// </summary>
/// <param name="valOriginal">valor trackeado en entity framework</param>
/// <param name="valNuevo">valor nuevo, normalmente el que se recibe desde web api</param>
/// <returns></returns>
public async Task Update(UnidadOrganizacionalEmpresas valOriginal, UnidadOrganizacionalEmpresas valNuevo)
{
try
{
_db.Entry(valOriginal).CurrentValues.SetValues(valNuevo); //actualizamos los valores de la entidad
await _db.SaveChangesAsync();
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public async Task Create(UnidadOrganizacionalEmpresas model)
{
try
{
_db.UnidadOrganizacionalEmpresas.Add(model);
await _db.SaveChangesAsync();
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public async Task <IHttpActionResult> ValidadorClaves(UnidadOrganizacionalEmpresas model)
{
try
{
var campo = await _repository.ValidadorClaves(model);
return(Ok(campo));
}
catch (Exception e)
{
log.Error(new MDCSet(this.ControllerContext.RouteData), e);
return(InternalServerError(e));
}
}
public async Task <IHttpActionResult> Create(UnidadOrganizacionalEmpresas obj)
{
try
{
log.Info(new MDCSet(this.ControllerContext.RouteData));
await _repository.Create(obj);
return(Ok("Unidad organizacional creada correctamente!"));
}
catch (Exception e)
{
log.Error(new MDCSet(this.ControllerContext.RouteData), e);
return(InternalServerError(e));
}
}
public async Task <IHttpActionResult> GetInformacionNodoEmpresa(UnidadOrganizacionalEmpresas id)
{
try
{
var campo = await _repository.GetInformacionUnidadEmpresa(id.ClaveUnidad);
return(Ok(campo));
}
catch (Exception e)
{
log.Error(new MDCSet(this.ControllerContext.RouteData), e);
return(InternalServerError(e));
}
}
public async Task <IHttpActionResult> GetPropuestasAsociadosNodoEmpresa(UnidadOrganizacionalEmpresas id)
{
try
{
log.Info(new MDCSet(this.ControllerContext.RouteData), new InfoException(id.ClaveUnidad));
var _propuestasAsociados = await _propuestasRepo.GetPropuestasAsociadosUnidadesEmpresa(id.ClaveUnidad);
return(Ok(_propuestasAsociados));
}
catch (Exception e)
{
log.Error(new MDCSet(this.ControllerContext.RouteData), e);
return(InternalServerError(e));
}
}
public async Task <IHttpActionResult> UpdateEstado(UnidadOrganizacionalEmpresas obj)
{
try
{
log.Info(new MDCSet(this.ControllerContext.RouteData));
await _repository.UpdateEstado(obj);
return(Ok("Registro actualizado correctamente!"));
}
catch (Exception e)
{
log.Error(new MDCSet(this.ControllerContext.RouteData), e);
return(InternalServerError(e));
}
}
public async Task <IHttpActionResult> GetAllnodes(UnidadOrganizacionalEmpresas uo)
{
try
{
log.Info(new MDCSet(this.ControllerContext.RouteData));
var campo = await _repository.GetAllnodes(uo);
return(Ok(campo));
}
catch (Exception e)
{
log.Error(new MDCSet(this.ControllerContext.RouteData), e);
return(InternalServerError(e));
}
}
public async Task CrearHistorial(UnidadOrganizacionalEmpresas _param, UnidadOrganizacionalEmpresas _valueToCompare)
{
try
{
if (_valueToCompare != null)
{
if ((_valueToCompare.NombreUnidad != _param.NombreUnidad) || (_valueToCompare.padre != _param.padre) || (_valueToCompare.ContactoId != _param.ContactoId))
{
var accion = "";
if ((_valueToCompare.NombreUnidad != _param.NombreUnidad))
{
accion += "Cambio de nombre de unidad, ";
}
else
{
if (!String.IsNullOrEmpty(_param.comentarios))
{
_param.oldValueUnidad = _param.comentarios;
}
else
{
_param.oldValueUnidad = null;
}
}
if ((_valueToCompare.padre != _param.padre))
{
accion += "Cambio de padre, ";
}
if ((_valueToCompare.ContactoId != _param.ContactoId))
{
accion += "Cambio de titular, ";
}
accion = accion.Substring(0, accion.Length - 2);
await Create(_param, accion);
}
}
else
{
await Create(_param, "Se crea una nueva unidad");
}
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public async Task Update(UnidadOrganizacionalEmpresas model)
{
try
{
var _model = await _db.UnidadOrganizacionalEmpresas.FirstOrDefaultAsync(e => e.ClaveUnidad == model.ClaveUnidad);
if (_model != null)
{
_db.Entry(_model).CurrentValues.SetValues(model);
await _db.SaveChangesAsync();
}
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public async Task CrearArbolUnidadOrganizacional(UnidadOrganizacionalEmpresas model)
{
try
{
//(1) Se crean los nodos de la unidad organizacional
await CreaNodo(model);
//(2) Se crea un registro en el historial de puestos del contacto
await ActualizaHistorialPuestosContacto(model);
//(3) Se crea un registro en el historial de unidades organizacionales de las empresas
await new HistorialUnidadesOrganizacionalesEmpresasRepository().CrearHistorial(model, null);
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public async Task UpdateEstado(UnidadOrganizacionalEmpresas obj)
{
try
{
var _obj = await _db.UnidadOrganizacionalEmpresas.FirstOrDefaultAsync(e => e.ClaveUnidad == obj.ClaveUnidad);
if (_obj != null)
{
_obj.Estado = obj.Estado;
await _db.SaveChangesAsync();
}
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public async Task <IHttpActionResult> ActualizaArbol(UnidadOrganizacionalEmpresas id)
{
try
{
await _repository.ActualizaArbol(id);
//if (id.ContactoId != null)
//{
// await _repository.ActualizaUnidadContacto(Convert.ToInt32(id.ContactoId), id.ClaveUnidad);
//}
return(Ok("Informacion actualizada"));
}
catch (Exception e)
{
log.Error(new MDCSet(this.ControllerContext.RouteData), e);
return(InternalServerError(e));
}
}
public async Task <Boolean> ValidadorClaves(UnidadOrganizacionalEmpresas model)
{
try
{
var existente = false;
var datos = await _db.UnidadOrganizacionalEmpresas.AsNoTracking().Distinct().ToListAsync();
datos.RemoveAll(x => x.PatronClave == ""); //Removemos las claves vacias (existen datos asi)
var patrones = datos.Select(x => x.PatronClave).Distinct(); //Hacemos un distinct del patron de las claves (de PEMEX588 recuperamos PEMEX)
var coincidencias = patrones.Where(x => x.Equals(model.ClaveUnidad)).Count();
if (coincidencias > 0)
{
existente = true;
}
return(existente);
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public async Task <IHttpActionResult> DeleteUnidad(UnidadOrganizacionalEmpresas model)
{
try
{
//log.Info(new MDCSet(this.ControllerContext.RouteData), new InfoException(Id));
var message = await _repository.VerificaAccionEliminarUnidad(model.ClaveUnidad);
if (!String.IsNullOrEmpty(message))
{
throw new Exception(message);
}
else
{
await _repository.Delete(model.ClaveUnidad);
return(Ok("Unidad organizacional eliminada correctamente!"));
}
}
catch (Exception e)
{
log.Error(new MDCSet(this.ControllerContext.RouteData), e);
return(InternalServerError(e));
}
}
public async Task CreaNodo(UnidadOrganizacionalEmpresas model)
{
try
{
var ultimoNodo = "";
int numero;
var lista = await _db.UnidadOrganizacionalEmpresas.Where(x => x.EmpresaId == model.EmpresaId && x.padre == model.padre)
.OrderBy(x => x.FechaEfectiva)
.Select(x => x.ClaveUnidad)
.AsNoTracking().ToListAsync();
if (lista.Count > 0)
{
ultimoNodo = lista.ElementAt(lista.Count - 1); //De acuerdo a la lista elegimos el ultimo nodo
numero = RetornaDigitos(ultimoNodo, 3); //Retornamos todos los numeros que contiene la cadena para posteriormente tomarlos en cuenta para el proximo id de la clave de la unidad
}
else
{
numero = 0; //En caso de que sea el primer nodo raiz u hoja
}
if (model.padre != null) //Para el caso de los NODOS HOJAS(cualquiera que tenga una unidad como padre)
{
if (!String.IsNullOrEmpty(ultimoNodo))
{
if (ultimoNodo.IndexOf('.') > 0) //Para los nuevos casos como CFE1.2
{
var array = ultimoNodo.Split('.');
var ultima = array[array.Length - 1];
numero = Convert.ToInt32(ultima);
}
else //Para los casos migrados como CFE1285
{
numero = RetornaDigitos(ultimoNodo, 3);
}
}
var duplicidad = await Validador(model.padre.Trim() + "." + (++numero) + ""); //Verificamos si existe el registros
while (duplicidad.Count() > 0) //Verifica las claves hasta que haya una clave disponible en la base de datos
{
numero = numero * 2;
duplicidad = await Validador(model.padre.Trim() + "." + (numero) + "");
}
model.ClaveUnidad = model.padre.Trim() + "." + numero + ""; //Da como resultado algo parecido a: CFE1 + ".2" ==> CFE1.2
}
else //Para el caso de los NODOS RAMAS (las que no tienen asociado ninguna unidad organizacional)
{
var duplicidad = await Validador(model.ClaveUnidad + (++numero) + ""); //Verificamos si existe el registros
while (duplicidad.Count() > 0) //Verifica las claves hasta que haya una clave disponible en la base de datos
{
numero = numero * 2;
duplicidad = await Validador(model.ClaveUnidad + (numero) + "");
}
model.ClaveUnidad += numero; //Da como resultado algo parecido a: CFE + "2"
}
_db.UnidadOrganizacionalEmpresas.Add(model);
await _db.SaveChangesAsync();
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public async Task ActualizaArbol(UnidadOrganizacionalEmpresas param)
{
try
{
var nodo = await _db.UnidadOrganizacionalEmpresas.Where(x => x.ClaveUnidad == param.ClaveUnidad).FirstOrDefaultAsync();
//El siguiente objeto se utiliza para realizar comparaciones de valores
UnidadOrganizacionalEmpresas nodoToCompare = new UnidadOrganizacionalEmpresas();
nodoToCompare.NombreUnidad = nodo.NombreUnidad;
nodoToCompare.ContactoId = nodo.ContactoId;
nodoToCompare.padre = nodo.padre;
//(1) Se crean los nodos de la unidad organizacional
if (nodo != null)
{
if ((param.CampoAgrupador != param.oldValueCampoAgrupador) || (nodo.padre != param.padre)) //Cuando se detecta un cambio de campo agrupador o de padre se deben de actualizar las migas de pan
{
if (param.padre != null) //Es una raiz (nodos que NO estan a nivel 0 en una unidad organizacional)
{
if (nodo.padre != param.padre) //Cuando se hizo un cambio de padres entre los nodos
{
nodo.padre = param.padre;
}
var migaNodoPadre = await _db.UnidadOrganizacionalEmpresas.Where(x => x.ClaveUnidad.Equals(nodo.padre)).AsNoTracking().Select(x => x.Descripcion).FirstOrDefaultAsync();
await Update(nodo, param); //actualizamos los demas parametros
ActualizaMigasDePanRamas(nodo.ClaveUnidad.Trim(), migaNodoPadre, param.CampoAgrupador);
}
else //Es una rama (nodos que ESTAN a nivel 0)
{
if (nodo.padre != param.padre)
{
nodo.padre = param.padre;
}
var migaNodoPadre = await _db.Empresa.Where(x => x.EmpresaId == param.EmpresaId).AsNoTracking().Select(x => x.NombreEmpresa).FirstOrDefaultAsync();
await Update(nodo, param); //actualizamos los demas parametros
ActualizaMigasDePanRamas(nodo.ClaveUnidad.Trim(), migaNodoPadre, param.CampoAgrupador);
}
}
else
{
await Update(nodo, param);
ActualizaMigasDePanRamas(param.ClaveUnidad.Trim(), param.newValueUnidad, param.CampoAgrupador); //actualizamos la miga de pan (old value, new value)
//if (!param.CampoAgrupador) //En caso de que sea un campo agrupador no se actualizaran las migas de pan
//{
// ActualizaMigasDePanRamas(param.ClaveUnidad.Trim(), param.newValueUnidad, param.oldValueUnidad); //actualizamos la miga de pan (old value, new value)
//}
}
//(2) Se crea un registro en el historial de puestos del contacto
await ActualizaHistorialPuestosContacto(param);
//(3) Se crea un registro en el historial de unidades organizacionales de las empresas
await new HistorialUnidadesOrganizacionalesEmpresasRepository().CrearHistorial(param, nodoToCompare);
}
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public async Task <IEnumerable <UnidadOrganizacionalEmpresas> > GetAllnodes(UnidadOrganizacionalEmpresas uo)
{
try
{
List <UnidadOrganizacionalEmpresas> entities = null;
if (String.IsNullOrEmpty(uo.ClaveUnidad))
{
entities = await _db.UnidadOrganizacionalEmpresas
.Where(x => x.padre == null && x.EmpresaId == uo.EmpresaId)
.AsNoTracking().ToListAsync();
try
{
foreach (var item in entities)
{
if (item.ContactoId != null)
{
item.contacto = await _db.Contacto.AsNoTracking().Where(x => x.ContactoId == item.ContactoId).FirstOrDefaultAsync();
}
item.Children = await _db.UnidadOrganizacionalEmpresas
.Where(x => x.padre == item.ClaveUnidad)
.Where(x => x.Estado == 1)
.OrderByDescending(e => e.FechaEfectiva)
.AsNoTracking()
.ToListAsync();
if (item.Children.Count > 0)
{
foreach (var child in item.Children)
{
if (child.ContactoId != null)
{
child.contacto = await _db.Contacto.AsNoTracking().Where(x => x.ContactoId == child.ContactoId).FirstOrDefaultAsync();
}
}
}
}
}
catch (Exception e) { }
}
else
{
var entities1 = await _db.UnidadOrganizacionalEmpresas
.Where(x => x.ClaveUnidad == uo.ClaveUnidad)
.Where(x => x.Estado == 1)
.OrderByDescending(e => e.FechaEfectiva)
.AsNoTracking().ToListAsync();
entities1 = entities1.Distinct(new ComparerIdOrClave()).ToList();
foreach (var item in entities1)
{
if (item.ContactoId != null)
{
item.contacto = await _db.Contacto.AsNoTracking().Where(x => x.ContactoId == item.ContactoId).FirstOrDefaultAsync();
}
entities = await _db.UnidadOrganizacionalEmpresas
.Where(x => x.padre == item.ClaveUnidad && x.EmpresaId == item.EmpresaId && x.Estado == 1)
.AsNoTracking().ToListAsync();
item.Children = entities;
if (item.Children.Count > 0)
{
foreach (var child in item.Children)
{
if (child.ContactoId != null)
{
child.contacto = await _db.Contacto.AsNoTracking().Where(x => x.ContactoId == child.ContactoId).FirstOrDefaultAsync();
}
}
}
break;
}
return(entities1.OrderBy(x => x.NombreUnidad));
}
return(entities.OrderBy(x => x.NombreUnidad));
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
