public void Register(TypeAdapterConfig config)
{
config.NewConfig<Customer, CustomerDTO>();
config.NewConfig<Product, ProductDTO>();
config.ForType<Product, ProductDTO>()
.Map(dest => dest.Title, src => src.Title + "_AppendSomething!");
}
public void Basic_Poco_Is_Mapped_With_New_Config()
{
var config = new TypeAdapterConfig();
config.NewConfig<Customer, CustomerDTO>()
.Map(dest => dest.Address_Country, src => "TestAddressCountry");
var customer = new Customer
{
Id = 12345,
Name = "TestName",
Surname = "TestSurname"
};
var customerDto = customer.Adapt<CustomerDTO>(config);
customerDto.Id.ShouldEqual(12345);
customerDto.Name.ShouldEqual("TestName");
customerDto.Address_Country.ShouldEqual("TestAddressCountry");
}
public void Register(TypeAdapterConfig config)
{
config.NewConfig <Entity.NotificationQueue, Model.NotificationQueueModel>()
.Map(dest => dest.Id, src => src.Id)
.Map(dest => dest.Key, src => src.Key)
.Map(dest => dest.Status, src => src.Status)
.Map(dest => dest.Priority, src => src.Priority)
.Map(dest => dest.Encoding, src => src.Encoding)
.Map(dest => dest.To, src => src.To)
.Map(dest => dest.Cc, src => src.Cc)
.Map(dest => dest.Bcc, src => src.Bcc)
.Map(dest => dest.Subject, src => src.Subject)
.Map(dest => dest.Body, src => src.Body)
.Map(dest => dest.BodyType, src => src.BodyType)
.Map(dest => dest.Tag, src => src.Tag)
.Map(dest => dest.SendOn, src => src.SendOn)
.Map(dest => dest.ProjectId, src => src.ProjectId)
.Map(dest => dest.ToAgencyId, src => src.ToAgencyId)
.Map(dest => dest.ChesTransactionId, src => src.ChesTransactionId)
.Map(dest => dest.ChesMessageId, src => src.ChesMessageId)
.Inherits <Entity.BaseEntity, Api.Models.BaseModel>();
}
public void Register(TypeAdapterConfig config)
{
config.NewConfig <Entity.ProjectProperty, Model.ProjectPropertyModel>()
.Map(dest => dest.Id, src => src.Id)
.Map(dest => dest.ProjectId, src => src.ProjectId)
.Map(dest => dest.PropertyType, src => src.PropertyType)
.Map(dest => dest.ParcelId, src => src.ParcelId)
.Map(dest => dest.Parcel, src => src.Parcel)
.Map(dest => dest.BuildingId, src => src.BuildingId)
.Map(dest => dest.Building, src => src.Building)
.Inherits <Entity.BaseEntity, Api.Models.BaseModel>();
config.NewConfig <Model.ProjectPropertyModel, Entity.ProjectProperty>()
.Map(dest => dest.Id, src => src.Id)
.Map(dest => dest.ProjectId, src => src.ProjectId)
.Map(dest => dest.PropertyType, src => src.PropertyType)
.Map(dest => dest.ParcelId, src => src.ParcelId)
.Map(dest => dest.Parcel, src => src.Parcel)
.Map(dest => dest.BuildingId, src => src.BuildingId)
.Map(dest => dest.Building, src => src.Building)
.Inherits <Api.Models.BaseModel, Entity.BaseEntity>();
}
public void Register(TypeAdapterConfig config)
{
config.NewConfig <Entity.PimsOrganization, Model.OrganizationModel>()
.Map(dest => dest.Id, src => src.OrganizationId)
.Map(dest => dest.IsDisabled, src => src.IsDisabled)
.Map(dest => dest.Name, src => src.Name)
.Map(dest => dest.Alias, src => src.OrganizationAlias)
.Map(dest => dest.IncorporationNumber, src => src.IncorporationNumber)
.Map(dest => dest.Comment, src => src.Comment)
.Map(dest => dest.Addresses, src => src.PimsOrganizationAddresses)
.Map(dest => dest.ContactMethods, src => src.PimsContactMethods)
.Map(dest => dest.Persons, src => src.GetPersons())
.Inherits <Entity.IBaseAppEntity, Api.Models.BaseAppModel>();
config.NewConfig <Model.OrganizationModel, Entity.PimsOrganization>()
.Map(dest => dest.OrganizationId, src => src.Id)
.Map(dest => dest.IsDisabled, src => src.IsDisabled)
.Map(dest => dest.Name, src => src.Name)
.Map(dest => dest.OrganizationAlias, src => src.Alias)
.Map(dest => dest.IncorporationNumber, src => src.IncorporationNumber)
.Map(dest => dest.Comment, src => src.Comment)
.Map(dest => dest.PimsOrganizationAddresses, src => src.Addresses)
.Map(dest => dest.PimsContactMethods, src => src.ContactMethods)
.Inherits <Api.Models.BaseAppModel, Entity.IBaseAppEntity>()
.IgnoreNonMapped(true) // with this we explicitly ignore the persons list if it gets sent to the backend
.IgnoreNullValues(true)
.AfterMapping((src, dest) =>
{
// ensure many-to-many OrganizationAddress entities have set the proper FK to owning Organization
foreach (var oa in dest.PimsOrganizationAddresses)
{
oa.OrganizationId = dest.OrganizationId;
}
foreach (var cm in dest.PimsContactMethods)
{
cm.OrganizationId = dest.OrganizationId;
}
});
}
public void Register(TypeAdapterConfig config)
{
//SessionInformation -> Session
config.ForType <SessionInformation, Session>()
.Map(dst => dst.Id, src => src.SessionId)
.Map(dst => dst.Started, src => src.SessionStarted)
.Map(dst => dst.UserName, src => src.User);
//Session -> UserSessionDto
config.ForType <Session, UserSessionDto>()
.Map(dst => dst.SessionId, src => src.Id)
.Map(dst => dst.Started, src => src.Started)
.Map(dst => dst.Applications, src => src.Applications)
.Map(dst => dst.Processes, src => src.ProcessEntities);
//Session -> UserSessionDto
config.ForType <SessionInformation, UserSessionDto>()
.Map(dst => dst.SessionId, src => src.SessionId)
.Map(dst => dst.Started, src => src.SessionStarted)
.Map(dst => dst.UserName, src => src.User)
.Map(dst => dst.OS, src => src.OS);
}
// We user Mapster to convert Database objects to API objects automatically using the .Adapt<T>() operator
// This file is the sole location where we set up Mapster configurations for types.
public static void UseMapster(this IApplicationBuilder app)
{
TypeAdapterConfig <RaidParticipation, McRaidDescription>
.ForType()
.Map(dest => dest.Raid, src => src.Raid.Raid)
.Map(dest => dest.Gym, src => src.Raid.Gym)
.Map(dest => dest.Location, src => src.Raid.Location.Adapt <McLocation>())
.Map(dest => dest.RaidUnlockTime, src => src.Raid.RaidUnlockTime)
.Map(dest => dest.RaidEndTime, src => src.Raid.RaidEndTime)
.Map(dest => dest.Address, src => src.Raid.Address)
.Map(dest => dest.Alignment, src => src.Raid.Alignment)
.Map(dest => dest.Remarks, src => src.Raid.Remarks)
.Map(dest => dest.UniqueID, src => src.UniqueID)
.Map(dest => dest.PublicID, src => src.PublicID)
.Map(dest => dest.UpdateCount, src => src.Raid.UpdateCount)
.Map(dest => dest.User, src => src.Raid.User.Adapt <McTelegramUser>())
.Map(dest => dest.Valor, src => src.Participants.Get(Team.Valor).Select(x => 1 + x.Extra).Sum())
.Map(dest => dest.Mystic, src => src.Participants.Get(Team.Mystic).Select(x => 1 + x.Extra).Sum())
.Map(dest => dest.Instinct, src => src.Participants.Get(Team.Instinct).Select(x => 1 + x.Extra).Sum())
.Map(dest => dest.Unknown, src => src.Participants.Get(Team.Unknown).Select(x => 1 + x.Extra).Sum())
.Map(dest => dest.Maybe, src => src.Maybe != null ? src.Maybe.Count : 0);
}
public void MapToInheritedInterface()
{
var dto = new InheritedDto
{
Id = 1,
Name = "Test",
DateOfBirth = new DateTime(1978, 12, 10),
UnmappedSource = "Lorem ipsum"
};
var config = new TypeAdapterConfig();
IInheritedDto idto = dto.Adapt <IInheritedDto>(config);
idto.ShouldNotBeNull();
idto.ShouldSatisfyAllConditions(
() => idto.Id.ShouldBe(dto.Id),
() => idto.Name.ShouldBe(dto.Name),
() => idto.DateOfBirth.ShouldBe(dto.DateOfBirth),
() => idto.UnmappedTarget.ShouldBeNull()
);
}
public void Base_Configuration_DestinationTransforms_Apply_To_Derived_Class()
{
var config = TypeAdapterConfig <SimplePoco, SimpleDto> .NewConfig();
config.AddDestinationTransform((string x) => x.Trim());
config.Compile();
TypeAdapterConfig <DerivedPoco, DerivedDto> .NewConfig()
.Inherits <SimplePoco, SimpleDto>()
.Compile();
var source = new DerivedPoco
{
Id = new Guid(),
Name = "SourceName "
};
var dto = TypeAdapter.Adapt <DerivedDto>(source);
dto.Id.ShouldEqual(source.Id);
dto.Name.ShouldEqual(source.Name.Trim());
}
public void NewConfig_Overwrites_Config()
{
var config = new TypeAdapterConfig();
config.NewConfig<Customer, CustomerDTO>()
.Map(dest => dest.Name, src => src.Name + "_Enhanced");
config.NewConfig<Customer, CustomerDTO>()
.Map(dest => dest.Address_Country, src => "TestAddressCountry");
var customer = new Customer
{
Id = 12345,
Name = "TestName",
Surname = "TestSurname"
};
var customerDto = customer.Adapt<CustomerDTO>(config);
customerDto.Id.ShouldEqual(12345);
customerDto.Name.ShouldEqual("TestName");
customerDto.Address_Country.ShouldEqual("TestAddressCountry");
}
public void Register(TypeAdapterConfig config)
{
config.NewConfig <Entity.IDisableBaseAppEntity, Models.BaseAppModel>()
.Inherits <Entity.IBaseAppEntity, Models.BaseAppModel>();
config.NewConfig <Entity.IBaseAppEntity, Models.BaseAppModel>()
.Map(dest => dest.AppCreateTimestamp, src => src.AppCreateTimestamp)
.Map(dest => dest.AppLastUpdateTimestamp, src => src.AppLastUpdateTimestamp)
.Map(dest => dest.AppLastUpdateUserid, src => src.AppLastUpdateUserid)
.Map(dest => dest.AppCreateUserid, src => src.AppCreateUserid)
.Inherits <Entity.IBaseEntity, Models.BaseModel>();
config.NewConfig <Models.BaseAppModel, Entity.IDisableBaseAppEntity>()
.Inherits <Models.BaseAppModel, Entity.IBaseAppEntity>();
config.NewConfig <Models.BaseAppModel, Entity.IBaseAppEntity>()
.Map(dest => dest.AppCreateTimestamp, src => src.AppCreateTimestamp)
.Map(dest => dest.AppLastUpdateTimestamp, src => src.AppLastUpdateTimestamp)
.Map(dest => dest.AppLastUpdateUserid, src => src.AppLastUpdateUserid)
.Map(dest => dest.AppCreateUserid, src => src.AppCreateUserid)
.Inherits <Models.BaseModel, Entity.IBaseEntity>();
}
public void Should_Ignore_Non_Mapped()
{
TypeAdapterConfig <SimplePoco, SimpleDto> .NewConfig()
.Map(dest => dest.Id, src => src.Id)
.IgnoreNonMapped(true)
.Compile();
var poco = new SimplePoco
{
Id = Guid.NewGuid(),
Name1 = "Name1",
Name2 = "Name2",
Name3 = "Name3"
};
var dto = poco.Adapt <SimplePoco, SimpleDto>();
dto.Id.ShouldBe(poco.Id);
dto.Name1.ShouldBeNull();
dto.Name2.ShouldBeNull();
dto.Name3.ShouldBeNull();
}
public async Task UpsertHallsAsync(CinemaHallsModel hallsModel)
{
foreach (HallModel hall in hallsModel.Halls)
{
int result;
try
{
result = await _hallRepository.UpsertHallAsync(
new HallEntity(
hall.Id,
hall.Name,
hallsModel.CinemaId
)
);
}
catch (UniqueIndexException e)
{
throw new ConflictException(e);
}
List <SeatModel> hallSeats = hallsModel
.Seats
.FindAll(seat => seat.HallId == hall.Id);
if (hall.Id == result)
{
await _hallRepository.DeleteHallPlanAsync(result);
}
TypeAdapterConfig <SeatModel, SeatEntity>
.NewConfig()
.Map(dest => dest.HallId, sourse => result);
await _hallRepository.AddHallPlanAsync(
hallSeats
.Adapt <List <SeatEntity> >()
);
}
}
public void Register(TypeAdapterConfig config)
{
config.NewConfig <Entity.ParcelFiscal, Model.ParcelFiscalModel>()
.EnumMappingStrategy(EnumMappingStrategy.ByName)
.Map(dest => dest.ParcelId, src => src.ParcelId)
.Map(dest => dest.FiscalYear, src => src.FiscalYear)
.Map(dest => dest.EffectiveDate, src => src.EffectiveDate)
.Map(dest => dest.Key, src => src.Key)
.Map(dest => dest.Value, src => src.Value)
.Map(dest => dest.Note, src => src.Note)
.Inherits <Entity.BaseEntity, BModel.BaseModel>();
config.NewConfig <Model.ParcelFiscalModel, Entity.ParcelFiscal>()
.EnumMappingStrategy(EnumMappingStrategy.ByName)
.Map(dest => dest.ParcelId, src => src.ParcelId)
.Map(dest => dest.FiscalYear, src => src.FiscalYear)
.Map(dest => dest.EffectiveDate, src => src.EffectiveDate)
.Map(dest => dest.Key, src => src.Key)
.Map(dest => dest.Value, src => src.Value)
.Map(dest => dest.Note, src => src.Note)
.Inherits <BModel.BaseModel, Entity.BaseEntity>();
}
public void Register(TypeAdapterConfig config)
{
config.NewConfig <ProjectProperty, ProjectPropertyModel>()
.Map(dest => dest.PropertyTypeId,
src => src.Building != null ? PropertyTypes.Building : PropertyTypes.Land)
.Map(dest => dest.Id, src => src.BuildingId ?? src.ParcelId)
.Map(dest => dest.Classification,
src => src.Building != null ? src.Building.Classification.Name : src.Parcel.Classification.Name)
.Map(dest => dest.Name, src => src.Building != null ? src.Building.Name : src.Parcel.Name)
.Map(dest => dest.Address,
src => src.Building != null
? src.Building.Address.FormatAddress()
: src.Parcel.Address.FormatAddress())
.Map(dest => dest.AdministrativeArea,
src => src.Building != null ? src.Building.Address.AdministrativeArea : src.Parcel.Address.AdministrativeArea)
.Map(dest => dest.Assessed,
src => src.Building != null
? src.Building.GetCurrentEvaluation(EvaluationKeys.Assessed)
: src.Parcel.GetCurrentEvaluation(EvaluationKeys.Assessed))
.Map(dest => dest.NetBook,
src => src.Building != null
? src.Building.GetCurrentFiscal(FiscalKeys.NetBook)
: src.Parcel.GetCurrentFiscal(FiscalKeys.NetBook))
.Map(dest => dest.Market,
src => src.Building != null
? src.Building.GetCurrentFiscal(FiscalKeys.Market)
: src.Parcel.GetCurrentFiscal(FiscalKeys.Market))
.Map(dest => dest.Zoning, src => src.Building != null ? src.Building.GetZoning().First() : src.Parcel.Zoning)
.Map(dest => dest.ZoningPotential, src => src.Building != null ? src.Building.GetZoningPotential().First() : src.Parcel.ZoningPotential)
.Map(dest => dest.AgencyCode,
src => src.Building != null ? GetAgencyCode(src.Building.Agency) : GetAgencyCode(src.Parcel.Agency))
.Map(dest => dest.SubAgency,
src => src.Building != null ? GetAgencyName(src.Building.Agency) : GetAgencyName(src.Parcel.Agency))
.Map(dest => dest.LandArea, src => src.Building != null ? GetLandArea(src.Building.Parcels.FirstOrDefault().Parcel) : GetLandArea(src.Parcel))
.Map(dest => dest.ParcelId, src => src.Building != null ? src.Building.Parcels.FirstOrDefault().ParcelId : src.Parcel.GetId())
.Inherits <BaseEntity, BaseModel>();
}
public void MapFromTest()
{
var currentDate = DateTime.Now;
var objC = new ConfigC()
{
BirthDate = currentDate,
Id = 1,
Name = "Timuçin",
Surname = "KIVANÇ"
};
TypeAdapterConfig <ConfigC, ConfigD> .NewConfig()
//.Map(dest => dest.FullName, (src) => string.Concat(src.Name, " ", src.Surname));
.Map(dest => dest.FullName, src => string.Concat(src.Name, " ", src.Surname));
var objD = TypeAdapter.Adapt <ConfigC, ConfigD>(objC);
Assert.IsNotNull(objD);
Assert.IsTrue(objD.Id == 1 && objD.FullName == "Timuçin KIVANÇ" && objD.BirthDate == currentDate);
}
public void Register(TypeAdapterConfig config)
{
//ApplicationInformation -> ApplicationEntity
config.ForType <ApplicationInformation, ApplicationEntity>()
.Map(dst => dst.SessionId, src => src.Session)
.Map(dst => dst.Saved, src => src.FetchTime)
.Ignore(i => i.Session);
//ApplicationInformation -> ApplicationDto
config.ForType <ApplicationInformation, ApplicationDto>()
.Map(dst => dst.SessionId, src => src.Session)
.Map(dst => dst.Started, src => src.StartTime)
.Map(dst => dst.LastUse, src => src.FetchTime)
.Map(dst => dst.Name, src => src.ApplicationName);
//ApplicationEntity -> ApplicationDto
config.ForType <ApplicationEntity, ApplicationDto>()
.Map(dst => dst.Started, src => src.StartTime)
.Map(dst => dst.LastUse, src => src.Saved)
.Map(dst => dst.Name, src => src.ApplicationName)
.Map(dst => dst.SessionId, src => src.SessionId);
}
public void Register(TypeAdapterConfig config)
{
config.NewConfig <Entity.PimsInsurance, Model.InsuranceModel>()
.Map(dest => dest.Id, src => src.InsuranceId)
.Map(dest => dest.InsuranceType, src => src.InsuranceTypeCodeNavigation)
.Map(dest => dest.OtherInsuranceType, src => src.OtherInsuranceType)
.Map(dest => dest.CoverageDescription, src => src.CoverageDescription)
.Map(dest => dest.CoverageLimit, src => src.CoverageLimit)
.Map(dest => dest.ExpiryDate, src => src.ExpiryDate)
.Map(dest => dest.IsInsuranceInPlace, src => src.IsInsuranceInPlace)
.Inherits <Entity.IBaseEntity, Api.Models.BaseModel>();
config.NewConfig <Model.InsuranceModel, Entity.PimsInsurance>()
.Map(dest => dest.InsuranceId, src => src.Id)
.Map(dest => dest.InsuranceTypeCode, src => src.InsuranceType.Id)
.Map(dest => dest.OtherInsuranceType, src => src.OtherInsuranceType)
.Map(dest => dest.CoverageDescription, src => src.CoverageDescription)
.Map(dest => dest.CoverageLimit, src => src.CoverageLimit)
.Map(dest => dest.ExpiryDate, src => src.ExpiryDate)
.Map(dest => dest.IsInsuranceInPlace, src => src.IsInsuranceInPlace)
.Inherits <Api.Models.BaseModel, Entity.IBaseEntity>();
}
public void Register(TypeAdapterConfig config)
{
config.NewConfig <Entity.Project, Model.SurplusPropertyListModel>()
.Map(dest => dest.ProjectNumber, src => src.ProjectNumber)
.Map(dest => dest.ReportedFiscalYear, src => src.ReportedFiscalYear.FiscalYear())
.Map(dest => dest.ActualFiscalYear, src => src.ActualFiscalYear.FiscalYear())
.Map(dest => dest.MajorActivity, src => src.Status.Name)
.Map(dest => dest.Status, src => SalesStatus(src)) // TODO: Need valid list and determine if it can be changed.
.Map(dest => dest.AgencyCode, src => AgencyConverter.ConvertAgency(src.Agency))
.Map(dest => dest.Name, src => src.Name)
.Map(dest => dest.CurrentMarketValue, src => src.Market)
.Map(dest => dest.NetBookValue, src => src.NetBook)
.Map(dest => dest.Risk, src => src.Risk.Name)
.Map(dest => dest.CompletedOn, src => src.CompletedOn)
.Map(dest => dest.ItemType, src => (string)null)
.Map(dest => dest.Path, src => (string)null)
.Map(dest => dest.Manager, src => src.Manager)
.Map(dest => dest.ReportingNote, src => src.GetNoteText(Entity.NoteTypes.Reporting))
.Map(dest => dest.FinancialNote, src => src.GetNoteText(Entity.NoteTypes.Financial))
.Map(dest => dest.InterestFromEnhancedReferralNote, src => src.GetNoteText(Entity.NoteTypes.AgencyInterest))
.AfterMapping((src, dest) =>
{
var metadata = JsonSerializer.Deserialize <Entity.Models.DisposalProjectMetadata>(src.Metadata ?? "{}", _serializerOptions);
var priorSnapshot = src.Snapshots.Any() ? src.Snapshots.LastOrDefault() : null;
var prevMetadata = priorSnapshot != null ? JsonSerializer.Deserialize <Entity.Models.DisposalProjectSnapshotMetadata>(priorSnapshot.Metadata ?? "{}", _serializerOptions) : null;
dest.SalesCost = metadata.SalesCost;
dest.NetProceeds = metadata.NetProceeds;
dest.WeeklyIntegrityCheck = prevMetadata?.NetProceeds;
dest.BaselineIntegrityCheck = prevMetadata?.BaselineIntegrity;
dest.ProgramCost = metadata.ProgramCost;
dest.GainLoss = metadata.GainLoss;
dest.OcgFinancialStatement = metadata.OcgFinancialStatement;
dest.InterestComponent = metadata.InterestComponent;
dest.Slip = metadata.SaleWithLeaseInPlace;
dest.MarketedOn = metadata.MarketedOn;
dest.InterestedReceivedOn = metadata.InterestedReceivedOn;
});
}
public void CustomConvert()
{
TypeAdapterConfig <ClassA, ClassB>
.NewConfig()
.Ignore(b => b.Price)
.Map(b => b.Name, a => $"{a.Id}_{a.Name}");
var classA = new ClassA()
{
Id = 1,
Name = "Test",
Price = 12.34m
};
var classB = classA.Adapt <ClassB>();
classB.Should().BeEquivalentTo(new ClassB()
{
Id = 1,
Name = "1_Test",
Price = 0m,
});
}
public void Register(TypeAdapterConfig config)
{
config.NewConfig <Entity.PimsSecurityDepositReturn, SecurityDepositReturnModel>()
.Map(dest => dest.Id, src => src.SecurityDepositReturnId)
.Map(dest => dest.ParentDepositId, src => src.SecurityDepositId)
.Map(dest => dest.TerminationDate, src => src.TerminationDate)
.Map(dest => dest.ClaimsAgainst, src => src.ClaimsAgainst)
.Map(dest => dest.ReturnAmount, src => src.ReturnAmount)
.Map(dest => dest.ReturnDate, src => src.ReturnDate)
.Map(dest => dest.ContactHolder, src => src.PimsSecurityDepositReturnHolder)
.Inherits <Entity.IBaseEntity, BaseModel>();
config.NewConfig <SecurityDepositReturnModel, Entity.PimsSecurityDepositReturn>()
.Map(dest => dest.SecurityDepositReturnId, src => src.Id)
.Map(dest => dest.SecurityDepositId, src => src.ParentDepositId)
.Map(dest => dest.TerminationDate, src => src.TerminationDate)
.Map(dest => dest.ClaimsAgainst, src => src.ClaimsAgainst)
.Map(dest => dest.ReturnAmount, src => src.ReturnAmount)
.Map(dest => dest.ReturnDate, src => src.ReturnDate)
.Map(dest => dest.PimsSecurityDepositReturnHolder, src => src.ContactHolder)
.Inherits <BaseModel, Entity.IBaseEntity>();
}
public void Register(TypeAdapterConfig config)
{
config.NewConfig <Entity.AccessRequest, Model.AccessRequestModel>()
.Map(dest => dest.Id, src => src.Id)
.Map(dest => dest.Status, src => src.Status)
.Map(dest => dest.Agencies, src => src.Agencies)
.Map(dest => dest.Roles, src => src.Roles)
.Map(dest => dest.UserId, src => src.UserId)
.Map(dest => dest.User, src => src.User)
.Map(dest => dest.Note, src => src.Note)
.Inherits <Entity.BaseEntity, Models.BaseModel>();
config.NewConfig <Model.AccessRequestModel, Entity.AccessRequest>()
.Map(dest => dest.Id, src => src.Id)
.Map(dest => dest.Status, src => src.Status)
.Map(dest => dest.Agencies, src => src.Agencies)
.Map(dest => dest.Roles, src => src.Roles)
.Map(dest => dest.UserId, src => src.UserId)
.Map(dest => dest.User, src => src.User)
.Map(dest => dest.Note, src => src.Note)
.Inherits <Models.BaseModel, Entity.BaseEntity>();
}
/// <summary>
/// 构造函数
/// </summary>
public ItemTableBLL()
{
TypeAdapterConfig <ItemTable, ItemTableViewModel> .NewConfig()
.Map(dest => dest.ItemID, src => src.ItemID)
.Map(dest => dest.ItemName, src => src.ItemName)
.Map(dest => dest.CategoryTypeID, src => src.CategoryTypeID)
.Map(dest => dest.ItemPrice, src => src.ItemPrice)
.Map(dest => dest.ItemBuyDate, src => src.ItemBuyDate)
.Map(dest => dest.UserID, src => src.UserID)
.Map(dest => dest.Recommend, src => src.Recommend)
.Map(dest => dest.ModifyDate, src => src.ModifyDate)
.Map(dest => dest.Synchronize, src => src.Synchronize)
.Map(dest => dest.ItemAppID, src => src.ItemAppID)
.Map(dest => dest.RegionID, src => src.RegionID)
.Map(dest => dest.RegionType, src => src.RegionType)
.Map(dest => dest.ItemType, src => src.ItemType)
.Map(dest => dest.ZhuanTiID, src => src.ZhuanTiID)
.Map(dest => dest.CardID, src => src.CardID)
.Map(dest => dest.ItemTypeName, src => src.ItemTypeTable.ItemTypeName)
.Map(dest => dest.CardName, src => src.CardID)
.Compile();
}
public void Property_Is_Mapped_To_Different_Property_Successfully()
{
TypeAdapterConfig <SimplePoco, SimpleDto> .NewConfig()
.Map(dest => dest.AnotherName, src => src.Name)
.Map(dest => dest.LastModified, src => DateTime.Now)
.Map(dest => dest.FileData, src => new FileData {
Content = src.FileContent
})
.Compile();
var poco = new SimplePoco {
Id = Guid.NewGuid(), Name = "TestName", FileContent = "Foo"
};
var dto = TypeAdapter.Adapt <SimplePoco, SimpleDto>(poco);
dto.Id.ShouldBe(poco.Id);
dto.Name.ShouldBe(poco.Name);
dto.AnotherName.ShouldBe(poco.Name);
dto.LastModified.Ticks.ShouldBeGreaterThan(0);
dto.FileData.Content.ShouldBe("Foo");
}
public void Register(TypeAdapterConfig config)
{
config.NewConfig <Entity.PimsResearchFile, ResearchFileModel>()
.Map(dest => dest.Id, src => src.ResearchFileId)
.Map(dest => dest.Name, src => src.Name)
.Map(dest => dest.RfileNumber, src => src.RfileNumber)
.Map(dest => dest.RoadAlias, src => src.RoadAlias)
.Map(dest => dest.RoadName, src => src.RoadName)
.Map(dest => dest.ResearchFileStatusTypeCode, src => src.ResearchFileStatusTypeCodeNavigation)
.Map(dest => dest.ResearchProperties, src => src.PimsPropertyResearchFiles)
.Inherits <Entity.IBaseAppEntity, BaseAppModel>();
config.NewConfig <ResearchFileModel, Entity.PimsResearchFile>()
.Map(dest => dest.ResearchFileId, src => src.Id)
.Map(dest => dest.Name, src => src.Name)
.Map(dest => dest.RfileNumber, src => src.RfileNumber)
.Map(dest => dest.RoadAlias, src => src.RoadAlias)
.Map(dest => dest.RoadName, src => src.RoadName)
.Map(dest => dest.ResearchFileStatusTypeCodeNavigation, src => src.ResearchFileStatusTypeCode)
.Map(dest => dest.PimsPropertyResearchFiles, src => src.ResearchProperties)
.Inherits <BaseAppModel, Entity.IBaseAppEntity>();
}
public void TestMappingToSelf()
{
var config = new TypeAdapterConfig();
config.NewConfig <Post, Post>()
.Map(nameof(Post.Secret), x => default(string))
.Map(nameof(Post.Dic) + ".Secret", x => default(string));
var p1 = new Post
{
Secret = "Test",
Dic = new Dictionary <string, string>
{
{ "Secret", "test" },
{ "B", "test2" }
}
};
p1.Adapt(p1, config);
p1.Dic["Secret"].ShouldBeNull();
p1.Secret.ShouldBeNull();
}
public void Register(TypeAdapterConfig config)
{
config.NewConfig <Entity.PimsAccessRequestOrganization, Model.AccessRequestOrganizationModel>()
.Map(dest => dest.Id, src => src.OrganizationId)
.Map(dest => dest.Name, src => src.Organization == null ? null : src.Organization.OrganizationName)
.Inherits <Entity.IDisableBaseAppEntity, Models.BaseAppModel>();
config.NewConfig <Model.AccessRequestOrganizationModel, Entity.PimsAccessRequestOrganization>()
.Map(dest => dest.OrganizationId, src => src.Id)
.Inherits <Models.BaseAppModel, Entity.IDisableBaseAppEntity>();
config.NewConfig <Entity.PimsOrganization, Model.AccessRequestOrganizationModel>()
.Map(dest => dest.Id, src => src.Id)
.Map(dest => dest.Name, src => src.OrganizationName)
.Inherits <Entity.IDisableBaseAppEntity, Models.BaseAppModel>();
config.NewConfig <Model.AccessRequestOrganizationModel, Entity.PimsOrganization>()
.Map(dest => dest.Id, src => src.Id)
.Map(dest => dest.OrganizationName, src => src.Name)
.Inherits <Models.BaseAppModel, Entity.IDisableBaseAppEntity>();
}
public IActionResult getMapsterTest()
{
var user = new UserInfo()
{
Id = 1, Name = "cy", Address = "深证保安区"
};
//1.简单直接 Adapt 转换
var destObject1 = user.Adapt <UserInfoDto>();
//2.自定义配置转换
var config = new TypeAdapterConfig();
//映射规则
config.ForType <UserInfo, UserInfoDto>()
.Map(dest => dest.NameDto, src => src.Name)
.Map(dest => dest.AddressDto, src => src.Address)
.NameMatchingStrategy(NameMatchingStrategy.ConvertDestinationMemberName(dest => dest.Replace("User", "")));
var mapper = new Mapper(config);//务必将mapper设为单实例
var dto = mapper.Map <UserInfoDto>(user);
//3.
//映射规则
config.ForType <UserInfo, UserInfoDto>()
.Map(dest => dest.NameDto, src => src.Name)
.Map(dest => dest.AddressDto, src => src.Address)
.IgnoreNullValues(true) //忽略空值映射
.Ignore(dest => dest.NameDto) //忽略指定字段
.IgnoreAttribute(typeof(DataMemberAttribute)) //忽略指定特性的字段
.NameMatchingStrategy(NameMatchingStrategy.IgnoreCase) //忽略字段名称的大小写
.IgnoreNonMapped(true); //忽略除以上配置的所有字段
config.ForType <UserInfo, UserInfoDto>()
.IgnoreMember((member, side) => !member.Type.Namespace.StartsWith("System")); //实现更细致的忽略规则
return(Json("ok"));
}
public void Setup()
{
TypeAdapterConfig <CharacterDto, Character> .NewConfig().ConstructUsing(src => new Character(null, null, null, null, null, null, null, _logger));
TypeAdapterConfig <MapMonsterDto, MapMonster> .NewConfig().ConstructUsing(src => new MapMonster(new List <NpcMonsterDto>(), _logger));
new Mapper();
PacketFactory.Initialize <NoS0575Packet>();
var contextBuilder =
new DbContextOptionsBuilder <NosCoreContext>().UseInMemoryDatabase(
databaseName: Guid.NewGuid().ToString());
DataAccessHelper.Instance.InitializeForTest(contextBuilder.Options);
var map = new MapDto {
MapId = 1
};
_mapDao.InsertOrUpdate(ref map);
var _acc = new AccountDto {
Name = "AccountTest", Password = "******".ToSha512()
};
_accountDao.InsertOrUpdate(ref _acc);
_chara = new Character(null, null, null, _characterRelationDao, _characterDao, _itemInstanceDao, _accountDao, _logger)
{
Name = "TestExistingCharacter",
Slot = 1,
AccountId = _acc.AccountId,
MapId = 1,
State = CharacterState.Active
};
CharacterDto character = _chara;
_characterDao.InsertOrUpdate(ref character);
_session.InitializeAccount(_acc);
_handler = new CharacterScreenPacketController(null, null, new Adapter(), _characterDao, _accountDao, _itemInstanceDao, _mateDao, _logger);
_handler.RegisterSession(_session);
}
public void Register(TypeAdapterConfig config)
{
config.NewConfig <Entity.PimsProperty, Model.PropertyModel>()
.Map(dest => dest.Id, src => src.PropertyId)
.Map(dest => dest.RowVersion, src => src.ConcurrencyControlNumber)
.Map(dest => dest.PID, src => src.ParcelIdentity)
.Map(dest => dest.PIN, src => src.Pin)
.Map(dest => dest.PropertyTypeId, src => src.PropertyTypeCode)
.Map(dest => dest.PropertyType, src => src.PropertyTypeCodeNavigation.Description)
.Map(dest => dest.StatusId, src => src.PropertyStatusTypeCode)
.Map(dest => dest.Status, src => src.PropertyStatusTypeCodeNavigation.Description)
.Map(dest => dest.DataSourceId, src => src.PropertyDataSourceTypeCode)
.Map(dest => dest.DataSource, src => src.PropertyDataSourceTypeCodeNavigation.Description)
.Map(dest => dest.DataSourceEffectiveDate, src => src.PropertyDataSourceEffectiveDate)
.Map(dest => dest.ClassificationId, src => src.PropertyClassificationTypeCode)
.Map(dest => dest.Classification, src => src.PropertyClassificationTypeCodeNavigation.Description)
.Map(dest => dest.Tenure, src => String.Join(", ", src.PimsPropPropTenureTypes.Select(tt => tt.PropertyTenureTypeCodeNavigation.Description)))
.Map(dest => dest.Name, src => src.Name)
.Map(dest => dest.Description, src => src.Description)
.Map(dest => dest.IsSensitive, src => src.IsSensitive)
.Map(dest => dest.AreaUnitId, src => src.PropertyAreaUnitTypeCode)
.Map(dest => dest.AreaUnit, src => src.PropertyAreaUnitTypeCodeNavigation.Description)
.Map(dest => dest.LandArea, src => src.LandArea)
.Map(dest => dest.LandLegalDescription, src => src.LandLegalDescription)
.Map(dest => dest.Zoning, src => src.Zoning)
.Map(dest => dest.ZoningPotential, src => src.ZoningPotential)
.Map(dest => dest.Latitude, src => src.Location.Coordinate.Y)
.Map(dest => dest.Longitude, src => src.Location.Coordinate.X)
.Map(dest => dest.AddressId, src => src.AddressId)
.Map(dest => dest.Address, src => src.Address)
.Map(dest => dest.RegionId, src => src.RegionCode)
.Map(dest => dest.Region, src => src.RegionCodeNavigation != null ? src.RegionCodeNavigation.RegionName : null)
.Map(dest => dest.DistrictId, src => src.DistrictCode)
.Map(dest => dest.District, src => src.DistrictCodeNavigation != null ? src.DistrictCodeNavigation.DistrictName : null);
}
public AmoCRMtoDomain(TypeAdapterConfig config)
{
config.NewConfig <ContactDTO, Contact>()
.Ignore(dest => dest.ChangeValueDelegate)
.Map(dest => dest.Leads, src => src.Leads != null ? src.Leads.IDs.Select(c => new Lead {
Id = c
}) : null)
.Map(dest => dest.Company, src => src.Company != null ? new Company {
Id = src.Company.Id.Value
} : null)
.Map(dest => dest.Fields, src => src.CustomFields != null ? src.CustomFields : null)
;
config.NewConfig <Contact, ContactDTO>()
.Map(dest => dest.Leads, src => src.Leads)
.Map(dest => dest.CustomFields, src => src.Fields)
.IgnoreIf((src, dest) => src.Leads == null, dest => dest.Leads);
;
config.NewConfig <List <Lead>, LeadsField>()
.Map(dest => dest.IDs, src => src.Select(x => x.Id))
;
config.NewConfig <LeadDTO, Lead>()
.Map(dest => dest.Company, src => src.Company != null ? new Company {
Id = (int)src.Company.Id
} : null)
.Map(dest => dest.Contacts, src => src.Contacts != null ? src.Contacts.IDs.Select(c => new Contact {
Id = c
}) : null)
.Map(dest => dest.MainContact, src => src.MainContact != null ? new Contact {
Id = (int)src.MainContact.Id
} : null)
.Map(dest => dest.Fields, src => src.CustomFields ?? null)
;
}
public static TypeAdapterConfig CreateMap()
{
TypeAdapterConfig config = new TypeAdapterConfig();
config.NewConfig <Kind, KindResponse>()
.MaxDepth(1)
.Map(dest => dest.KindId, src => src.Id)
.TwoWays();
config.NewConfig <AddKindRequest, Kind>()
.MaxDepth(1)
.Map(dest => dest.Name, src => src.KindName)
.TwoWays();
//config.NewConfig<Genre, GetGenreRequest>();
config.NewConfig <Genre, GenreResponse>()
.MaxDepth(1)
.Map(dest => dest.GenreId, src => src.Id)
.TwoWays();
config.NewConfig <AddGenreRequest, Genre>()
.MaxDepth(1)
.Map(dest => dest.Name, src => src.GenreName)
.TwoWays();
//config.NewConfig<AddVideoRequest, Video>();
//config.NewConfig<EditVideoRequest, Video>();
config.NewConfig <Video, VideoResponse>()
.MaxDepth(2)
.TwoWays();
config.Compile();
return(config);
}
static void Main(string[] args)
{
var simpleInfo = new SimpleInfo()
{
Id = 1,
Name = "test"
};
var simpleBiz = simpleInfo.Adapt <Simple>();
//Simple simpleBiz = new Simple();
//simpleInfo.Adapt(simpleBiz);
var config = new TypeAdapterConfig();
var assemblies = GetAssemblies();
//映射规则
config.Scan(assemblies);
var mapper = new Mapper(config); //务必将mapper设为单实例, 保存到IOC容器中
var simple = mapper.Map <Simple>(simpleInfo);
var view = mapper.Map <SimpleView>(simple);
var info = new UserInfo()
{
Age = 8,
like = "fasf",
Name = "Nestor",
Sex = "Male"
};
var dto = mapper.Map <User>(info);
var userView = mapper.Map <UserView>(dto);
}
public CompileContext(TypeAdapterConfig config)
{
this.Config = config;
}
public void Register(TypeAdapterConfig config)
{
config.ForType<Person, PersonDTO>();
}
public void Adapt_With_Destination_Type_And_Config_Succeeds()
{
var config = new TypeAdapterConfig();
config.ForType<Product, ProductDTO>();
var product = new Product {Id = Guid.NewGuid(), Title = "ProductA", CreatedUser = new User {Name = "UserA"}};
var dto = product.Adapt<ProductDTO>(config);
dto.ShouldNotBeNull();
dto.Id.ShouldBe(product.Id);
}