/// <summary>
/// Find out if a bidirectional relation exists, if exists then add entity to the collection
/// </summary>
/// <param name="manyToOneType">Many to one relation</param>
/// <param name="childEntityType">Entity type of the child</param>
/// <param name="propertyName">Property name of the ManyToOne realtion</param>
/// <param name="childEntityInfo">Entity info of the child</param>
/// <param name="childMeta">Child metadata</param>
/// <returns>true if the child entity was added or removed from the parent entity collection, otherwise false</returns>
private bool TryToFindAndLinkBidirectionalRelation(ManyToOneType manyToOneType,
EntityType childEntityType, string propertyName,
EntityInfo childEntityInfo, IClassMetadata childMeta)
{
var fk = FindForeignKey(propertyName, childMeta);
var parentMeta = _session.SessionFactory.GetClassMetadata(manyToOneType.ReturnedClass);
var propNames = parentMeta.PropertyNames;
var propTypes = parentMeta.PropertyTypes;
var childPersister = childMeta as AbstractEntityPersister;
if (childPersister == null)
{
return(false);
}
var colProp = new Dictionary <string, string>();
for (var i = 0; i < childPersister.PropertyNames.Length; i++)
{
var propName = childPersister.PropertyNames[i];
var propType = childPersister.GetPropertyType(propName);
if (propType.IsAssociationType)
{
continue;
}
foreach (var col in childPersister.GetPropertyColumnNames(i))
{
if (col == null)
{
continue; // formula
}
if (!colProp.ContainsKey(col))
{
colProp.Add(col, propName);
}
}
}
if (childPersister.IdentifierType.IsComponentType)
{
var componentType = (ComponentType)childPersister.IdentifierType;
for (var i = 0; i < componentType.PropertyNames.Length; i++)
{
colProp.Add(childPersister.IdentifierColumnNames[i], componentType.PropertyNames[i]);
}
}
else
{
foreach (var col in childPersister.IdentifierColumnNames)
{
colProp.Add(col, childPersister.IdentifierPropertyName);
}
}
for (var i = 0; i < propNames.Length; i++)
{
var propType = propTypes[i];
var propName = propNames[i];
if (!propType.IsAssociationType || !propType.IsCollectionType)
{
continue;
}
var colType = (CollectionType)propType;
var refCols = colType.GetReferencedColumns(_session.GetSessionImplementation().Factory);
var refProps = refCols.Select(refCol => !colProp.ContainsKey(refCol) ? refCol : colProp[refCol]).ToArray();
if (NHMetadataBuilder.CatColumnNames(refProps) != fk)
{
continue;
}
var elmType = colType.GetElementType(_session.GetSessionImplementation().Factory);
if (!elmType.ReturnedClass.IsAssignableFrom(childMeta.MappedClass))
{
continue;
}
var parentEntity = GetRelatedEntity(propertyName, childEntityType, childEntityInfo, childMeta);
if (parentEntity == null)
{
return(false);
}
var coll = parentMeta.GetPropertyValue(parentEntity, propName) as IEnumerable;
if (coll == null) //Should happen only if the parent entity is not in db
{
//TODO: instantiate collection
continue;
}
var collType = coll.GetType();
//Initialize collection in order to prevent flushing
if (!NHibernateUtil.IsInitialized(coll))
{
NHibernateUtil.Initialize(coll);
}
if (colType.ReturnedClass.IsGenericType)
{
var state = childEntityInfo.EntityState;
if (_saveMap.ContainsKey(manyToOneType.ReturnedClass))
{
var parentEntityInfo =
_saveMap[manyToOneType.ReturnedClass].FirstOrDefault(o => o.Entity == parentEntity);
if (parentEntityInfo != null)
{
switch (parentEntityInfo.EntityState)
{
case EntityState.Added:
//if the parent is added then we need to add child to the collection even if the it is only updated or unmodified
if (state != EntityState.Deleted)
{
state = EntityState.Added;
}
break;
case EntityState.Deleted:
//TODO: check for cascade option
break;
case EntityState.Modified:
break;
}
}
}
//TODO: check if parent is new
switch (state)
{
case EntityState.Deleted:
var removeMethod = collType.GetMethod("Remove") ??
collType.GetInterfaces()
.Select(o => o.GetMethod("Remove"))
.FirstOrDefault(o => o != null);
var removed = false;
if (removeMethod != null)
{
IEqualityComparer comparer = new EntityComparer(childMeta);
foreach (var item in coll)
{
if (comparer.Equals(item, childEntityInfo.Entity))
{
removed = (bool)removeMethod.Invoke(coll, new[] { item });
break;
}
}
}
childMeta.SetPropertyValue(childEntityInfo.Entity, propertyName, null); //Remove relation on both sides
return(removed);
case EntityState.Added:
var addMethod = collType.GetMethod("Add") ??
collType.GetInterfaces()
.Select(o => o.GetMethod("Add"))
.FirstOrDefault(o => o != null);
if (addMethod != null)
{
addMethod.Invoke(coll, new[] { childEntityInfo.Entity });
return(true);
}
break;
}
}
//TODO: non generic collections
}
return(false);
}
public ActionResult SendEmailtoIT(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
T_Employee t_employee = null;
if (db != null)
{
t_employee = db.T_Employees.Find(id);
t_employee.setDateTimeToClientTime();
if (t_employee == null)
{
return(HttpNotFound());
}
}
//db is null for 'invoke action' business rule, set your own context here and find object - todo
//db.Entry(t_employee).State = EntityState.Modified; //change state if only you want to modify t_employee object
string emailTo = "*****@*****.**";
string subject = "WSH Update";
string msgDetails = "";
string style = "";
msgDetails = EntityComparer.EnumeratePropertyValues <T_Employee>(t_employee, "T_Employee", new string[] { "T_SSN", "T_DateOfBirth", "T_CurrentEmployeePayDetailsID", "T_CurrentEmployeeEmploymentProfileID", "T_CurrentEmployeeJobAssignmentID" });
msgDetails = msgDetails.Replace("</table></div>", "");
//current service record
style = "background-color: #ffffff; color: black;";
msgDetails += "<tr style=\"" + style + "\"><td width=200>" + ("Employee Type" + " </td><td> " + t_employee.t_currentemployeeemploymentprofile.t_employmentrecordemployeetype.DisplayValue + "</td></tr>");
style = "background-color: #eeeeee; color: black;";
msgDetails += "<tr style=\"" + style + "\"><td width=200>" + ("Hired At Facility" + " </td><td> " + t_employee.t_currentemployeeemploymentprofile.t_employmentrecordhiredatfacility.DisplayValue + "</td></tr>");
style = "background-color: #ffffff; color: black;";
msgDetails += "<tr style=\"" + style + "\"><td width=200>" + ("Hire Date" + " </td><td> " + t_employee.t_currentemployeeemploymentprofile.T_HireDate + "</td></tr>");
style = "background-color: #eeeeee; color: black;";
msgDetails += "<tr style=\"" + style + "\"><td width=200>" + ("Separation Date" + " </td><td> " + t_employee.t_currentemployeeemploymentprofile.T_TerminationDate + "</td></tr>");
//primary job assignment
style = "background-color: #ffffff; color: black;";
msgDetails += "<tr style=\"" + style + "\"><td width=200>" + ("Supervisor" + " </td><td> " + t_employee.t_currentemployeejobassignment.t_employeesupervisor.DisplayValue + "</td></tr>");
style = "background-color: #eeeeee; color: black;";
msgDetails += "<tr style=\"" + style + "\"><td width=200>" + ("Manager" + " </td><td> " + t_employee.t_currentemployeejobassignment.t_jobassignmentmanageremployee.DisplayValue + "</td></tr>");
style = "background-color: #ffffff; color: black;";
msgDetails += "<tr style=\"" + style + "\"><td width=200>" + ("Position Level" + " </td><td> " + t_employee.t_currentemployeejobassignment.t_positionjobassignment.DisplayValue + "</td></tr>");
msgDetails += "</table></div>";
SendEmail mail = new SendEmail();
RegisterViewModel usermodel = new RegisterViewModel();
var EmailTemplate = db.EmailTemplates.FirstOrDefault(e => e.associatedemailtemplatetype.DisplayValue == "Business Rule");
if (EmailTemplate != null)
{
string mailbody = string.Empty;
if (!string.IsNullOrEmpty(EmailTemplate.EmailContent))
{
mailbody = EmailTemplate.EmailContent;
mailbody = mailbody.Replace("###Message###", msgDetails);
}
if (!string.IsNullOrEmpty(EmailTemplate.EmailSubject))
{
subject = EmailTemplate.EmailSubject;
}
emailTo = string.Join(",", emailTo.Split(',').Distinct().ToArray());
mail.Notify(usermodel.UserName, emailTo, mailbody, subject);
}
return(Json("Success", "application/json", System.Text.Encoding.UTF8, JsonRequestBehavior.AllowGet));
}
public void CRUD_Test()
{
var repositoryContext = new RepositoryContext();
Account expectedAccount = TestEntities.GetTestAccount(
1,
Guid.Parse("B2A4DF0B-B0B4-46E6-A308-6DFB79909CD3"),
"AccOld");
try
{
// delete test account
TestDataCleaner.DeleteTestAccount(repositoryContext, expectedAccount.AccountId);
// create
repositoryContext.AccountRepository.Upsert(expectedAccount);
// read by id
Account actualAccount = repositoryContext.AccountRepository.Get(expectedAccount.AccountId);
Assert.IsNotNull(actualAccount);
Assert.IsTrue(EntityComparer.AreAccountEqual(expectedAccount, actualAccount));
if (expectedAccount.AccountGuid.HasValue)
{
// read by guid
actualAccount = repositoryContext.AccountRepository.Get(expectedAccount.AccountGuid.Value);
Assert.IsNotNull(actualAccount);
Assert.IsTrue(EntityComparer.AreAccountEqual(expectedAccount, actualAccount));
}
int?actualAccountId;
if (expectedAccount.AccountGuid.HasValue)
{
// read id by guid
actualAccountId = repositoryContext.AccountRepository.GetId(expectedAccount.AccountGuid.Value);
Assert.AreEqual(expectedAccount.AccountId, actualAccountId);
}
// read id by account number
actualAccountId = repositoryContext.AccountRepository.GetId(expectedAccount.AccountNumber);
Assert.AreEqual(expectedAccount.AccountId, actualAccountId);
// update
Account expectedAccountNew =
TestEntities.GetTestAccount(2, expectedAccount.AccountGuid.Value, "AccNew");
repositoryContext.AccountRepository.Upsert(expectedAccountNew);
Assert.AreEqual(expectedAccount.AccountId, expectedAccountNew.AccountId);
Account actualAccountNew = repositoryContext.AccountRepository.Get(expectedAccountNew.AccountId);
Assert.IsNotNull(actualAccountNew);
Assert.IsTrue(EntityComparer.AreAccountEqual(expectedAccountNew, actualAccountNew));
// delete
repositoryContext.AccountRepository.Delete(expectedAccount.AccountId);
// read by id
actualAccount = repositoryContext.AccountRepository.Get(expectedAccount.AccountId);
Assert.IsNull(actualAccount);
if (expectedAccount.AccountGuid.HasValue)
{
// read by guid
actualAccount = repositoryContext.AccountRepository.Get(expectedAccount.AccountGuid.Value);
Assert.IsNull(actualAccount);
// read id by guid
actualAccountId = repositoryContext.AccountRepository.GetId(expectedAccount.AccountGuid.Value);
Assert.IsNull(actualAccountId);
}
// read id by account number
actualAccountId = repositoryContext.AccountRepository.GetId(expectedAccount.AccountNumber);
Assert.IsNull(actualAccountId);
}
finally
{
// delete test account
TestDataCleaner.DeleteTestAccount(repositoryContext, expectedAccount.AccountId);
repositoryContext.Dispose();
}
}
public void Setup()
{
_comparer = new EntityComparer <Log>();
}
public IQuery GenerateInsertQuery(IReadOnlyList <DatabaseKey> keys, IDatabaseTableData tableData)
{
if (keys.Count == 0)
{
return(Queries.Empty());
}
IMultiQuery query = Queries.BeginTransaction();
query.Add(GenerateDeleteQuery(tableData.TableDefinition, keys));
if (tableData.Entities.Count == 0)
{
return(query.Close());
}
var columns = tableData.TableDefinition.TableColumns
.Select(c => c.Value)
.Where(col => !col.IsMetaColumn && !col.IsConditionColumn)
.GroupBy(columns => columns.ForeignTable ?? tableData.TableDefinition.TableName)
.ToDictionary(g => g.Key, g => g.ToList());
HashSet <EntityKey> entityKeys = new();
Dictionary <string, List <Dictionary <string, object?> > > inserts = new(tableData.Entities.Count);
List <string> duplicates = new List <string>();
var comparer = new EntityComparer(tableData.TableDefinition);
foreach (var entity in tableData.Entities.OrderBy(t => t, comparer))
{
if (!entity.Phantom && !keys.Contains(entity.Key))
{
continue;
}
bool duplicate = tableData.TableDefinition.PrimaryKey != null && !entityKeys.Add(new EntityKey(entity, tableData.TableDefinition));
foreach (var table in columns)
{
bool isDefault = true;
bool isMainTable = table.Key == tableData.TableDefinition.TableName;
var cells = table.Value.ToDictionary(c => c.DbColumnName, c =>
{
var cell = entity.GetCell(c.DbColumnName) !;
if (c.AutogenerateComment != null && cell is DatabaseField <string> sField)
{
var evaluator = new DatabaseExpressionEvaluator(calculatorService, parameterFactory, tableData.TableDefinition, c.AutogenerateComment !);
var comment = evaluator.Evaluate(entity);
if (comment is string s)
{
return(s.AddComment(sField.Current.Value));
}
}
var columnDefinition = tableData.TableDefinition.TableColumns[cell.FieldName];
if (!columnDefinition.CanBeNull && cell.Object is null)
{
return(columnDefinition.Default ?? 0L);
}
if (columnDefinition.CanBeNull && cell.Object is null)
{
return(null);
}
if (!isMainTable && columnDefinition.IsTypeFloat && ((cell.Object == null && columnDefinition.Default != null) || cell.Object != null && !cell.Object.Equals(columnDefinition.Default ?? 0f)))
{
isDefault = false;
}
if (!isMainTable && columnDefinition.IsTypeLong && ((cell.Object == null && columnDefinition.Default != null) || cell.Object != null && !cell.Object.Equals(columnDefinition.Default ?? 0L)))
{
isDefault = false;
}
return(FixUnixTimestampAndNullability(columnDefinition, cell.Object));
});
if (!isMainTable)
{
if (isDefault)
{
continue;
}
var newCells = new Dictionary <string, object?>();
var foreignKeys = tableData.TableDefinition.ForeignTableByName ![table.Key].ForeignKeys;
/// <summary>
/// Updates the resources.
/// </summary>
/// <param name="request">The request.</param>
public static void UpdateResources(CalendarEventUpdateResourcesRequest request)
{
if (request == null)
{
throw new ArgumentNullException("request");
}
ListRequest listRequest = null;
ListResponse listResponse = null;
//Get the event primary key from target
PrimaryKeyId eventId = request.Target.PrimaryKeyId.Value;
//Возможные новые pk
Dictionary <PrimaryKeyId, PrimaryKeyId> primaryKeyMap = null;
List <ResourceActionWrapper> resourceActions = new List <ResourceActionWrapper>();
//Determine update or create actions
foreach (EntityObject entityObject in request.EntityObjects)
{
if (entityObject.MetaClassName == CalendarEventResourceEntity.ClassName)
{
//Assign eventId properties
entityObject[CalendarEventResourceEntity.FieldEventId] = eventId;
listRequest = (ListRequest)EventHelper.ConstructRequest <ListRequest>(entityObject, false);
listRequest.Filters = ConstructFilterByEntity(entityObject);
listResponse = (ListResponse)BusinessManager.Execute(listRequest);
//BusinessManager.List(entityObject.MetaClassName, ConstructFilterByEntity(entityObject));
if (listResponse.EntityObjects.Length != 0)
{
//Update disable
//foreach (EntityObject existEntity in listResponse.EntityObjects)
//{
// entityObject.PrimaryKeyId = existEntity.PrimaryKeyId;
// resourceActions.Add(new ResourceActionWrapper(entityObject, new UpdateRequest()));
//}
}
else
{
resourceActions.Add(new ResourceActionWrapper(entityObject, new CreateRequest()));
}
}
}
//Determine delete action
listRequest = (ListRequest)EventHelper.ConstructRequest <ListRequest>(new CalendarEventResourceEntity(), false);
listRequest.Filters = new FilterElement[] { new FilterElement(CalendarEventResourceEntity.FieldEventId, FilterElementType.Equal, eventId) };
listResponse = (ListResponse)BusinessManager.Execute(listRequest);
foreach (CalendarEventResourceEntity resourceEntity in listResponse.EntityObjects)
{
EntityComparer entityComp = new EntityComparer(resourceEntity, CalendarEventResourceEntity.ComparedProperties);
if (Array.Find <EntityObject>(request.EntityObjects, entityComp.CompareEntity) == null)
{
resourceActions.Add(new ResourceActionWrapper(resourceEntity, new DeleteRequest()));
}
}
//Пытаемся разбить event на exception
if (resourceActions.Count != 0)
{
bool exceptionCreated;
primaryKeyMap = EventHelper.PrepareChangeData((VirtualEventId)eventId, out exceptionCreated);
}
//Execute action
foreach (ResourceActionWrapper resourceAction in resourceActions)
{
//получаем возможно новый pk event
eventId = EventHelper.FindDestiantionId(primaryKeyMap, eventId);
//получаем возможно новый pk resource
if (resourceAction.ResourceEntity.PrimaryKeyId != null)
{
resourceAction.ResourceEntity.PrimaryKeyId = EventHelper.FindDestiantionId(primaryKeyMap,
resourceAction.ResourceEntity.PrimaryKeyId.Value);
}
//записываем возможно изменившийся pk event-a
resourceAction.ResourceEntity[CalendarEventResourceEntity.FieldEventId] = eventId;
//вызываем запросы на модификацию
BusinessManager.Execute(resourceAction.ResourceActionRequest);
}
}
public void CRUD_Test()
{
var repositoryContext = new RepositoryContext();
Account testAccount = TestEntities.GetTestAccount(
1,
Guid.Parse("579526DD-D75C-46E2-8A30-A1D3828F92A5"),
"UserOld");
try
{
// delete test account
TestDataCleaner.DeleteTestAccount(repositoryContext, testAccount.AccountId);
// create account
repositoryContext.AccountRepository.Upsert(testAccount);
// create
User expectedUser = TestEntities.GetTestUser(
1,
Guid.Parse("86641E45-CB9C-4CC3-93EB-E6D26FDC91BE"),
"User",
testAccount.AccountId);
repositoryContext.UserRepository.Upsert(expectedUser);
// read by id
User actualUser = repositoryContext.UserRepository.Get(expectedUser.UserId);
Assert.NotNull(actualUser);
Assert.True(EntityComparer.AreUserEqual(expectedUser, actualUser));
// read by guid
if (expectedUser.UserGuid.HasValue)
{
actualUser = repositoryContext.UserRepository.Get(expectedUser.UserGuid.Value);
Assert.NotNull(actualUser);
Assert.True(EntityComparer.AreUserEqual(expectedUser, actualUser));
}
// read by logon name
actualUser = repositoryContext.UserRepository.Get(expectedUser.LogonName);
Assert.NotNull(actualUser);
Assert.True(EntityComparer.AreUserEqual(expectedUser, actualUser));
int?actualUserId;
// read id by guid
if (expectedUser.UserGuid.HasValue)
{
actualUserId = repositoryContext.UserRepository.GetId(expectedUser.UserGuid.Value);
Assert.Equal(expectedUser.UserId, actualUserId);
}
// read id by logon name
actualUserId = repositoryContext.UserRepository.GetId(expectedUser.LogonName);
Assert.Equal(expectedUser.UserId, actualUserId);
// update
User expectedUserNew = TestEntities.GetTestUser(
2,
expectedUser?.UserGuid.Value ?? null,
"UserNew",
expectedUser.AccountId);
repositoryContext.UserRepository.Upsert(expectedUserNew);
Assert.Equal(expectedUser.UserId, expectedUserNew.UserId);
User actualUserNew = repositoryContext.UserRepository.Get(expectedUserNew.UserId);
Assert.NotNull(actualUserNew);
Assert.True(EntityComparer.AreUserEqual(expectedUserNew, actualUserNew));
// delete
repositoryContext.UserRepository.Delete(expectedUserNew.UserId);
// read by id
actualUser = repositoryContext.UserRepository.Get(expectedUserNew.UserId);
Assert.Null(actualUser);
if (expectedUserNew.UserGuid.HasValue)
{
// read by guid
actualUser = repositoryContext.UserRepository.Get(expectedUserNew.UserGuid.Value);
Assert.Null(actualUser);
}
// read by logon name
actualUser = repositoryContext.UserRepository.Get(expectedUser.LogonName);
Assert.Null(actualUser);
if (expectedUserNew.UserGuid.HasValue)
{
// read id by guid
actualUserId = repositoryContext.UserRepository.GetId(expectedUserNew.UserGuid.Value);
Assert.Null(actualUserId);
}
// read id by logon name
actualUserId = repositoryContext.UserRepository.GetId(expectedUserNew.LogonName);
Assert.Null(actualUserId);
// test by account
// create users
var expectedUsers = new List <User>
{
TestEntities.GetTestUser(
1,
Guid.Parse("5B446BFB-7BCF-4A49-84EA-EB8D738F11DF"),
"User1",
testAccount.AccountId),
TestEntities.GetTestUser(
2,
Guid.Parse("EC15A8F5-941B-4C46-8EDA-83CD5B42E482"),
"User2",
testAccount.AccountId)
};
foreach (User user in expectedUsers)
{
repositoryContext.UserRepository.Upsert(user);
}
// read by account
List <User> actualUsers = repositoryContext.UserRepository.GetByAccount(testAccount.AccountId);
Assert.Equal(expectedUsers.Count, actualUsers.Count);
foreach (User user in expectedUsers)
{
actualUser = actualUsers.Single(ar => ar.UserGuid == user.UserGuid);
Assert.True(EntityComparer.AreUserEqual(user, actualUser));
}
// delete by account
repositoryContext.UserRepository.DeleteByAccount(testAccount.AccountId);
// read by account
actualUsers = repositoryContext.UserRepository.GetByAccount(testAccount.AccountId);
Assert.Empty(actualUsers);
}
finally
{
// delete test account
TestDataCleaner.DeleteTestAccount(repositoryContext, testAccount.AccountId);
repositoryContext.Dispose();
}
}
public void CompareCollectionObjectEqualityTest()
{
var original = new Order
{
Id = Guid.NewGuid().ToString(),
Items = new List <OrderLine>
{
new OrderLine {
Sku = "XYZ-123", Quanity = 1, UnitPrice = 10000
},
new OrderLine {
Sku = "abc-123", Quanity = 1, UnitPrice = 10000
}
}
};
var current = new Order
{
Id = original.Id,
Items = new List <OrderLine>
{
new OrderLine {
Sku = "abc-123", Quanity = 2, UnitPrice = 5000
},
new OrderLine {
Sku = "xyz-123", Quanity = 2, UnitPrice = 5000
}
}
};
var configuration = new Configuration();
configuration.Configure(config => config
.Entity <Order>(e =>
{
e.Collection(p => p.Items)
.CollectionComparison(CollectionComparison.ObjectEquality)
.ElementEquality((o, c) =>
{
var l = o as OrderLine;
var r = c as OrderLine;
return(string.Equals(l?.Sku, r?.Sku, StringComparison.OrdinalIgnoreCase));
});
})
.Entity <OrderLine>(e =>
{
e.Property(p => p.Sku).Equality(StringEquality.OrdinalIgnoreCase);
})
);
var comparer = new EntityComparer(configuration);
var changes = comparer.Compare(original, current);
changes.Should().NotBeNull();
changes.Count.Should().Be(4);
changes[0].Path.Should().Be("Items[0].Quanity");
changes[1].Path.Should().Be("Items[0].UnitPrice");
changes[2].Path.Should().Be("Items[1].Quanity");
changes[3].Path.Should().Be("Items[1].UnitPrice");
WriteMarkdown(changes);
}
public void CompareComplexCompareTest()
{
var original = new Contact
{
Id = Guid.NewGuid().ToString(),
Created = DateTime.Now,
Updated = DateTime.Now,
FirstName = "Jim",
LastName = "Bob",
JobTitle = "CEO",
Status = Status.New,
Roles = new[] { "Administrator", "User" },
Categories = new HashSet <string> {
"Person", "Owner"
},
Data = new Dictionary <string, object>
{
{ "Boost", 1 },
{ "Path", "./home" }
},
EmailAddresses = new List <EmailAddress>
{
new EmailAddress {
Address = "*****@*****.**", Type = ContactType.Business
},
new EmailAddress {
Address = "*****@*****.**", Type = ContactType.Personal
},
},
MailingAddresses = new List <MailingAddress>
{
new MailingAddress
{
Address1 = "123 Main St",
City = "New York",
State = "NY",
Zip = "10026"
}
},
PhoneNumbers = new List <PhoneNumber>
{
new PhoneNumber {
Number = "888-555-1212", Type = ContactType.Business
}
}
};
var current = new Contact
{
Id = original.Id,
Created = original.Created,
Updated = original.Updated.AddSeconds(1),
FirstName = "Jim",
LastName = "Bob",
JobTitle = "CEO",
Status = Status.Verified,
Roles = new[] { "User" },
Categories = new HashSet <string> {
"Person", "Owner", "Blah"
},
Data = new Dictionary <string, object>
{
{ "Boost", 2 },
{ "Path", "./path" }
},
EmailAddresses = new List <EmailAddress>
{
new EmailAddress {
Address = "*****@*****.**", Type = ContactType.Business
},
new EmailAddress {
Address = "*****@*****.**", Type = ContactType.Personal
},
new EmailAddress {
Address = "*****@*****.**", Type = ContactType.Home
},
},
MailingAddresses = new List <MailingAddress>
{
new MailingAddress
{
Address1 = "123 Main St",
City = "New York",
State = "NY",
Zip = "10027"
}
},
PhoneNumbers = new List <PhoneNumber>
{
new PhoneNumber {
Number = "800-555-1212", Type = ContactType.Business
}
}
};
var configuration = new Configuration();
configuration.Configure(config => config
.Entity <Contact>(e =>
{
e.Property(p => p.FirstName).Display("First Name");
e.Collection(p => p.Roles)
.CollectionComparison(CollectionComparison.ObjectEquality)
.ElementEquality(StringEquality.OrdinalIgnoreCase);
e.Collection(p => p.EmailAddresses).ElementFormatter(v =>
{
var address = v as EmailAddress;
return(address?.Address);
});
})
.Entity <EmailAddress>(e =>
{
e.Property(p => p.Address).Display("Email Address");
})
);
var comparer = new EntityComparer(configuration);
var changes = comparer.Compare(original, current);
changes.Should().NotBeNull();
changes.Count.Should().Be(10);
WriteMarkdown(changes);
}
public void CRUD_Test()
{
var repositoryContext = new RepositoryContext();
Account testAccount = TestEntities.GetTestAccount(
1,
Guid.Parse("64651A7C-CB82-4F45-92CA-397AD8519D75"),
"AccRole");
try
{
// delete test account
TestDataCleaner.DeleteTestAccount(repositoryContext, testAccount.AccountId);
// create account
repositoryContext.AccountRepository.Upsert(testAccount);
// create
AccountRole expectedAccountRole = TestEntities.GetTestAccountRole(
1,
Guid.Parse("7B46F4DD-1E5E-47F9-ADBB-A37A60B1BAB2"),
testAccount.AccountId,
"AccRoleOld");
repositoryContext.AccountRoleRepository.Upsert(expectedAccountRole);
// read by id
AccountRole actualAccountRole =
repositoryContext.AccountRoleRepository.Get(expectedAccountRole.AccountRoleId);
Assert.NotNull(actualAccountRole);
Assert.True(EntityComparer.AreAccountRoleEqual(expectedAccountRole, actualAccountRole));
if (expectedAccountRole.AccountRoleGuid.HasValue)
{
// read by guid
actualAccountRole =
repositoryContext.AccountRoleRepository.Get(expectedAccountRole.AccountRoleGuid.Value);
Assert.NotNull(actualAccountRole);
Assert.True(EntityComparer.AreAccountRoleEqual(expectedAccountRole, actualAccountRole));
}
int?actualAccountRoleId;
if (expectedAccountRole.AccountRoleGuid.HasValue)
{
// read id by guid
actualAccountRoleId =
repositoryContext.AccountRoleRepository.GetId(expectedAccountRole.AccountRoleGuid.Value);
Assert.AreEqual(expectedAccountRole.AccountRoleId, actualAccountRoleId);
}
// read id by account id and role name
actualAccountRoleId = repositoryContext.AccountRoleRepository.GetId(
expectedAccountRole.AccountId,
expectedAccountRole.RoleName);
Assert.AreEqual(expectedAccountRole.AccountRoleId, actualAccountRoleId);
// update
AccountRole expectedAccountRoleNew = TestEntities.GetTestAccountRole(
2,
expectedAccountRole?.AccountRoleGuid.Value ?? null,
expectedAccountRole.AccountId,
"AccRoleNew");
expectedAccountRoleNew.AccountRoleGuid = expectedAccountRole.AccountRoleGuid;
repositoryContext.AccountRoleRepository.Upsert(expectedAccountRoleNew);
Assert.AreEqual(expectedAccountRole.AccountRoleId, expectedAccountRoleNew.AccountRoleId);
AccountRole actualAccountRoleNew =
repositoryContext.AccountRoleRepository.Get(expectedAccountRoleNew.AccountRoleId);
Assert.NotNull(actualAccountRoleNew);
Assert.True(EntityComparer.AreAccountRoleEqual(expectedAccountRoleNew, actualAccountRoleNew));
// delete
repositoryContext.AccountRoleRepository.Delete(expectedAccountRoleNew.AccountRoleId);
// read by id
actualAccountRole = repositoryContext.AccountRoleRepository.Get(expectedAccountRoleNew.AccountRoleId);
Assert.Null(actualAccountRole);
if (expectedAccountRoleNew.AccountRoleGuid.HasValue)
{
// read by guid
actualAccountRole =
repositoryContext.AccountRoleRepository.Get(expectedAccountRoleNew.AccountRoleGuid.Value);
Assert.Null(actualAccountRole);
// read id by guid
actualAccountRoleId =
repositoryContext.AccountRoleRepository.GetId(expectedAccountRoleNew.AccountRoleGuid.Value);
Assert.Null(actualAccountRoleId);
}
// read id by account id and role number
actualAccountRoleId = repositoryContext.AccountRoleRepository.GetId(
expectedAccountRoleNew.AccountId,
expectedAccountRoleNew.RoleName);
Assert.Null(actualAccountRoleId);
// test by account
// create account roles
var expectedAccountRoles = new List <AccountRole>
{
TestEntities.GetTestAccountRole(
1,
Guid.Parse("AF8F597E-82A3-4184-932D-6AA31DA4E6F2"),
testAccount.AccountId,
"AccRole1")
};
foreach (AccountRole accountRole in expectedAccountRoles)
{
repositoryContext.AccountRoleRepository.Upsert(accountRole);
}
// read by account
var actualAccountRoles = new List <AccountRole>
{
repositoryContext.AccountRoleRepository.GetByAccount(testAccount.AccountId)
};
Assert.AreEqual(expectedAccountRoles.Count, actualAccountRoles.Count);
foreach (AccountRole accountRole in expectedAccountRoles)
{
actualAccountRole =
actualAccountRoles.Single(ar => ar.AccountRoleGuid == accountRole.AccountRoleGuid);
Assert.True(EntityComparer.AreAccountRoleEqual(accountRole, actualAccountRole));
}
// delete by account
repositoryContext.AccountRoleRepository.DeleteByAccount(testAccount.AccountId);
// read by account
actualAccountRoles = new List <AccountRole>
{
repositoryContext.AccountRoleRepository.GetByAccount(testAccount.AccountId)
};
Assert.IsEmpty(actualAccountRoles);
}
finally
{
// delete test account
TestDataCleaner.DeleteTestAccount(repositoryContext, testAccount.AccountId);
repositoryContext.Dispose();
}
}
public void CRUD_Test()
{
var repositoryContext = new RepositoryContext();
Account testAccount = TestEntities.GetTestAccount(
1,
Guid.Parse("DA8306F8-B255-4737-925C-AACCA7EB2B87"),
"UserRole");
try
{
// delete test account
TestDataCleaner.DeleteTestAccount(repositoryContext, testAccount.AccountId);
// create account
repositoryContext.AccountRepository.Upsert(testAccount);
// create account roles
AccountRole testAccountRole1 = TestEntities.GetTestAccountRole(
1,
Guid.Parse("FFDEA1D7-78BA-414C-8A7B-A3B09A50DDF2"),
testAccount.AccountId,
"UserRole1");
repositoryContext.AccountRoleRepository.Upsert(testAccountRole1);
AccountRole testAccountRole2 = TestEntities.GetTestAccountRole(
2,
Guid.Parse("B0775CA4-7339-4127-BDF3-440B85F71AC5"),
testAccount.AccountId,
"UserRole2");
repositoryContext.AccountRoleRepository.Upsert(testAccountRole2);
// create user
User testUser = TestEntities.GetTestUser(
1,
Guid.Parse("EE837AA8-D3B8-47D4-B5DF-23E389BCFBA4"),
"UserRole",
testAccount.AccountId);
repositoryContext.UserRepository.Upsert(testUser);
// create
UserRole expectedUserRole = TestEntities.GetTestUserRole(
testUser.UserId,
testAccountRole1.AccountRoleId);
repositoryContext.UserRoleRepository.Add(expectedUserRole);
// read
UserRole actualUserRole = repositoryContext.UserRoleRepository.Get(
expectedUserRole.UserId,
expectedUserRole.AccountRoleId);
Assert.NotNull(actualUserRole);
Assert.True(EntityComparer.AreUserRoleEqual(expectedUserRole, actualUserRole));
// delete
repositoryContext.UserRoleRepository.Delete(expectedUserRole.UserId, expectedUserRole.AccountRoleId);
// read
actualUserRole = repositoryContext.UserRoleRepository.Get(
expectedUserRole.UserId,
expectedUserRole.AccountRoleId);
Assert.Null(actualUserRole);
// test by user
// create user roles
var expectedUserRoles = new List <UserRole>
{
TestEntities.GetTestUserRole(testUser.UserId, testAccountRole1.AccountRoleId),
TestEntities.GetTestUserRole(testUser.UserId, testAccountRole2.AccountRoleId)
};
foreach (UserRole userRole in expectedUserRoles)
{
repositoryContext.UserRoleRepository.Add(userRole);
}
// read by user
List <UserRole> actualUserRoles = repositoryContext.UserRoleRepository.Get(testUser.UserId);
Assert.AreEqual(expectedUserRoles.Count, actualUserRoles.Count);
foreach (UserRole userRole in expectedUserRoles)
{
actualUserRole =
actualUserRoles.Single(
ur => ur.UserId == userRole.UserId && ur.AccountRoleId == userRole.AccountRoleId);
Assert.True(EntityComparer.AreUserRoleEqual(userRole, actualUserRole));
}
// delete by user
repositoryContext.UserRoleRepository.Delete(testUser.UserId);
// read by user
actualUserRoles = repositoryContext.UserRoleRepository.Get(testUser.UserId);
Assert.IsEmpty(actualUserRoles);
}
finally
{
// delete test account
TestDataCleaner.DeleteTestAccount(repositoryContext, testAccount.AccountId);
repositoryContext.Dispose();
}
}
private IQuery GenerateInsertQuery(ICollection <uint> keys, IDatabaseTableData tableData)
{
if (keys.Count == 0)
{
return(Queries.Empty());
}
IMultiQuery query = Queries.BeginTransaction();
query
.Table(tableData.TableDefinition.TableName)
.WhereIn(tableData.TableDefinition.TablePrimaryKeyColumnName, keys.Distinct())
.Delete();
if (tableData.Entities.Count == 0)
{
return(query.Close());
}
var columns = tableData.TableDefinition.TableColumns
.Select(c => c.Value)
.Where(col => !col.IsMetaColumn && !col.IsConditionColumn)
.ToList();
HashSet <EntityKey> entityKeys = new();
List <Dictionary <string, object?> > inserts = new(tableData.Entities.Count);
List <string> duplicates = new List <string>();
var comparer = new EntityComparer(tableData.TableDefinition);
foreach (var entity in tableData.Entities.OrderBy(t => t, comparer))
{
bool duplicate = tableData.TableDefinition.PrimaryKey != null && !entityKeys.Add(new EntityKey(entity, tableData.TableDefinition));
var cells = columns.ToDictionary(c => c.DbColumnName, c =>
{
var cell = entity.GetCell(c.DbColumnName) !;
if (c.AutogenerateComment != null && cell is DatabaseField <string> sField)
{
var evaluator = new DatabaseExpressionEvaluator(calculatorService, parameterFactory, tableData.TableDefinition, c.AutogenerateComment !);
var comment = evaluator.Evaluate(entity);
if (comment is string s)
{
return(s.AddComment(sField.Current.Value));
}
}
return(cell.Object);
});
if (duplicate)
{
duplicates.Add("(" + string.Join(", ", cells.Values) + ")");
}
else
{
inserts.Add(cells);
}
}
query.Table(tableData.TableDefinition.TableName)
.BulkInsert(inserts);
if (duplicates.Count > 0)
{
query.Comment("duplicates, cannot insert:");
foreach (var line in duplicates)
{
query.Comment(line);
}
}
query.Add(BuildConditions(keys, tableData));
return(query.Close());
}
/// <summary>
/// Combine 2 entity comparers so that values will be sorted by <paramref name="first"/>
/// fist, and <paramref name="second"/> second.
/// </summary>
/// <param name="first"></param>
/// <param name="second"></param>
public EntityComparer(EntityComparer first, EntityComparer second)
{
_parameters = new List <SortParameter>(first._parameters);
_parameters.AddRange(second._parameters);
}
private void LoadEntities()
{
_systemComparer = new Logic.SystemComparer(_sourceConnection, _targetConnection);
WorkAsync(new WorkAsyncInfo
{
Message = "Getting Metadata",
Work = (worker, args) =>
{
LogInfo("Start retrieving metadata on Source");
_systemComparer.RetrieveMetadata(ConnectionType.Source, _configuration.IncludeAttributeMetadata, worker.ReportProgress);
//_systemComparer.RetrieveOrganization(ConnectionType.Source, worker.ReportProgress);
_systemComparer.RetrieveForms(ConnectionType.Source, _configuration.IncludeForms, worker.ReportProgress);
_systemComparer.RetrieveViews(ConnectionType.Source, _configuration.IncludeViews, worker.ReportProgress);
LogInfo("Start retrieving metadata on Target");
_systemComparer.RetrieveMetadata(ConnectionType.Target, _configuration.IncludeAttributeMetadata, worker.ReportProgress);
//_systemComparer.RetrieveOrganization(ConnectionType.Target, worker.ReportProgress);
_systemComparer.RetrieveForms(ConnectionType.Target, _configuration.IncludeForms, worker.ReportProgress);
_systemComparer.RetrieveViews(ConnectionType.Target, _configuration.IncludeViews, worker.ReportProgress);
args.Result = _systemComparer;
},
PostWorkCallBack = (args) =>
{
LogInfo("Postprocessing Metadata");
if (args.Error != null)
{
LogError(args.Error.ToString(), args);
MessageBox.Show(args.Error.ToString(), "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
var emds = (Logic.SystemComparer)args.Result;
comparisonListView.Items.Clear();
/*OrganizationComparer orgComparer = new OrganizationComparer();
* MetadataComparison orgComparison = null;
* orgComparison = orgComparer.Compare("Organization", emds._sourceCustomizationRoot.Organizations,
* emds._targetCustomizationRoot.Organizations);*/
if (_configuration.IncludeViews)
{
EntityComparer viewComparer = new EntityComparer();
MetadataComparison viewComparison = viewComparer.Compare("Views",
emds._sourceCustomizationRoot.Views,
emds._targetCustomizationRoot.Views);
AddItem(viewComparison, null);
}
if (_configuration.IncludeForms)
{
EntityComparer formComparer = new EntityComparer();
MetadataComparison formComparison = formComparer.Compare("Forms",
emds._sourceCustomizationRoot.Forms,
emds._targetCustomizationRoot.Forms);
AddItem(formComparison, null);
}
MetadataComparer comparer = new MetadataComparer();
MetadataComparison comparison = comparer.Compare("Entities",
emds._sourceCustomizationRoot.EntitiesRaw,
emds._targetCustomizationRoot.EntitiesRaw);
AddItem(comparison, null);
},
ProgressChanged = e => { SetWorkingMessage(e.UserState.ToString()); }
});
}
/// <summary>
/// Updates the resources.
/// </summary>
/// <param name="request">The request.</param>
public static void UpdateResources(CalendarEventUpdateResourcesRequest request)
{
if (request == null)
throw new ArgumentNullException("request");
ListRequest listRequest = null;
ListResponse listResponse = null;
//Get the event primary key from target
PrimaryKeyId eventId = request.Target.PrimaryKeyId.Value;
//Возможные новые pk
Dictionary<PrimaryKeyId, PrimaryKeyId> primaryKeyMap = null;
List<ResourceActionWrapper> resourceActions = new List<ResourceActionWrapper>();
//Determine update or create actions
foreach (EntityObject entityObject in request.EntityObjects)
{
if(entityObject.MetaClassName == CalendarEventResourceEntity.ClassName)
{
//Assign eventId properties
entityObject[CalendarEventResourceEntity.FieldEventId] = eventId;
listRequest = (ListRequest)EventHelper.ConstructRequest<ListRequest>(entityObject, false);
listRequest.Filters = ConstructFilterByEntity(entityObject);
listResponse = (ListResponse)BusinessManager.Execute(listRequest);
//BusinessManager.List(entityObject.MetaClassName, ConstructFilterByEntity(entityObject));
if(listResponse.EntityObjects.Length != 0)
{
//Update disable
//foreach (EntityObject existEntity in listResponse.EntityObjects)
//{
// entityObject.PrimaryKeyId = existEntity.PrimaryKeyId;
// resourceActions.Add(new ResourceActionWrapper(entityObject, new UpdateRequest()));
//}
}
else
{
resourceActions.Add(new ResourceActionWrapper(entityObject, new CreateRequest()));
}
}
}
//Determine delete action
listRequest = (ListRequest)EventHelper.ConstructRequest<ListRequest>(new CalendarEventResourceEntity(), false);
listRequest.Filters = new FilterElement[] { new FilterElement(CalendarEventResourceEntity.FieldEventId, FilterElementType.Equal, eventId) };
listResponse = (ListResponse)BusinessManager.Execute(listRequest);
foreach (CalendarEventResourceEntity resourceEntity in listResponse.EntityObjects)
{
EntityComparer entityComp = new EntityComparer(resourceEntity, CalendarEventResourceEntity.ComparedProperties);
if(Array.Find<EntityObject>(request.EntityObjects, entityComp.CompareEntity) == null)
{
resourceActions.Add(new ResourceActionWrapper(resourceEntity, new DeleteRequest()));
}
}
//Пытаемся разбить event на exception
if(resourceActions.Count != 0)
{
bool exceptionCreated;
primaryKeyMap = EventHelper.PrepareChangeData((VirtualEventId)eventId, out exceptionCreated);
}
//Execute action
foreach (ResourceActionWrapper resourceAction in resourceActions)
{
//получаем возможно новый pk event
eventId = EventHelper.FindDestiantionId(primaryKeyMap, eventId);
//получаем возможно новый pk resource
if (resourceAction.ResourceEntity.PrimaryKeyId != null)
{
resourceAction.ResourceEntity.PrimaryKeyId = EventHelper.FindDestiantionId(primaryKeyMap,
resourceAction.ResourceEntity.PrimaryKeyId.Value);
}
//записываем возможно изменившийся pk event-a
resourceAction.ResourceEntity[CalendarEventResourceEntity.FieldEventId] = eventId;
//вызываем запросы на модификацию
BusinessManager.Execute(resourceAction.ResourceActionRequest);
}
}
public override void OnActionExecuting(ActionExecutingContext filterContext)
{
//Stores the Request in an Accessible object
var request = filterContext.HttpContext.Request;
string entity = filterContext.ActionDescriptor.ControllerDescriptor.ControllerName;
var RecdId = 0;
if (filterContext.ActionParameters.First().Key.ToUpper() == "ID")
{
RecdId = Convert.ToInt32(filterContext.ActionParameters.First().Value);
}
//Generate an audit
JournalEntry audit = new JournalEntry()
{
UserName = (request.IsAuthenticated) ? filterContext.HttpContext.User.Identity.Name : "Anonymous",
RoleName = (request.IsAuthenticated) ?string.Join(",", ((CustomPrincipal)filterContext.HttpContext.User).userroles) : "Anonymous",
EntityName = entity,
RecordInfo = "<a href=\"" + request.RawUrl.Replace("RenderPartial=True&", "").Replace("EditQuick", "Edit") + "\">" + (RecdId > 0 ? EntityComparer.GetDisplayValueForAssociation(entity, Convert.ToString(RecdId)) : "Click to view") + "</a>",
DateTimeOfEntry = DateTime.UtcNow,
RecordId = RecdId,
Type = string.IsNullOrEmpty(name) ? filterContext.ActionDescriptor.ActionName : name
};
//Stores the Audit in the Database
JournalEntryContext context = new JournalEntryContext();
context.JournalEntries.Add(audit);
context.SaveChanges();
//Finishes executing the Action as normal
base.OnActionExecuting(filterContext);
}
