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