public AseguradoManagementService(IAseguradoRepository aseguradoRepository,
IUbicacionRepository ubicacionRepository, ICatalogoRepository catalogoRepository,
IPersonaRepository personaRepository)
{
if (aseguradoRepository == (IAseguradoRepository)null)
{
throw new ArgumentNullException("aseguradoRepository");
}
if (ubicacionRepository == (IUbicacionRepository)null)
{
throw new ArgumentNullException("ubicacionRepository");
}
if (catalogoRepository == (ICatalogoRepository)null)
{
throw new ArgumentNullException("catalogoRepository");
}
if (personaRepository == (IPersonaRepository)null)
{
throw new ArgumentNullException("personaRepository");
}
_aseguradoRepository = aseguradoRepository;
_ubicacionRepository = ubicacionRepository;
_catalogoRepository = catalogoRepository;
_personaRepository = personaRepository;
}
/// <summary>
/// Constructor de la clase Fachada que basicamente inyecta las dependencias de los repositorios con Ninject.
/// </summary>
public Fachada(ISocioRepository pSocioRepository,
IPagoRepository pPagoRepository,
ITransaccionRepository pTransaccionRepository,
ITipoBienRepository pTipoBienRepository,
IModificacionRespository pModificacionRespository,
IRubroRepository pRubroRepository,
IPersonaRepository pPersonaRepository,
IRepository <Persona> pRepositoryBasePersona,
IRepository <Pago> pRepositoryBasePago,
IRepository <Socio> pRepositoryBaseSocio,
IRepository <Transaccion> pRepositoryBaseTransaccion,
IRepository <Rubro> pRepositoryBaseRubro,
IRepository <Modificacion> pRepositoryBasModificacion,
IRepository <TipoBien> pRepositoryBaseTipobien,
ILogger pLogger)
{
cSocioRepository = pSocioRepository;
cPagoRepository = pPagoRepository;
cTransaccionRepository = pTransaccionRepository;
cTipoBienRepository = pTipoBienRepository;
cModificacionRespository = pModificacionRespository;
cRubroRepository = pRubroRepository;
cPersonaRepository = pPersonaRepository;
cRepositoryBasePersona = pRepositoryBasePersona;
cRepositoryBasePago = pRepositoryBasePago;
cRepositoryBaseSocio = pRepositoryBaseSocio;
cRepositoryBaseTransaccion = pRepositoryBaseTransaccion;
cRepositoryBaseRubro = pRepositoryBaseRubro;
cRepositoryBasModificacion = pRepositoryBasModificacion;
cRepositoryBaseTipobien = pRepositoryBaseTipobien;
cLogger = pLogger;
}
public DataEncuestaFactory(ILugarRepository lugarRepository, ICodigoRepository codigoRepository, IPersonaRepository personaRepository, IEspacioRepository espacioRepository)
{
_lugarRepository = lugarRepository;
_codigoRepository = codigoRepository;
_personaRepository = personaRepository;
_espacioRepository = espacioRepository;
}
public PacienteController(IPersonaRepository personaRepository, IPacienteRepository pacienteRepository, IUtilRepository utilrepository, ICitaRepository citaRepository)
{
_personaRepository = personaRepository;
_pacienteRepository = pacienteRepository;
_utilrepository = utilrepository;
_citarepository = citaRepository;
}
public CommonDrillService(ICommonDrillRepository commonDrillRepository, IPersonaRepository personaRepository, ISolutionRepository solutionRepository, IConfigTenantRepository configTenantRepository)
{
_commonDrillRepository = commonDrillRepository;
_personaRepository = personaRepository;
_solutionRepository = solutionRepository;
_configTenantRepository = configTenantRepository;
}
/// <summary>
/// Recupera todas las entidades Persona.
/// </summary>
/// <returns>
/// Todas las entidades Persona.
/// </returns>
public IEnumerable <PersonaDto> GetAll()
{
// .en answer variable
// .es Variable de respuesta.
// list new cosntructor (int32) initial size http://msdn.microsoft.com/en-us/library/dw8e0z9z(v=vs.110).aspx
var result = new List <PersonaDto>(0);
try
{
IPersonaRepository repo = ApplicationLayer.IocContainer.Resolve <IPersonaRepository>();
var entities = repo.GetAll();
// Mapeamos los datos.
entities.ToList()
.ForEach(entity =>
{
var entityDto = this.PersonaMapper.EntityMapping(entity);
result.Add(entityDto);
});
// Confirmamos la transacción.
this.Commit();
}
catch (Exception ex)
{
throw ex;
}
// Devolver resultado.
return(result);
}
public UsuarioService(IUsuarioRepository usuarioRepository, IApiResponseMessage apiResponseMessage, ISesionService sesionService, IEnvioEmail envioEmail, IPersonaRepository personaRepository)
{
_usuarioRepository = usuarioRepository;
_personaRepository = personaRepository;
_apiResponseMessage = apiResponseMessage;
_envioEmail = envioEmail;
_sesionService = sesionService;
}
public PrimeraVisitaService(IPrimeraVisitaRepository primeraVisitaRepository, ICalzadoHabitualRepository calzadoHabitualRepository,
IPersonaRepository personaRepository, IPodologoRepository podologoRepository)
{
_primeraVisitaRepository = primeraVisitaRepository;
_calzadoHabitualRepository = calzadoHabitualRepository;
_personaRepository = personaRepository;
_podologoRepository = podologoRepository;
}
public PersonaController(IPersonaRepository personaRepository, ClinicaServiceContext contexto, IUtilRepository utilRepository,
IEmpleadoRepository empleadoRepository, ICajaRepository cajaRepository)
{
_context = contexto;
_personaRepository = personaRepository;
_utilrepository = utilRepository;
_empleadorepository = empleadoRepository;
_cajaRepository = cajaRepository;
}
/// <summary>Initializes a new instance of the <see cref="PersonaManager"/> class.</summary>
/// <param name="personaRepository">Administra las operaciones de persistencia de la entidad Persona.</param>
/// <param name="personaValidator">Valida el objeto de tipo Persona.</param>
/// <param name="pagedListValidator">Valida el objeto de tipo PagedList.</param>
public PersonaManager(
IPersonaRepository personaRepository,
IValidator <Persona> personaValidator,
IValidator <PagedList <object> > pagedListValidator)
{
this.personaRepository = personaRepository;
this.personaValidator = personaValidator;
this.pagedListValidator = pagedListValidator;
}
public PersonaController(ApplicationDbContext context, IPersonaRepository personaRepository, ICountryRepository countryRepository,
IStateRepository stateRepository, ICityRepository cityRepository)
{
_context = context;
_personaRepository = personaRepository;
_countryRepository = countryRepository;
_stateRepository = stateRepository;
_cityRepository = cityRepository;
}
public LicenciaController(ILicenciaRepository licenciaRepository,
IPersonaRepository personaRepository,
ITipoDocumentoRepository tipoDocumentoRepository,
IHttpContextAccessor contextAccessor)
{
_licenciaRepository = licenciaRepository;
_personaRepository = personaRepository;
_tipoDocumentoRepository = tipoDocumentoRepository;
_contextAccessor = contextAccessor;
}
public PersonasController(IPersonaRepository personaRepository)
{
_personaRepository = personaRepository;
var m = new AutoMapper.MapperConfiguration(c =>
{
c.CreateMap <Model.PersonaMVC, DTO.PersonaDTO>();
});
_mapper = m.CreateMapper();
}
public CrearUsuarioCommandHandler(IAuthIntegrationEventService integrationEventService, IEmpresaRepository empresaRepository, IPersonaRepository personaRepository,
IIdentityService identityService, ILogger logger, UserManager<Usuario> userManager, IOptions<AuthSettings> settings)
{
_integrationEventService = integrationEventService ?? throw new ArgumentNullException(nameof(integrationEventService));
_empresaRepository = empresaRepository ?? throw new ArgumentNullException(nameof(empresaRepository));
_personaRepository = personaRepository ?? throw new ArgumentNullException(nameof(personaRepository));
_identityService = identityService ?? throw new ArgumentNullException(nameof(identityService));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_userManager = userManager ?? throw new ArgumentNullException(nameof(userManager));
_settings = settings ?? throw new ArgumentNullException(nameof(settings));
}
public PrestamosController(IPrestamoRepository prestamoRepository, IPersonaRepository personaRepository, IParametrosRepository parametrosRepository)
{
_prestamoRepository = prestamoRepository;
_personaRepository = personaRepository;
_parametrosRepository = parametrosRepository;
var m = new AutoMapper.MapperConfiguration(c =>
{
c.CreateMap <Model.PrestamoMVC, DTO.PrestamoDTO>();
});
_mapper = m.CreateMapper();
}
public NotificacionService(INotificacionRepository notificacionRepository,
IMedicionRepository medicionRepository,
IIndicadorRepository indicadorRepository,
IIndicadorAutomaticoService indicadorAutomaticoService,
IPersonaRepository personaRepository)
{
this.NotificacionRepository = notificacionRepository;
this.MedicionRepository = medicionRepository;
this.IndicadorRepository = indicadorRepository;
this.IndicadorAutomaticoService = indicadorAutomaticoService;
this.PersonaRepository = personaRepository;
}
public MedicionService(IMedicionRepository medicionRepository,
IIndicadorRepository indicadorRepository,
IIndicadorService indicadorService,
IIndicadorAutomaticoRepository indicadorAutomaticoRepository,
IPersonaRepository personaRepository)
{
this.MedicionRepository = medicionRepository;
this.IndicadorRepository = indicadorRepository;
this.IndicadorService = indicadorService;
this.IndicadorAutomaticoRepository = indicadorAutomaticoRepository;
this.PersonaRepository = personaRepository;
}
/// <summary>
/// Inicializa los repositorios internos de la clase.
/// </summary>
public Sistema(IPersonaRepository repositoryPersona, IRepository <Usuario> repositoryUsuario)
{
// Setter!
_repositoryPersona = repositoryPersona ??
throw new ArgumentNullException("Se requiere el repositorio de personas");
_repositoryUsuario = repositoryUsuario ??
throw new ArgumentNullException("Se requiere repositorio de usuarios");
// Inicializacion del repositorio.
_repositoryPersona.Initialize();
_repositoryUsuario.Initialize();
}
public ConsignacionesController(IConsignacionRepository consignacionRepository, IPersonaRepository personaRepository, IPrestamoRepository prestamoRepository, IParametrosRepository parametrosRepository)
{
_consignacionRepository = consignacionRepository;
_personaRepository = personaRepository;
_prestamoRepository = prestamoRepository;
_parametrosRepository = parametrosRepository;
var m = new AutoMapper.MapperConfiguration(c =>
{
c.CreateMap <Model.ConsignacionMVC, DTO.ConsignacionDTO>();
});
_mapper = m.CreateMapper();
}
// <summary>
// Obtiene la referencia a la factoría de repositorios de la entidad <see cref="T:Persona"/>.
// </summary>
//private PersonaRepositoryFactory PersonaRepositoryFactory
//{
//get { return this.personaRepositoryFactory; }
//}
#endregion
#region Create Method
// from template Application\UpdateBase\I2ServiceRegionCreateMethod.tt
/// <summary>
/// Crea una entidad Persona.
/// </summary>
/// <param name="personaDto">
/// DTO que contiene la información para crear la entidad.
/// </param>
/// <returns>
/// El identificador de la entidad creada.
/// </returns>
public int Create(PersonaDto personaDto)
{
#region Preconditions
// Comprobar el DTO de entrada.
Guard.ArgumentIsNotNull(
personaDto,
string.Format(
FrameworkResource.DataTransferObjectIsNull,
SharedResources.PersonaAlias));
// Comprobar los campos mandatory dentro del DTO.
Guard.ArgumentNotNullOrEmpty(
personaDto.Nombre,
string.Format(
FrameworkResource.PropertyRequired,
SharedResources.Persona_NombreAlias,
SharedResources.PersonaAlias)
);
#endregion
// el dto debe corresponder a un transient el id debe tener el valor por defecto
Guard.Against <ArgumentException>(personaDto.Id != default(Int32),
string.Format(
FrameworkResource.IsNotTransient,
SharedResources.PersonaAlias
)
);
Persona persona = PersonaFactory.Create(personaDto.Nombre);
persona.BooleanField = personaDto.BooleanField;
persona.DatetimeField = personaDto.DatetimeField;
persona.ByteField = personaDto.ByteField;
persona.GuidField = personaDto.GuidField;
persona.DecimalField = personaDto.DecimalField;
persona.DobleField = personaDto.DobleField;
persona.FloatField = personaDto.FloatField;
persona.IntField = personaDto.IntField;
persona.LongField = personaDto.LongField;
persona.DateTimeOffsetField = personaDto.DateTimeOffsetField;
persona.ShortField = personaDto.ShortField;
persona.TimeSpanField = personaDto.TimeSpanField;
persona.Int16Field = personaDto.Int16Field;
persona.Int32Field = personaDto.Int32Field;
persona.Int64Field = personaDto.Int64Field;
IPersonaRepository repo = ApplicationLayer.IocContainer.Resolve <IPersonaRepository>();
repo.Add(persona);
this.Commit();
return(persona.Id);
}
// code generated from template "ServiceGetPaged.tt"
/// <summary>
/// Recupera una lista paginada de entidades Persona, según la especificación indicada.
/// </summary>
/// <param name="specificationDto">
/// Especificación que se va a aplicar.
/// </param>
/// <returns>
/// La lista paginada de entidades 'Persona', según la especificación indicada.
/// </returns>
public PagedElements <PersonaDto> GetPaged(SpecificationDto specificationDto)
{
#region Preconditions
// Comprobar el DTO de entrada.
Guard.ArgumentIsNotNull(
specificationDto,
string.Format(
FrameworkResource.EspecificationDataTransferObjectIsNull,
"Persona"));
#endregion
List <PersonaDto> result = new List <PersonaDto>(0);
int totalElements = 0;
try
{
// Creamos el repositorio de la entidad.
IPersonaRepository repo = ApplicationLayer.IocContainer.Resolve <IPersonaRepository>();
// Obtenemos las entidades aplicando la especificación.
ISpecification <Persona> filter =
specificationDto.ToSpecification <Persona>();
PagedElements <Persona> entities =
repo.GetPagedElements(
specificationDto.PageIndex,
specificationDto.PageSize,
filter.IsSatisfiedBy(),
entity => entity.Id,
true);
totalElements = entities.TotalElements;
// Mapeamos los datos.
entities.ToList()
.ForEach(entity =>
{
var entityDto = this.personaMapper.EntityMapping(entity);
result.Add(entityDto);
});
// Confirmamos la transacción.
this.Commit();
}
catch (Exception ex)
{
throw ex;
}
// Devolver el resultado.
return(new PagedElements <PersonaDto>(result, totalElements));
}
/// <summary>
/// Elimina una determinada entidad Persona.
/// </summary>
/// <param name="id">
/// Identificador de la entidad que se va a eliminar.
/// </param>
/// <returns>
/// Es <b>true</b> si la eliminación ha sido correcta; en caso contrario <b>false</b>.
/// </returns>
public bool Delete(int id)
{
IPersonaRepository repo = ApplicationLayer.IocContainer.Resolve <IPersonaRepository>();
IEnumerable <Persona> results = repo.GetFilteredElements(u => u.Id == id);
Persona persona2Delete = results.First();
if (!persona2Delete.CanBeDeleted())
{
return(false);
}
repo.Remove(persona2Delete);
this.Commit();
return(true);
}
/// <summary>
/// Inicializa los repositorios internos de la clase.
/// </summary>
public Sistema(IPersonaRepository repositoryPersona, IRepository <Usuario> repositoryUsuario,
ICotizacionRepository repositoryCotizacion, IRepository <Item> RepositoryItem)
{
// Setter!
_repositoryPersona = repositoryPersona ??
throw new ArgumentNullException("Se requiere el repositorio de personas");
_repositoryUsuario = repositoryUsuario ??
throw new ArgumentNullException("Se requiere repositorio de usuarios");
_repositoryCotizacion = repositoryCotizacion ??
throw new ArgumentNullException("Se requiere base de datos de cotizaciones");
_repositoryItem = RepositoryItem ??
throw new ArgumentNullException("Se requiere base de datos de items");
// Inicializacion del repositorio.
_repositoryPersona.Initialize();
_repositoryUsuario.Initialize();
_repositoryCotizacion.Initialize();
_repositoryItem.Initialize();
}
public IndicadorService(IIndicadorRepository indicadorRepository,
IIndicadorAutomaticoRepository indicadorAutomaticoRepository,
IResponsableIndicadorRepository responsableIndicadorRepository,
IInteresadoIndicadorRepository interesadoIndicadorRepository,
IMetaRepository metaRepository,
IAuditoriaService auditoriaService,
IMedicionRepository medicionRepository,
IPersonaRepository personaRepository,
IAccesoIndicadorRepository accesoIndicadorRepository)
{
this.IndicadorRepository = indicadorRepository;
this.IndicadorAutomaticoRepository = indicadorAutomaticoRepository;
this.ResponsableIndicadorRepository = responsableIndicadorRepository;
this.InteresadoIndicadorRepository = interesadoIndicadorRepository;
this.MetaRepository = metaRepository;
this.AuditoriaService = auditoriaService;
this.MedicionRepository = medicionRepository;
this.PersonaRepository = personaRepository;
this.AccesoIndicadorRepository = accesoIndicadorRepository;
}
public UnityOfWork(PaqueteTuristicoContext context)
{
_Context = context;
Alimentaciones = new AlimentacionRepository(_Context);
CategoriaAlimentaciones = new CategoriaAlimentacionRepository(_Context);
CategoriaHospedajes = new CategoriaHospedajeRepository(_Context);
CategoriaTransportes = new CategoriaTransporteRepository(_Context);
CalificacionHospedajes = new CalificacionHospedajeRepository(_Context);
ComprobantePagos = new ComprobantePagoRepository(_Context);
Hospedajes = new HospedajeRepository(_Context);
MedioPagos = new MedioPagoRepository(_Context);
Paquetes = new PaqueteRepository(_Context);
Personas = new PersonaRepository(_Context);
ServicioHospedajes = new ServicioHospedajeRepository(_Context);
ServicioTuristicos = new ServicioTuristicoRepository(_Context);
TipoComprobantes = new TipoComprobanteRepository(_Context);
TipoHospedajes = new TipoHospedajeRepository(_Context);
TipoTransportes = new TipoTransporteRepository(_Context);
Transportes = new TransporteRepository(_Context);
VentaPaquetes = new VentaPaqueteRepository(_Context);
}
/// <summary>
/// Recupera una entidad Persona mediante su identificador correspondiente.
/// </summary>
/// <param name="entityBId">
/// Identificador de la entidad que se va a recuperar.
/// </param>
/// <returns>
/// La entidad Persona recuperada o valor nulo si no se encuentra.
/// </returns>
public PersonaDto GetById(Int32 entityBId)
{
// Variable de respuesta.
PersonaDto entityDto = null;
try
{
IPersonaRepository repo = ApplicationLayer.IocContainer.Resolve <IPersonaRepository>();
// Obtener y comprobar la entidad.
//ISpecification<Persona> spec = new DirectSpecification<Persona>(t => t.Id == entityBId);
var temp = repo.GetFilteredElements(t => t.Id == entityBId);
//string s = string.Format(Inflexion2.Resources.NoDataById, "Persona", entityBId);
//Guard.ArgumentIsNotNull( entity, s );
if (temp.Count() > 0)
{
Persona entity = temp.Single();
// Mapeamos los datos.
entityDto = this.PersonaMapper.EntityMapping(entity);
}
}
catch (Exception ex)
{
throw ex;
}
finally
{
// Confirmamos la transacción.
this.Commit();
}
// Devolvemos el resultado.
return(entityDto);
}
// ServiceUpdateMethod.tt
/// <summary>
/// Actualiza una determinada entidad Persona.
/// </summary>
/// <param name="personaDto">
/// DTO que contiene la información de la entidad que se va a actualizar.
/// </param>
/// <returns>
/// Es <b>true</b> si la actualización ha sido correcta; en caso contrario <b>false</b>.
/// </returns>
public bool Update(PersonaDto personaDto)
{
#region preconditions
// Comprobar el DTO de entrada.
Guard.ArgumentIsNotNull(
personaDto,
string.Format(
FrameworkResource.DataTransferObjectIsNull,
"Persona"));
// en una actualización no comprobamos los campos mandatory.
#endregion
try
{
// Creamos el repositorio de la entidad.
IPersonaRepository repo = ApplicationLayer.IocContainer.Resolve <IPersonaRepository>();
// Obtener y comprobar validez de la inserción a modificar.
Persona entity2Update = repo.GetFilteredElements(t => t.Id == personaDto.Id).Single();
Guard.ArgumentIsNotNull(
entity2Update,
string.Format(
FrameworkResource.CanNotUpdateInexistenceEntity,
"Persona"));
// Comprobar duplicidades;
// Actualización de la entidad.
// Datos mandatory
entity2Update.Nombre = personaDto.Nombre;
// asignación de Datos no mandatory con ciclo de vida variable, no se incluyen aquellas propiedaes constantes o derivadas
entity2Update.BooleanField = personaDto.BooleanField; // property.AutoProperty = True; property.OnlyGetProperty = False
entity2Update.DatetimeField = personaDto.DatetimeField; // property.AutoProperty = True; property.OnlyGetProperty = False
entity2Update.ByteField = personaDto.ByteField; // property.AutoProperty = True; property.OnlyGetProperty = False
entity2Update.GuidField = personaDto.GuidField; // property.AutoProperty = True; property.OnlyGetProperty = False
entity2Update.DecimalField = personaDto.DecimalField; // property.AutoProperty = True; property.OnlyGetProperty = False
entity2Update.DobleField = personaDto.DobleField; // property.AutoProperty = True; property.OnlyGetProperty = False
entity2Update.FloatField = personaDto.FloatField; // property.AutoProperty = True; property.OnlyGetProperty = False
entity2Update.IntField = personaDto.IntField; // property.AutoProperty = True; property.OnlyGetProperty = False
entity2Update.LongField = personaDto.LongField; // property.AutoProperty = True; property.OnlyGetProperty = False
entity2Update.DateTimeOffsetField = personaDto.DateTimeOffsetField; // property.AutoProperty = True; property.OnlyGetProperty = False
entity2Update.ShortField = personaDto.ShortField; // property.AutoProperty = True; property.OnlyGetProperty = False
entity2Update.TimeSpanField = personaDto.TimeSpanField; // property.AutoProperty = True; property.OnlyGetProperty = False
entity2Update.Int16Field = personaDto.Int16Field; // property.AutoProperty = True; property.OnlyGetProperty = False
entity2Update.Int32Field = personaDto.Int32Field; // property.AutoProperty = True; property.OnlyGetProperty = False
entity2Update.Int64Field = personaDto.Int64Field; // property.AutoProperty = True; property.OnlyGetProperty = False
// igualmente hemos de mapear las entidades emparentadas.
if (!entity2Update.CanBeSaved())
{
return(false);
}
repo.Modify(entity2Update);
// Confirmamos la transacción.
this.Commit();
}
catch (Exception ex)
{
throw ex;
}
// Devolvemos el resultado.
return(true);
}
public PersonaController(IPersonaRepository repository)
{
this.repository = repository;
}
public void Initialize()
{
repository = new MockPersonaRepository();
}
public PersonaDataService(IPersonaRepository repository)
{
this.repository = repository;
}
public PersonaService(IPersonaRepository personaRepository, IMapper mapper)
{
_personaRepository = personaRepository;
_mapper = mapper;
}
public PersonasController(IPersonaRepository persona)
{
this.personaRepository = persona;
}
