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; }