/// <summary>
        /// Add PK and FK fields, as hidden ones, if they weren´t already provided in the metadata.xml configuration.
        /// This avoid common mistakes.
        /// </summary>
        private static void AddHiddenRequiredFields(ApplicationSchemaDefinition schema)
        {
            var idFieldDefinition = schema.Fields.FirstOrDefault(f => f.Attribute == schema.IdFieldName);

            if (idFieldDefinition == null && !schema.Abstract)
            {
                //if its abstract, it may be declared on the child schemas, so we wont take any action
                var idField = ApplicationFieldDefinition.HiddenInstance(schema.ApplicationName, schema.IdFieldName);
                schema.Displayables.Add(idField);
            }
            CreateMissingRelationshipFields(schema);
        }
 private static void CreateMissingRelationshipFields(ApplicationSchemaDefinition schema)
 {
     foreach (var dataProviderContainer in schema.DataProviderContainers)
     {
         if (schema.Fields.All(f => f.Attribute != dataProviderContainer.Target))
         {
             //adding hidden field to the from clause, in the case it wasn´t explicity declared in the metadata.xml
             var fromField = ApplicationFieldDefinition.HiddenInstance(schema.ApplicationName, dataProviderContainer.Target);
             schema.Displayables.Add(fromField);
         }
     }
 }
        private static IEnumerable <IApplicationAttributeDisplayable> InverseFKsFields(ApplicationSchemaDefinition thisSchema)
        {
            var resultList   = new List <IApplicationAttributeDisplayable>();
            var applications = MetadataProvider.Applications();

            if (MetadataProvider.InternalCache == null)
            {
                MetadataProvider.InternalCache = new MetadataProviderInternalCache();
            }

            var cache = MetadataProvider.InternalCache;

            var relationshipName = EntityUtil.GetRelationshipName(thisSchema.ApplicationName);

            if (!cache.RelationshipsByNameCache.ContainsKey(relationshipName))
            {
                return(resultList);
            }

            var relationships = MetadataProvider.InternalCache.RelationshipsByNameCache[relationshipName];

            foreach (var association in relationships)
            {
                var entityAssociation = association.EntityAssociation;
                foreach (var attribute in entityAssociation.Attributes)
                {
                    if (attribute.To != null)
                    {
                        resultList.Add(ApplicationFieldDefinition.HiddenInstance(thisSchema.ApplicationName,
                                                                                 attribute.To));
                    }
                }
            }


            return(resultList);
        }