/// <summary>
/// Creates a formato
/// </summary>
/// <param name="formatoEntity"></param>
/// <returns></returns>
public object[] CreateFormato(BusinessEntities.FormatoEntity formatoEntity)
{
try
{
using (var scope = new TransactionScope())
{
var formato = new FORMATO
{
IdFormato = formatoEntity.IdFormato,
IdNorma = formatoEntity.IdNorma,
Codigo = formatoEntity.Codigo,
Nombre = formatoEntity.Nombre,
IdTipoFormato = formatoEntity.IdTipoFormato,
IdPlazo = formatoEntity.IdPlazo,
IdPeriodicidad = formatoEntity.IdPeriodicidad,
IdEstado = formatoEntity.IdEstado,
DiasPlazo = formatoEntity.DiasPlazo,
IdSeccion = formatoEntity.IdSeccion,
InlcuyeFecha = formatoEntity.InlcuyeFecha
};
_unitOfWork.FormatoRepository.Insert(formato);
_unitOfWork.Save();
scope.Complete();
object[] resultado = { "0000", formato.IdFormato };
return(resultado);
}
}
catch (Exception e)
{
var cod = new CodigoError();
var codigoError = cod.Error(e.ToString());
object[] resultado = { codigoError, e.ToString() };
return(resultado);
}
}
public object[] setDescripcionList(List <NormaEntity> normas)
{
try
{
foreach (NormaEntity norma in normas)
{
var valor = GetTablaValorById(norma.IdTipoNorma);
if (valor != null)
{
norma.DescripcionTipoNorma = valor.ValorAlfanumerico;
}
var entidad = _entidadServices.GetEntidadById(norma.IdEntidadEmite);
if (entidad != null)
{
norma.DescripcionEntidadEmite = entidad.Nombre;
}
}
object[] resultado = { "0000", normas };
return(resultado);
}
catch (Exception e)
{
var cod = new CodigoError();
var codigoError = cod.Error(e.ToString());
object[] resultado = { codigoError, e.ToString() };
return(resultado);
}
}
/// <summary>
/// Fetches normaSector details by id
/// </summary>
/// <param name="normaSectorId"></param>
/// <returns></returns>
public object[] GetNormaSectorById(int normaSectorId)
{
try
{
var normaSector = _unitOfWork.NormaSectorRepositoryCustom.GetManyByIdNorma(normaSectorId).ToList();
if (normaSector != null)
{
Mapper.Initialize(cfg =>
{
cfg.CreateMap <NORMA_SECTOR, NormaSectorEntity>();
});
var normaSectorModel = Mapper.Map <List <NORMA_SECTOR>, List <NormaSectorEntity> >(normaSector);
object[] resultado = { "0000", normaSectorModel };
return(resultado);
}
return(null);
}
catch (Exception e)
{
var cod = new CodigoError();
var codigoError = cod.Error(e.ToString());
object[] resultado = { codigoError, e.ToString() };
return(resultado);
}
}
/// <summary>
/// Inactivates a formato
/// </summary>
/// <param name="formatoId"></param>
/// <returns></returns>
public object[] InactivateFormato(int formatoId)
{
var success = false;
try
{
if (formatoId > 0)
{
using (var scope = new TransactionScope())
{
var formato = _unitOfWork.FormatoRepository.GetByID(formatoId);
if (formato != null)
{
formato.IdEstado = 0;
_unitOfWork.FormatoRepository.Update(formato);
_unitOfWork.Save();
scope.Complete();
success = true;
}
}
}
object[] resultado = { "0000", success };
return(resultado);
}
catch (Exception e)
{
var cod = new CodigoError();
var codigoError = cod.Error(e.ToString());
object[] resultado = { codigoError, e.ToString() };
return(resultado);
}
}
/// <summary>
/// Fetches all the normaPadre
/// </summary>
/// <returns></returns>
public object[] GetNormasPadre()
{
try
{
var normas = _unitOfWork.NormaRepository.GetAll().ToList();
if (normas.Any())
{
Mapper.Initialize(cfg =>
{
cfg.CreateMap <NORMA, NormaPadreEntity>();
});
var normaPadreList = Mapper.Map <List <NORMA>, List <NormaPadreEntity> >(normas);
object[] resultado = { "0000", normaPadreList };
return(resultado);
}
return(null);
}
catch (Exception e)
{
var cod = new CodigoError();
var codigoError = cod.Error(e.ToString());
object[] resultado = { codigoError, e.ToString() };
return(resultado);
}
}
/// <summary>
/// Creates a normaSector
/// </summary>
/// <param name="normaSectorEntity"></param>
/// <returns></returns>
public object[] CreateNormaSector(int idSectorServicio, int idNorma)
{
var success = false;
try
{
using (var scope = new TransactionScope())
{
var normaSector = new NORMA_SECTOR
{
IdEstado = 1,
IdNorma = idNorma,
IdSector = idSectorServicio
};
_unitOfWork.NormaSectorRepository.Insert(normaSector);
_unitOfWork.Save();
scope.Complete();
success = true;
//return normaSector.IdNormaSector;
}
object[] resultado = { "0000", success };
return(resultado);
}
catch (Exception e)
{
var cod = new CodigoError();
var codigoError = cod.Error(e.ToString());
object[] resultado = { codigoError, e.ToString() };
return(resultado);
}
}
/// <summary>
/// Retrieve if exist a plantilla in formato entity by IdFormato
/// </summary>
/// <param name="formatoId"></param>
/// <returns></returns>
public object[] ExistPlantilla(int formatoId)
{
try
{
var plantillas = _unitOfWork.FormatoPlantillaRepository.GetMany(c => c.IdFormato == formatoId);
if (plantillas.Count() > 0)
{
object[] resultado = { "0000", true };
return(resultado);
}
else
{
object[] resultado = { "0000", false };
return(resultado);
}
}
catch (Exception e)
{
var cod = new CodigoError();
var codigoError = cod.Error(e.ToString());
object[] resultado = { codigoError, e.ToString() };
return(resultado);
}
}
/// <summary>
/// Fetches all the formatos
/// </summary>
/// <returns></returns>
public object[] GetAllFormatos()
{
try
{
var formatos = _unitOfWork.FormatoRepository.GetAll().ToList();
if (formatos.Any())
{
Mapper.Initialize(cfg =>
{
cfg.CreateMap <FORMATO, FormatoEntity>();
});
var formatosModel = Mapper.Map <List <FORMATO>, List <FormatoEntity> >(formatos);
object[] resultado = { "0000", formatosModel };
return(resultado);
}
var cod = new CodigoError();
var codigoError = cod.Error("null");
object[] resultado2 = { codigoError };
return(resultado2);
}
catch (Exception e)
{
var cod = new CodigoError();
var codigoError = cod.Error(e.ToString());
object[] resultado = { codigoError, e.ToString() };
return(resultado);
}
}
/// <summary>
/// Fetches formato details by id
/// </summary>
/// <param name="formatoId"></param>
/// <returns></returns>
public object[] GetFormatoById(int formatoId)
{
try
{
var formato = _unitOfWork.FormatoRepository.GetByID(formatoId);
if (formato != null)
{
Mapper.Initialize(cfg =>
{
cfg.CreateMap <FORMATO, FormatoEntity>();
});
var formatoModel = Mapper.Map <FORMATO, FormatoEntity>(formato);
object[] resultado = { "0000", formatoModel };
return(resultado);
}
var cod = new CodigoError();
var codigoError = cod.Error("null");
object[] resultado2 = { codigoError };
return(resultado2);
}
catch (Exception e)
{
var cod = new CodigoError();
var codigoError = cod.Error(e.ToString());
object[] resultado = { codigoError, e.ToString() };
return(resultado);
}
}
/// <summary>
/// Activates a norma
/// </summary>
/// <param name="normaId"></param>
/// <returns></returns>
public object[] ActivateNorma(int normaId)
{
var success = false;
try
{
if (normaId > 0)
{
using (var scope = new TransactionScope())
{
var norma = _unitOfWork.NormaRepository.GetByID(normaId);
if (norma != null)
{
norma.IdEstado = 1;
_unitOfWork.NormaRepository.Update(norma);
_unitOfWork.Save();
scope.Complete();
success = true;
}
}
}
object[] resultado = { "0000", success };
return(resultado);
}
catch (Exception e)
{
var cod = new CodigoError();
var codigoError = cod.Error(e.ToString());
object[] resultado = { codigoError, e.ToString() };
return(resultado);
}
}
/// <summary>
/// Fetches all the actives normas
/// </summary>
/// <returns></returns>
public object[] GetAllNormasActive()
{
try
{
var normaServicios = _unitOfWork.NormaRepositoryCustom.GetMany().ToList();
if (normaServicios.Any())
{
Mapper.Initialize(cfg =>
{
cfg.CreateMap <NORMA, NormaEntity>();
});
var normasModel = Mapper.Map <List <NORMA>, List <NormaEntity> >(normaServicios);
object[] resultado = { "0000", normasModel };
return(resultado);
}
var cod = new CodigoError();
var codigoError = cod.Error("null");
object[] resultado2 = { codigoError };
return(resultado2);
}
catch (Exception e)
{
var cod = new CodigoError();
var codigoError = cod.Error(e.ToString());
object[] resultado = { codigoError, e.ToString() };
return(resultado);
}
}
/// <summary>
/// Find when the formato has changed the state
/// </summary>
/// <returns></returns>
public object[] changeFormatoState(FormatoEntity formatoEntity)
{
bool success = false;
try
{
if (formatoEntity.IdFormato > 0)
{
//Obtiene Formato almacenado
var formato = _unitOfWork.FormatoRepository.GetByID(formatoEntity.IdFormato);
if (formato != null)
{
success = true;
//Encuentra si el formato cambio de estado con respecto al formato a actualizar
if (!(formato.IdEstado == formatoEntity.IdEstado))
{
//Si el formato a actualizar tiene estado activo, activa todas sus relaciones
if (formatoEntity.IdEstado == 1)
{
var flagObject = ActivateFormatoRelations(formatoEntity.IdFormato);
if (flagObject[0].Equals("0000"))
{
success = (bool)flagObject.ElementAt(1);
}
else
{
return(flagObject);
}
}
else
{
var flagObject = InactivateFormatoRelations(formatoEntity.IdFormato);
if (flagObject[0].Equals("0000"))
{
success = (bool)flagObject.ElementAt(1);
}
else
{
return(flagObject);
}
}
}
}
}
object[] resultado = { "0000", success };
return(resultado);
}
catch (Exception e)
{
var cod = new CodigoError();
var codigoError = cod.Error(e.ToString());
object[] resultado = { codigoError, e.ToString() };
return(resultado);
}
}
/// <summary>
/// Validate the normaSector asociated with Norma
/// </summary>
/// <returns></returns>
public object[] ValidateSector(NormaEntity normaEntity, IEnumerable <NormaSectorEntity> normaSectorById)
{
int match = 0;
try
{
if (normaSectorById != null)
{
foreach (NormaSectorEntity sectorExistente in normaSectorById)
{
foreach (DataModel.NORMA_SECTOR sectorNuevo in normaEntity.NORMA_SECTOR)
{
if (sectorNuevo.IdSector.Equals(sectorExistente.IdSector))
{
match++;
}
}
//Si el sector existente no se encuentra en los seleccionados
//valida que dicho sector no tenga relaciones para poderlo borrar
if (match == 0)
{
//Valido relaciones
var flagObject = ExistSectorFormato(sectorExistente.IdSector);
if (flagObject[0].Equals("0000"))
{
bool flag = (bool)flagObject.ElementAt(1);
if (flag)
{
object[] resultado2 = { "0000", false };
return(resultado2);
}
}
else
{
return(flagObject);
}
}
else
{
match = 0;
}
}
}
object[] resultado = { "0000", true };
return(resultado);
}
catch (Exception e)
{
var cod = new CodigoError();
var codigoError = cod.Error(e.ToString());
object[] resultado = { codigoError, e.ToString() };
return(resultado);
}
}
/// <summary>
/// Retrieve description from id
/// </summary>
/// <param name="formatoEntity"></param>
/// <returns></returns>
public object[] setDescripcion(FormatoEntity formato)
{
try
{
var norma = _unitOfWork.NormaRepository.GetByID(formato.IdNorma);
if (norma != null)
{
formato.nombreNorma = norma.NombreNorma;
}
var valor = _tablaValorServices.GetTablaValorById(formato.IdTipoFormato);
if (valor != null)
{
formato.nombreTipoFormato = valor.ValorAlfanumerico;
}
var tipoPeriodicidad = _periodicidadServices.GetPeriodicidadById(formato.IdPeriodicidad);
if (tipoPeriodicidad != null)
{
formato.nombrePeriodicidad = tipoPeriodicidad.Descripcion;
}
var tipoPlazo = _plazoServices.GetPlazoById(formato.IdPlazo);
if (tipoPlazo != null)
{
formato.nombrePlazo = tipoPlazo.Descripcion;
}
var seccion = _tablaValorServices.GetTablaValorById(formato.IdSeccion);
if (seccion != null)
{
formato.nombreSeccion = valor.ValorAlfanumerico;
}
if (formato.IdEstado == 1)
{
formato.nombreEstado = "Activo";
}
else
{
formato.nombreEstado = "Inactivo";
}
object[] resultado = { "0000", formato };
return(resultado);
}
catch (Exception e)
{
var cod = new CodigoError();
var codigoError = cod.Error(e.ToString());
object[] resultado = { codigoError, e.ToString() };
return(resultado);
}
}
/// <summary>
/// return true if exist sector formato by sectorid
/// </summary>
/// <returns></returns>
public object[] ExistSectorFormato(int sectorId)
{
try
{
var exist = _unitOfWork.NormaRepositoryCustom.ExistServicio(sectorId);
object[] resultado = { "0000", exist };
return(resultado);
}
catch (Exception e)
{
var cod = new CodigoError();
var codigoError = cod.Error(e.ToString());
object[] resultado = { codigoError, e.ToString() };
return(resultado);
}
}
/// <summary>
/// Updates a norma
/// </summary>
/// <param name="normaId"></param>
/// <param name="normaEntity"></param>
/// <returns></returns>
public object[] UpdateNorma(int normaId, BusinessEntities.NormaEntity normaEntity)
{
var success = false;
try
{
if (normaEntity != null)
{
using (var scope = new TransactionScope())
{
var normaServicio = _unitOfWork.NormaRepository.GetByID(normaId);
if (normaServicio != null)
{
normaServicio.CodigoNorma = normaEntity.CodigoNorma;
normaServicio.Descripcion = normaEntity.Descripcion;
normaServicio.FechaInicio = normaEntity.FechaInicio;
normaServicio.FechaNorma = normaEntity.FechaNorma;
normaServicio.IdEntidadEmite = normaEntity.IdEntidadEmite;
normaServicio.IdEstado = normaEntity.IdEstado;
normaServicio.IdNorma = normaEntity.IdNorma;
normaServicio.IdNormaPadre = normaEntity.IdNormaPadre;
normaServicio.IdTipoNorma = normaEntity.IdTipoNorma;
normaServicio.NombreNorma = normaEntity.NombreNorma;
normaServicio.NORMA_SECTOR = normaEntity.NORMA_SECTOR;
normaServicio.IdUrlLink = normaEntity.IdUrlLink;
normaServicio.NombreArchivo = normaEntity.NombreArchivo;
normaServicio.IdSeccion = normaEntity.IdSeccion;
_unitOfWork.NormaRepository.Update(normaServicio);
_unitOfWork.Save();
scope.Complete();
success = true;
}
}
}
object[] resultado = { "0000", success };
return(resultado);
}
catch (Exception e)
{
var cod = new CodigoError();
var codigoError = cod.Error(e.ToString());
object[] resultado = { codigoError, e.ToString() };
return(resultado);
}
}
/// <summary>
/// Retrieve if exist a norma in formato entity by IdNorma
/// </summary>
/// <param name="normaId"></param>
/// <returns></returns>
public object[] ExistNormaFormato(int normaId)
{
try
{
bool exist = false;
exist = _unitOfWork.FormatoRepositoryCustom.ExistNorma(normaId);
object[] resultado = { "0000", exist };
return(resultado);
}
catch (Exception e)
{
var cod = new CodigoError();
var codigoError = cod.Error(e.ToString());
object[] resultado = { codigoError, e.ToString() };
return(resultado);
}
}
/// <summary>
/// Updates a formato
/// </summary>
/// <param name="formatoId"></param>
/// <param name="formatoEntity"></param>
/// <returns></returns>
public object[] UpdateFormato(int formatoId, BusinessEntities.FormatoEntity formatoEntity)
{
var success = false;
try
{
if (formatoEntity != null)
{
using (var scope = new TransactionScope())
{
var formato = _unitOfWork.FormatoRepository.GetByID(formatoId);
if (formato != null)
{
formato.IdFormato = formatoEntity.IdFormato;
formato.IdNorma = formatoEntity.IdNorma;
formato.Codigo = formatoEntity.Codigo;
formato.Nombre = formatoEntity.Nombre;
formato.IdTipoFormato = formatoEntity.IdTipoFormato;
formato.IdPlazo = formatoEntity.IdPlazo;
formato.IdPeriodicidad = formatoEntity.IdPeriodicidad;
formato.IdEstado = formatoEntity.IdEstado;
formato.DiasPlazo = formatoEntity.DiasPlazo;
formato.IdSeccion = formatoEntity.IdSeccion;
formato.InlcuyeFecha = formatoEntity.InlcuyeFecha;
_unitOfWork.FormatoRepository.Update(formato);
_unitOfWork.Save();
scope.Complete();
success = true;
}
}
}
object[] resultado = { "0000", success };
return(resultado);
}
catch (Exception e)
{
var cod = new CodigoError();
var codigoError = cod.Error(e.ToString());
object[] resultado = { codigoError, e.ToString() };
return(resultado);
}
}
/// <summary>
/// Fetches all the normas
/// </summary>
/// <returns></returns>
public object[] GetAllNormas()
{
try
{
var normaServicios = _unitOfWork.NormaRepository.GetAll().ToList();
if (normaServicios.Any())
{
Mapper.Initialize(cfg =>
{
cfg.CreateMap <NORMA, NormaEntity>();
});
var normasModel = Mapper.Map <List <NORMA>, List <NormaEntity> >(normaServicios);
foreach (NormaEntity norma in normasModel)
{
if (norma.IdEstado == 1)
{
norma.DescripcionEstado = "Activo";
}
else
{
norma.DescripcionEstado = "Inactivo";
}
}
object[] resultado = { "0000", normasModel };
return(resultado);
}
var cod = new CodigoError();
var codigoError = cod.Error("null");
object[] resultado2 = { codigoError };
return(resultado2);
}
catch (Exception e)
{
var cod = new CodigoError();
var codigoError = cod.Error(e.ToString());
object[] resultado = { codigoError, e.ToString() };
return(resultado);
}
}
public object[] setDescripcion(NormaEntity norma, List <NormaSectorEntity> normaSector)
{
try
{
var valor = GetTablaValorById(norma.IdTipoNorma);
if (valor != null)
{
norma.DescripcionTipoNorma = valor.ValorAlfanumerico;
}
var entidad = _entidadServices.GetEntidadById(norma.IdEntidadEmite);
if (entidad != null)
{
norma.DescripcionEntidadEmite = entidad.Nombre;
}
if (normaSector != null)
{
Mapper.Initialize(cfg =>
{
cfg.CreateMap <NormaSectorEntity, NORMA_SECTOR>();
});
var sectorModel = Mapper.Map <List <NormaSectorEntity>, List <NORMA_SECTOR> >(normaSector);
foreach (NORMA_SECTOR sector in sectorModel)
{
norma.NORMA_SECTOR.Add(sector);
}
}
object[] resultado = { "0000", norma };
return(resultado);
}
catch (Exception e)
{
var cod = new CodigoError();
var codigoError = cod.Error(e.ToString());
object[] resultado = { codigoError, e.ToString() };
return(resultado);
}
}
/// <summary>
/// Creates a norma
/// </summary>
/// <param name="normaEntity"></param>
/// <returns></returns>
public object[] CreateNorma(BusinessEntities.NormaEntity normaEntity)
{
try
{
using (var scope = new TransactionScope())
{
var normaServicio = new NORMA
{
CodigoNorma = normaEntity.CodigoNorma,
Descripcion = normaEntity.Descripcion,
FechaInicio = normaEntity.FechaInicio,
FechaNorma = normaEntity.FechaNorma,
IdEntidadEmite = normaEntity.IdEntidadEmite,
IdEstado = normaEntity.IdEstado,
IdNorma = normaEntity.IdNorma,
IdNormaPadre = normaEntity.IdNormaPadre,
IdTipoNorma = normaEntity.IdTipoNorma,
NombreNorma = normaEntity.NombreNorma,
NORMA_SECTOR = normaEntity.NORMA_SECTOR,
IdUrlLink = normaEntity.IdUrlLink,
NombreArchivo = normaEntity.NombreArchivo,
IdSeccion = normaEntity.IdSeccion
};
_unitOfWork.NormaRepository.Insert(normaServicio);
_unitOfWork.Save();
scope.Complete();
object[] resultado = { "0000", normaServicio.IdNorma };
return(resultado);
}
}
catch (Exception e)
{
var cod = new CodigoError();
var codigoError = cod.Error(e.ToString());
object[] resultado = { codigoError, e.ToString() };
return(resultado);
}
}
/// <summary>
/// Fetches norma details by id
/// </summary>
/// <param name="normaId"></param>
/// <returns></returns>
public object[] GetNormaById(int normaId)
{
try
{
var normaServicio = _unitOfWork.NormaRepository.GetByID(normaId);
if (normaServicio != null)
{
Mapper.Initialize(cfg =>
{
cfg.CreateMap <NORMA, NormaEntity>();
});
var normaModel = Mapper.Map <NORMA, NormaEntity>(normaServicio);
if (normaModel.IdEstado == 1)
{
normaModel.DescripcionEstado = "Activo";
}
else
{
normaModel.DescripcionEstado = "Inactivo";
}
object[] resultado = { "0000", normaModel };
return(resultado);
}
var cod = new CodigoError();
var codigoError = cod.Error("null");
object[] resultado2 = { codigoError };
return(resultado2);
}
catch (Exception e)
{
var cod = new CodigoError();
var codigoError = cod.Error(e.ToString());
object[] resultado = { codigoError, e.ToString() };
return(resultado);
}
}
/// <summary>
/// Find when the norma has changed the state
/// </summary>
/// <returns></returns>
public object[] changeNormaState(NormaEntity normaEntity)
{
try
{
if (normaEntity.IdNorma > 0)
{
//Obtiene Norma almacenada
var norma = _unitOfWork.NormaRepository.GetByID(normaEntity.IdNorma);
if (norma != null)
{
//Encuentra si la Norma cambio de estado con respecto a la norma a actualizar
if (!(norma.IdEstado == normaEntity.IdEstado))
{
//Si la Norma a actualizar tiene estado activo, activa todas sus relaciones
if (normaEntity.IdEstado == 1)
{
var flagObject = ActivateNormaRelations(normaEntity.IdNorma);
if (flagObject[0].Equals("0000"))
{
bool flag = (bool)flagObject.ElementAt(1);
if (flag)
{
//Y activa los sectores nuevos a almacenar
foreach (var item in normaEntity.NORMA_SECTOR)
{
item.IdEstado = 1;
}
}
}
else
{
return(flagObject);
}
}
else
{
var flagObject = InactivateNormaRelations(normaEntity.IdNorma);
if (flagObject[0].Equals("0000"))
{
bool flag = (bool)flagObject.ElementAt(1);
if (flag)
{
foreach (var item in normaEntity.NORMA_SECTOR)
{
item.IdEstado = 0;
}
}
}
else
{
return(flagObject);
}
}
}
}
}
object[] resultado = { "0000", normaEntity };
return(resultado);
}
catch (Exception e)
{
var cod = new CodigoError();
var codigoError = cod.Error(e.ToString());
object[] resultado = { codigoError, e.ToString() };
return(resultado);
}
}
/// <summary>
/// Inactivates a formato entity relations
/// </summary>
/// <param name="formatoId"></param>
/// <returns></returns>
public object[] InactivateFormatoRelations(int formatoId)
{
var success = false;
try
{
if (formatoId > 0)
{
using (var scope = new TransactionScope())
{
var plantillas = _unitOfWork.FormatoPlantillaRepository.GetMany(c => c.IdFormato == formatoId);
if (plantillas != null)
{
foreach (FORMATO_PLANTILLA plantilla in plantillas)
{
//Activar las plantillas
bool inactivatePlantilla = _formatoPlantillaServices.InactivatePlantilla(plantilla.IdFormatoPlantilla);
if (!inactivatePlantilla)
{
object[] resultado2 = { "0000", false };
return(resultado2);
}
//Obtener los registros de servicios asociados a estas plantillas
var servicios = _unitOfWork.FormatoServicioRepository.GetMany(c => c.IdFormatoPlantilla == plantilla.IdFormatoPlantilla);
//Obtener los registros de campos asociados a estas plantillas
var campos = _unitOfWork.PlantillaCampoRepository.GetMany(c => c.IdFormatoPlantilla == plantilla.IdFormatoPlantilla);
if (servicios != null)
{
foreach (FORMATO_SERVICIO servicio in servicios)
{
//Activar los servicios asociados a la plantilla
bool inactivateServicio = _formatoServicioServices.InactivateServicio(servicio.IdFormatoServicio);
if (!inactivateServicio)
{
object[] resultado2 = { "0000", false };
return(resultado2);
}
}
}
if (campos != null)
{
foreach (PLANTILLA_CAMPO campo in campos)
{
//Activar los campos asociados a la plantilla
bool inactivateCampo = _plantillaCampoServices.InactivateCampo(campo.IdPlantillaCampo);
if (!inactivateCampo)
{
object[] resultado2 = { "0000", false };
return(resultado2);
}
}
}
}
}
scope.Complete();
success = true;
}
}
object[] resultado = { "0000", success };
return(resultado);
}
catch (Exception e)
{
var cod = new CodigoError();
var codigoError = cod.Error(e.ToString());
object[] resultado = { codigoError, e.ToString() };
return(resultado);
}
}
/// <summary>
/// Activates a norma
/// </summary>
/// <param name="normaId"></param>
/// <returns></returns>
public object[] ActivateNormaRelations(int normaId)
{
var success = false;
try
{
if (normaId > 0)
{
using (var scope = new TransactionScope())
{
var norma = _unitOfWork.NormaRepository.GetByID(normaId);
if (norma != null)
{
//Obtener los formatos relacionados con Norma para cambiarles el estado
var formatos = _unitOfWork.FormatoRepositoryCustom.GetByIdNorma(normaId);
if (formatos != null)
{
foreach (FORMATO formato in formatos)
{
//Obtener los registros de campos asociados a estos formatos
var campos = _unitOfWork.FormatoRepositoryCustom.GetCamposByFormato(formato.IdFormato);
if (campos != null)
{
foreach (PLANTILLA_CAMPO campo in campos)
{
//Activar los campos
bool activateCampo = _plantillaCampoServices.ActivateCampo(campo.IdPlantillaCampo);
if (!activateCampo)
{
object[] resultado2 = { "0000", false };
return(resultado2);
}
}
}
//Activar todos los formatos devueltos segun idNorma
var flagObject = _formatoServices.ActivateFormato(formato.IdFormato);
if (flagObject[0].Equals("0000"))
{
bool flag = (bool)flagObject.ElementAt(1);
if (!flag)
{
object[] resultado2 = { "0000", false };
return(resultado2);
}
}
else
{
return(flagObject);
}
}
}
//Obtiene los sectores segun idNorma
var sectores = _normaSectorServices.GetNormaSectorByIdNorma(normaId);
if (sectores != null)
{
foreach (NormaSectorEntity sector in sectores)
{
//Activar los sectores
bool activateSector = _normaSectorServices.ActivateNormaSector(sector.IdNormaSector);
if (!activateSector)
{
object[] resultado2 = { "0000", false };
return(resultado2);
}
}
success = true;
}
norma.IdEstado = 1;
_unitOfWork.NormaRepository.Update(norma);
_unitOfWork.Save();
scope.Complete();
success = true;
}
}
}
object[] resultado = { "0000", success };
return(resultado);
}
catch (Exception e)
{
var cod = new CodigoError();
var codigoError = cod.Error(e.ToString());
object[] resultado = { codigoError, e.ToString() };
return(resultado);
}
}