/// <exclude />
        public static Guid GetMetaDataReferencedPageId(IData metaData)
        {
            PropertyInfo propertyInfo = PageMetaDataFacade.GetDefinitionPageReferencePropertyInfo(metaData.DataSourceId.InterfaceType);

            Guid pageId = (Guid)propertyInfo.GetValue(metaData, null);

            return(pageId);
        }
        /// <summary>
        /// Using the given pageType this methods adds meta data instances that are missing
        /// </summary>
        /// <param name="definingPageType"></param>
        /// <param name="metaDataDefinitionName"></param>
        /// <param name="newDataTemplate"></param>
        public static void AddNewMetaDataToExistingPages(this IPageType definingPageType, string metaDataDefinitionName, IData newDataTemplate)
        {
            IPageMetaDataDefinition pageMetaDataDefinition = GetMetaDataDefinition(definingPageType.Id, metaDataDefinitionName);

            DataTypeDescriptor dataTypeDescriptor = DynamicTypeManager.GetDataTypeDescriptor(pageMetaDataDefinition.MetaDataTypeId);
            Type metaDataType = TypeManager.GetType(dataTypeDescriptor.TypeManagerTypeName);

            IEnumerable <IPage> affectedPages = PageMetaDataFacade.GetMetaDataAffectedPagesByPageTypeId(definingPageType.Id);

            AddNewMetaDataToExistingPages(affectedPages, metaDataDefinitionName, metaDataType, newDataTemplate);
        }
        /// <exclude />
        public static IData GetMetaData(Guid pageId, Guid pageVersionId, string definitionName, Type metaDataType)
        {
            Verify.ArgumentNotNull(definitionName, nameof(definitionName));
            Verify.ArgumentNotNull(metaDataType, nameof(metaDataType));

            //TODO: Consider caching here
            var parameterExpression = Expression.Parameter(metaDataType);

            var lambdaExpression = Expression.Lambda(
                Expression.And(
                    Expression.And(
                        Expression.Equal(
                            Expression.Property(
                                parameterExpression,
                                PageMetaDataFacade.GetDefinitionNamePropertyInfo(metaDataType)
                                ),
                            Expression.Constant(
                                definitionName,
                                typeof(string)
                                )
                            ),
                        Expression.Equal(
                            Expression.Property(
                                parameterExpression,
                                GetDefinitionPageReferencePropertyInfo(metaDataType)
                                ),
                            Expression.Constant(
                                pageId,
                                typeof(Guid)
                                )
                            )
                        ),
                    Expression.Equal(
                        Expression.Property(
                            parameterExpression,
                            GetDefinitionPageReferencePropertyVersionInfo(metaDataType)
                            ),
                        Expression.Constant(
                            pageVersionId,
                            typeof(Guid)
                            )
                        )
                    ),
                parameterExpression
                );

            Expression whereExpression = ExpressionCreator.Where(DataFacade.GetData(metaDataType).Expression, lambdaExpression);

            IEnumerable <IData> dataset = ExpressionHelper.GetCastedObjects <IData>(metaDataType, whereExpression);

            return(dataset.SingleOrDefaultOrException("There're multiple meta data on a page. Page '{0}', definition name '{1}', meta type '{2}'",
                                                      pageId, definitionName, metaDataType.FullName));
        }