public void Map_GivenObjects_ShouldMapCorrectly()
{
//---------------Set up test pack-------------------
Mapper.AddMap <Parent, Child>((parent1, child1) =>
{
child1.ParentId = parent1.Id;
});
var parent = new Parent()
{
Id = 100,
Name = "name",
Surname = "surname"
};
var child = new Child()
{
Name = "child",
Id = 1
};
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
Mapper.Map(parent, child, true, "Id", "Name");
//---------------Test Result -----------------------
Assert.AreEqual(100, parent.Id);
Assert.AreEqual(100, child.ParentId);
}
public static void Init()
{
Mapper.AddMap <AdminPermission, AdminPermissionDto>(src =>
{
var adminUserViewModel = new AdminPermissionDto();
adminUserViewModel.InjectFrom(src);
if (src.ParentId > 0)
{
adminUserViewModel.IsParentSelected = true;
}
return(adminUserViewModel);
});
Mapper.AddMap <AdminPermissionDto, AdminPermission>((from, to) =>
{
var existing = to as AdminPermission ?? new AdminPermission();
existing.InjectFrom(new LoopInjection(new[] { "ParentId", "Left", "Right" }), from);
if (from.IsParentSelected)
{
existing.ParentId = from.ParentId;
}
return(existing);
});
}
public void Map_GivenObjectsNoActions_ShouldMapCorrectly()
{
//---------------Set up test pack-------------------
Mapper.AddMap <Parent, Child>();
var parent = new Parent()
{
Id = 100,
Name = "name",
Surname = "surname"
};
var child = new Child()
{
Name = "child",
Id = 1
};
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
Mapper.Map(parent, child);
//---------------Test Result -----------------------
Assert.AreEqual(100, parent.Id);
Assert.AreEqual(parent.Id, child.Id);
Assert.AreEqual(parent.Name, child.Name);
Assert.AreEqual(parent.Surname, child.Surname);
}
public void ShouldMapWithNewAddedMap()
{
var customer = GetCustomer();
Mapper.AddMap <Customer, CustomerInput>((src, tag) =>
{
var res = new CustomerInput();
return(res);
});
Mapper.AddMap <Customer, CustomerInput>(src =>
{
var res = new CustomerInput();
res.Id = src.Id;
res.FirstName = src.FirstName;
res.LastName = src.LastName;
return(res);
});
var c1 = Mapper.Map <Customer, CustomerInput>(customer);
var c2 = Mapper.Map <CustomerInput>(customer);
c1.InjectFrom <AreEqual>(c2);
Assert.AreEqual(customer.Id, c1.Id);
Assert.AreEqual(customer.FirstName, c1.FirstName);
Assert.AreEqual(customer.LastName, c1.LastName);
}
public void ShouldUseTag()
{
var customer = GetCustomer();
Mapper.AddMap <Customer, Customer>((src, tag) =>
{
var t1 = (Tag1)tag;
var res = new Customer {
LastName = t1.P1
};
res.Id = src.Id;
res.FirstName = src.FirstName + t1.P1;
return(res);
});
const string P1 = "abc";
var c1 = Mapper.Map <Customer, Customer>(customer, new Tag1 {
P1 = P1
});
var c2 = Mapper.Map <Customer>(customer, new Tag1 {
P1 = P1
});
c1.InjectFrom <AreEqual>(c2);
Assert.AreEqual(customer.Id, c1.Id);
Assert.AreEqual(customer.FirstName + P1, c1.FirstName);
Assert.AreEqual(P1, c1.LastName);
}
public void ShouldMapDifferentlyUsingMultipleMapperInstances()
{
var mapper1 = new MapperInstance();
var mapper2 = new MapperInstance();
Mapper.AddMap <Customer, Customer>(o => (Customer) new Customer().InjectFrom(o));
mapper1.AddMap <Customer, Customer>(o => new Customer {
Id = 1, FirstName = "mapper1"
});
mapper2.AddMap <Customer, Customer>(o => new Customer {
Id = 2, FirstName = "mapper2"
});
var customer = GetCustomer();
var m1 = mapper1.Map <Customer>(customer);
var m2 = mapper2.Map <Customer>(customer);
var m = Mapper.Map <Customer>(customer);
Assert.AreEqual(customer.Id, m.Id);
Assert.AreEqual(1, m1.Id);
Assert.AreEqual("mapper1", m1.FirstName);
Assert.AreEqual(2, m2.Id);
Assert.AreEqual("mapper2", m2.FirstName);
}
/// <summary>
/// Configure maps.
/// </summary>
public void Configure()
{
Mapper.AddMap <User, UserViewModel>((source, tag) =>
{
var result = new UserViewModel();
var sourceTag = tag as UserViewModel;
result.InjectFrom(source);
// When remapping after a postback model state error
// the posted model will be passed to the mapper as a tag param.
// here we override the entity data with the form posted information.
if (sourceTag != null)
{
result.InjectFrom(sourceTag);
}
if (source.ImageBlob != null)
{
result.ImageBlobId = source.ImageBlob.Id;
result.ImageBlobName = source.ImageBlob.Name;
}
// Map completion
result.ProfileCompletion = Mapper.Map <ProfileCompletionViewModel>(source);
// Map roles
result.Roles = source.Roles.Select(r => r.Role.GetDisplayName()).ToList();
return(result);
});
}
/// <summary>
/// Configure the map.
/// </summary>
public void Configure()
{
Mapper.AddMap <UserClaim, Claim>((source) =>
{
return(new Claim(source.ClaimType, source.ClaimValue));
});
}
public void Map_GivenNullFrom_ShouldThrowException()
{
//---------------Set up test pack-------------------
Mapper.AddMap <Parent, Child>();
var parent = new Parent()
{
Id = 100,
Name = "name",
Surname = "surname"
};
var child = new Child()
{
Name = "child",
Id = 1
};
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
Mapper.Map(default(Parent), child);
//---------------Test Result -----------------------
Assert.AreEqual(100, parent.Id);
Assert.AreEqual(parent.Id, child.Id);
Assert.AreEqual(parent.Name, child.Name);
Assert.AreEqual(parent.Surname, child.Surname);
}
public void Configure()
{
Mapper.AddMap <User, PlatformUserViewModel>((source, tag) =>
{
var result = new PlatformUserViewModel();
var sourceTag = tag as PlatformUserViewModel;
result.InjectFrom(source);
if (sourceTag != null)
{
result.InjectFrom(sourceTag);
}
if (source.ImageBlob != null)
{
result.ImageBlobId = source.ImageBlob.Id;
result.ImageBlobName = source.ImageBlob.Name;
}
result.Roles = source.Roles.Select(r => r.Role.ToString()).ToList();
return(result);
});
}
public static void Configure()
{
Mapper.DefaultMap = (src, resType, tag) =>
{
var res = Activator.CreateInstance(resType);
res.InjectFrom(src);
var srcTypeProps = src.GetType().GetProperties();
var resTypeProps = resType.GetProperties();
foreach (var resProp in resTypeProps.Where(p => p.PropertyType == typeof(ObjectId)))
{
var matchSrcProp = srcTypeProps.FirstOrDefault(p => p.Name == resProp.Name && p.PropertyType == typeof(string));
if (matchSrcProp != null)
{
string id = (string)matchSrcProp.GetValue(src);
if (ObjectId.TryParse(id, out ObjectId objId))
{
resProp.SetValue(res, objId);
}
}
}
foreach (var srcProp in srcTypeProps.Where(p => p.PropertyType == typeof(ObjectId)))
{
var matchResProp = resTypeProps.FirstOrDefault(p => p.Name == srcProp.Name && p.PropertyType == typeof(string));
if (matchResProp != null)
{
var objId = (ObjectId)srcProp.GetValue(src);
matchResProp.SetValue(res, objId.ToString());
}
}
return(res);
};
Mapper.AddMap <EndPoint, EndPointViewModel>(e =>
{
var evm = Mapper.MapDefault <EndPointViewModel>(e);
int i = 0;
foreach (var p in e.PassiveConnections)
{
var pvm = Mapper.Map <PassiveConnectionViewModel>(p);
pvm.Index = i++;
pvm.EndPointIndex = e.Index;
pvm.EndPointId = e.Id;
evm.PassiveConnectionViewModels.Add(pvm);
}
return(evm);
});
Mapper.AddMap <EndPointViewModel, EndPoint>(evm =>
{
var e = Mapper.MapDefault <EndPoint>(evm);
foreach (var pvm in evm.PassiveConnectionViewModels)
{
e.PassiveConnections.Add(Mapper.Map <PassiveConnection>(pvm));
}
return(e);
});
}
public static void Init()
{
Mapper.Reset();
Mapper.AddMap <Product, ProductViewModel>(src =>
{
var productViewModel = new ProductViewModel();
productViewModel.InjectFrom(src);
productViewModel.DefaultSharedOption =
Mapper.Map <ProductVariant, ProductVariantViewModel>(src.DefaultOption);
productViewModel.Options = new List <ProductVariantViewModel>();
foreach (var pv in src.Options)
{
productViewModel.Options.Add(Mapper.Map <ProductVariant, ProductVariantViewModel>(pv));
}
return(productViewModel);
});
Mapper.AddMap <Test, TestViewModel>(src =>
{
var testViewModel = new TestViewModel($"{src.Name} - {src.Id}");
testViewModel.InjectFrom(src);
testViewModel.Name = $"{src.Name} - {src.Weight} - {src.Age}";
testViewModel.Product = Mapper.Map <Product, ProductViewModel>(src.Product);
testViewModel.SpareTheProduct = Mapper.Map <Product, ProductViewModel>(src.SpareProduct);
testViewModel.Type = (Types)src.Type;
testViewModel.Weight = src.Weight * 2;
testViewModel.Products = new List <ProductViewModel>();
foreach (var product in src.Products)
{
testViewModel.Products.Add(Mapper.Map <Product, ProductViewModel>(product));
}
return(testViewModel);
});
Mapper.AddMap <User, UserViewModel>(src =>
{
var userViewModel = new UserViewModel();
userViewModel.InjectFrom(src);
userViewModel.BelongTo = Mapper.Map <Role, RoleViewModel>(src.Role);
return(userViewModel);
});
Mapper.AddMap <Author, AuthorViewModel>(src =>
{
var articles = new List <ArticleViewModel>(src.Articles.Count());
var authorViewModel = new AuthorViewModel();
authorViewModel.InjectFrom(src);
for (var i = 0; i < articles.Count; i++)
{
articles[i] = Mapper.Map <Article, ArticleViewModel>(src.Articles.ElementAt(i));
}
authorViewModel.OwnedArticles = articles;
return(authorViewModel);
});
}
public IToolRegion CloneRegion()
{
Mapper.AddMap <OutputsRegion, OutputsRegion>();
var outputsRegion = new OutputsRegion();
Mapper.Map(this, outputsRegion);
return(outputsRegion);
}
static HardwareMapperInitialise()
{
Mapper.AddMap <HardwareSettings, HardwareSettingsDto>(x =>
{
var settings = new HardwareSettingsDto();
settings.NetworkMonitoring.InjectFrom(x.NetworkMonitoring);
settings.CpuMonitoring.InjectFrom(x.CpuMonitoring);
settings.EmailAlertSettings.InjectFrom(x.EmailAlertSettings);
settings.Drives = x.Drives
.Select(c => new DriveSettingsDto().InjectFrom(c)).Cast <DriveSettingsDto>()
.ToList();
return(settings);
});
Mapper.AddMap <HardwareSettingsDto, HardwareSettings>(x =>
{
var settings = new HardwareSettings();
settings.NetworkMonitoring.InjectFrom(x.NetworkMonitoring);
settings.CpuMonitoring.InjectFrom(x.CpuMonitoring);
settings.EmailAlertSettings.InjectFrom(x.EmailAlertSettings);
settings.Drives = x.Drives
.Select(c => new DriveSettings().InjectFrom(c)).Cast <DriveSettings>()
.ToList();
return(settings);
});
Mapper.AddMap <HardwareSettingsViewModel, HardwareSettingsDto>(x =>
{
var settings = new HardwareSettingsDto();
settings.NetworkMonitoring.InjectFrom(x.NetworkMonitoring);
settings.CpuMonitoring.InjectFrom(x.CpuMonitoring);
settings.EmailAlertSettings.InjectFrom(x.EmailAlertSettings);
settings.Drives = x.Drives
.Select(c => new DriveSettingsDto().InjectFrom(c)).Cast <DriveSettingsDto>()
.ToList();
return(settings);
});
Mapper.AddMap <HardwareSettingsDto, HardwareSettingsViewModel>(x =>
{
var settings = new HardwareSettingsViewModel();
settings.NetworkMonitoring.InjectFrom(x.NetworkMonitoring);
settings.CpuMonitoring.InjectFrom(x.CpuMonitoring);
settings.EmailAlertSettings.InjectFrom(x.EmailAlertSettings);
settings.Drives = x.Drives
.Select(c => new DriveSettingsViewModel().InjectFrom(c)).Cast <DriveSettingsViewModel>()
.ToList();
return(settings);
});
}
static CastMapper()
{
Mapper.AddMap <CastResult, Cast>(source => new Cast()
{
Id = source.Person.Id,
Name = source.Person.Name,
Birthday = source.Person.Birthday
});
}
/// <summary>
/// Creates maps for the ValueInjecter library.
/// </summary>
public static void Init()
{
Mapper.AddMap <UserDTO, User>(src => new User
{
Id = src.Id,
Name = src.Name,
Surname = src.Surname,
UserName = src.Login,
Password = src.Password,
EMail = src.EMail,
Money = src.Value
});
Mapper.AddMap <User, UserDTO>(src => new UserDTO
{
Id = src.Id,
Name = src.Name,
Value = src.Money,
Login = src.UserName,
EMail = src.EMail,
Password = src.Password,
Surname = src.Surname
});
Mapper.AddMap <Transaction, TransactionDTO>(src => new TransactionDTO
{
Id = src.Id,
BuyerId = src.BuyerId,
SellerId = src.SellerId,
StockId = src.StockId,
Amount = src.Amount,
Price = src.Price,
Date = src.Date
});
Mapper.AddMap <SellOffer, SellOfferDTO>(src => new SellOfferDTO
{
Id = src.Id,
SellerId = src.SellerId,
ShareId = src.ShareId,
Amount = src.Amount,
Price = src.Price,
Date = DateTime.SpecifyKind(src.Date, DateTimeKind.Utc)
});
Mapper.AddMap <BuyOffer, BuyOfferDTO>(src => new BuyOfferDTO
{
Id = src.Id,
BuyerId = src.BuyerId,
StockId = src.StockId,
Amount = src.Amount,
Price = src.Price,
Date = DateTime.SpecifyKind(src.Date, DateTimeKind.Utc)
});
}
void VerifyMapDAOEntryIsCreated()
{
var mapper = new Mapper();
var parts = new List <BlobId>();
var blob = new BlobId();
parts.Add(blob);
var fileId = mapper.AddMap(parts);
Assert.True(mapper.GetFileMap.Any(f => f.FileId.Equals(fileId)));
Assert.True(mapper.GetFileMap.Any(f => f.BlobParts.Contains(blob)));
}
public void Configure()
{
Mapper.AddMap <ArticleImage, ArticleImageJsonModel>((source) =>
{
var result = new ArticleImageJsonModel();
var imageServices = DependencyResolver.Current.GetService <IImageService>();
result.InjectFrom(source);
string pictureUrl = imageServices.BuildUrl(source.Name, source.Label);
result.Url = pictureUrl;
result.Label = source.Label;
result.Description = source.Description;
return(result);
});
}
public void MapToExistingObj()
{
var customer = GetCustomer();
var res = new Customer();
Mapper.AddMap <Customer, Customer>((from, tag) =>
{
var existing = tag as Customer;
existing.InjectFrom(from);
return(existing);
});
Mapper.Map <Customer>(customer, res);
Assert.AreEqual(customer.FirstName, res.FirstName);
}
public static void Init()
{
Mapper.AddMap <QuizCategoryCreateAdminDto, QuizCategory>((from, to) =>
{
var existing = to as QuizCategory ?? new QuizCategory();
existing.InjectFrom(from);
return(existing);
});
Mapper.AddMap <QuizCategoryEditAdminDto, QuizCategory>((from, to) =>
{
var existing = to as QuizCategory ?? new QuizCategory();
existing.InjectFrom(from);
return(existing);
});
}
public static void Init()
{
Mapper.AddMap <QuizQuestionCreateAdminDto, QuizQuestion>((from, to) =>
{
var existing = to as QuizQuestion ?? new QuizQuestion();
existing.InjectFrom(from);
return(existing);
});
Mapper.AddMap <QuizQuestionEditAdminDto, QuizQuestion>((from, to) =>
{
var existing = to as QuizQuestion ?? new QuizQuestion();
existing.InjectFrom(from);
return(existing);
});
}
public static void Init()
{
Mapper.AddMap <QuizAnswerCreateAdminDto, QuizAnswer>((from, to) =>
{
var existing = to as QuizAnswer ?? new QuizAnswer();
existing.InjectFrom(from);
return(existing);
});
Mapper.AddMap <QuizAnswerEditAdminDto, QuizAnswer>((from, to) =>
{
var existing = to as QuizAnswer ?? new QuizAnswer();
existing.InjectFrom(from);
return(existing);
});
}
public static void Init()
{
Mapper.AddMap <EmailTemplateCreateAdminDto, EmailTemplate>((from, to) =>
{
var existing = to as EmailTemplate ?? new EmailTemplate();
existing.InjectFrom(from);
return(existing);
});
Mapper.AddMap <EmailTemplateEditAdminDto, EmailTemplate>((from, to) =>
{
var existing = to as EmailTemplate ?? new EmailTemplate();
existing.InjectFrom(from);
return(existing);
});
}
public static void Init()
{
Mapper.AddMap <GeneralSettingCreateAdminDto, GeneralSetting>((from, to) =>
{
var existing = to as GeneralSetting ?? new GeneralSetting();
existing.InjectFrom(from);
return(existing);
});
Mapper.AddMap <GeneralSettingEditAdminDto, GeneralSetting>((from, to) =>
{
var existing = to as GeneralSetting ?? new GeneralSetting();
existing.InjectFrom(from);
return(existing);
});
}
public void Configure()
{
Mapper.AddMap <StateHistory, StateHistoryViewModel>((source) =>
{
var result = new StateHistoryViewModel();
result.InjectFrom(source);
return(result);
});
Mapper.AddMap <StateViewModel, State>((source) =>
{
var result = new State();
result.InjectFrom(source);
return(result);
});
}
public static void Init()
{
Mapper.AddMap <PageCreateAdminDto, Page>((from, to) =>
{
var existing = to as Page ?? new Page();
existing.InjectFrom(from);
return(existing);
});
Mapper.AddMap <PageEditAdminDto, Page>((from, to) =>
{
var existing = to as Page ?? new Page();
existing.InjectFrom(from);
return(existing);
});
}
public void Configure()
{
Mapper.AddMap <TagResult, TagResultViewModel>((source) =>
{
var result = new TagResultViewModel();
result.InjectFrom(source);
Tag tag = _tagRepository.GetById(Convert.ToInt32(source.TagId));
Article article = _articleRepository.GetById(Convert.ToInt32(source.ArticleId));
result.TagName = tag.Name;
result.ArticleName = article.Title;
return(result);
});
}
/// <summary>
/// Configure maps.
/// </summary>
public void Configure()
{
Mapper.AddMap <Article, ArticleViewModel>((source) =>
{
var result = new ArticleViewModel();
result.InjectFrom(source);
if (source.ImageBlob != null)
{
result.ImageBlobId = source.ImageBlob.Id;
result.ImageBlobName = source.ImageBlob.Name;
}
return(result);
});
}
public void Configure()
{
Mapper.AddMap <EventTrackingParameter, EventTrackingParameterViewModel>((source) =>
{
var result = new EventTrackingParameterViewModel();
result.InjectFrom(source);
return(result);
});
Mapper.AddMap <EventTrackingParameterViewModel, EventTrackingParameter>((source) =>
{
var result = new EventTrackingParameter();
result.InjectFrom(source);
return(result);
});
}
public void Configure()
{
Mapper.AddMap <StateUnited, StateUnitedViewModel>((source) =>
{
var result = new StateUnitedViewModel();
result.InjectFrom(source);
return(result);
});
Mapper.AddMap <StateUnitedViewModel, StateUnited>((source) =>
{
var result = new StateUnited();
result.InjectFrom(source);
return(result);
});
}
