public void Map_InterfaceToCollection_Success()
{
TinyMapper.Bind <Source3, Target3>();
var source = new Source3
{
List = new List <int> {
1, 2, 3
}
};
var actual = TinyMapper.Map <Target3>(source);
Assert.Equal(source.List, actual.List);
}
public ActionResult Edit(int pokemonId = 0)
{
PokemonSpecy pokemonEntity = _pokemonSpeciesService.FindPokemonSpeciesById(pokemonId);
TinyMapper.Bind <PokemonSpecy, PokemonSpeciesViewModel>();
PokemonSpeciesViewModel model = TinyMapper.Map <PokemonSpeciesViewModel>(pokemonEntity);
List <PokemonType> pokemonTypeList = _pokemonTypesService.GetAllTypes();
model.Types = pokemonTypeList.Select(e => new PokemonTypeViewModel()
{
ID = e.ID, Name = e.Name
}).ToList();
return(View(model));
}
public Sals UpdateSalValue(NistSalModel updateValue, int assessmentid)
{
TinyMapper.Bind <NistSalModel, NIST_SAL_INFO_TYPES>(config =>
{
config.Ignore(x => x.Assessment_Id);
});
using (CSET_Context db = new CSET_Context())
{
NIST_SAL_INFO_TYPES update = db.NIST_SAL_INFO_TYPES.Where(x => x.Assessment_Id == assessmentid && x.Type_Value == updateValue.Type_Value).FirstOrDefault();
TinyMapper.Map <NistSalModel, NIST_SAL_INFO_TYPES>(updateValue, update);
db.SaveChanges();
return(CalculateOveralls(assessmentid, db));
}
}
public Sals SaveNistQuestions(int assessmentid, NistQuestionsAnswers answer)
{
using (CSET_Context db = new CSET_Context())
{
var dbAnswer = db.NIST_SAL_QUESTION_ANSWERS.Where(x => x.Assessment_Id == assessmentid && x.Question_Id == answer.Question_Id).FirstOrDefault();
if (dbAnswer == null)
{
throw new ApplicationException(String.Format("Question {0} could not be found for assessment {1}!", answer.Question_Number, assessmentid));
}
TinyMapper.Bind <NistQuestionsAnswers, NIST_SAL_QUESTION_ANSWERS>();
TinyMapper.Map <NistQuestionsAnswers, NIST_SAL_QUESTION_ANSWERS>(answer, dbAnswer);
db.SaveChanges();
return(CalculateOveralls(assessmentid, db));
}
}
public void Map_Hierarchy_Success()
{
TinyMapper.Bind <Source, Target>();
var source = new Source
{
Id = 1,
String = "tiny"
};
var actual = TinyMapper.Map <Target>(source);
Assert.Equal(source.Id, actual.Id);
Assert.Equal(source.String, actual.String);
}
public List <GenSalPairs> GetGeneralSalDescriptionsWeights()
{
int assessmentid = Auth.AssessmentForUser();
//TODO: make this async
TinyMapper.Bind <GENERAL_SAL_DESCRIPTIONS, GeneralSalDescriptionsWeights>();
TinyMapper.Bind <GEN_SAL_WEIGHTS, GenSalWeights>();
List <GenSalPairs> result = new List <GenSalPairs>();
var sliders = from d in db.GENERAL_SAL_DESCRIPTIONS
from g in db.GENERAL_SAL.Where(g => g.Assessment_Id == assessmentid && g.Sal_Name == d.Sal_Name).DefaultIfEmpty()
orderby d.Sal_Order
select new GenSalCategory
{
d = d,
SliderValue = (int?)g.Slider_Value
};
bool first = true;
GenSalPairs pair = null;
foreach (var slider in sliders.ToList())
{
GeneralSalDescriptionsWeights s = TinyMapper.Map <GeneralSalDescriptionsWeights>(slider.d);
if (first)
{
pair = new GenSalPairs();
pair.OnSite = s;
result.Add(pair);
}
else
{
pair.OffSite = s;
}
first = !first;
s.values = new List <string>();
s.Slider_Value = slider.SliderValue ?? 0;
foreach (GEN_SAL_WEIGHTS w in db.GEN_SAL_WEIGHTS.Where(x => String.Equals(x.Sal_Name, slider.d.Sal_Name)))
{
s.GEN_SAL_WEIGHTS.Add(TinyMapper.Map <GenSalWeights>(w));
s.values.Add(" " + w.Display + " ");
}
}
return(result);
}
protected override void RegisterMappings(ContainerBuilder builder)
{
TinyMapper.Bind <Device, DeviceModel>(cfg =>
{
cfg.Bind(souruce => souruce.Id, target => target.DeviceId);
cfg.Bind(source => source.DeviceName, target => target.Name);
cfg.Bind(source => source.Description, target => target.Description);
});
TinyMapper.Bind <DeviceModel, Device>(cfg =>
{
cfg.Bind(souruce => souruce.DeviceId, target => target.Id);
cfg.Bind(source => source.Name, target => target.DeviceName);
cfg.Bind(source => source.Description, target => target.Description);
});
//TypeDescriptor.AddAttributes(typeof(SomeDummyType), new TypeConverterAttribute(typeof(SomeDummyTypeConverter)));
}
private static void MeasureTinyMapper()
{
Person person = Person.Create();
TinyMapper.Bind <Person, PersonDto>();
Stopwatch stopwatch = Stopwatch.StartNew();
for (int i = 0; i < Iterations; i++)
{
var personDto = TinyMapper.Map <PersonDto>(person);
}
stopwatch.Stop();
Console.WriteLine("TinyMapper: {0}ms", stopwatch.Elapsed.TotalMilliseconds);
}
public void Map_MultiTarget()
{
TinyMapper.Bind <SourceName, TargetName>(config =>
{
config.Bind(s => s.CName, t => t.C2Name1);
config.Bind(s => s.CName, t => t.C2Name2);
});
var result = TinyMapper.Map <TargetName>(new SourceName
{
CName = "7788"
});
Assert.Equal("7788", result.C2Name1);
Assert.Equal("7788", result.C2Name2);
}
public void Test()
{
var fromDatabase = new List <Survey>
{
new Survey {
Id = 1, Data = "Data1"
},
new Survey {
Id = 2, Data = "Data2"
}
};
TinyMapper.Bind <List <Survey>, List <SurveyDto> >();
var dto = TinyMapper.Map <List <SurveyDto> >(fromDatabase);
}
public Customer AddEditCustomer(Customer customer)
{
TinyMapper.Bind <Customer, Customer>();
var cust = Customers.FirstOrDefault(x => x.CustomerId == customer.CustomerId);
cust = TinyMapper.Map <Customer>(customer);
Customers[cust.CustomerId] = cust;
return(cust);
//var exists = Customers.Exists(x => x.CustomerId == customer.CustomerId);
//if (exists)
//{
// var cust = Customers.First(x => x.CustomerId == customer.CustomerId);
// cust
//}
}
public List <Importance> GetImportance()
{
int assessmentId = Auth.AssessmentForUser();
TinyMapper.Bind <IMPORTANCE, Importance>();
List <Importance> rlist = new List <Importance>();
using (CSET_Context context = new CSET_Context())
{
foreach (IMPORTANCE import in context.IMPORTANCE)
{
rlist.Add(TinyMapper.Map <IMPORTANCE, Importance>(import));
}
}
return(rlist);
}
public async Task <IActionResult> AddUser([FromBody] Good good)
{
if (good != null)
{
TinyMapper.Bind <Good, web_store.BL.Model.Good>();
var newGood = TinyMapper.Map <web_store.BL.Model.Good>(good);
await goodService.AddGood(newGood);
return(Ok(good));
}
else
{
return(BadRequest());
}
}
public void SimpleQueryMappedTransaction()
{
var context = new DashboardDataContext();
TinyMapper.Bind <User, UserDTO>();
IRepository <User> userRepo = new Repository <User>(context);
using (var scope = new TransactionScope())
{
var user = userRepo.Entity.ByName("Nate", null).ToDto().ToList();
Assert.IsNotNull(user);
scope.Complete();
}
}
public static void AddMappings()
{
TinyMapper.Bind <User, UserModel>();
TinyMapper.Bind <UserModel, User>();
TinyMapper.Bind <Book, BookModel>();
TinyMapper.Bind <BookModel, Book>();
TinyMapper.Bind <CreateBookModel, Book>();
TinyMapper.Bind <Page, PageModel>();
TinyMapper.Bind <CreatePageModel, Page>();
TinyMapper.Bind <Activity, ActivityModel>();
TinyMapper.Bind <CreateActivityModel, Activity>();
}
public void Map_To_IEnumerable_Success()
{
var target = new PersonComplex
{
Emails = new[] { "*****@*****.**", "*****@*****.**" },
FirstName = "John",
LastName = "Doe"
};
TinyMapper.Bind <PersonComplex, PersonComplexTarget4>();
var actual = TinyMapper.Map <PersonComplexTarget4>(target);
Assert.Equal(target.FirstName, actual.FirstName);
Assert.Equal(target.LastName, actual.LastName);
Assert.Equal(target.Emails, actual.Emails.Cast <string>());
}
public void Map_Arrays_Success()
{
TinyMapper.Bind <Source1, Target1>();
var source = new Source1
{
Ints = new[] { 0, 1 },
Bools = new[] { true },
Strings = new[] { "Nelibur", "TinyMapper" }
};
var target = TinyMapper.Map <Target1>(source);
Assert.Equal(target.Ints, source.Ints);
Assert.Equal(target.Bools, source.Bools);
Assert.Equal(target.Strings, source.Strings);
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
// Add framework services.
services.AddMvc();
// TinyMapper binding configuration
TinyMapper.Bind <Item, ItemViewModel>();
// Add EntityFramework's Identity support.
services.AddEntityFramework();
// Add ApplicationDbContext.
services.AddDbContext <ApplicationDbContext>(options =>
options.UseSqlServer(Configuration["Data:DefaultConnection:ConnectionString"]));
// Add ApplicationDbContext's DbSeeder
services.AddSingleton <DbSeeder>();
}
public void Map_Dictionary_Success()
{
TinyMapper.Bind <Source1, Target1>();
var source = new Source1
{
Id = Guid.NewGuid(),
Dictionary = new Dictionary <string, int> {
{ "Key1", 1 }, { "Key2", 2 }
}
};
var target = TinyMapper.Map <Target1>(source);
Assert.Equal(source.Id, target.Id);
Assert.Equal(source.Dictionary, target.Dictionary);
}
/// <summary>
/// The configure.
/// </summary>
public void Configure()
{
// character information mappings
TinyMapper.Bind <Character, CharacterInformation>(config =>
{
config.Bind(source => source.Created, target => target.Birthday);
});
// character inventory mappings
TinyMapper.Bind <Inventory, CharacterInventory>();
// ItemDescription mappings
TinyMapper.Bind <Item, ItemDescription>(config =>
{
config.Bind(source => source.Icon, target => target.IconUrl);
});
}
public void Map_Collections_Success()
{
TinyMapper.Bind <Source1, Target1>();
var source = new Source1
{
Items = new List <Item1>
{
new Item1
{
Int = 1,
String = "2",
List = new List <int> {
1, 2, 3
},
Bools = new[] { true, false }
},
new Item1
{
Int = 2,
String = "3",
List = new List <int> {
2, 3
},
Bools = new[] { false, false }
}
}
};
// DynamicAssemblyBuilder.Get().Save();
var actual = TinyMapper.Map <Target1>(source);
Assert.Equal(source.Items.Count, actual.Items.Count);
Assert.Equal(source.Items1, actual.Items1);
for (int i = 0; i < source.Items.Count; i++)
{
Item1 expectedItem = source.Items[i];
Item2 actualItem = actual.Items[i];
Assert.Equal(expectedItem.Bools, actualItem.Bools);
Assert.Equal(expectedItem.Int, actualItem.Int);
Assert.Equal(expectedItem.List, actualItem.List);
Assert.Equal(expectedItem.String, actualItem.String);
}
}
/// <summary>
/// Returns a list of individuals assigned to findings/observations.
/// </summary>
/// <returns></returns>
public List <Individual> GetFindingIndividuals()
{
using (var db = new CSET_Context())
{
var findings = (from a in db.FINDING_CONTACT
join b in db.FINDING on a.Finding_Id equals b.Finding_Id
join c in db.ANSWER on b.Answer_Id equals c.Answer_Id
join d in db.ASSESSMENT_CONTACTS on a.Assessment_Contact_Id equals d.Assessment_Contact_Id
join i in db.IMPORTANCE on b.Importance_Id equals i.Importance_Id
where c.Assessment_Id == assessmentID
orderby a.Assessment_Contact_Id, b.Answer_Id, b.Finding_Id
select new { a, b, d, i.Value }).ToList();
List <Individual> list = new List <Individual>();
int contactid = 0;
Individual individual = null;
foreach (var f in findings)
{
if (contactid != f.a.Assessment_Contact_Id)
{
individual = new Individual()
{
Findings = new List <Findings>(),
INDIVIDUALFULLNAME = Utilities.FormatName(f.d.FirstName, f.d.LastName)
};
list.Add(individual);
}
contactid = f.a.Assessment_Contact_Id;
TinyMapper.Bind <FINDING, Findings>();
Findings rfind = TinyMapper.Map <Findings>(f.b);
rfind.Finding = f.b.Summary;
rfind.ResolutionDate = f.b.Resolution_Date.ToString();
rfind.Importance = f.Value;
var othersList = (from a in f.b.FINDING_CONTACT
join b in db.ASSESSMENT_CONTACTS on a.Assessment_Contact_Id equals b.Assessment_Contact_Id
select Utilities.FormatName(b.FirstName, b.LastName)).ToList();
rfind.OtherContacts = string.Join(",", othersList);
individual.Findings.Add(rfind);
}
return(list);
}
}
public static void Register()
{
TinyMapper.Bind <PacketDevice, Device>();
TinyMapper.Bind <PacketFacility, Facility>();
TinyMapper.Bind <PacketPlan, Plan>(config =>
{
// Couldn't get this to map properly with reflection so just ignore it and set it manually.
config.Ignore(w => w.Spec);
});
TinyMapper.Bind <PacketOperatingSystem, OperatingSystem>();
TinyMapper.Bind <AddDeviceRequest, PacketAddDeviceRequest>(config =>
{
config.Ignore(w => w.ProjectId);
config.Bind(source => source.LocationId, target => target.Facility);
config.Bind(source => source.PlanId, target => target.Plan);
config.Bind(source => source.OperatingSystemId, target => target.OperatingSystem);
});
}
public L7ConversationFacade(IUnitOfWork unitOfWork,
IRepositoryWriterAsync <L7ConversationEntity> repositoryWriterAsync,
IRepositoryReaderAsync <L7ConversationEntity> repositoryReaderAsync,
IRepositoryWriterAsync <L7ConversationPdusShardEntity> pduShardRepositoryWriterAsync,
IRepositoryReaderAsync <L7ConversationPdusShardEntity> pduShardRepositoryReaderAsync)
{
TypeDescriptor.AddAttributes(typeof(IPEndPointEntity), new TypeConverterAttribute(typeof(IPEndPointEntityConverter)));
TinyMapper.Bind <L7ConversationEntity, L7ConversationListDTO>();
TinyMapper.Bind <L7ConversationEntity, L7ConversationDetailDTO>();
TinyMapper.Bind <L7ConversationEntity, L7ConversationProcessingDTO>();
TinyMapper.Bind <L7PduEntity, L7PduDTO>();
this._unitOfWork = unitOfWork;
this._repositoryReaderAsync = repositoryReaderAsync;
this._repositoryWriterAsync = repositoryWriterAsync;
this._pduShardRepositoryReaderAsync = pduShardRepositoryReaderAsync;
this._pduShardRepositoryWriterAsync = pduShardRepositoryWriterAsync;
}
private static void MapPerson()
{
TinyMapper.Bind <Person, PersonDto>();
var person = new Person
{
Id = Guid.NewGuid(),
FirstName = "John",
LastName = "Doe",
Email = "*****@*****.**",
Address = "Wall Street",
CreateTime = DateTime.Now,
Nickname = "Object Mapper",
Phone = "Call Me Maybe"
};
var personDto = TinyMapper.Map <PersonDto>(person);
}
public void Map_BindCaseSensitive_Success()
{
TinyMapper.Bind <SourceItem, TargetItem>();
TinyMapper.Bind <Source1, Target1>(config =>
{
config.Bind(from => from.CaseSensitive, to => to.Casesensitive);
});
var source = new Source1
{
CaseSensitive = "CaseSensitive"
};
var actual = TinyMapper.Map <Target1>(source);
Assert.Equal(source.CaseSensitive, actual.Casesensitive);
}
public static void SetUp()
{
TinyMapper.Bind <CustomerDto, Customer>();
TinyMapper.Bind <OrderDto, Order>();
TinyMapper.Bind <EmployeeDto, Employee>();
TinyMapper.Bind <OrderDetailDto, OrderDetail>();
TinyMapper.Bind <ShipperDto, Shipper>();
TinyMapper.Bind <ProductDto, Product>();
TinyMapper.Bind <CategoryDto, Category>();
TinyMapper.Bind <SupplierDto, Supplier>();
TinyMapper.Bind <CustomerDemographicDto, CustomerDemographic>();
TinyMapper.Bind <TerritoryDto, Territory>();
TinyMapper.Bind <RegionDto, Region>();
TinyMapper.Bind <List <CustomerDto>, List <Customer> >();
TinyMapper.Bind <CityDto, City>();
TinyMapper.Bind <List <CityDto>, List <City> >();
}
public void Map_Success()
{
// use custom attributes: 'IgnoreAttribute' and 'BindAttribute'
TinyMapper.Bind <Source, Target>(config =>
{
config.Ignore(x => x.DateTime);
config.Bind(from => from.LegacyString, to => to.LatestString);
config.Bind(from => from.SealedString, to => to.ProtectedString);
});
Source source = CreateSource();
var actual = TinyMapper.Map <Target>(source);
Assert.Equal(actual.DateTime, default(DateTime));
Assert.Equal(actual.FirstName, source.FirstName);
Assert.Equal(actual.LatestString, source.LegacyString);
Assert.Equal(actual.ProtectedString, source.SealedString);
}
public ActionResult EditApproved([Bind(Include = "Assets,Segments,Id,CampaignId,ReferenceNumber,OrderNumber,CampaignName,WhiteLabel,ReBroadCast,ReBroadcastDate,FromLine,SubjectLine,HtmlImageFiles,CreativeURL,DeployDate,ZipURL,GeoDetails,Demographics,Quantity,SpecialInstructions,LinkBreakout,ReportSiteLink,CreatedAt,CreatedBy,IsUseApiDataForOpen,IsOpenPixel,OpenPixelUrl,BannerUrl,OpenGoals,ClickGoals,DataFileQuantity,IsOmniOrder,OmniDeployDate,Impressions,ChannelTypes")] CampaignApprovedVm campaignApprovedVm)
{
if (ModelState.IsValid)
{
// Updatin Testing
TinyMapper.Bind <CampaignApprovedVm, CampaignApproved>(config =>
{
config.Ignore(x => x.ChannelTypes);
config.Ignore(x => x.Assets);
config.Ignore(x => x.Segments);
});
var campaignApproved = TinyMapper.Map <CampaignApproved>(campaignApprovedVm);
campaignApproved.ChannelTypes = campaignApprovedVm.ChannelTypes == null ? null :
string.Join(",", campaignApprovedVm.ChannelTypes);
Db.Entry(campaignApproved).State = EntityState.Modified;
Db.SaveChanges();
// Updatin Asssets
var campaignAssets = Db.CampaignAssets.FirstOrDefault(x => x.CampaignId == campaignApprovedVm.CampaignId);
campaignAssets.CreativeFiles = campaignApprovedVm.Assets.CreativeFiles;
campaignAssets.CreativeUrl = campaignApprovedVm.Assets.CreativeUrl;
campaignAssets.ZipCodeFile = campaignApprovedVm.Assets.ZipCodeFile;
campaignAssets.ZipCodeUrl = campaignApprovedVm.Assets.ZipCodeUrl;
campaignAssets.TestSeedFile = campaignApprovedVm.Assets.TestSeedFile;
campaignAssets.LiveSeedFile = campaignApprovedVm.Assets.LiveSeedFile;
Db.Entry(campaignAssets).State = EntityState.Modified;
Db.SaveChanges();
TempData["Success"] = "Approved data saved successfully!";
}
else
{
var errorList = (from item in ModelState.Values
from error in item.Errors
select error.ErrorMessage).ToList();
TempData["Error"] = "There is error in saving data." + string.Join("<br/>", errorList);
}
var proData = VendorsList.FirstOrDefault(x => x.Text.Contains("Pro"));
ViewBag.Vendor = new SelectList(VendorsList, "Value", "Text", proData);
ViewBag.WhiteLabel = new SelectList(CustomersWithWLList, "Value", "Text", campaignApprovedVm.WhiteLabel);
return(View(campaignApprovedVm));
}
public void SimpleCustomHeirarchyMappingTest()
{
// Arrange
SourceB source = new SourceB
{
FirstName = "John",
LastName = "Doe",
Age = 37
};
TinyMapper.Bind <SourceA, TargetA>(n => n.Bind(from => from.FirstName, to => to.Name));
// Act
var target = TinyMapper.Map <TargetA>(source);
// Assert
Assert.NotNull(target);
Assert.Same(source.FirstName, target.Name);
}