public ResultOperationInfo <CheckStatusInfo> GetId(int itemId)
{
var item = UnitOfWork.GetRepository <CheckStatus>().GetIncluding(itemId);
var itemInfo = MapperInstance.Map <CheckStatus, CheckStatusInfo>(item);
return(new ResultOperationInfo <CheckStatusInfo>(itemInfo, true, Localization.Success_OperationComplited));
}
public ResultOperationInfo <IEnumerable <ClientMessageInfo> > GetAll()
{
var collection = UnitOfWork.GetRepository <ClientMessage>().GetAllIncluding(p => p.Client);
var collectionInfo = MapperInstance.Map <IEnumerable <ClientMessage>, IEnumerable <ClientMessageInfo> >(collection);
return(new ResultOperationInfo <IEnumerable <ClientMessageInfo> >(collectionInfo, true, Localization.Success_OperationComplited));
}
public void MapperInstance()
{
var customer = GetCustomer();
var mapper1 = new MapperInstance();
var mapper2 = new MapperInstance();
mapper1.AddMap <Customer, CustomerInput>((from) =>
{
var input = new CustomerInput();
input.InjectFrom(from);
return(input);
});
mapper2.AddMap <Customer, CustomerInput>((from) =>
{
var input = new CustomerInput();
input.FirstName = from.FirstName;
return(input);
});
var input1 = mapper1.Map <CustomerInput>(customer);
var input2 = mapper2.Map <CustomerInput>(customer);
Assert.AreEqual(customer.LastName, input1.LastName);
Assert.AreEqual(null, input2.LastName);
}
public async void LoginInSystem_OK(string role)
{
UserDto dto = this.GetNewValidDto();
dto.IsAdmin = false;
var repositoryMock = this.GetNewEmptyMockedRepository();
repositoryMock.Setup(r => r.SelectAllAsync())
.Returns(Task.FromResult((IEnumerable <UserEntity>) new List <UserEntity> {
MapperInstance.Map <UserEntity>(dto)
}))
.Verifiable();
repositoryMock.Setup(r => r.SelectIncludingSystems(It.IsAny <string>()))
.Returns(MapperInstance.Map <UserEntity>(dto))
.Verifiable();
var serviceMock = this.GetNewService(repositoryMock.Object, role);
var obtainedDto = await serviceMock.Service.LoginInSystemAsync(this.GetNewValidLoginDto(), "MockSystem");
serviceMock.MockUnitOfWork.VerifyAll();
obtainedDto.Should().NotBeNull();
obtainedDto.Id.Should().Be(dto.Id);
obtainedDto.Name.Should().Be(dto.Name);
obtainedDto.Role.Should().Be(role);
obtainedDto.Token.Should().NotBeNullOrEmpty();
}
public async void LoginAsAdmin_OK()
{
UserDto dto = this.GetNewValidDto();
dto.IsAdmin = true;
var repositoryMock = this.GetNewEmptyMockedRepository();
repositoryMock.Setup(r => r.SelectAllAsync())
.Returns(Task.FromResult(
(IEnumerable <UserEntity>) new List <UserEntity> {
MapperInstance.Map <UserEntity>(dto)
})
)
.Verifiable();
var serviceMock = this.GetNewService(repositoryMock.Object);
var obtainedDto = await serviceMock.Service.LoginAsAdminAsync(this.GetNewValidLoginDto());
serviceMock.MockUnitOfWork.VerifyAll();
obtainedDto.Should().NotBeNull();
obtainedDto.Id.Should().Be(dto.Id);
obtainedDto.Name.Should().Be(dto.Name);
obtainedDto.Role.Should().Be(UserRole.Admin.ToString());
obtainedDto.Token.Should().NotBeNullOrEmpty();
}
public ResultOperationInfo <IEnumerable <WorkTimeDispatcherInfo> > GetAll()
{
var collection = UnitOfWork.GetRepository <WorkTimeDispatcher>().GetAllIncluding();
var collectionInfo = MapperInstance.Map <IEnumerable <WorkTimeDispatcher>, IEnumerable <WorkTimeDispatcherInfo> >(collection);
return(new ResultOperationInfo <IEnumerable <WorkTimeDispatcherInfo> >(collectionInfo, true, Localization.Success_OperationComplited));
}
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);
}
public void GetWithUsers_GetOne()
{
SystemDto systemDto = this.GetNewValidDto();
UserDto userDto = GetValidUserDto();
SystemEntity entity = MapperInstance.Map <SystemEntity>(systemDto);
entity.UserSystemLst.Add(new UserSystemEntity
{
SystemId = systemDto.Id,
System = entity,
UserId = userDto.Id,
User = MapperInstance.Map <UserEntity>(userDto)
});
var repositoryMock = this.GetNewEmptyMockedRepository();
repositoryMock.Setup(r => r.SelectIncludingUsers(It.IsAny <string>()))
.Returns(entity);
var serviceMock = this.GetNewService(repositoryMock.Object);
var obtainedDto = serviceMock.Service.GetWithUsers(systemDto.Id);
serviceMock.MockUnitOfWork.Verify(mock => mock.Systems.SelectIncludingUsers(It.IsAny <string>()), Times.Once);
obtainedDto.Should().NotBeNull();
obtainedDto.Users.Should().NotBeNull();
obtainedDto.Users.Should().HaveCount(1);
obtainedDto.Id.Should().Be(systemDto.Id);
obtainedDto.Users.First().UserId.Should().Be(userDto.Id);
}
public ResultOperationInfo <ClientMessageInfo> GetId(int itemId)
{
var item = UnitOfWork.GetRepository <ClientMessage>().GetIncluding(itemId, p => p.Client);
var itemInfo = MapperInstance.Map <ClientMessage, ClientMessageInfo>(item);
return(new ResultOperationInfo <ClientMessageInfo>(itemInfo, true, Localization.Success_OperationComplited));
}
public ResultOperationInfo <UserInfo> GetId(int itemId)
{
var item = UnitOfWork.GetRepository <User>().GetIncluding(itemId, p => p.DispatherMessages);
var itemInfo = MapperInstance.Map <User, UserInfo>(item);
return(new ResultOperationInfo <UserInfo>(itemInfo, true, Localization.Success_OperationComplited));
}
public async Task AddItemsAsync(IEnumerable <CustomerItem> customerItems)
{
foreach (var customerItem in customerItems)
{
var customer = MapperInstance.Map <CustomerItem, Customer>(customerItem);
await CustomerRepository.AddItemAsync(customer);
}
}
/// <summary>
/// Maps source object to result type.
/// </summary>
/// <param name="mapper">The mapper instance.</param>
/// <param name="resultType">The result type.</param>
/// <param name="source">The source object.</param>
/// <param name="tag">The object used to send additional paramaters for the mapping code.</param>
/// <returns>The mapped object.</returns>
public static object Map(this MapperInstance mapper, Type resultType, object source, object tag = null)
{
if (!TryExistingMappings(mapper, resultType, source, tag, out object targetObject))
{
targetObject = mapper.DefaultMap(source, resultType, tag);
}
return(targetObject);
}
public static void SetTask(this Element element, Task task)
{
using (var tr = new Transaction(element.Document, "set task"))
{
tr.Start();
MapperInstance.Get().SetEntity(element, task);
tr.Commit();
}
}
public ResultOperationInfo Add(CheckStatusInfo itemInfo)
{
var item = MapperInstance.Map <CheckStatusInfo, CheckStatus>(itemInfo);
var addedItem = UnitOfWork.GetRepository <CheckStatus>().Add(item);
return(addedItem == null
? new ResultOperationInfo(false, Localization.Error_OperationComplited)
: new ResultOperationInfo(true, Localization.Success_OperationComplited));
}
public ResultOperationInfo Update(ClientMessageInfo itemInfo)
{
var item = MapperInstance.Map <ClientMessageInfo, ClientMessage>(itemInfo);
var updatedItem = UnitOfWork.GetRepository <ClientMessage>().Update(item, item.Id);
return(updatedItem == null
? new ResultOperationInfo(false, Localization.Error_OperationComplited)
: new ResultOperationInfo(true, Localization.Success_OperationComplited));
}
public ResultOperationInfo <ChannelsInfo> Create(ChannelsInfo itemInfo)
{
var item = MapperInstance.Map <ChannelsInfo, Channels>(itemInfo);
var addedItem = UnitOfWork.GetRepository <Channels>().Add(item);
var addedItemInfo = MapperInstance.Map <Channels, ChannelsInfo>(addedItem);
return(addedItem == null
? new ResultOperationInfo <ChannelsInfo>(null, false, Localization.Error_OperationComplited)
: new ResultOperationInfo <ChannelsInfo>(addedItemInfo, true, Localization.Success_OperationComplited));
}
/// <summary>
/// Attempts to transform an object using an existing map. If none is found, maps using the TInjection injection.
/// </summary>
/// <typeparam name="TInjection">The <see cref="IFWInjection"/> type.</typeparam>
/// <param name="mapper">The mapper instance.</param>
/// <param name="resultType">The result type.</param>
/// <param name="source">The source object.</param>
/// <param name="tag">The object used to send additional paramaters for the mapping code.</param>
/// <returns>The mapped object.</returns>
public static object MapInject <TInjection>(this MapperInstance mapper, Type resultType, object source, object tag = null)
where TInjection : IFWInjection, new()
{
if (!TryExistingMappings(mapper, resultType, source, tag, out object targetObject))
{
targetObject = Activator.CreateInstance(resultType);
targetObject.InjectFrom <TInjection>(source);
}
return(targetObject);
}
public ResultOperationInfo Add(DispatcherMessageInfo itemInfo)
{
var item = MapperInstance.Map <DispatcherMessageInfo, DispatherMessage>(itemInfo);
item.User = null;
var addedItem = UnitOfWork.GetRepository <DispatherMessage>().Add(item);
return(addedItem == null
? new ResultOperationInfo(false, Localization.Error_OperationComplited)
: new ResultOperationInfo(true, Localization.Success_OperationComplited));
}
public ResultOperationInfo <UserInfo> Create(UserInfo itemInfo)
{
var item = MapperInstance.Map <UserInfo, User>(itemInfo);
item.DispatherMessages = null;
var addedItem = UnitOfWork.GetRepository <User>().Add(item);
var addedItemInfo = MapperInstance.Map <User, UserInfo>(addedItem);
return(addedItem == null
? new ResultOperationInfo <UserInfo>(null, false, Localization.Error_OperationComplited)
: new ResultOperationInfo <UserInfo>(addedItemInfo, true, Localization.Success_OperationComplited));
}
/// <summary>
/// Checks for primitive mappings.
/// </summary>
internal static object MapPrimitive(this MapperInstance mapper, Type resultType, object source)
{
var sourceType = source.GetType();
mapper.Maps.TryGetValue(new Tuple <Type, Type>(sourceType, resultType), out Tuple <object, bool> funct);
if (funct != null)
{
var parameters = funct.Item2 ? new[] { source, null } : new[] { source };
return(funct.Item1.GetType().GetMethod("Invoke").Invoke(funct.Item1, parameters));
}
return(source);
}
public UserServiceSystemTest()
{
_user = this.GetNewValidDto();
_system = this.GetNewValidSystemDto();
_userEntity = MapperInstance.Map <UserEntity>(_user);
_systemEntity = MapperInstance.Map <SystemEntity>(_system);
_userEntityWithSystem = MapperInstance.Map <UserEntity>(_user);
_userEntityWithSystem.UserSystemLst.Add(new UserSystemEntity()
{
SystemId = _system.Id,
UserId = _user.Id,
System = _systemEntity,
User = _userEntity
});
this.SetupRepository();
}
/// <summary>
/// Attempts to transform an object using an existing map.
/// </summary>
private static bool TryExistingMappings(MapperInstance mapper, Type resultType, object source, object tag, out object result)
{
var sourceType = source.GetType();
mapper.Maps.TryGetValue(new Tuple <Type, Type>(sourceType, resultType), out Tuple <object, bool> funct);
if (funct != null)
{
var parameters = funct.Item2 ? new[] { source, tag } : new[] { source };
result = funct.Item1.GetType().GetMethod("Invoke").Invoke(funct.Item1, parameters);
return(true);
}
result = null;
return(false);
}
public async void GetByIdAsync_GetOne()
{
SystemDto dto = this.GetNewValidDto();
var repositoryMock = this.GetNewEmptyMockedRepository();
repositoryMock.Setup(r => r.SelectByIdAsync(It.IsAny <object[]>()))
.Returns(new ValueTask <SystemEntity>(MapperInstance.Map <SystemEntity>(dto)));
var serviceMock = this.GetNewService(repositoryMock.Object);
var obtainedDto = await serviceMock.Service.GetByIdAsync(new object[] { dto.Id });
serviceMock.MockUnitOfWork.Verify(mock => mock.Systems.SelectByIdAsync(It.IsAny <object[]>()), Times.Once);
obtainedDto.Should().NotBeNull();
obtainedDto.Id.Should().Be(dto.Id);
obtainedDto.Name.Should().Be(dto.Name);
obtainedDto.Description.Should().Be(dto.Description);
}
public static void UpdateTask(this Element element, Action <Task> update)
{
var mapper = MapperInstance.Get();
var task = mapper.GetEntity(element) ?? new Task()
{
Remarks = new List <string>(),
FixedRemarks = new List <string>()
};
update(task);
using (var tr = new Transaction(element.Document, "set task"))
{
tr.Start();
mapper.SetEntity(element, task);
tr.Commit();
}
}
public void MapMethod2()
{
MappingConfiguration.Add <XtoYConfiguration>();
MappingConfiguration.Build();
var x = new X()
{
X1 = 1,
X2 = 2
};
IMapper mapper = new MapperInstance();
var y = mapper.Map <X, Y>(x);
y.Y1.Should().Be(x.X1);
y.Y2.Should().Be(x.X2);
}
public void MapMethod3()
{
MappingConfiguration.Add <XtoYConfiguration>();
MappingConfiguration.Build();
var x = new X()
{
X1 = 1,
X2 = 2
};
IMapper mapper = new MapperInstance();
var y = (Y)mapper.Map(x, typeof(X), typeof(Y));
y.Y1.Should().Be(x.X1);
y.Y2.Should().Be(x.X2);
}
static JobAssistantMapper()
{
MapperObject = new MapperInstance();
DefineToolModelToToolMapping();
DefineAccessoryModelToAccessoryMapping();
// TODO: Add other types including category, trade, job, etc.
DefineCategoryToCategoryModelMapping();
DefineTradeToTradeModelMapping();
DefineJobToJobModelMapping();
DefineMaterialToMaterialModelMapping();
DefineApplicationToApplicationModelMapping();
DefineToolToToolModelMapping();
DefineAccessoryToAccessoryModelMapping();
DefineTenantToTenantModelMapping();
DefineTenantModelToTenantMapping();
}
protected async Task <TAlternateSingleDto> RunAlternateRequestAndDispatchEventAsync <TRequest, TDefinition, TAlternateSingleDto, TAlternateDomain>(Func <TDefinition, TAlternateDomain> func, TRequest request, string className, CancellationToken cancellationToken)
where TAlternateDomain : BaseDomainEventHandler <TId>
where TAlternateSingleDto : class
{
var timer = new Stopwatch();
timer.Start();
try
{
var definition = MapperInstance.Map <TRequest, TDefinition>(request);
return(await GetAlternateSingleDtoAndEvaluateEvents <TAlternateSingleDto, TAlternateDomain>(() => func(definition), cancellationToken));
}
finally
{
timer.Stop();
Log.Debug(LogMessage(className, timer));
}
}
private async Task <TAlternateSingleDto> GetAlternateSingleDtoAndEvaluateEvents <TAlternateSingleDto, TAlternateDomain>(Func <TAlternateDomain> func, CancellationToken cancellationToken)
where TAlternateDomain : BaseDomainEventHandler <TId>
where TAlternateSingleDto : class
{
//TODO: Add exception for null func
var domain = await Task.Run(func, cancellationToken);
if (domain == null)
{
return(null);
}
var events = domain.Events;
if (_eventDispatcher != null && events?.Any() == true)
{
_eventDispatcher.Dispatch(events);
}
return(MapperInstance.Map <TAlternateDomain, TAlternateSingleDto>(domain));
}
public async void GetAllAsync_GetOne()
{
SystemDto dto = this.GetNewValidDto();
var repositoryMock = this.GetNewEmptyMockedRepository();
repositoryMock.Setup(r => r.SelectAllAsync())
.Returns(Task.FromResult(
(IEnumerable <SystemEntity>) new List <SystemEntity> {
MapperInstance.Map <SystemEntity>(dto)
})
)
.Verifiable();
var serviceMock = this.GetNewService(repositoryMock.Object);
var dtos = await serviceMock.Service.GetAllAsync();
serviceMock.MockUnitOfWork.VerifyAll();
serviceMock.MockCache.Verify(mock => mock.GetAsync <IEnumerable <SystemEntity> >(It.IsAny <string>()), Times.Once);
serviceMock.MockCache.Verify(mock => mock.AddAsync(It.IsAny <string>(), It.IsAny <IEnumerable <SystemEntity> >()), Times.Once);
dtos.Should().NotBeNull();
dtos.Should().HaveCount(1);
}
private void MapperConfigure(MapperInstance cfd)
{
cfd.AddMap<Person, PersonInfoDto>(src =>
{
PersonInfoDto dst = new PersonInfoDto();
dst.InjectFrom(src);
dst.EmployeeBrithDate = src.Employee?.BirthDate;
return dst;
});
cfd.AddMap<EmailAddress, EmailDto>(src =>
{
EmailDto dst = new EmailDto();
dst.InjectFrom(src);
dst.EmailAddress = src.EmailAddress1;
return dst;
});
cfd.AddMap<ShipMethod, ShipMethodDto>(src =>
{
ShipMethodDto dst = new ShipMethodDto();
dst.InjectFrom(src);
return dst;
});
cfd.AddMap<ProductListPriceHistory, ProductListPriceHistoryDto>(src =>
{
ProductListPriceHistoryDto dst = new ProductListPriceHistoryDto();
dst.InjectFrom(src);
return dst;
});
cfd.AddMap<Product, ProductDto>(src =>
{
ProductDto dst = new ProductDto();
dst.InjectFrom(src);
dst.ProductListPriceHistories = new List<ProductListPriceHistoryDto>();
foreach (ProductListPriceHistory item in src.ProductListPriceHistories)
{
ProductListPriceHistoryDto itemDto = new ProductListPriceHistoryDto();
itemDto.InjectFrom(item);
dst.ProductListPriceHistories.Add(itemDto);
}
return dst;
});
cfd.AddMap<ProductModel, ProductModelDto>(src =>
{
ProductModelDto dst = new ProductModelDto();
dst.InjectFrom(src);
return dst;
});
cfd.AddMap<Product, Product2Dto>(src =>
{
Product2Dto dst = new Product2Dto();
dst.InjectFrom(src);
dst.ProductModel = new ProductModelDto();
dst.ProductModel.InjectFrom(src.ProductModel);
dst.ProductModelID = src.ProductModel?.ProductModelID;
return dst;
});
}
public ValueInjecterAdapter()
{
this.mapper = new MapperInstance();
this.MapperConfigure(this.mapper);
this.dbContext = null;
}
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);
}
