public async Task <Report> CreateAsync(Report report) { if (report == null) { throw new ArgumentException(nameof(report)); } if (!report.GarageId.HasValue) { throw new ArgumentException(nameof(report.GarageId)); } if (string.IsNullOrEmpty(report.Notes)) { throw new ArgumentException(nameof(report.Notes)); } if (string.IsNullOrEmpty(report.ReportTimePeriod)) { throw new ArgumentException(nameof(report.ReportTimePeriod)); } var reportEntity = new ReportEntity { DateCreated = DateTime.Now, GarageId = report.GarageId.Value, Notes = report.Notes, ReportTimePeriod = report.ReportTimePeriod }; _reportRepository.Add(reportEntity); await _reportRepository.SaveChangesAsync(); return(Mapper.Map <Report>(reportEntity)); }
public void CompareWithPureReflection() { var properties = new Dictionary <string, object>(); properties.Add("Name", "Hugo"); properties.Add("Id", 0); properties.Add("UpdateTime", DateTime.Now.Date); properties.Add("Summary", "description omit"); var data = new DataModel(); FillPropertyFromDictionaryByReflection(data, properties); FillPropertyFromDictionaryByLibrary(data, properties); var mapper = ConvertFromDictionary(AMapper.CreateMap <IDictionary, DataModel>(), p => p); Mapper <IDictionary <string, object>, DataModel> .InitializePropertyMapper(ReflectionUtils.GetDictionaryValue); var times = 100000; var timeOfDirect = new TestTimer(n => FillPropertyFromDictionaryByDirectCalls(data, properties)).TimeForTimes(times); var timeOfReflection = new TestTimer(n => FillPropertyFromDictionaryByReflection(data, properties)).TimeForTimes(times); var timeOfLibrary = new TestTimer(n => FillPropertyFromDictionaryByLibrary(data, properties)).TimeForTimes(times); var timeOfMyMapper = new TestTimer(n => FillPropertyFromDictionaryByMyMapper(data, properties)).TimeForTimes(times); var timeOfMapper = new TestTimer(n => FillPropertyFromDictionaryByAutoMapper(data, properties)).TimeForTimes(times); var timeOfFastMember = new TestTimer(n => FillPropertyFromDictionaryByFastMembers(data, properties)).TimeForTimes(times); var timeOfFasterflect = new TestTimer(n => FillPropertyFromDictionaryByFasterflect(data, properties)).TimeForTimes(times); Assert.IsTrue(timeOfReflection > timeOfLibrary); Assert.IsTrue(timeOfMapper > timeOfReflection); }
public static string ImportHallSeats(CinemaContext context, string jsonString) { var halls = JsonConvert.DeserializeObject <ImportHallDto[]>(jsonString); var validHalls = new List <Hall>(); var sb = new StringBuilder(); foreach (var hall in halls) { bool isValid = IsValid(hall, out var validationResults); if (isValid) { var currentHall = Mapper.Map <ImportHallDto, Hall>(hall); var seats = CreateSeats(hall.Seats, currentHall); var hallType = CreateType(hall.Is3D, hall.Is4Dx); validHalls.Add(currentHall); sb.AppendLine(string.Format(SuccessfulImportHallSeat, hall.Name, hallType, currentHall.Seats.Count)); } else { sb.AppendLine(ErrorMessage); } } context.Halls.AddRange(validHalls); context.SaveChanges(); return(sb.ToString().TrimEnd()); }
/// <summary> /// Get data. /// </summary> /// <param name="searchInfo">The search info.</param> /// <param name="predicate">The predicate.</param> /// <returns></returns> private List <OrderView> GetData(SearchInfo searchInfo, Expression <Func <Order, bool> > predicate) { if (searchInfo.Take != null && searchInfo.Skip != null) { return(_orderRepository.GetOrders(predicate) .Skip(searchInfo.Skip.Value) .Take(searchInfo.Take.Value) .Select(order => Mapper.Map <OrderView>(order)) .OrderBy(order => order.OrderID) .ToList()); } if (searchInfo.Take == null && searchInfo.Skip.HasValue) { return(_orderRepository.GetOrders(predicate) .Skip(searchInfo.Skip.Value) .Select(order => Mapper.Map <OrderView>(order)) .OrderBy(order => order.OrderID) .ToList()); } if (searchInfo.Skip == null && searchInfo.Take.HasValue) { return(_orderRepository.GetOrders(predicate) .Take(searchInfo.Take.Value) .Select(order => Mapper.Map <OrderView>(order)) .OrderBy(order => order.OrderID) .ToList()); } return(_orderRepository.GetOrders(predicate) .Select(order => Mapper.Map <OrderView>(order)) .ToList()); }
public IEnumerable <Hourage> GetUserHourageRecordsWithProject(string userId) { var dbHourageRecords = _hourageManagement.GetUserHourageRecordsWithProject(userId); var records = Mapper.Map <IEnumerable <HourageEntity>, IEnumerable <Hourage> >(dbHourageRecords); return(records); }
private void ImportUsers() { using (var sr = new StreamReader(string.Format(ImportPath, UsersPath))) { JsonReader jsonReader = new JsonTextReader(sr); var jsonSerializer = new JsonSerializer(); var userDtos = jsonSerializer.Deserialize <ImportUserDto[]>(jsonReader); var users = new List <User>(); foreach (var userDto in userDtos) { if (!IsValid(userDto)) { continue; } var user = Mapper.Map <User>(userDto); users.Add(user); } this._dbContext .Users .AddRange(users); this._dbContext .SaveChanges(); } }
static Mapper() { Mapping.CreateMap <With.Component.IActionable, Actionable>(); Mapping.CreateMap <With.Component.IComponent, Component>(); Mapping.CreateMap <With.Component.IComponentDescription, ComponentDescription>(); Mapping.CreateMap <With.Component.IDescription, Description>(); Mapping.CreateMap <With.Component.IEntity, Entity>(); Mapping.CreateMap <With.Component.IEntityDescription, EntityDescription>(); Mapping.CreateMap <With.Component.IIdentity, Identity>(); Mapping.CreateMap <With.Component.ILocation, Location>(); Mapping.CreateMap <With.Component.IMeasurement, Measurement>(); Mapping.CreateMap <With.Component.IObservable, Observable>(); Mapping.CreateMap <With.Component.IParameter, Parameter>(); Mapping.CreateMap <With.Component.IParameterDescription, ParameterDescription>(); Mapping.CreateMap <With.Component.IParameterValue, ParameterValue>(); Mapping.CreateMap <With.Component.IValueDescription, ValueDescription>(); Mapping.CreateMap <With.Message.IAdd, Add>(); Mapping.CreateMap <With.Message.IAction, Action>(); Mapping.CreateMap <With.Message.IDeregister, Deregister>(); Mapping.CreateMap <With.Message.IIgnore, Ignore>(); Mapping.CreateMap <With.Message.IObservation, Observation>(); Mapping.CreateMap <With.Message.IObserve, Observe>(); Mapping.CreateMap <With.Message.IRegister, Register>(); Mapping.CreateMap <With.Message.IRemove, Remove>(); }
public IEnumerable <Project> GetProjectsUserCreate(string userId) { var dbprojects = _projectManagement.GetProjectsUserCreate(userId); var projects = Mapper.Map <IEnumerable <ProjectEntity>, IEnumerable <Project> >(dbprojects); return(projects); }
public async Task <IEnumerable <Team> > GetForCurrentYear() { using (var dbContext = new TtcDbContext()) { int currentSeason = dbContext.CurrentSeason; var teams = await dbContext.Teams .Include(x => x.Players) .Include(x => x.Opponents) .Where(x => x.Year == currentSeason) .ToArrayAsync(); var result = Mapper.Map <IList <TeamEntity>, IList <Team> >(teams); foreach (var team in result) { var key = new TeamRankingKey(team.Competition, team.Frenoy.DivisionId); if (RankingCache.ContainsKey(key)) { team.Ranking = RankingCache[key]; } } InvalidateCache(); return(result); } }
public IEnumerable <Project> GetAllProjects() { var dbprojects = _projectManagement.GetAllProjectsWithCreator(); var projects = Mapper.Map <IEnumerable <ProjectEntity>, IEnumerable <Project> >(dbprojects); return(projects); }
public Dictionary <string, List <Report> > GetReportsByArea(long areaId) { var reports = _reportRepository.GetAll() .Where(report => report.Garage.AreaId == areaId) .GroupBy(report => report.ReportTimePeriod) .ToDictionary(reportGroup => reportGroup.Key, reportGroup => reportGroup); return(Mapper.Map <Dictionary <string, List <Report> > >(reports)); }
public static void AddEntities <TEntity, TRealmType>(this Realm realm, string folderPath) where TRealmType : RealmObject { foreach (TEntity entity in AuditHelper.GetEntities <TEntity>(folderPath)) { var realmObject = Mapper.Map <TRealmType>(entity); realm.Write(() => { realm.Add(realmObject); }); } }
public RecursoMes GetRecursoMes(int recursoMesId) { var recursoMesDb = dbContext.RecursosMeses.Find(recursoMesId); MapperManager.GetInstance(); var recursoMes = Mapper.Map <DataAccess.Models.RecursoMes, RecursoMes>(recursoMesDb); return(recursoMes); }
public List <RecursoMes> GetRecursosMesesPorFacility(int facilityId) { var recursosMesesDb = dbContext.RecursosMeses.Where(r => r.Recurso.FacilityId == facilityId && r.Recurso.Activo && r.Activo).ToList(); MapperManager.GetInstance(); var recursosMeses = new List <RecursoMes>(); recursosMesesDb.ForEach(p => recursosMeses.Add(Mapper.Map <DataAccess.Models.RecursoMes, RecursoMes>(p))); return(recursosMeses); }
public List <RecursoMes> GetAllRecursosMeses() { var recursosMesesDb = dbContext.RecursosMeses.ToList(); MapperManager.GetInstance(); var recursosMeses = new List <RecursoMes>(); recursosMesesDb.ForEach(p => recursosMeses.Add(Mapper.Map <DataAccess.Models.RecursoMes, RecursoMes>(p))); return(recursosMeses); }
public ListenerService( IParser parser, IRepository <Order> orderRepository, IConverter converter, IFilter <Order> filter) { _parser = parser; _orderRepository = orderRepository; _converter = converter; _filter = filter; Mapper.Reset(); Mapper.Initialize(cfg => { cfg.AddProfile(new HttpListenerMappingProfile()); }); }
public void Setup() { MockData.CreateMockData(); _agileMapper = new AgileMapperLibrary.Mapper(); _expressMapper = new ExpressMapperLibrary.Mapper(); _mapsterMapper = new MapsterLibrary.Mapper(); AutoMapper.MapperConfiguration config = new AutoMapper.MapperConfiguration(cfg => { cfg.CreateMap <Customer, CustomerDto>(); cfg.CreateMap <Address, AddressDto>(); }); _autoMapper = new AutoMapper.Mapper(config); }
public void MapIMapTo() { AutoMapper.Mapper mapper = new AutoMapper.Mapper(new AutoMapper.MapperConfiguration(config => { config.AddProfile <TestProfile>(); })); MapFrom mapFrom = new MapFrom { Id = 3 }; var mapto = mapper.Map <MapTo>(mapFrom); Assert.Equal(3, mapto.Id); }
private void ImportProducts() { var productsString = File.ReadAllText(string.Format(ImportPath, ProductsPath)); var deserializedProducts = JsonConvert.DeserializeObject <ImportProductDto[]>(productsString); var products = new List <Product>(); var random = new Random(); var usersCount = this._dbContext .Users .Count(); var counter = 1; foreach (var productDto in deserializedProducts) { if (!IsValid(productDto)) { continue; } var product = Mapper.Map <Product>(productDto); product.SellerId = random.Next(1, usersCount / 2); product.BuyerId = random.Next(usersCount / 2, usersCount + 1); products.Add(product); if (counter == 3) { product.BuyerId = null; counter = 0; } counter++; } this._dbContext .Products .AddRange(products); this._dbContext .SaveChanges(); }
public UserControllerTest() { IUserService service = new UserServiceMockup(); AutoMapper.IMapper mapper = new AutoMapper.Mapper(new AutoMapper.MapperConfiguration(cfg => { cfg.CreateMap <User, UserDTO>(); cfg.CreateMap <UserDTO, User>(); })); IOptions <AppSettings> options = new OptionsWrapper <AppSettings>(new AppSettings { Secret = "XXXX" }); controller = new UserController(service, mapper, options); }
public async Task <Team> GetTeam(int teamId, bool syncFrenoy) { using (var dbContext = new TtcDbContext()) { var teamEntity = await dbContext.Teams .Include(x => x.Players) .Include(x => x.Opponents) .SingleAsync(x => x.Id == teamId); var team = Mapper.Map <TeamEntity, Team>(teamEntity); if (syncFrenoy) { team.Ranking = await GetFrenoyRanking(dbContext, team.Competition, team.Frenoy.DivisionId); } return(team); } }
public void MapMappingWithConfigSaving() { AutoMapper.Mapper mapper = new AutoMapper.Mapper(new AutoMapper.MapperConfiguration(config => { config.AddProfile <TestProfile>(); })); MapTo2 mapTo = new MapTo2 { Prop = "Y", AnotherProp = "X" }; var mapBack = mapper.Map <MapFrom2>(mapTo); Assert.Equal("X", mapBack.Prop); }
public void MapMappingWithConfigReading() { AutoMapper.Mapper mapper = new AutoMapper.Mapper(new AutoMapper.MapperConfiguration(config => { config.AddProfile <TestProfile>(); })); MapFrom2 mapFrom = new MapFrom2 { Prop = "Z" }; var mapto = mapper.Map <MapTo2>(mapFrom); Assert.Equal("AZ", mapto.Prop); Assert.Equal("42", mapto.AnotherProp); }
public PageResult <ShippingSaleDto> GetPagedList(GetShippingSaleOrderRequest request) { if (request == null) { throw new ArgumentNullException("request"); } var filter = Mapper.Map <GetShippingSaleOrderRequest, ShippingOrderFilter>(request); int total; var order = request.SortOrder == null ? ShippingOrderSortOrder.Default : (ShippingOrderSortOrder)request.SortOrder; if (request.StoreId != null || request.DataRoleStores != null || request.StoreIds != null) { if (filter.StoreIds == null) { filter.StoreIds = new List <int>(); } } if (request.StoreId != null) { filter.StoreIds.Add(request.StoreId.Value); } if (request.DataRoleStores != null) { filter.StoreIds.AddRange(request.DataRoleStores); } if (request.StoreIds != null) { filter.StoreIds.AddRange(request.StoreIds); } var datas = _shippingSaleRepository.GetPagedList(request.PagerRequest, out total, filter, order); var dto = Mapper.Map <List <ShippingOrderModel>, List <ShippingSaleDto> >(datas); var pageResult = new PageResult <ShippingSaleDto>(dto, total); return(pageResult); }
public Hourage CreateHourageRecord(string workDescription, int projectId, DateTime date, double hours, string userId) { var hourageEntity = new HourageEntity { WorkDescription = workDescription, ProjectId = projectId, Date = date, Hours = hours, UserId = userId }; var savedHourage = _hourageManagement.Create(hourageEntity); savedHourage.Project = _projectManagement.GetProjectById(savedHourage.ProjectId); var hourage = Mapper.Map <HourageEntity, Hourage>(savedHourage); return(hourage); }
public IMapper Create(Assembly profilesAssembly, IFactory factory) { config.MappingAssemblies.Add(profilesAssembly); var cfg = new MapperConfigurationExpression(); var mapContext = cfg.AddYuzuMappersFromContainer(factory); cfg.AddProfilesFromContainer(config.MappingAssemblies, factory); cfg.AddProfilesForAttributes(config.MappingAssemblies, mapContext, factory); cfg.ConstructServicesUsing(factory.GetInstance); var mapperConfig = new AutoMapper.MapperConfiguration(cfg); var autoMapper = new AutoMapper.Mapper(mapperConfig); return(new AutoMapperIntegration(autoMapper)); }
public async void GetProductReturnsProductUsingInvalidId() { var options = new DbContextOptionsBuilder <ProductsDbContext>() .UseInMemoryDatabase(nameof(GetProductReturnsProductUsingInvalidId)) .Options; var dbContext = new ProductsDbContext(options); CreateProducts(dbContext); var productProfile = new ProductProfile(); var configuration = new AutoMapper.MapperConfiguration(cfg => cfg.AddProfile(productProfile)); var mapper = new AutoMapper.Mapper(configuration); var productsProvider = new ProductProvider(dbContext, null, mapper); var product = await productsProvider.GetProductAsync(-1); Assert.False(product.IsSucess); Assert.Null(product.product); Assert.NotNull(product.errorMessage); }
public async Task GetProductReturnNullProductAsync(int productId) { var dbContextOption = new DbContextOptionsBuilder <Databases.ProductsDbContext>() .UseInMemoryDatabase("GetProductReturnAllProducts"); using var productDbContext = new Databases.ProductsDbContext(dbContextOption.Options); var productProfile = new Profiles.ProductProfile(); var mapperConfig = new AutoMapper.MapperConfiguration(f => f.AddProfile(productProfile)); var mapper = new AutoMapper.Mapper(mapperConfig); var productProvider = new Providers.ProductProvider(productDbContext, null, mapper); var product = await productProvider.GetOneProductsAsync(productId); Assert.False(product.IsSuccess); Assert.Null(product.Result); Assert.NotNull(product.ErrorMessage); }
private IResultPatternProxy CreateProxyToObject(MethodInfo targetMethod, object result) { var returnType = GetMethodReturnType(targetMethod); var dynamicResult = _objectBuilder.CreateObject(CreateTypeName(returnType), null, returnType, new[] { typeof(IResultPatternProxy) }, true) as IResultPatternProxy; if (result != null) { var mapperConfiguration = new AutoMapper.MapperConfiguration(config => config.CreateMap(returnType, dynamicResult.GetType())); var mapper = new AutoMapper.Mapper(mapperConfiguration); mapper.Map(result, dynamicResult); dynamicResult.IsNull = false; var hh = returnType.IsAssignableFrom(dynamicResult.GetType()); } dynamicResult.IsNull = true; return(dynamicResult); }
public void Setup() { _mapper = new Mapper().Add <L, R>(); _mapperWithCustomBinding = new Mapper().Add <L, R>( (r => r.Id, l => l.Id), (r => r.Name, l => l.Name), (r => r.Year, l => l.Year)); var config = new AutoMapper.MapperConfiguration(cfg => cfg.CreateMap <L, R>()); _autoMapper = new AutoMapper.Mapper(config); var withCustomBindingConfig = new AutoMapper.MapperConfiguration(cfg => cfg.CreateMap <L, R>() .ForMember(dest => dest.Id, opt => opt.MapFrom((l, r, m) => r.Id = m)) .ForMember(dest => dest.Name, opt => opt.MapFrom((l, r, m) => r.Name = m)) .ForMember(dest => dest.Year, opt => opt.MapFrom((l, r, m) => r.Year = m))); _autoMapperWithCustomBinding = new AutoMapper.Mapper(withCustomBindingConfig); _list = Enumerable.Range(0, 10_000).Select(_ => L.Instance).ToList(); }