public void SetUp()
{
Mapper.AddProfile(new FormEventBsonDocumentProfile());
_entityMapper = new EntityMapper(Mapper.Engine);
_mongoDbProxy = new MongoDbProxy();
_collectionName = "DefaultTestCollection";
if (!_mongoDbProxy.CollectionExists(_collectionName))
_mongoDbProxy.CreateCollection(_collectionName);
}
public void map_using_field_as_getter()
{
var record = Substitute.For<IDataRecord>();
record["Id"].Returns("1");
var actual = new FieldGetterProperty();
var sut = new EntityMapper<FieldGetterProperty>("Entities");
sut.Map(record, actual);
actual.Id.Should().Be("1");
}
public void map_using_private_property()
{
var record = Substitute.For<IDataRecord>();
record["Id"].Returns("1");
var actual = new PrivateProperty();
var sut = new EntityMapper<PrivateProperty>("Entities");
sut.Map(record, actual);
actual.GetType().GetProperty("Id",BindingFlags.NonPublic|BindingFlags.Instance).GetValue(actual).Should().Be("1");
}
public void map_using_private_property_setter()
{
var record = Substitute.For<IDataRecord>();
record["Id"].Returns("1");
var actual = new PrivateSetterProperty();
var sut = new EntityMapper<PrivateSetterProperty>("Entities");
sut.Map(record, actual);
actual.Id.Should().Be("1");
}
public void ignore_property_with_no_setter_and_no_field()
{
var record = Substitute.For<IDataRecord>();
record["Id"].Returns("1");
var actual = new NoSetterAndNoField();
var sut = new EntityMapper<NoSetterAndNoField>("Entities");
sut.Map(record, actual);
actual.Id.Should().Be("11");
}
public SeedBase(string SeedVersion, ContentModel db, UmbracoProvider provider)
{
helper = new DataHelper();
mapper = new EntityMapper(helper);
UProvider = provider;
//IMPORTANT: REMOVE Guid.NewGuid() from seed version ID and change it to Guid.Parse(SeedVersion);
SeedVersionID = Guid.Parse(SeedVersion);
Db = db;
if (Db.SeedVersions.Find(SeedVersionID) == null)
{
SeedCanRun = true;
} else
{
SeedCanRun = false;
}
}
public BaseAPIController()
{
// HandleOptions();
IDataHelper helper = new DataHelper();
IEntityMapper mapper = new EntityMapper(helper);
string headerDateTime = "";
string culture = "";
string country = "";
string[] languages = HttpContext.Current.Request.UserLanguages;
if (languages == null || languages.Length == 0)
{
culture = CultureInfo.InvariantCulture.Name;
}
else
{
string language = languages[0].ToLowerInvariant().Trim();
culture = CultureInfo.CreateSpecificCulture(language).Name;
}
if (HttpContext.Current.Request.Headers["UserDateTime"] != null)
{
headerDateTime = HttpContext.Current.Request.Headers["UserDateTime"];
}
else if (HttpContext.Current.Request["UserDateTime"] != null)
{
headerDateTime = HttpContext.Current.Request["UserDateTime"];
}
else
{
headerDateTime = DateTime.Now.Ticks.ToString();
}
UserDateTime = new DateTime(long.Parse(headerDateTime));
UserCulture = new CultureInfo(culture);
Thread.CurrentThread.CurrentCulture.ClearCachedData();
Thread.CurrentThread.CurrentCulture = UserCulture;
Thread.CurrentThread.CurrentUICulture = UserCulture;
_RegionInfo = RegionInfo.CurrentRegion;
}
/// <summary>
/// Gets the master currency.
/// </summary>
/// <param name="shopContext">The shop context.</param>
/// <param name="entityMapper">The entity mapper.</param>
/// <returns>The master currency.</returns>
public static Currency GetMasterCurrency(this ShopContext shopContext, EntityMapper<Item, IEntity> entityMapper)
{
Assert.ArgumentNotNull(shopContext, "shopContext");
Assert.ArgumentNotNull(entityMapper, "entityMapper");
if (!ID.IsID(shopContext.GeneralSettings.MasterCurrency))
{
return null;
}
Item currencyItem = shopContext.Database != null ? shopContext.Database.GetItem(shopContext.GeneralSettings.MasterCurrency) : null;
if (currencyItem == null)
{
return null;
}
IEntity result = Context.Entity.Resolve<Currency>() as IEntity;
entityMapper.Map(currencyItem, result);
return result as Currency;
}
public User UserInfo(Guid userId, Guid tenantId)
{
var queryFilter = new List <QueryFilter>();
queryFilter.Add(new QueryFilter {
FieldName = "TenantId", Operator = "Equal", Value = tenantId.ToString()
});
queryFilter.Add(new QueryFilter {
FieldName = "InternalId", Operator = "Equal", Value = userId.ToString()
});
var queryContext = new QueryContext {
Fields = "FirstName,LastName", Filters = queryFilter, PageSize = 100, PageIndex = 1, MaxResult = 1
};
IEntityResourceManager _iEntityResourceManager = new VPC.Framework.Business.EntityResourceManager.Contracts.EntityResourceManager();
User userinfo = null;
DataTable user = _iEntityResourceManager.GetResult(tenantId, "User", queryContext);
if (user.Rows.Count > 0)
{
userinfo = EntityMapper <User> .Mapper(user);
}
return(userinfo);
}
public ActionResult <NoteListItem> NotePost([FromBody] NoteBase value)
{
if (value == null)
{
throw new ArgumentNullException($"Argument value cannot be null");
}
CU_B_NOTE Item = EntityMapper.CreateEntity <CU_B_NOTE>();
EntityMapper.UpdateEntity(value, Item);
Item.NOTE_DATE = DateTime.Today;
CU_B_NOTE LastNote = DBContext.CU_B_NOTE.Where(E => E.CUSTOMER_CODE == Item.CUSTOMER_CODE && E.NOTE_DATE == Item.NOTE_DATE).OrderByDescending(E => E.NOTE_COUNTER).FirstOrDefault();
Item.NOTE_COUNTER = LastNote != null ? LastNote.NOTE_COUNTER + 1 : 1;
value.SaveData <CU_B_NOTE>(DBContext, Item);
DBContext.CU_B_NOTE.Add(Item);
DBContext.SaveChanges();
return(NoteGet(Item.ROWGUID));
}
public async Task ModifyMemberInfoAsync(Int32 userId, Member member)
{
Check.IfNullOrZero(userId);
Check.IfNullOrZero(member);
await Task.Run(() =>
{
using var mapper = EntityMapper.CreateMapper();
{
try
{
var result = mapper.Update(member, mem => mem.Id == member.Id && mem.UserId == userId);
if (!result)
{
throw new BusinessException("修改桌面应用信息失败");
}
}
catch (System.Exception)
{
throw;
}
}
});
}
public async Task <bool> SaveVideoInfoAsync(CourseVideoDto videoInfo)
{
var video = EntityMapper.Map <CourseVideoDto, Video>(videoInfo);
var coursesection = new CourseSection
{
CourseId = videoInfo.CourseSectionId,
Title = videoInfo.SectionTitle,
Order = videoInfo.Order,
};
_unitOfWork.CoursesRepository.AddCourseSection(coursesection);
await _unitOfWork.SaveWorkAsync();
video.Duration = "5:00";
_unitOfWork.CoursesRepository.AddVideoInfo(video);
if (await _unitOfWork.SaveWorkAsync() > 0)
{
return(true);
}
return(false);
}
public async Task AddNewRoleAsync(Role role)
{
Check.IfNullOrZero(role);
await Task.Run(() =>
{
using var mapper = EntityMapper.CreateMapper();
{
try
{
#region 添加角色
{
mapper.Add(role);
}
#endregion
}
catch (System.Exception)
{
throw;
}
}
});
}
public async Task AddVisitorRecord(VisitorRecord visitorRecord)
{
Check.IfNullOrZero(visitorRecord);
await Task.Run(() =>
{
using var mapper = EntityMapper.CreateMapper();
{
try
{
#region 添加角色
{
mapper.Add(visitorRecord);
}
#endregion
}
catch (System.Exception)
{
throw;
}
}
});
}
public async Task <IEnumerable <CommonRemineEntities.Issue> > GetIssuesAsync(
NameValueCollection filters)
{
var parameters = new NameValueCollection();
foreach (var key in filters.AllKeys)
{
if (ParametersMapping.TryGetValue(key, out string convertedKey))
{
foreach (var value in filters.GetValues(key))
{
parameters.Add(convertedKey, value);
}
}
}
// TODO support multiple values
var redmineIssues = await RedmineManager.GetObjectsAsync <Issue>(parameters);
var issues = EntityMapper.Map <List <CommonRemineEntities.Issue> >(redmineIssues);
return(issues);
}
public TModelDTO[] PutArray(Type requestType, TModelDTO[] data)
{
TModelDTO[] items = data;
var entityMapper = new EntityMapper(DbContext)
{
UserName = UserName, UserId = UserId
};
var dtoMapper = new DTOMapper(DbContext);
var rqEntityType = dtoMapper.GetTypeMaps().FirstOrDefault(x => x.TargetType.Equals(requestType))?.SourceType;
if (rqEntityType == null)
{
return(null);
}
List <TModelDTO> resultItems = new List <TModelDTO>();
foreach (object item in items)
{
object entity = entityMapper.MapTo(item, null, requestType, rqEntityType);
try
{
DbContext.SaveChanges();
}
catch (Exception e)
{
throw e;
}
var dto = dtoMapper.MapTo(entity, requestType) as TModelDTO;
resultItems.Add(dto);
}
items = resultItems.ToArray();
return(items);
}
public List <Role> GetRoles(String roleName, Int32 pageIndex, Int32 pageSize, out Int32 totalCount)
{
using var mapper = EntityMapper.CreateMapper();
{
try
{
var where = FilterFactory.Create <Role>();
if (!String.IsNullOrEmpty(roleName))
{
where.And(w => w.Name.Contains(roleName));
}
#region totalCount
{
totalCount = mapper.Query <Role>().Where(where).Count();
}
#endregion
#region sql
{
return(mapper.Query <Role>().Where(where)
.Select(a => new
{
a.Name,
a.RoleIdentity,
a.Remark,
a.Id
}).ToList());
}
#endregion
}
catch (System.Exception)
{
throw;
}
}
}
public void BuildByDayOfWeek_ShouldMapToMessage()
{
var configuration = new MapperConfiguration(cfg => { cfg.AddProfile <PerDayOfWeekProfile>(); });
var mapper = new Mapper(configuration);
var mapperHelper = new EntityMapper(mapper);
var perDayOfWeekFaker = new Faker <PerDayOfWeekEntity>()
.RuleFor(p => p.Total, f => f.Random.Int(0, 10000))
.RuleFor(p => p.DayOfWeek, f => f.PickRandom <DayOfWeekEnum>())
.RuleFor(p => p.IsIncoming, f => f.Random.Bool())
.RuleFor(p => p.OutgoingTotal, f => f.Random.Int(0, 10000))
.RuleFor(p => p.IncomingTotal, f => f.Random.Int(0, 10000));
// Should have 1 complete day which needs a IsIncoming = true and an IsIncoming = false
var entity = perDayOfWeekFaker.Generate();
var secondEntity = perDayOfWeekFaker.Generate();
secondEntity.IsIncoming = !entity.IsIncoming;
secondEntity.DayOfWeek = entity.DayOfWeek;
var entities = new List <PerDayOfWeekEntity>()
{
entity,
secondEntity
};
var messagesByDayOfWeek = mapperHelper.BuildByDayOfWeek <MessageByDayOfWeek>(entities);
var messageDayOfWeek = messagesByDayOfWeek.First(c => c.DayOfWeek == Enum.GetName(typeof(DayOfWeekEnum), entity.DayOfWeek));
var incomingTotal = entity.IsIncoming ? entity.Total : secondEntity.Total;
var outgoingTotal = entity.IsIncoming ? secondEntity.Total : entity.Total;
Assert.Equal(incomingTotal, messageDayOfWeek.Incoming);
Assert.Equal(outgoingTotal, messageDayOfWeek.Outgoing);
Assert.Equal(incomingTotal + outgoingTotal, messageDayOfWeek.Total);
}
public IHttpActionResult PostInventoryItem([FromBody] ApiInventoryItem inventoryItem)
{
try
{
if (inventoryItem != null && ModelState.IsValid)
{
EntityMapper <ApiInventoryItem, InventoryItem> mapObj = new EntityMapper <ApiInventoryItem, InventoryItem>();
InventoryItem itemObj = new InventoryItem();
itemObj = mapObj.Translate(inventoryItem);
_itemService.SaveInventoryItem(itemObj);
return(CreatedAtRoute("DefaultApi", new { id = inventoryItem.ID }, inventoryItem));
}
else
{
var message = inventoryItem == null ? "Invalid Request" : (string.Join(" | ", ModelState.Values.SelectMany(v => v.Errors).Select(e => e.ErrorMessage)) + string.Join(" | ", ModelState.Values.SelectMany(v => v.Errors).Select(e => e.Exception)));
//return BadRequest(message);
return(Content(HttpStatusCode.BadRequest, message));
}
}
catch (System.Exception)
{
return(InternalServerError());
}
}
public Property OpenBankingToPublic_SimpleMap_V3_1_2_RC1_ToPublic_2(ObModels.PaymentInitiation.V3p1p4.Model.OBPostalAddress6 value)
{
var mapper = new EntityMapper();
Func <bool> rule = () =>
{
var r1 = mapper.Map(value, typeof(OBPostalAddress6)) as
OBPostalAddress6;
return(r1.AddressLine.SequenceEqual(value.AddressLine) &&
r1.BuildingNumber == value.BuildingNumber &&
r1.AddressType.ToString() == value.AddressType.ToString() &&
r1.Country == value.Country &&
r1.CountrySubDivision == value.CountrySubDivision &&
r1.Department == value.Department &&
r1.PostCode == value.PostCode &&
r1.StreetName == value.StreetName &&
r1.SubDepartment == value.SubDepartment &&
r1.TownName == value.TownName);
};
return(rule.When(value != null));
}
/// <summary>
///
/// </summary>
/// <param name="type">Тип отображаемой сущности.</param>
/// <param name="entity">Конкретная сущность, устанавливаемая текущей.</param>
/// <param name="child">Дочерняя сущность для показа</param>
public DataPresenterViewModel(Entity type, object entity, Entity child = Entity.Empty)
{
Entity = type;
if (EntityMapper.Childs(type).Contains(child))
{
ListedEntities = child;
}
else
{
ListedEntities = Entity;
}
// передана конкретная сущность для показа в списке сущностей этого типа
if (entity != null && child == Entity.Empty)
{
// after delete to show near entity
initIndex = ec.FindIndexOfSameEntity(entity, Items);
}
else
{
initIndex = -1;
}
CreateCommands();
}
public async Task <List <Member> > GetMembersAsync(Int32 userId)
{
Check.IfNullOrZero(userId);
return(await Task.Run(() =>
{
using var mapper = EntityMapper.CreateMapper();
{
try
{
return mapper.Query <Member>()
.Where(w => w.UserId == userId)
.Select(a => new
{
a.MemberType,
a.Id,
a.AppId,
a.Name,
a.IconUrl,
a.Width,
a.Height,
a.IsOnDock,
a.IsOpenMax,
a.IsSetbar,
a.DeskIndex,
a.FolderId,
a.IsIconByUpload
}).ToList();
}
catch (System.Exception)
{
throw;
}
}
}));
}
public Event RefreshFlights(string eventId)
{
var dbEvent = _repository.Single(GuidUtil.ToGuid(eventId));
bool isRefreshAllowed = string.IsNullOrEmpty(dbEvent.PNR) &&
(!dbEvent.LastModifiedPricesUtc.HasValue ||
dbEvent.LastModifiedPricesUtc.Value.AddMinutes(30) < DateTime.UtcNow);
if (isRefreshAllowed)
{
dbEvent.LastModifiedPricesUtc = DateTime.UtcNow;
// todo: async
var bitArray = new BitArray(BitConverter.GetBytes(dbEvent.OutboundFlightSearch.DaysOfWeek));
var response = _flightRepository.Search(dbEvent.OutboundFlightSearch.DepartureStation, dbEvent.OutboundFlightSearch.ArrivalStation, dbEvent.OutboundFlightSearch.StartDate, dbEvent.OutboundFlightSearch.EndDate, (short)dbEvent.Participants.Count, bitArray, (short?)dbEvent.OutboundFlightSearch.MaxPrice);
UpdateFlights(dbEvent.OutboundFlightSearch, response.OutboundFlights);
UpdateFlights(dbEvent.InboundFlightSearch, response.InboundFlights);
_dbContext.Current.SaveChanges();
}
return(EntityMapper.Map(dbEvent, includeFlights: true, includeParticipants: false, includeAvailability: false));
}
public void PantryItem_ToDomainModel_ShouldMapNonNullItem()
{
DB.PantryItem dbItem = new DB.PantryItem
{
Id = 1,
Item = new DB.Item(),
Quantity = new Quantity {
Amount = 100, Unit = "ml"
},
BuyDate = DateTime.Parse("6/1/2018"),
ExpirationDate = DateTime.Parse("6/1/2020")
};
PantryItem item = EntityMapper.ToDomainModel(dbItem);
dbItem.Should().NotBeNull();
dbItem.Id.Should().Be(1);
dbItem.Item.Should().NotBeNull();
dbItem.Quantity.Should().NotBeNull();
dbItem.Quantity.Amount.Should().Be(100);
dbItem.Quantity.Unit.Should().Be("ml");
dbItem.BuyDate.Should().Be(DateTime.Parse("6/1/2018"));
dbItem.ExpirationDate.Should().Be(DateTime.Parse("6/1/2020"));
}
public async Task EnableAsync(Int32 userId)
{
Check.IfNullOrZero(userId);
await Task.Run(() =>
{
using var mapper = EntityMapper.CreateMapper();
{
try
{
var user = new User().Enable();
var result = mapper.Update(user, acc => acc.Id == userId);
if (!result)
{
throw new BusinessException("用户启用失败");
}
}
catch (System.Exception)
{
throw;
}
}
});
}
public async Task DeleteAppTypeAsync(Int32 appTypeId)
{
Check.IfNullOrZero(appTypeId);
await Task.Run(() =>
{
using var mapper = EntityMapper.CreateMapper();
try
{
#region 前置条件验证
{
var result = mapper.Query <App>().Where(a => a.AppTypeId == appTypeId).Count();
if (result > 0)
{
throw new BusinessException($@"当前分类下存在应用,不能删除当前分类");
}
}
#endregion
#region 移除应用分类
{
var appType = new AppType();
appType.Remove();
var result = mapper.Update(appType, type => type.Id == appTypeId);
if (!result)
{
throw new BusinessException("移除应用分类失败");
}
}
#endregion
}
catch (System.Exception)
{
throw;
}
});
}
public void SaveAdmin(AdminEntity param)
{
param.Password = HexPassword(param.Password);
using (var context = base.CreateContext())
{
UserInfo pObj;
if (param.RowID == Guid.Empty)
{
context.UserInfoes.Add(pObj = new UserInfo());
EntityMapper.Map <AdminEntity, UserInfo>(param, pObj);
pObj.RowID = Guid.NewGuid();
pObj.LastSignInDate = DateTime.Now;
pObj.LastSignInIP = "127.0.0.1";
}
else
{
pObj = context.UserInfoes.Single(t => t.RowID == param.RowID);
EntityMapper.Map <AdminEntity, UserInfo>(param, pObj);
}
context.SaveChanges();
string roleIDSet = string.Join(",", param.RoleIDs);
context.msp_Assign_User_Role(pObj.RowID, roleIDSet);
}
}
public async Task ModifyAppIconAsync(Int32 userId, Int32 appId, String newIcon)
{
Check.IfNullOrZero(userId);
Check.IfNullOrZero(appId);
Check.IfNullOrZero(newIcon);
await Task.Run(() =>
{
using var mapper = EntityMapper.CreateMapper();
try
{
var app = new App();
app.ModifyIconUrl(newIcon);
var result = mapper.Update(app, a => a.Id == appId && a.UserId == userId);
if (!result)
{
throw new BusinessException("修改应用图标失败");
}
}
catch (System.Exception)
{
throw;
}
});
}
public ActionResult <IEnumerable <CustomerListItem> > ByPhoneNumber(string PhoneNumber)
{
if (string.IsNullOrWhiteSpace(PhoneNumber))
{
throw new ArgumentNullException("PhoneNumber");
}
var predicate = PredicateBuilder.New <CU_B_ADDRESS_BOOK>(false);
predicate = predicate.Or(E => E.CU_B_ADDRESS.Any(A => A.PHONE1 == PhoneNumber));
predicate = predicate.Or(E => E.CU_B_ADDRESS.Any(A => A.PHONE2 == PhoneNumber));
predicate = predicate.Or(E => E.CU_B_ADDRESS.Any(A => A.PHONE3 == PhoneNumber));
predicate = predicate.Or(E => E.CU_B_ADDRESS.Any(A => A.MOBILE == PhoneNumber));
List <CustomerListItem> Result = new List <CustomerListItem>();
foreach (CU_B_ADDRESS_BOOK Item in DBContext.CU_B_ADDRESS_BOOK.Include(E => E.CU_B_ADDRESS).Where(predicate).Take(Settings.Value.MaxQueryResult))
{
CustomerListItem ResultItem = EntityMapper.Map <CustomerListItem, CU_B_ADDRESS_BOOK>(DBContext, Item, Item.CU_B_ADDRESS_BOOK_EXT_AUS);
Result.Add(ResultItem);
}
return(Result);
}
private static MensajeDto ToMensajeDto(Mensaje entity, bool cargarClientes = true, long?clienteId = null)
{
if (entity == null)
{
return(null);
}
MensajeDto dto = new MensajeDto();
EntityMapper.Map(entity, dto);
if (clienteId.HasValue)
{
dto.Leido = entity.MensajeClientes.Where(mc => mc.ClienteId == clienteId).Single().Leido;
}
else
{
dto.MensajesLeidos = entity.MensajeClientes.Where(mc => mc.Leido).Count();
dto.CantClientes = entity.MensajeClientes.Count();
}
if (cargarClientes && entity.MensajeClientes.Count > 0)
{
dto.Clientes = new List <ClienteDto>();
ClienteDto clienteDto = null;
foreach (var mensajeCliente in entity.MensajeClientes)
{
clienteDto = new ClienteDto();
clienteDto.CUIT = mensajeCliente.Cliente.CUIT;
clienteDto.RazonSocial = mensajeCliente.Cliente.RazonSocial;
dto.Clientes.Add(clienteDto);
}
}
return(dto);
}
public int Update <T>(T entity)
{
var mapper = EntityMapper.MapProperties(entity);
var sqlIdPairs = EntityMapper.GetSqlPairs(mapper.IdNames);
var sqlValuePairs = EntityMapper.GetSqlPairs(mapper.ValueNames);
var sql = $@"UPDATE [{typeof(T).Name}]
SET {sqlValuePairs}
WHERE {sqlIdPairs}";
try
{
using (var connection = _context.Connection)
{
connection.Open();
var id = connection.Execute(sql, mapper.AllPairs, commandType: CommandType.Text);
connection.Close();
return(id);
}
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
public ActionResult <List <Language> > Language(bool?isActive = true)
{
List <Language> Result = new List <Language>();
var predicate = PredicateBuilder.New <SY_LANGUAGE>(true);
if (isActive.HasValue)
{
if (isActive.Value)
{
predicate = predicate.And(E => (E.DT_START == null || E.DT_START <= DateTime.Today) && ((E.DT_END == null) || E.DT_END >= DateTime.Today));
}
else
{
predicate = predicate.And(E => !((E.DT_START == null || E.DT_START <= DateTime.Today) && ((E.DT_END == null) || E.DT_END >= DateTime.Today)));
}
}
foreach (SY_LANGUAGE item in DBContext.SY_LANGUAGE.Where(predicate))
{
Language model = EntityMapper.Map <Language, SY_LANGUAGE>(DBContext, item);
Result.Add(model);
}
return(Result);
}
public async Task ReadNotify(IList <Int32> notifyIds)
{
Check.IfNullOrZero(notifyIds);
await Task.Run(() =>
{
using var mapper = EntityMapper.CreateMapper();
{
try
{
var notify = new Notify();
notify.Read();
var result = mapper.Update(notify, n => notifyIds.Contains(n.Id));
if (!result)
{
throw new BusinessException("读取消息失败");
}
}
catch (System.Exception)
{
throw;
}
}
});
}
/// <summary>
/// This method is used in the Template to get the C# Collection type name for the CollectionType of the given reference.
/// </summary>
/// <param name="reference"></param>
/// <returns></returns>
public static string GetCollectionType(DirectedReference reference)
{
switch (GetAssociationType(reference))
{
case AssociationType.None:
//throw new ArgumentException("Reference " + reference.Reference.Name + " does not have an association type for End" + (reference.Entity1IsFromEnd ? "1" : "2"));
return("XXXXXX");
case AssociationType.Map:
// {0} should be the primary key column type, {1} is the entity type.
//return string.Format("System.Collections.Generic.IDictionary<{0}, {1}>",
// GetIndexColumnTypeName(reference, EntityMapper.GetPrimaryTable(reference.FromEntity)),
// reference.FromEntity.Name.GetCSharpFriendlyIdentifier());
return(string.Format("IDictionary<{0}, {1}>",
GetIndexColumnTypeName(reference, EntityMapper.GetPrimaryTable(reference.ToEntity)),
reference.ToEntity.Name));
case AssociationType.List:
case AssociationType.Bag:
//return string.Format("System.Collections.Generic.IList<{0}>", reference.ToEntity.Name.GetCSharpFriendlyIdentifier());
return(string.Format("IList<{0}>", reference.ToEntity.Name));
case AssociationType.Set:
//return string.Format("Iesi.Collections.Generic.ISet<{0}>", reference.ToEntity.Name.GetCSharpFriendlyIdentifier());
return(string.Format("Iesi.Collections.Generic.ISet<{0}>", reference.ToEntity.Name));
//case AssociationType.IDBag:
// Should this also be an IDictionary?
// throw new NotImplementedException("Have not implemented IDBag types yet.");
case AssociationType.IDBag:
return(string.Format("Iesi.Collections.Generic.ISet<{0}>", reference.ToEntity.Name));
default:
throw new NotImplementedException("Collection type not handled yet in GetCollectionType(): " + GetAssociationType(reference));
}
}
public ActionResult SaveMenu(int?menuid)
{
var parentList = _menusTask.GetParentList().ToSelectList(c => c.MenuId.ToString(), c => c.MenuName);
parentList.Insert(0, new SelectListItem {
Text = "根菜单", Value = "0"
});
ViewData["ParentList"] = parentList;
var model = new SaveMenuModel
{
SortOrder = 1,
};
if (menuid != null)
{
var info = _menusTask.GetByMenuId((int)menuid);
if (info != null)
{
model = EntityMapper.Map <AdminMenu, SaveMenuModel>(info);
}
}
return(View(model));
}
public ActionResult Edit(EmployeePassEditModel model, HttpPostedFileBase file)
{
if (!ModelState.IsValid)
{
return(View(model));
}
if (file != null)
{
model.PhotoPath = SaveFileAndGetUrl(file);
}
var result = _employeePassService.Update(EntityMapper.MapEditModelToDto(model));
if (result.IsFailed)
{
TempData[ErrorMessage] = result.Errors;
return(View(model));
}
TempData[SuccessMessage] = $"Пропуск под номером №{result.Data} был изменен";
return(RedirectToAction("Index"));
}
public UmbracoProviderTest()
{
_Helper = new DataHelper();
_Mapper = new EntityMapper(_Helper);
_Provider = UmbracoProvider.GetInstance(_Mapper, "nl-NL");
}
public PrivilegeManagement.Model.Menu Get(int id)
{
var menu = _context.Menus.GetById(id);
return(_context.CreateProxy(EntityMapper.Map <Model.Menu, PrivilegeManagement.Model.Menu>(menu)));
}
public void Setup()
{
Mapper.AddProfile(new FormEventReplaceableAttributesProfile());
_entityMapper = new EntityMapper(Mapper.Engine);
}
public void Properties_and_table_names_are_matched_using_the_given_convention()
{
_row.Add("CHILD ID", 1);
_row.Add("PARENT ID", _guid1);
_row.Add("PARENT NAME", "parent name");
_mapper = new EntityMapper(new ConventionReader(new UpperCaseConvention()));
var instance = _mapper.CreateInstanceGraph<Child>(_row, _childParentRelation);
Assert.IsNotNull(instance.Parent);
Assert.AreEqual(1, instance.Id);
Assert.AreEqual(_guid1, instance.Parent.Id);
Assert.AreEqual("parent name", instance.Parent.Name);
}
public void Setup()
{
Mapper.AddProfile(new FormEventFormEventPostModelProfile());
_entityMapper = new EntityMapper(Mapper.Engine);
}
public void get_keys()
{
var expected = new Ok { FirstName = "Arne", Id = "22" };
var sut = new EntityMapper<Ok>("Users");
sut.Freeze();
var keys = sut.GetKeys(expected);
keys.Length.Should().Be(1);
keys[0].Value.Should().Be(expected.Id);
}
public PrivilegeManagement.Model.Menu Add(PrivilegeManagement.Model.Menu entity)
{
Model.Menu menu = EntityMapper.Map <PrivilegeManagement.Model.Menu, Model.Menu>(entity);
_context.Menus.Create(menu);
return(_context.CreateProxy(entity));
}
public void get_keys_none_is_mapped()
{
var expected = new Empty();
var sut = new EntityMapper<Empty>("Users");
var keys = sut.GetKeys(expected);
keys.Length.Should().Be(0);
}
public void can_create_using_the_generated_factory_method()
{
var sut = new EntityMapper<PrivateDefaultConstructor>("Entities");
var record = Substitute.For<IDataRecord>();
var actual = sut.Create(record);
actual.Should().NotBeNull();
}
public void Creating_instance_with_multiple_values_with_column_name_according_to_convention_sets_corresponding_properties()
{
_mapper = new EntityMapper(new ConventionReader(new UpperCaseConvention()));
_row.Add("NAME", "a name");
_row.Add("ID", _guid1);
var instance = _mapper.CreateInstance<ClassWithoutRelations>(_row);
Assert.AreEqual("a name", instance.Name);
Assert.AreEqual(_guid1, instance.Id);
}
public void only_a_setter_property()
{
var actual = new JustASetter();
var record = Substitute.For<IDataRecord>();
record["Prop"].Returns(10);
var sut = new EntityMapper<JustASetter>("Users");
sut.Map(record, actual);
actual.GetValue().Should().Be(10);
}
public void Setup()
{
Mapper.AddProfile(new PageEventPageEventDataModelProfile());
_entityMapper = new EntityMapper(Mapper.Engine);
}
public void Setup()
{
Mapper.AddProfile(new PageEventBsonDocumentProfile());
_entityMapper = new EntityMapper(Mapper.Engine);
}
public void SetUp()
{
_row = new Row();
_mapper = new EntityMapper(new ConventionReader(new DefaultConvention()));
_parentChildRelation = ObjectRelation.CreateTwoWay<Parent, Child>(x => x.Children, x => x.Parent);
_childParentRelation = ObjectRelation.CreateTwoWay<Parent, Child>(x => x.Children, x => x.Parent);
_childGrandChildRelation = ObjectRelation.CreateTwoWay<Child, GrandChild>(x => x.GrandChildren, x => x.Child);
_idLessRelation = ObjectRelation.CreateTwoWay<ParentWithoutId, ChildWithoutId>(x => x.Children, x => x.Parent);
}
