public void GetRelatedEntity_NotGeneric_RelatedEntitiesDifferentEntity_Test()
{
// Arrange
var odataUser = new OdataObject <User, int>();
var re1 = new RelatedEntity {
Id = "7"
};
var person1 = new Person {
Id = 7, FirstName = "Jared"
};
var json1 = JsonConvert.SerializeObject(person1);
re1.Object = new JRaw(json1);
var rec = new RelatedEntityCollection {
re1
};
rec.RelatedEntity = "Person";
odataUser.RelatedEntityCollection.Add(rec);
// Act
var odataPersonCollection = odataUser.GetRelatedEntityCollection(nameof(Smile));
// Assert
Assert.IsNull(odataPersonCollection);
}
public void ShouldSerializePopulatedRelatedEntityCollection()
{
// Arrange
var relatedEntityCollection = new RelatedEntityCollection {
Entity = "Addendum", EntityId = "10", RelatedEntity = "Fake"
};
var json1 = "{ \"Id\" : \"1\" }";
var jObject1 = JObject.Parse(json1);
var json2 = "{ \"Id\" : \"2\" }";
var jObject2 = JObject.Parse(json1);
var relatedEntity1 = new RelatedEntity {
Id = jObject1.GetValue("Id").ToString(), Object = new JRaw(json1)
};
var relatedEntity2 = new RelatedEntity {
Id = jObject2.GetValue("Id").ToString(), Object = new JRaw(json2)
};
relatedEntityCollection.Add(relatedEntity1);
relatedEntityCollection.Add(relatedEntity2);
var odata = new OdataObject <Addendum, long>()
{
Object = new Addendum {
Id = 10, Property = "A", Value = "B"
}
};
odata.RelatedEntityCollection.Add(relatedEntityCollection);
// Act & Assert
Assert.IsTrue(ExcludeEmptyEnumerablesContractResolver.Instance.ShouldSerialize(odata, new JsonProperty {
PropertyName = "RelatedEntityCollection", UnderlyingName = "RelatedEntityCollection"
}));
}
public void SerializeOdataOjectAsJsonTest()
{
// Arrange
var expected = "{\"Id\":10,\"Object\":{\"Id\":10,\"CreateDate\":\"0001-01-01T00:00:00\",\"CreatedBy\":0,\"Entity\":null,\"EntityId\":null,\"LastUpdated\":null,\"LastUpdatedBy\":null,\"Property\":\"A\",\"Value\":\"B\"},\"RelatedEntityCollection\":[{\"Count\":2,\"RelatedEntity\":\"Fake\",\"RelatedEntities\":[{\"Id\":\"1\",\"Object\":{ \"Id\" : \"1\" },\"Uri\":null},{\"Id\":\"2\",\"Object\":{ \"Id\" : \"2\" },\"Uri\":null}]}],\"Uri\":null}";
var relatedEntityCollection = new RelatedEntityCollection {
Entity = "Addendum", EntityId = "10", RelatedEntity = "Fake"
};
var json1 = "{ \"Id\" : \"1\" }";
var jObject1 = JObject.Parse(json1);
var json2 = "{ \"Id\" : \"2\" }";
var jObject2 = JObject.Parse(json1);
var relatedEntity1 = new RelatedEntity {
Id = jObject1.GetValue("Id").ToString(), Object = new JRaw(json1)
};
var relatedEntity2 = new RelatedEntity {
Id = jObject2.GetValue("Id").ToString(), Object = new JRaw(json2)
};
relatedEntityCollection.Add(relatedEntity1);
relatedEntityCollection.Add(relatedEntity2);
var odata = new OdataObject <Addendum, long>()
{
Object = new Addendum {
Id = 10, Property = "A", Value = "B"
}
};
odata.RelatedEntityCollection.Add(relatedEntityCollection);
// Act
var actual = new Serializer().Json(odata, ContractResolver.Instance);
// Assert
Assert.AreEqual(expected, Encoding.UTF8.GetString(actual));
}
protected override void Execute(CodeActivityContext context)
{
// TODO: VALIDATE ENTITY OR THROW EXCEPTION
Workflows.UserInteractions.Request.ContactEntityRequest request = new UserInteractions.Request.ContactEntityRequest(
Entity.Get(context),
RelatedEntity.Get(context),
RegardingMessage.Get(context),
IntroductionScript.Get(context)
);
request.AllowEditRelatedEntity = AllowEditRelatedEntity.Get(context);
request.AllowEditContactDateTime = AllowEditContactDateTime.Get(context);
request.AllowEditRegarding = AllowEditRegarding.Get(context);
request.AllowCancel = AllowCancel.Get(context);
UserInteractionRequest.Set(context, request);
return;
}
/// <summary>
/// Shows the edit.
/// </summary>
private void ShowEdit()
{
// Check that we have source and target ids from the query string
if (!sourceEntityId.HasValue || !targetEntityId.HasValue)
{
nbMessages.Text = "Invalid source and target entities provided.";
pnlEdit.Visible = false;
}
lTitle.Text = HeaderTitle;
lIcon.Text = $"<i class=\"{ HeaderIconCssClass}\"></i> ";
avcAttributes.NumberOfColumns = AttributeColumns;
// Render header content
var mergeFields = Rock.Lava.LavaHelper.GetCommonMergeFields(this.RockPage, this.CurrentPerson);
lHeaderContent.Text = HeaderLavaTemplate.ResolveMergeFields(mergeFields);
// Check if quantity should be show
nudQuantity.Visible = GetAttributeValue(AttributeKey.ShowQuantity).AsBoolean();
// Check if notes should be shown
txtNotes.Visible = GetAttributeValue(AttributeKey.ShowNote).AsBoolean();
RelatedEntity relatedEntity = null;
// Determine if we should show existing values and if so load their values
if (EnableEdit)
{
// Check for existing values, if there are multiple we'll assume the first item
relatedEntity = GetExistingRelationship();
if (relatedEntity != null)
{
if (relatedEntity.Quantity.HasValue)
{
nudQuantity.Value = relatedEntity.Quantity.Value;
}
txtNotes.Text = relatedEntity.Note;
}
}
// We need to configure the attribute value container
if (EnableAttributeEditing)
{
if (relatedEntity == null)
{
// Create a stub of a relationship object so that the attribute editor knows what attributes to show
relatedEntity = new RelatedEntity();
relatedEntity.SourceEntityTypeId = sourceEntityTypeId;
relatedEntity.TargetEntityTypeId = targetEntityTypeId;
relatedEntity.PurposeKey = PurposeKey;
}
relatedEntity.LoadAttributes();
avcAttributes.AddEditControls(relatedEntity, Rock.Security.Authorization.EDIT, CurrentPerson);
}
}
public void OneToManySortTest()
{
// Arrange
var user1 = new User {
Id = 1, Name = "User1", UserTypeId = 3
};
var user2 = new User {
Id = 2, Name = "User2", UserTypeId = 3
};
var entities = new List <User> {
user1, user2
};
var membership1 = new UserGroupMembership {
Id = 11, UserId = 1, UserGroupId = 7
};
var relatedObjectJson1 = new JRaw(JsonConvert.SerializeObject(membership1));
var relatedEntity1 = new RelatedEntity {
Object = relatedObjectJson1
};
var membership2 = new UserGroupMembership {
Id = 14, UserId = 2, UserGroupId = 8
};
var relatedObjectJson2 = new JRaw(JsonConvert.SerializeObject(membership2));
var relatedEntity2 = new RelatedEntity {
Object = relatedObjectJson2
};
var relatedEntities = new List <RelatedEntity> {
relatedEntity1, relatedEntity2
};
var sorterDictionary = new SortMethodDictionary <User>();
var sortDetails = new SortDetails
{
EntityName = "User",
RelatedEntity = "UserGroupMembership",
EntityToRelatedEntityProperty = "UserId",
RelatedEntityType = RelatedEntity.Type.OneToMany
};
// Act
var actualCollections = sorterDictionary[RelatedEntity.Type.OneToMany](entities, relatedEntities, sortDetails);
// Assert
Assert.AreEqual(2, actualCollections.Count);
Assert.AreEqual("User", actualCollections[0].Entity);
Assert.AreEqual("UserGroupMembership", actualCollections[0].RelatedEntity);
Assert.AreEqual("1", actualCollections[0].EntityId);
Assert.AreEqual(1, actualCollections[0].RelatedEntities.Count);
Assert.AreEqual(relatedObjectJson1, actualCollections[0].RelatedEntities[0].Object);
Assert.AreEqual("User", actualCollections[1].Entity);
Assert.AreEqual("UserGroupMembership", actualCollections[1].RelatedEntity);
Assert.AreEqual("2", actualCollections[1].EntityId);
Assert.AreEqual(1, actualCollections[1].RelatedEntities.Count);
Assert.AreEqual(relatedObjectJson2, actualCollections[1].RelatedEntities[0].Object);
}
public async Task <D365ServiceResponse> GetClientUpcomingAppointments(string RecordId)
{
D365CrudService service = new D365CrudService();
QueryFilter filter = new QueryFilter();
filter.AddCriteria(D365Appointment.STATUS_FIELD, ComparisonOperators.Equal, D365Appointment.CONFIRMED_STATUS);
filter.AddCriteria(D365Appointment.CLIENT_ID_FIELD, ComparisonOperators.Equal, RecordId);
filter.AddCriteria(D365Appointment.START_DATE_FIELD, ComparisonOperators.GreaterThan, DateTime.Now.Date);
RelatedEntity branch = new RelatedEntity()
{
IdField = D365Appointment.BRANCH_ID_FIELD,
Fields = new SelectFieldsList(Branch.FIELDS)
};
RelatedEntity advisor = new RelatedEntity()
{
IdField = D365Appointment.ADVISOR_ID_NAV_FIELD,
Fields = new SelectFieldsList(SystemUser.FIELDS)
};
RetreiveMultipleRequest request = new RetreiveMultipleRequest()
{
EntityName = D365Appointment.ENTITY_NAME,
Fields = new SelectFieldsList(D365Appointment.FIELDS),
Filter = filter,
RelatedEntities = new RelatedEntity[2] {
branch, advisor
}
};
D365ServiceResponse response = await service.RetreiveMultiple(request);
return(response);
}
public void SortTest()
{
// Arrange
var user1 = new User {
Id = 1, Name = "User1", UserTypeId = 3
};
var user2 = new User {
Id = 2, Name = "User2", UserTypeId = 3
};
var user3 = new User {
Id = 3, Name = "User3", UserTypeId = 4
};
var users = new [] { user1, user2, user3 };
var userType1 = new UserType {
Id = 3, Name = "Example Users"
};
var userType2 = new UserType {
Id = 4, Name = "Example Users"
};
var userType1Json = new JRaw(JsonConvert.SerializeObject(userType1.AsOdata <UserType, int>()));
var userType2Json = new JRaw(JsonConvert.SerializeObject(userType2.AsOdata <UserType, int>()));
var relatedEntity1 = new RelatedEntity {
Object = userType1Json
};
var relatedEntity2 = new RelatedEntity {
Object = userType1Json
};
var relatedEntity3 = new RelatedEntity {
Object = userType2Json
};
var relatedEntitites = new[] { relatedEntity1, relatedEntity2, relatedEntity3 };
var sorter = new RelatedEntitySorter <User, int>();
var sortDetails = new SortDetails("User", "UserType", RelatedEntity.Type.ManyToOne);
// Act
var collection = sorter.Sort(users, relatedEntitites, sortDetails);
// Assert
Assert.AreEqual(3, collection.Count);
Assert.AreEqual("User", collection[0].Entity);
Assert.AreEqual("UserType", collection[0].RelatedEntity);
Assert.AreEqual("1", collection[0].EntityId);
Assert.AreEqual(2, collection[0].RelatedEntities.Count);
Assert.AreEqual("User", collection[1].Entity);
Assert.AreEqual("UserType", collection[1].RelatedEntity);
Assert.AreEqual("2", collection[1].EntityId);
Assert.AreEqual(2, collection[1].RelatedEntities.Count);
Assert.AreEqual("User", collection[2].Entity);
Assert.AreEqual("UserType", collection[2].RelatedEntity);
Assert.AreEqual("3", collection[2].EntityId);
Assert.AreEqual(1, collection[2].RelatedEntities.Count);
}
public void ImplicitOperatorNullTest()
{
// Arrange
OdataObject <Entity1, int> o = null;
// Act
RelatedEntity e = o;
// Assert
Assert.IsNull(e);
}
protected virtual void TMasterFieldUpdated(PXCache sender, PXFieldUpdatedEventArgs e)
{
TMaster row = (TMaster)e.Row;
if (row == null || row.ClassID == null)
{
return;
}
RelatedEntity pars = this.Caches <RelatedEntity>().Current as RelatedEntity;
if (pars == null || pars.Type == null || pars.RefNoteID == null)
{
return;
}
EntityHelper helper = new EntityHelper(this);
Type entityType = PXBuildManager.GetType(pars.Type, false);
var related = new EntityHelper(this).GetEntityRow(entityType, pars.RefNoteID);
if (related == null)
{
return;
}
Type graphType = helper.GetPrimaryGraphType(entityType, related, true);
if (graphType == null)
{
return;
}
TMaster copy = PXCache <TMaster> .CreateCopy(row);
PXGraph graph = CreateInstance(graphType);
Type noteType = EntityHelper.GetNoteType(entityType);
PXView view = new PXView(this, false, BqlCommand.CreateInstance(BqlCommand.Compose(typeof(Select <,>), entityType, typeof(Where <,>), noteType, typeof(Equal <>), typeof(Required <>), noteType)));
graph.Caches[entityType].Current = view.SelectSingle(pars.RefNoteID);
PXCache <TMaster> cache = graph.Caches <TMaster>();
cache.SetDefaultExt(copy, typeof(CRActivity.bAccountID).Name);
cache.SetDefaultExt(copy, typeof(CRActivity.contactID).Name);
if (copy.BAccountID != null)
{
row.BAccountID = copy.BAccountID;
}
if (copy.ContactID != null)
{
row.ContactID = copy.ContactID;
}
}
public override void UpdatedAllRelated(TForeignEntity ForeignEntity)
{
TForeignKey?foreignKey = foreignKeyManager.GetEntityKey(ForeignEntity);
if (propRelated != null)
{
EntityCollection <TForeignEntity, TRelatedEntity> relatedCollection = getRColc(ForeignEntity);
foreach (TRelatedEntity RelatedEntity in relatedCollection)
{
// when an unchanged entity reference to added entity it's state change from unchanged to modified,
// therefore when insert added entity to database, any related entity can be added or modified.
if (RelatedEntity.HasBusy() || !RelatedEntity.HasChanged())
{
throw new EntityRelationManagerException($"[{this}] UpdatedAllRelated Failed, {RelatedEntity} With {RelatedEntity.State} State Is Not Supported");
}
setFKey(RelatedEntity, foreignKey);
RelatedEntity.State |= EntityState.Busy;
RelatedEntity.OnPropertyChanged(propForeignKey.Name);
RelatedEntity.OnPropertyChanged(propForeignReference.Name);
RelatedEntity.State ^= EntityState.Busy;
}
}
else
{
foreach (TRelatedEntity RelatedEntity in relatedEntitySet)
{
TForeignEntity foreignEntity = getFRef(RelatedEntity);
if (foreignEntity == ForeignEntity)
{
// when an unchanged entity reference to added entity it's state change from unchanged to modified,
// therefore when insert added entity to database, any related entity can be added or modified.
if (RelatedEntity.HasBusy() || !RelatedEntity.HasChanged())
{
throw new EntityRelationManagerException($"[{this}] UpdatedAllRelated Failed, {RelatedEntity} With {RelatedEntity.State} State Is Not Supported");
}
setFKey(RelatedEntity, foreignKey);
RelatedEntity.State |= EntityState.Busy;
RelatedEntity.OnPropertyChanged(propForeignKey.Name);
RelatedEntity.OnPropertyChanged(propForeignReference.Name);
RelatedEntity.State ^= EntityState.Busy;
}
}
}
}
public void ImplicitOperatorNullTest()
{
// Arrange
RelatedEntity <User, int> re1 = null;
// Act
RelatedEntity re2 = re1;
// Assert
Assert.IsNull(re2);
}
public void SettingObjectKeyIdPropertyTest()
{
// Arrange
string json = "{\"Key\":3,\"IdProperty\":\"Key\",\"Addenda\":[],\"Object\":{\"Id\":3,\"UserGroupId\":3,\"UserId\":3},\"PropertyUris\":[],\"RelatedEntities\":[],\"Uri\":\"http://localhost:3896/UserGroupMembershipService.svc/UserGroupMemberships(3)\"}";
var relatedEntity = new RelatedEntity();
// Act
relatedEntity.Object = new JRaw(json);
// Assert
Assert.AreEqual("3", relatedEntity.Id);
}
public void ImplicitOperatorDefaultTest()
{
// Arrange
var re1 = new RelatedEntity <User, int>();
// Act
RelatedEntity re2 = re1;
// Assert
Assert.IsNotNull(re2);
Assert.AreEqual("0", re2.Id);
}
public void ImplicitOperatorNewJRawStringTest()
{
// Arrange
var re1 = new RelatedEntity <JRaw, string>();
// Act
RelatedEntity re2 = re1;
// Assert
Assert.IsNotNull(re2);
Assert.IsNull(re2.Id);
}
/// <summary>
/// Handles the Click event of the btnSave control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="EventArgs"/> instance containing the event data.</param>
protected void btnSave_Click(object sender, EventArgs e)
{
var rockContext = new RockContext();
var relatedEntityService = new RelatedEntityService(rockContext);
RelatedEntity relatedEntity = null;
// Check if we should be editing existing records and if so load it
if (EnableEdit)
{
relatedEntity = GetExistingRelationship(rockContext, relatedEntityService);
}
if (relatedEntity == null)
{
relatedEntity = new RelatedEntity();
relatedEntity.SourceEntityTypeId = sourceEntityTypeId;
relatedEntity.TargetEntityTypeId = targetEntityTypeId;
relatedEntity.SourceEntityId = sourceEntityId.Value;
relatedEntity.TargetEntityId = targetEntityId.Value;
relatedEntity.PurposeKey = PurposeKey;
relatedEntityService.Add(relatedEntity);
}
// Save quantity
if (GetAttributeValue(AttributeKey.ShowQuantity).AsBoolean())
{
relatedEntity.Quantity = nudQuantity.Value;
}
// Save note
if (GetAttributeValue(AttributeKey.ShowNote).AsBoolean())
{
relatedEntity.Note = txtNotes.Text;
}
rockContext.SaveChanges();
// Save the attributes
if (EnableAttributeEditing)
{
// Save the attributes
relatedEntity.LoadAttributes(rockContext);
avcAttributes.GetEditValues(relatedEntity);
rockContext.SaveChanges();
relatedEntity.SaveAttributeValues(rockContext);
}
Response.Redirect(PreviousUrl);
}
public void ManyToOneSortByPropertyOtherThanIdTest()
{
// Arrange
var user1 = new User2 {
Id = 1, Name = "User1", UserTypeName = "Example Users"
};
var user2 = new User2 {
Id = 2, Name = "User2", UserTypeName = "Example Users"
};
var entities = new List <User2> {
user1, user2
};
var userType1 = new UserType {
Id = 3, Name = "Example Users"
};
var relatedObjectJson = new JRaw(JsonConvert.SerializeObject(userType1));
var relatedEntity1 = new RelatedEntity {
Object = relatedObjectJson
};
var relatedEntities = new List <RelatedEntity> {
relatedEntity1
};
var sorterDictionary = new SortMethodDictionary <User2>();
var sortDetails = new SortDetails
{
EntityName = "User",
RelatedEntity = "UserType",
EntityToRelatedEntityProperty = "UserTypeName",
RelatedEntityType = RelatedEntity.Type.ManyToOne,
RelatedEntityIdProperty = "Name"
};
// Act
var actualCollections = sorterDictionary[RelatedEntity.Type.ManyToOne](entities, relatedEntities, sortDetails);
// Assert
Assert.AreEqual(2, actualCollections.Count);
Assert.AreEqual("User", actualCollections[0].Entity);
Assert.AreEqual("UserType", actualCollections[0].RelatedEntity);
Assert.AreEqual("1", actualCollections[0].EntityId);
Assert.AreEqual(1, actualCollections[0].RelatedEntities.Count);
Assert.AreEqual(relatedObjectJson, actualCollections[0].RelatedEntities[0].Object);
Assert.AreEqual("User", actualCollections[1].Entity);
Assert.AreEqual("UserType", actualCollections[1].RelatedEntity);
Assert.AreEqual("2", actualCollections[1].EntityId);
Assert.AreEqual(1, actualCollections[1].RelatedEntities.Count);
Assert.AreEqual(relatedObjectJson, actualCollections[1].RelatedEntities[0].Object);
}
protected override void Execute(CodeActivityContext context)
{
// TODO: VALIDATE ENTITY OR THROW EXCEPTION
Workflows.UserInteractions.Request.SendCorrespondenceRequest request = new UserInteractions.Request.SendCorrespondenceRequest(
Entity.Get(context),
RelatedEntity.Get(context),
WorkflowManager.Get(context).Application.CorrespondenceGetIdByName(CorrespondenceName.Get(context)),
AllowUserSelection.Get(context),
AllowAlternateAddress.Get(context)
);
request.AllowCancel = AllowCancel.Get(context);
request.Attention = Attention.Get(context);
request.AllowEditRelatedEntity = AllowEditRelatedEntity.Get(context);
request.AllowHistoricalSendDate = AllowHistoricalSendDate.Get(context);
request.AllowFutureSendDate = AllowFutureSendDate.Get(context);
request.AllowSendByFacsimile = AllowSendByFacsimile.Get(context);
request.AllowSendByEmail = AllowSendByEmail.Get(context);
request.AllowSendByInPerson = AllowSendByInPerson.Get(context);
request.SendDate = SendDate.Get(context);
request.AlternateAddress = AlternateAddress.Get(context);
request.AlternateFaxNumber = AlternateFaxNumber.Get(context);
request.AlternateEmail = AlternateEmail.Get(context);
UserInteractionRequest.Set(context, request);
return;
}
public void ImplicitCastJRawStringObjectTest()
{
// Arrange
var odataObj = new OdataObject <JRaw, string>();
// Act
RelatedEntity re = odataObj;
// Assert
foreach (var prop in odataObj.GetType().GetProperties())
{
Assert.AreEqual(re.GetType().GetProperty(prop.Name).GetValue(re)?.ToString(), prop.GetValue(odataObj)?.ToString());
}
}
public async Task <EntitiesResponseModel> GetAsync(GetEntitiesRequestModel request)
{
var subjectRepository = _repositoryResolver.GetRepository(request.RepositoryAlias);
var parentPath = request is GetEntitiesOfParentRequestModel parentRequest ? parentRequest.ParentPath
: request is GetEntitiesOfRelationRequestModel relationRequest ? relationRequest.Related.ParentPath
: default;
var parent = await _parentService.GetParentAsync(ParentPath.TryParse(parentPath));
var related = default(IRelated);
if (request is GetEntitiesOfRelationRequestModel relatedRequest)
{
var relatedRepository = _repositoryResolver.GetRepository(relatedRequest.Related.RepositoryAlias ?? throw new ArgumentNullException());
var relatedEntity = await relatedRepository.GetByIdAsync(relatedRequest.Related.Id ?? throw new ArgumentNullException(), new ViewContext(null, default))
?? throw new NotFoundException("Could not find related entity");
related = new RelatedEntity(parent, relatedEntity, relatedRequest.Related.RepositoryAlias);
}
var protoEntity = await subjectRepository.NewAsync(new ViewContext(null, parent), default);
await _authService.EnsureAuthorizedUserAsync(request.UsageType, protoEntity);
await _dataViewResolver.ApplyDataViewToViewAsync(request.View);
var action = (request.UsageType & ~(UsageType.List)) switch
{
UsageType.Add when related != null => async() => await subjectRepository.GetAllNonRelatedAsync(new RelatedViewContext(related, null, default), request.View),
_ when related != null => async() => await subjectRepository.GetAllRelatedAsync(new RelatedViewContext(related, null, default), request.View),
_ when related == null => async() => await subjectRepository.GetAllAsync(new ViewContext(null, parent), request.View),
_ => default(Func <Task <IEnumerable <IEntity> > >)
};
if (action == default)
{
throw new InvalidOperationException($"UsageType {request.UsageType} is invalid for this method");
}
var entities = await action.Invoke();
return(new EntitiesResponseModel
{
Entities = entities,
MoreDataAvailable = request.View.MoreDataAvailable
});
}
}
public override void UpdatedAllOrphan(TForeignEntity ForeignEntity)
{
TForeignKey foreignKey = foreignKeyManager.GetEntityKey(ForeignEntity);
if (propRelated != null)
{
EntityCollection <TForeignEntity, TRelatedEntity> relatedCollection = getRColc(ForeignEntity);
foreach (TRelatedEntity RelatedEntity in orphanage.GetAllRelated(foreignKeyManager.GetEntityKey(ForeignEntity)).ToArray())
{
if (!RelatedEntity.HasEditable() || RelatedEntity.HasBusy())
{
throw new EntityRelationManagerException($"[{this}] UpdatedAllOrphan Failed, {RelatedEntity} With {RelatedEntity.State} State Is Not Supported");
}
// UpdatedOrphan ....
setFRef(RelatedEntity, ForeignEntity);
OrphanageRemove(RelatedEntity, foreignKey);
relatedCollection.InternalAdd(RelatedEntity);
RelatedEntity.State |= EntityState.Busy;
RelatedEntity.OnPropertyChanged(propForeignReference.Name);
RelatedEntity.State ^= EntityState.Busy;
}
}
else
{
foreach (TRelatedEntity RelatedEntity in orphanage.GetAllRelated(foreignKeyManager.GetEntityKey(ForeignEntity)).ToArray())
{
if (!RelatedEntity.HasEditable() || RelatedEntity.HasBusy())
{
throw new EntityRelationManagerException($"[{this}] UpdatedAllOrphan Failed, {RelatedEntity} With {RelatedEntity.State} State Is Not Supported");
}
// UpdatedOrphan ....
setFRef(RelatedEntity, ForeignEntity);
OrphanageRemove(RelatedEntity, foreignKey);
RelatedEntity.State |= EntityState.Busy;
RelatedEntity.OnPropertyChanged(propForeignReference.Name);
RelatedEntity.State ^= EntityState.Busy;
}
}
}
public override void RestoreAllRelated(TForeignEntity ForeignEntity)
{
TForeignKey?foreignKey = foreignKeyManager.GetEntityKey(ForeignEntity);
if (propRelated != null)
{
EntityUnique <TForeignEntity, TRelatedEntity> relatedUnique = getRUniq(ForeignEntity);
TRelatedEntity RelatedEntity = relatedUnique.Entity;
if (!RelatedEntity.IsNull())
{
UpdateUniqueConstraint(foreignKey, getFKey(RelatedEntity));
setFKey(RelatedEntity, foreignKey);
RelatedEntity.State |= EntityState.Busy;
RelatedEntity.OnPropertyChanged(propForeignKey.Name);
RelatedEntity.OnPropertyChanged(propForeignReference.Name);
RelatedEntity.State ^= EntityState.Busy;
}
}
else
{
foreach (TRelatedEntity RelatedEntity in relatedEntitySet)
{
TForeignEntity foreignEntity = getFRef(RelatedEntity);
if (foreignEntity == ForeignEntity)
{
UpdateUniqueConstraint(foreignKey, getFKey(RelatedEntity));
setFKey(RelatedEntity, foreignKey);
RelatedEntity.State |= EntityState.Busy;
RelatedEntity.OnPropertyChanged(propForeignKey.Name);
RelatedEntity.OnPropertyChanged(propForeignReference.Name);
RelatedEntity.State ^= EntityState.Busy;
break;
}
}
}
}
public void OverridesSameRelation()
{
var rel1 = new List <string> {
"Abc", "Def"
};
var rel2 = new List <string> {
"Def", "Abc"
};
var relatedEntity1 = new RelatedEntity(rel1, new HypermediaObjectReference(new TestHypermediaObject()));
var relatedEntity2 = new RelatedEntity(rel2, new HypermediaObjectReference(new TestHypermediaObject()));
relationDictionary.Add(relatedEntity1);
relationDictionary.Add(relatedEntity2);
Assert.AreEqual(1, relationDictionary.Count);
Assert.AreEqual(relationDictionary[rel1], relatedEntity2);
}
public override void NotifyAllRelated(TForeignEntity ForeignEntity)
{
if (propRelated != null)
{
EntityUnique <TForeignEntity, TRelatedEntity> relatedUnique = getRUniq(ForeignEntity);
TRelatedEntity RelatedEntity = relatedUnique.Entity;
if (!RelatedEntity.IsNull())
{
if (!RelatedEntity.HasEditable() || RelatedEntity.HasBusy())
{
throw new EntityRelationManagerException($"[{this}] NotifyAllRelated Failed, {RelatedEntity} With {RelatedEntity.State} State Is Not Supported");
}
RelatedEntity.State |= EntityState.Busy;
RelatedEntity.OnPropertyChanged(propForeignReference.Name);
RelatedEntity.State ^= EntityState.Busy;
}
}
else
{
foreach (TRelatedEntity RelatedEntity in relatedEntitySet)
{
TForeignEntity foreignEntity = getFRef(RelatedEntity);
if (foreignEntity == ForeignEntity)
{
if (!RelatedEntity.HasEditable() || RelatedEntity.HasBusy())
{
throw new EntityRelationManagerException($"[{this}] NotifyAllRelated Failed, {RelatedEntity} With {RelatedEntity.State} State Is Not Supported");
}
RelatedEntity.State |= EntityState.Busy;
RelatedEntity.OnPropertyChanged(propForeignReference.Name);
RelatedEntity.State ^= EntityState.Busy;
break;
}
}
}
}
static void UpdateIDFs(RelatedEntity phenotype, int totalNumberOfDisease, int NbDisease_i, double TotalOfSumMinMaxNorm, double SumOfMinMaxNorm_i)
{
//IDF UNARY
phenotype.IDFs.Where(IDF => IDF.IDFType == IDFType.Unary).FirstOrDefault().Value = 1.0;
//NbDisease_i
phenotype.IDFs.Where(IDF => IDF.IDFType == IDFType.NbDisease_i).FirstOrDefault().Value =
(double)NbDisease_i;
//Inverse_NbDisease_i
phenotype.IDFs.Where(IDF => IDF.IDFType == IDFType.Inverse_NbDisease_i).FirstOrDefault().Value =
(double)totalNumberOfDisease / (double)NbDisease_i;
//IDF_Classic_NbDisease_i
phenotype.IDFs.Where(IDF => IDF.IDFType == IDFType.IDF_Classic_NbDisease_i).FirstOrDefault().Value =
Math.Log10((double)totalNumberOfDisease / (double)NbDisease_i);
//IDF_Smooth_NbDisease_i
phenotype.IDFs.Where(IDF => IDF.IDFType == IDFType.IDF_Smooth_NbDisease_i).FirstOrDefault().Value =
Math.Log10(1.0 + ((double)totalNumberOfDisease / (double)NbDisease_i));
//Prob_IDF_NbDisease_i
phenotype.IDFs.Where(IDF => IDF.IDFType == IDFType.Prob_IDF_NbDisease_i).FirstOrDefault().Value =
Math.Log10((((double)totalNumberOfDisease - (double)NbDisease_i)) / (double)NbDisease_i);
//SumOfRawCount_i
phenotype.IDFs.Where(IDF => IDF.IDFType == IDFType.SumOfMinMaxNorm_i).FirstOrDefault().Value =
(double)SumOfMinMaxNorm_i;
//Inverse_SumOfRawCount_i
phenotype.IDFs.Where(IDF => IDF.IDFType == IDFType.Inverse_SumOfMinMaxNorm_i).FirstOrDefault().Value =
TotalOfSumMinMaxNorm / (double)SumOfMinMaxNorm_i;
//IDF_Classic_SumOfRawCount_i
phenotype.IDFs.Where(IDF => IDF.IDFType == IDFType.IDF_Classic_SumOfMinMaxNorm_i).FirstOrDefault().Value =
Math.Log10(TotalOfSumMinMaxNorm / (double)SumOfMinMaxNorm_i);
//IDF_Smooth_SumOfRawCount_i
phenotype.IDFs.Where(IDF => IDF.IDFType == IDFType.IDF_Smooth_SumOfMinMaxNorm_i).FirstOrDefault().Value =
Math.Log10(1.0 + (TotalOfSumMinMaxNorm / (double)SumOfMinMaxNorm_i));
//Prob_IDF_SumOfRawCount_i
//phenotype.IDFs.Where(IDF => IDF.IDFType == IDFType.Prob_IDF_SumOfRawCount_i).FirstOrDefault().Value =
//Math.Log10(((1.0 - (double)SumOfRawCount_i)) / (double)SumOfRawCount_i);
}
/// <summary>
/// Adds a relationship between the relatedEntity and the entity
/// </summary>
/// <typeparam name="TT">The type of the t.</typeparam>
/// <param name="entityId">The entity identifier.</param>
/// <param name="relatedEntity">The related entity.</param>
/// <param name="purposeKey">The purpose key.</param>
public void AddRelatedToSourceEntity <TT>(int entityId, TT relatedEntity, string purposeKey) where TT : IEntity
{
var relatedEntityTypeId = EntityTypeCache.GetId <TT>();
var sourceEntityTypeId = EntityTypeCache.GetId <T>();
var relatedEntityRecord = new RelatedEntity();
relatedEntityRecord.SourceEntityTypeId = sourceEntityTypeId.Value;
relatedEntityRecord.SourceEntityId = entityId;
relatedEntityRecord.TargetEntityTypeId = relatedEntityTypeId.Value;
relatedEntityRecord.TargetEntityId = relatedEntity.Id;
relatedEntityRecord.PurposeKey = purposeKey;
var relatedEntityService = new Rock.Model.RelatedEntityService(this.Context as RockContext);
relatedEntityService.Add(relatedEntityRecord);
}
//Read the configuration for filtering
static private bool FilterFunctionForOneRelatedEntities(RelatedEntity x)
{
if (ConfigurationManager.Instance.config.TFTypeOfBestCombination == "NULL" ||
ConfigurationManager.Instance.config.IDFTypeOfBestCombination == "NULL")
{
return(true);
}
else
{
return(x.TermFrequencies
.Where(tf => tf.TFType == (TFType)Enum.Parse(typeof(TFType), ConfigurationManager.Instance.config.TFTypeOfBestCombination))
.FirstOrDefault().Value
*
x.IDFs.Where(idf => idf.IDFType == (IDFType)Enum.Parse(typeof(IDFType), ConfigurationManager.Instance.config.IDFTypeOfBestCombination))
.FirstOrDefault().Value
>= ConfigurationManager.Instance.config.Threshold);
}
}
public void GetRelatedEntity_NotGeneric_Test()
{
// Arrange
var odataUser = new OdataObject <User, int>();
var re1 = new RelatedEntity {
Id = "7"
};
var smile1 = new Smile {
Id = 7, SmileType = "Wide"
};
var json1 = JsonConvert.SerializeObject(smile1);
re1.Object = new JRaw(json1);
var re2 = new RelatedEntity {
Id = "8"
};
var smile2 = new Smile {
Id = 8, SmileType = "Flat"
};
var json2 = JsonConvert.SerializeObject(smile2);
re2.Object = new JRaw(json2);
var rec = new RelatedEntityCollection {
re1, re2
};
rec.RelatedEntity = "Smile";
odataUser.RelatedEntityCollection.Add(rec);
// Act
var odataSmileCollection = odataUser.GetRelatedEntityCollection(nameof(Smile));
// Assert
Assert.AreEqual(2, odataSmileCollection.Count);
Assert.AreEqual("7", odataSmileCollection[0].Id);
var jObj0 = JObject.Parse(odataSmileCollection[0].Object.ToString());
Assert.AreEqual("Wide", jObj0["Type"]);
Assert.AreEqual("8", odataSmileCollection[1].Id);
var jObj1 = JObject.Parse(odataSmileCollection[1].Object.ToString());
Assert.AreEqual("Flat", jObj1["Type"]);
}
public virtual IEnumerable relate(PXAdapter adapter)
{
bool lint = entityFilter.AskExt() == WebDialogResult.OK && entityFilter.VerifyRequired();
if (lint)
{
PXCache cache = this.Caches <CRSMEmail>();
RelatedEntity relatedEntity = entityFilter.Current;
EntityHelper helper = new EntityHelper(this);
Type entityType = PXBuildManager.GetType(relatedEntity.Type, false);
object row = helper.GetEntityRow(entityType, relatedEntity.RefNoteID);
Type graphType = helper.GetPrimaryGraphType(row, false);
Type actualEntityType = PXSubstManager.Substitute(entityType, graphType);
object actualRow = helper.GetEntityRow(actualEntityType, relatedEntity.RefNoteID);
PXGraph graph = PXGraph.CreateInstance(graphType);
graph.Caches[actualEntityType].Current = actualRow;
foreach (PXResult <CRSMEmail, EMailAccount, EPView> email in SelectedList())
{
((CRSMEmail)email).Selected = false;
CRSMEmail copy = PXCache <CRSMEmail> .CreateCopy(email);
CRActivity newActivity = (CRActivity)graph.Caches[typeof(CRActivity)].Insert();
copy.BAccountID = newActivity.BAccountID;
copy.ContactID = newActivity.ContactID;
copy.RefNoteID = newActivity.RefNoteID;
copy.MPStatus = MailStatusListAttribute.Processed;
copy.Exception = null;
PXRefNoteSelectorAttribute.EnsureNotePersistence(this, entityFilter.Current.Type, entityFilter.Current.RefNoteID);
copy = (CRSMEmail)cache.Update(copy);
}
Save.Press();
}
else
{
entityFilter.Ask(Messages.Warning, Messages.SelectRecord, MessageButtons.OK);
}
Emails.Cache.IsDirty = false;
Emails.Cache.Clear();
Emails.Cache.ClearQueryCacheObsolete();
Emails.View.RequestRefresh();
return(adapter.Get());
}
/// <summary>
/// Adds the relationship.
/// </summary>
private void AddRelationship()
{
var rockContext = new RockContext();
var relatedEntityService = new RelatedEntityService(rockContext);
var relatedEntity = new RelatedEntity();
relatedEntityService.Add(relatedEntity);
relatedEntity.SourceEntityTypeId = sourceEntityTypeId;
relatedEntity.TargetEntityTypeId = targetEntityTypeId;
relatedEntity.SourceEntityId = CurrentSourceEntityId;
relatedEntity.TargetEntityId = CurrentTargetEntityId;
relatedEntity.PurposeKey = CurrentPurposeKey;
rockContext.SaveChanges();
ShowContent();
}
public void Enums_are_mapped_by_int_value()
{
var source = new RelatedEntity { Enum = SomeEnum.Value2 };
var target = _mapper.Map<RelatedDTO>(source);
Assert.AreEqual(SomeOtherEnum.OtherValue2, target.Enum);
}
