public Task PushPage(Page page, FreshBasePageModel model, bool modal = false,
bool animate = true)
{
return(modal
? Navigation.PushModalAsync(CreateContainerPageSafe(page))
: NavigationDetail.PushAsync(page, animate));
}
/// <summary>
/// Order entities according to principal self navigation count ascendingly
/// for defining state appropriately.
/// </summary>
/// <example>
/// firstCategory which has null value on ParentCategory property has 0 principal self
/// navigation count. If ParentCategory of secondCategory is firstCategory, then secondCategory
/// has 1 principal self navigation count, if ParentCategory of thirdCateogry is secondCategory,
/// then it has 2 principal self navigaiton count. In this case, state of enitites must be defined
/// in ascending order. In our example, the order is like below:
/// 1. firstCategory, 2. secondCategory, 3. thirdCateogry.
/// </example>
/// <exception cref="ArgumentNullException">
/// When entityCollection is null.
/// </exception>
/// <exception cref="InvalidOperationException">
/// When entities in collection do not have same type.
/// </exception>
/// <param name="entityCollection">EntityCollection to define state define order.</param>
/// <returns>Orderer entity collection suiting for defining state.</returns>
private IEnumerable <object> DefineStateDefineOrder(IEnumerable <object> entityCollection)
{
if (entityCollection == null)
{
throw new ArgumentNullException(nameof(entityCollection));
}
if (!entityCollection.Any())
{
return(entityCollection);
}
// Get type of entity
string entityTypeName = entityCollection.First().GetType().Name;
// All entities must have same type in collection.
if (entityCollection
.Any(m => m != null && m.GetType().Name != entityTypeName))
{
throw new InvalidOperationException(string.Format(
"All entities must have same type in collection to define state define order."
+ " Entity type: {0}.",
entityTypeName));
}
// Check if entity has navigation propert to itself. If not, then
// there is no need to order them, otherwise order.
IGraphEntityTypeManager entityTypeManager = GetEntityTypeManager(entityTypeName);
NavigationDetail navigationDetail = entityTypeManager.GetNavigationDetail();
bool hasPrinciplaSelfNavigationProperty = navigationDetail
.Relations
.Any(m => m.Direction == NavigationDirection.From &&
m.PropertyTypeName == entityTypeName);
if (!hasPrinciplaSelfNavigationProperty)
{
return(entityCollection);
}
// Initialize store for ordered entities.
Dictionary <object, int> principalCountStore =
new Dictionary <object, int>();
for (int i = 0; i < entityCollection.Count(); i++)
{
dynamic entity = entityCollection.ElementAt(i);
int principalSelfCount = CalculatePrincipalSelfNavigationCount(
entity, principalCountStore);
}
// Order according to principal slef navigation properties ascendingly.
return(principalCountStore.OrderBy(m => m.Value).Select(m => m.Key));
}
public MainPage()
{
this.InitializeComponent();
App.Customers.Add(new Customer()
{
Name = "Björn Johansson", PNr = 8912022738
});
App.Customers.Add(new Customer()
{
Name = "Fredrik Karlsson", PNr = 9202131242
});
App.Customers.Add(new Customer()
{
Name = "Amanda Andersson", PNr = 9412038234
});
App.Customers.Add(new Customer()
{
Name = "Alexander Johansson", PNr = 8205021523
});
App.Customers.Add(new Customer()
{
Name = "Alex Larsen", PNr = 6305151526
});
App.Customers.Add(new Customer()
{
Name = "Anders Larsson", PNr = 6908172592
});
App.Customers.Add(new Customer()
{
Name = "Anders Ohlsen", PNr = 7811022849
});
App.Customers.Add(new Customer()
{
Name = "Pontus Fyhrberg", PNr = 7412199572
});
//CustomersListView.ItemsSource = App.Customers.OrderBy(x => x.Name);
NavigationDetail.Navigate(typeof(Startsida));
//string appName = Windows.ApplicationModel.Package.Current.DisplayName;
}
/// <summary>
/// Calculate count of principal self navigation properties for
/// ordering to be able to successfully define order.
/// </summary>
/// <remarks>
/// If Category has principal navigation to itself named ParentCategory, we need to
/// find count of them to be able to define order appropriately. We need to define state of
/// them in ascending order.
/// </remarks>
/// <example>
/// firstCategory which has null value on ParentCategory property has 0 principal self
/// navigation count. If ParentCategory of secondCategory is firstCategory, then secondCategory
/// has 1 principal self navigation count, if ParentCategory of thirdCateogry is secondCategory,
/// then it has 2 principal self navigaiton count.
/// </example>
/// <typeparam name="TEntity">Type of entity.</typeparam>
/// <param name="entity">Entity to find principla self navigaiton count.</param>
/// <param name="store">Store to add calculated count and check first.</param>
/// <returns>Count of principal self navigation count.</returns>
private int CalculatePrincipalSelfNavigationCount <TEntity>(
TEntity entity,
Dictionary <object, int> store)
where TEntity : class
{
if (store.ContainsKey(entity))
{
return(store[entity]);
}
string typeName = entity.GetType().Name;
// Get navigation details and find properties which is refers to itslef.
IGraphEntityManager <TEntity> entityManager = GetEntityManager <TEntity>();
NavigationDetail navigationDetail = entityManager.GetNavigationDetail();
List <string> selfReferringPrincipalPropertyNames = navigationDetail
.Relations
.Where(m => m.Direction == NavigationDirection.From &&
m.PropertyTypeName == typeName)
.Select(m => m.PropertyName)
.ToList();
// Loop through principal navigation properties and add their count.
int principalSelfCount = 0;
foreach (string propertyName in selfReferringPrincipalPropertyNames)
{
TEntity principalEntity = entity.GetPropertyValue(propertyName) as TEntity;
// If principla entity is null then continue
if (principalEntity == null)
{
continue;
}
// Othewise calculate principal count as 1 + count for principal entity
principalSelfCount++;
principalSelfCount += CalculatePrincipalSelfNavigationCount(principalEntity, store);
}
store.Add(entity, principalSelfCount);
return(principalSelfCount);
}
/// <summary>
/// Get navigation details according to name of type
/// </summary>
/// <returns>Navigation details of type</returns>
public NavigationDetail GetNavigationDetail()
{
// Try to get from store
if (Store.NavigationDetail.ContainsKey(EntityTypeName))
{
return(Store.NavigationDetail[EntityTypeName]);
}
NavigationDetail navigationDetail = ContextHelper
.ObjectContext
.MetadataWorkspace
.GetItems <EntityType>(DataSpace.CSpace)
.Where(m => m.Name.Equals(EntityTypeName))
.Select(n => new NavigationDetail(n))
.FirstOrDefault();
// Add to store
Store.NavigationDetail.Add(EntityTypeName, navigationDetail);
return(navigationDetail);
}
private void TextBlock_Tapped_3(object sender, TappedRoutedEventArgs e)
{
NavigationDetail.Navigate(typeof(Redigera));
MySplitView.IsPaneOpen = false;
}
private void Registrera_Tapped_1(object sender, TappedRoutedEventArgs e)
{
NavigationDetail.Navigate(typeof(Registrera));
MySplitView.IsPaneOpen = false;
}
private void Startsida_Tapped(object sender, TappedRoutedEventArgs e)
{
NavigationDetail.Navigate(typeof(Startsida));
MySplitView.IsPaneOpen = false;
}
/// <summary>
/// Add all child or parents entities related to given entity
/// and entity itself to the relatedEntityList.
/// </summary>
/// <exception cref="ArgumentNullException">
/// When entity or relatedEntityList is null.
/// </exception>
/// <typeparam name="TEntity">Type of entity.</typeparam>
/// <param name="entity">Entity to get all related entities.</param>
/// <param name="relatedEntityList">List of entities to add.</param>
public void GetAllEntities <TEntity>(
TEntity entity,
List <object> relatedEntityList)
where TEntity : class
{
if (entity == null)
{
throw new ArgumentNullException(nameof(entity));
}
if (relatedEntityList == null)
{
throw new ArgumentNullException(nameof(relatedEntityList));
}
if (!relatedEntityList.Contains(entity))
{
relatedEntityList.Add(entity);
}
IGraphEntityManager <TEntity> graphEntityManager = GetEntityManager <TEntity>();
NavigationDetail navigationDetail = graphEntityManager
.GetNavigationDetail();
List <PropertyInfo> navigationPropeties = navigationDetail
.Relations
.Select(n => entity.GetProperty(n.PropertyName))
.ToList();
if (navigationPropeties != null &&
navigationPropeties.Count > 0)
{
foreach (PropertyInfo childEntityProperty in navigationPropeties)
{
if (childEntityProperty.PropertyType.IsCollectionType())
{
// If child entity is collection get all entities inside this collection.
IEnumerable <object> enumerableChildEntity =
entity.GetPropertyValue(childEntityProperty.Name) as IEnumerable <object>;
if (enumerableChildEntity != null)
{
for (int i = 0; i < enumerableChildEntity.Count(); i++)
{
dynamic childEntity = enumerableChildEntity.ElementAt(i);
if (childEntity != null &&
!relatedEntityList.Contains(childEntity))
{
GetAllEntities(
childEntity,
relatedEntityList);
}
}
}
}
else
{
// If child entity is not collection get its own.
dynamic childEntity = entity.GetPropertyValue(childEntityProperty.Name);
if (childEntity != null &&
!relatedEntityList.Contains(childEntity))
{
GetAllEntities(
childEntity,
relatedEntityList);
}
}
}
}
}
/// <summary>
/// Set property of parent entity to targetValue
/// which has property value equals to currentValue.
/// </summary>
/// <typeparam name="TEntity">Type of entity.</typeparam>
/// <param name="currentValue">Current value of property to replace.</param>
/// <param name="targetValue">Target value to set value of property of parent.</param>
private void ReplaceEntitiesInParents <TEntity>(
TEntity currentValue,
TEntity targetValue)
where TEntity : class
{
IGraphEntityManager <TEntity> graphEntityManager = GetEntityManager <TEntity>();
NavigationDetail navigationDetailOfCurrent = graphEntityManager
.GetNavigationDetail();
// Get parent properties of entity.
// Properties which have navigation property type of which
// is type of entity. Ignore navigation properties
// which are mutual navigation properties with entity itself.
string typeName = currentValue.GetType().Name;
List <NavigationDetail> parentNavigationDetails = GetNavigationDetails()
.Select(n => new NavigationDetail()
{
SourceTypeName = n.SourceTypeName,
Relations = n.Relations
.Where(r => r.PropertyTypeName.Equals(typeName) &&
r.SourceMultiplicity == RelationshipMultiplicity.Many &&
!navigationDetailOfCurrent
.Relations
.Any(c => c.PropertyTypeName.Equals(n.SourceTypeName) &&
c.TargetMultiplicity == r.SourceMultiplicity &&
c.FromKeyNames.SequenceEqual(r.FromKeyNames) &&
c.ToKeyNames.SequenceEqual(r.ToKeyNames)))
.ToList()
})
.Where(n => n.Relations != null &&
n.Relations.Count() > 0)
.ToList();
// Get assembly to be able to get types according to type name
Assembly entityAssembly = currentValue.GetType().Assembly;
if (parentNavigationDetails != null && parentNavigationDetails.Count() > 0)
{
foreach (NavigationDetail parentNavigation in parentNavigationDetails)
{
Type parentType = entityAssembly.GetTypes()
.FirstOrDefault(t => t.Name.Equals(parentNavigation.SourceTypeName));
// Get local set of parent
IEnumerable <object> localParentSet = Context
.Set(parentType)
.Local
.CastToGeneric();
foreach (NavigationRelation navigationRelation in parentNavigation.Relations)
{
PropertyInfo childProperty =
parentType.GetProperty(navigationRelation.PropertyName);
if (!childProperty.PropertyType.IsCollectionType())
{
// Get all parent entities which have current entity inside
var containerParentCollection = localParentSet
.Where(m => m.GetPropertyValue(navigationRelation.PropertyName) != null &&
m.GetPropertyValue(navigationRelation.PropertyName).Equals(currentValue))
.ToList();
// If collection is empty then skip.
if (containerParentCollection == null ||
containerParentCollection.Count == 0)
{
continue;
}
foreach (var containerParent in containerParentCollection)
{
// If parent is null then skip.
if (containerParent == null)
{
continue;
}
// If parent with property value of currentValue found replace values
/*
* If duplicate entity is in the entity, state of which has already
* been defined and if state of this parent entity is Unchanged or
* Modified, trying to change navigation property of this parent entity
* will throw InvalidOperationException with following message:
* "A referential integrity constraint violation occurred:
* A primary key property that is a part of referential integrity constraint
* cannot be changed when the dependent object is Unchanged unless it is being
* set to the association's principal object. The principal object must
* be tracked and not marked for deletion."
* As a workaround I am storing current state of parent entity, changing the
* state to Added, then replacing duplicate entity and in the end
* I set state of parent entity to stored current state.
*/
// Store current state
var currentState = Context.Entry(containerParent).State;
// Change state to added
Context.Entry(containerParent).State = EntityState.Added;
// Replace value through
// context.Entry(containerParent).Member(propertyName).CurrentValue
// because otherwise EntityFramework will not be able to track entities
Context.Entry(containerParent)
.Member(navigationRelation.PropertyName).CurrentValue = targetValue;
// Restore state to current state
Context.Entry(containerParent).State = currentState;
}
}
}
}
}
}
/// <summary>
/// Get parents of entity which contains this entity
/// </summary>
/// <exception cref="ArgumentNullException">
/// When entity is null
/// </exception>
/// <typeparam name="TEntity">Type of entity.</typeparam>
/// <param name="entity">Entity to get parent.</param>
/// <param name="onlyPrincipal">Get only one-to-one parent of entity</param>
/// <returns>Principal parent of entity.</returns>
public IEnumerable <object> GetParents <TEntity>(
TEntity entity,
bool onlyPrincipal)
where TEntity : class
{
if (entity == null)
{
throw new ArgumentNullException(nameof(entity));
}
string typeName = entity.GetType().Name;
List <RelationshipMultiplicity> principalRelationshipMultiplicity =
new List <RelationshipMultiplicity>()
{
RelationshipMultiplicity.One,
RelationshipMultiplicity.ZeroOrOne
};
IGraphEntityTypeManager graphEntityTypeMangeer = GetEntityTypeManager(typeName);
NavigationDetail navigationDetailOfCurrent = graphEntityTypeMangeer
.GetNavigationDetail();
// Get only those parent property navigation details
// which has navigation property to this entity
var parentNavigationDetails = navigationDetailOfCurrent
.Relations
.Where(r => r.Direction == NavigationDirection.From)
.Select(r =>
{
IGraphEntityTypeManager typeManager =
GetEntityTypeManager(r.PropertyTypeName);
return(new
{
SourceTypeName = r.PropertyTypeName,
Relation = typeManager
.GetNavigationDetail()
.Relations
.FirstOrDefault(pr =>
pr.PropertyTypeName.Equals(typeName) &&
pr.SourceMultiplicity == r.TargetMultiplicity &&
pr.TargetMultiplicity == r.SourceMultiplicity &&
pr.ToKeyNames.SequenceEqual(r.ToKeyNames))
});
})
.Where(r => r.Relation != null);
if (onlyPrincipal)
{
parentNavigationDetails = parentNavigationDetails
.Where(r => principalRelationshipMultiplicity
.Contains(r.Relation.TargetMultiplicity));
}
List <string> parentPropertyNames = navigationDetailOfCurrent
.Relations
.Where(r => parentNavigationDetails.Any(p =>
p.SourceTypeName == r.PropertyTypeName &&
p.Relation.SourceMultiplicity == r.TargetMultiplicity &&
p.Relation.TargetMultiplicity == r.SourceMultiplicity &&
p.Relation.ToKeyNames.SequenceEqual(r.ToKeyNames)))
.Select(r => r.PropertyName)
.ToList();
if (parentPropertyNames != null &&
parentPropertyNames.Count > 0)
{
foreach (string propertyName in parentPropertyNames)
{
object parent = entity.GetPropertyValue(propertyName);
if (parent != null)
{
yield return(parent);
}
}
}
}
/// <summary>
/// Construct filter expression for entity.
/// </summary>
/// <param name="entity">Entity to construct filter expression for.</param>
/// <param name="typeOfFilter">Type of filter expression.</param>
/// <returns>Filter expression according to entity.</returns>
public Expression <Func <TEntity, bool> > ConstructFilterExpression(
TEntity entity,
FilterType typeOfFilter)
{
Expression <Func <TEntity, bool> > filterExpression = null;
IEnumerable <string> primaryKeyNames = GetPrimaryKeys();
if (primaryKeyNames.Count() == 0)
{
throw new ArgumentException(string.Format(
"'{0}' has no configured primary key.",
typeof(TEntity).Name));
}
List <Expression> equalityExpressions = new List <Expression>();
IEnumerable <Expression> singleExpressionList;
ParameterExpression parameterExp = Expression.Parameter(typeof(TEntity), "m");
Expression pkFilter = null;
Expression ukFilter = null;
bool primaryKeysHaveDefaultValues = entity.HasDefaultValues(primaryKeyNames);
if (!primaryKeysHaveDefaultValues &&
typeOfFilter != FilterType.OnlyUnique)
{
// If primary keys do not have their default values
// add this check to equlity expression list
singleExpressionList = parameterExp
.ConstructEqualityExpressions(
entity,
primaryKeyNames);
pkFilter = singleExpressionList.ConstructAndChain();
}
if (typeOfFilter != FilterType.OnlyId &&
(primaryKeysHaveDefaultValues ||
typeOfFilter != FilterType.IdOptionalUnique))
{
IEnumerable <PropertiesWithSource> uniqueProperties =
MappingStorage.Instance.UniqueProperties.Where(
m => m.SourceType.Equals(entity.GetType()));
if (uniqueProperties.Count() > 0)
{
foreach (PropertiesWithSource unique in uniqueProperties)
{
/*
***********************************************************
* If any of current set of properties
* marked as unique is foreign key,
* has default value, and appropriate navigation property is not
* null and also origin of this foreign
* key has any store generated primary key then this
* uniqueness must be ignored.
* For example if PersonId (int) and DocumentType (short) has been
* set as composite unique in PersonDocument and
* if PersonId is foreign key to Person, which in its term has
* Primary key which is store generated and if there is no navigation
* property to Person from PersonDocument or PersonDocument.Person is not null
* then PersonId = 0 and DocumentType = 5 should not
* be treated as unique, because the real value of PersonId
* will be computed when data will be inserted.
***********************************************************
*/
IGraphEntityTypeManager uniqueSourceTypeManager = ContextFactory
.GetEntityTypeManager(unique.SourceType.Name);
bool uniquenessMustBeIgnored = false;
var uniquePropertyNames = unique.Properties.Select(m => m.Name).ToList();
var uniqueForeignKeys = uniqueSourceTypeManager
.GetForeignKeyDetails()
.Select(m => new
{
TargetClass = m.FromDetails.ContainerClass,
Keys = m.ToDetails.Keys.Intersect(uniquePropertyNames)
})
.Where(m => m.Keys != null &&
m.Keys.Any());
NavigationDetail navigationDetailsOfCurrent = GetNavigationDetail();
// If unuque property is foreign key
if (uniqueForeignKeys != null &&
uniqueForeignKeys.Any())
{
foreach (var uniqueFk in uniqueForeignKeys)
{
// If foreign key has default value
if (uniqueFk.Keys.Any(u => entity.HasDefaultValue(u)))
{
// Get navigation relation according to foreign key
NavigationRelation navigationRelation = navigationDetailsOfCurrent
.Relations
.FirstOrDefault(r => r.Direction == NavigationDirection.From &&
r.PropertyTypeName.Equals(uniqueFk.TargetClass) &&
r.ToKeyNames.Intersect(uniqueFk.Keys).Any());
// If corresponding navigation property is not null
// or there is no such navigation property
if (navigationRelation == null ||
entity.GetPropertyValue(navigationRelation.PropertyName) != null)
{
bool foreignKeyHasStoreGeneratedPrimaryKey =
uniqueFk.Keys.Any(k =>
{
// Get origin of foreign key and check
// if it has store generated key.
string foreignKeyOrigin = uniqueSourceTypeManager
.GetOriginOfForeignKey(k);
IGraphEntityTypeManager foreignKeyOriginTypeManger = ContextFactory
.GetEntityTypeManager(foreignKeyOrigin);
return(foreignKeyOriginTypeManger.HasStoreGeneratedKey());
});
// If origin of foreign key has store generated Primary key
if (foreignKeyHasStoreGeneratedPrimaryKey)
{
uniquenessMustBeIgnored = true;
break;
}
}
}
}
}
// If uniqueness must be ignored then skip this iteration
if (uniquenessMustBeIgnored)
{
continue;
}
singleExpressionList = parameterExp
.ConstructEqualityExpressions(
entity,
unique.Properties
.Select(m => m.Name).ToList());
equalityExpressions.Add(singleExpressionList.ConstructAndChain());
}
if (equalityExpressions.Count > 0)
{
ukFilter = equalityExpressions.ConstructOrChain();
}
}
}
equalityExpressions.Clear();
if (pkFilter != null)
{
equalityExpressions.Add(pkFilter);
}
if (ukFilter != null)
{
equalityExpressions.Add(ukFilter);
}
if (equalityExpressions.Count > 0)
{
Expression filterBaseExpression = typeOfFilter == FilterType.IdAndUnique
? equalityExpressions.ConstructAndChain()
: equalityExpressions.ConstructOrChain();
filterExpression = Expression.Lambda <Func <TEntity, bool> >(
filterBaseExpression, parameterExp);
}
return(filterExpression);
}
public Task PopToRoot(bool animate = true)
{
return(NavigationDetail.PopToRootAsync(animate));
}
public Task PopPage(bool modal = false, bool animate = true)
{
return(modal
? Navigation.PopModalAsync(animate)
: NavigationDetail.PopAsync(animate));
}
