/// <returns>a Zetbox TypeRef for a given System.Type</returns> public static TypeRef ToRef(this Type t, IReadOnlyZetboxContext ctx) { if (t == null) { throw new ArgumentNullException("t"); } if (ctx == null) { throw new ArgumentNullException("ctx"); } // TODO: think about and implement naked types (i.e. without arguments) if (t.IsGenericTypeDefinition) { throw new ArgumentOutOfRangeException("t"); } var result = GetFromCache(t, ctx); if (result != null) { return(result); } result = LookupByType(ctx, ctx.GetQuery <TypeRef>(), t); if (result != null) { AddToCache(t, result, ctx); } return(result); }
public static CompoundObject GetCompoundObjectDefinition(this ICompoundObject obj, IReadOnlyZetboxContext ctx) { if (obj == null) { throw new ArgumentNullException("obj"); } if (ctx == null) { throw new ArgumentNullException("ctx"); } return GetCompoundObjectDefinition(ctx.GetInterfaceType(obj), ctx); }
/// <summary> /// Initializes caches for the provider of the given Context /// </summary> /// <param name="metaCtx">the context used to access the meta data</param> private void CreateInvokeInfosForDataTypes(IReadOnlyZetboxContext metaCtx) { if (metaCtx == null) { throw new ArgumentNullException("metaCtx"); } foreach (var objClass in metaCtx.GetQuery <CompoundObject>()) { try { CreateInvokeInfosForAssembly(objClass); } catch (Exception ex) { Log.Warn("Exception in CreateInvokeInfosForObjectClasses", ex); } } // put this in separate loop to avoid mono bug #701187 // see https://bugzilla.novell.com/show_bug.cgi?id=701187 foreach (var objClass in metaCtx.GetQuery <ObjectClass>()) { try { CreateInvokeInfosForAssembly(objClass); } catch (Exception ex) { Log.Warn("Exception in CreateInvokeInfosForObjectClasses", ex); } } }
public static void ExportFromContext(IReadOnlyZetboxContext ctx, string filename, string[] schemaModules, string[] ownerModules) { using (var s = new FileSystemPackageProvider(filename, BasePackageProvider.Modes.Write)) { ExportFromContext(ctx, s, schemaModules, ownerModules); } }
public static void ExportFromContext(IReadOnlyZetboxContext ctx, Stream stream, string[] schemaModules, string[] ownerModules, string streamDescription) { using (var s = new StreamPackageProvider(stream, BasePackageProvider.Modes.Write, streamDescription)) { ExportFromContext(ctx, s, schemaModules, ownerModules); } }
public static TCacheItem TransientState <TCacheItem>(this IReadOnlyZetboxContext ctx, string transientCacheKey, Func <TCacheItem> getter) { if (ctx == null) { throw new ArgumentNullException("ctx"); } if (string.IsNullOrEmpty(transientCacheKey)) { throw new ArgumentNullException("transientCacheKey"); } if (getter == null) { throw new ArgumentNullException("getter"); } if (!ctx.TransientState.ContainsKey(transientCacheKey)) { var result = getter(); ctx.TransientState[transientCacheKey] = result; return(result); } else { // Cachehit // Maybe count it here return((TCacheItem)ctx.TransientState[transientCacheKey]); } }
public static void CollectChildClasses(this ObjectClass cls, IReadOnlyZetboxContext ctx, List <ObjectClass> children, bool includeAbstract) { if (cls == null) { throw new ArgumentNullException("cls"); } if (ctx == null) { throw new ArgumentNullException("ctx"); } if (children == null) { throw new ArgumentNullException("children"); } var nextChildren = ctx .GetQuery <ObjectClass>() .Where(oc => oc.BaseObjectClass != null && oc.BaseObjectClass.ID == cls.ID) .ToList(); if (nextChildren.Count() > 0) { foreach (ObjectClass oc in nextChildren) { if (includeAbstract || !oc.IsAbstract) { children.Add(oc); } CollectChildClasses(oc, ctx, children, includeAbstract); } ; } }
/// <summary> /// Initializes this CustomActionsManager. This method is thread-safe and won't do /// anything if the ActionsManager is already initialized. /// </summary> public virtual void Init(IReadOnlyZetboxContext ctx) { lock (_initLock) { var implType = this.GetType(); if (_initImpls.ContainsKey(implType)) { return; } try { Log.InfoFormat("Initializing Actions for [{0}] by [{1}]", ExtraSuffix, implType.Name); Log.TraceTotalMemory("Before BaseCustomActionsManager.Init()"); ReflectMethods(ctx); CreateInvokeInfosForDataTypes(ctx); foreach (var key in _reflectedMethods.Where(i => !_attachedMethods.ContainsKey(i.Key)).Select(i => i.Key)) { Log.Warn(string.Format("Couldn't find any method for Invocation {0}", key)); } Log.TraceTotalMemory("After BaseCustomActionsManager.Init()"); } finally { _initImpls[implType] = implType; } } }
public IEnumerable <T> Find(IReadOnlyZetboxContext ctx) { if (ctx == null) { throw new ArgumentNullException("ctx"); } return(ctx.FindPersistenceObjects <T>(_guid)); }
public static CompoundObject GetCompoundObjectDefinition(this InterfaceType ifType, IReadOnlyZetboxContext ctx) { if (ctx == null) { throw new ArgumentNullException("ctx"); } Type type = ifType.Type; CompoundObject result; result = ctx.TransientState("__CompoundObjectExtensions__GetCompoundObjectDefinition__", type, () => ctx.GetQuery<CompoundObject>().First(o => o.Module.Namespace == type.Namespace && o.Name == type.Name)); return result; }
private static void AddToCache(Type t, TypeRef tr, IReadOnlyZetboxContext ctx) { if (!ctx.TransientState.ContainsKey(transientCacheKey)) { ctx.TransientState[transientCacheKey] = new Dictionary <Type, TypeRef>(); } var cache = (Dictionary <Type, TypeRef>)ctx.TransientState[transientCacheKey]; cache[t] = tr; }
public static Interface GetIExportableInterface(this IReadOnlyZetboxContext ctx) { if (ctx == null) { throw new ArgumentNullException("ctx"); } // TODO: use named objects return(ctx.GetQuery <Zetbox.App.Base.Interface>().First(o => o.Name == "IExportable" && o.Module.Name == "ZetboxBase")); }
private static void PrimeCaches(Toolkit?tk, IReadOnlyZetboxContext ctx) { if (_pmdCache == null) { _pmdCache = new ViewModelDescriptorCache(ctx); } if (tk.HasValue && !_viewCaches.ContainsKey(tk.Value)) { _viewCaches[tk.Value] = ViewDescriptorToolkitCache.Content.CreateCache(tk.Value, ctx); } }
public static ObjectClass GetObjectClass(this IDataObject obj, IReadOnlyZetboxContext ctx) { if (obj == null) { throw new ArgumentNullException("obj"); } if (ctx == null) { throw new ArgumentNullException("ctx"); } return(ctx.FindPersistenceObject <ObjectClass>(obj.ObjectClassID)); }
public override IServerCollectionHandler GetServerCollectionHandler( IReadOnlyZetboxContext ctx, InterfaceType aType, InterfaceType bType, RelationEndRole endRole) { if (ctx == null) throw new ArgumentNullException("ctx"); return GetServerCollectionHandlerHelper( typeof(ServerCollectionHandler<,,,>), ctx.ToImplementationType(aType), ctx.ToImplementationType(bType), endRole); }
private static TypeRef GetFromCache(Type t, IReadOnlyZetboxContext ctx) { if (!ctx.TransientState.ContainsKey(transientCacheKey)) { ctx.TransientState[transientCacheKey] = new Dictionary <Type, TypeRef>(); } var cache = (Dictionary <Type, TypeRef>)ctx.TransientState[transientCacheKey]; if (cache.ContainsKey(t)) { return(cache[t]); } return(null); }
public static Content CreateCache(Toolkit tk, IReadOnlyZetboxContext ctx) { var result = new Content(); // All View Descriptors for the given Toolkit result._allVDCache = new ReadOnlyCollection <ViewDescriptor>( ctx.GetQuery <ViewDescriptor>().WithEagerLoading().Where(obj => obj.Toolkit == tk).ToList()); // Dictionary by Kind result._vdCache = result._allVDCache.Where(obj => obj.ControlKind != null).GroupBy(obj => obj.ControlKind) .ToDictionary(g => g.Key.ExportGuid, g => new ReadOnlyCollection <ViewDescriptor>(g.ToList())); return(result); }
public static ObjectClass GetObjectClass(this Type type, IReadOnlyZetboxContext ctx) { if (type == null) { throw new ArgumentNullException("type"); } if (ctx == null) { throw new ArgumentNullException("ctx"); } ObjectClass result = ctx.TransientState("__ObjectClassExtensions__GetObjectClass__", type.FullName, () => ctx.GetQuery <ObjectClass>().First(o => o.Module.Namespace == type.Namespace && o.Name == type.Name)); return(result); }
/// <returns>a Zetbox TypeRef for a given System.Type</returns> public static TypeRef ToRef(this Type t, IReadOnlyZetboxContext ctx) { if (t == null) { throw new ArgumentNullException("t"); } if (ctx == null) { throw new ArgumentNullException("ctx"); } // TODO: think about and implement naked types (i.e. without arguments) if (t.IsGenericTypeDefinition) { throw new ArgumentOutOfRangeException("t"); } var result = GetFromCache(t, ctx); if (result != null) return result; result = LookupByType(ctx, ctx.GetQuery<TypeRef>(), t); if (result != null) AddToCache(t, result, ctx); return result; }
public void Submitted(IReadOnlyZetboxContext ctx, IEnumerable<IDataObject> added, IEnumerable<IDataObject> modified, IEnumerable<Tuple<InterfaceType, int>> deleted) { _queue.Enqueue(new IndexUpdate() { added = added.Select(obj => new Tuple<InterfaceType, int, IndexUpdate.Text>( ctx.GetInterfaceType(obj), obj.ID, Rebuilder.ExtractText(obj, _formatter, _resolver) )).ToList().AsReadOnly(), modified = modified.Select(obj => new Tuple<InterfaceType, int, IndexUpdate.Text>( ctx.GetInterfaceType(obj), obj.ID, Rebuilder.ExtractText(obj, _formatter, _resolver) )).ToList().AsReadOnly(), deleted = deleted.ToList().AsReadOnly() }); }
public ToStringFilterModel(IReadOnlyZetboxContext frozenCtx) : base() { if (frozenCtx == null) { throw new ArgumentNullException("frozenCtx"); } base.IsServerSideFilter = false; base.Label = FilterModelsResources.ToStringFilterModel_Label; base.ViewModelType = ViewModelDescriptors.Zetbox_Client_Presentables_FilterViewModels_SingleValueFilterViewModel.Find(frozenCtx); base.FilterArguments.Add(new FilterArgumentConfig( new ClassValueModel <string>(base.Label, FilterModelsResources.ToStringFilterModel_Description, true, false), ViewModelDescriptors.Zetbox_Client_Presentables_ValueViewModels_ClassValueViewModel_1_System_String_.Find(frozenCtx) )); base.RefreshOnFilterChanged = false; }
private static TypeRef LookupByType(IReadOnlyZetboxContext ctx, IQueryable <TypeRef> source, Type t) { // TODO: think about and implement naked types (i.e. without arguments) if (t.IsGenericTypeDefinition) { throw new ArgumentOutOfRangeException("t"); } if (t.IsGenericType) { string fullName = t.GetGenericTypeDefinition().FullName; var args = t.GetGenericArguments().Select(arg => arg.ToRef(ctx)).ToArray(); var argsCount = args.Count(); foreach (var tRef in source.Where(tRef => tRef.Assembly.Name == t.Assembly.FullName && tRef.FullName == fullName && tRef.GenericArguments.Count == argsCount)) { bool equal = true; for (int i = 0; i < tRef.GenericArguments.Count; i++) { equal &= args[i] == tRef.GenericArguments[i]; if (!equal) { break; } } if (equal) { return(tRef); } } return(null); } else { // ToList: Workaround Case 1212 return(source.FirstOrDefault(tRef => tRef.Assembly.Name == t.Assembly.FullName && tRef.FullName == t.FullName && tRef.GenericArguments.Count == 0)); } }
public static void CollectChildClasses(this ObjectClass cls, IReadOnlyZetboxContext ctx, List<ObjectClass> children, bool includeAbstract) { if (cls == null) throw new ArgumentNullException("cls"); if (ctx == null) throw new ArgumentNullException("ctx"); if (children == null) throw new ArgumentNullException("children"); var nextChildren = ctx .GetQuery<ObjectClass>() .Where(oc => oc.BaseObjectClass != null && oc.BaseObjectClass.ID == cls.ID) .ToList(); if (nextChildren.Count() > 0) { foreach (ObjectClass oc in nextChildren) { if (includeAbstract || !oc.IsAbstract) children.Add(oc); CollectChildClasses(oc, ctx, children, includeAbstract); }; } }
private static void WriteStartDocument(IPackageProvider s, IReadOnlyZetboxContext ctx, IEnumerable <Zetbox.App.Base.Module> moduleList) { XmlWriter writer = s.Writer; writer.WriteStartDocument(); if (moduleList.Count() == 1) { // use exported module as default namespace writer.WriteStartElement("ZetboxPackaging", "http://dasz.at/Zetbox"); foreach (var module in moduleList) { writer.WriteAttributeString("xmlns", module.Name, null, module.Namespace); } } else { writer.WriteStartElement("ZetboxPackaging", "http://dasz.at/Zetbox"); foreach (var module in moduleList) { writer.WriteAttributeString("xmlns", module.Name, null, module.Namespace); } } DateTime?lastChanged = new DateTime?[] { ctx.GetQuery <Zetbox.App.Base.Assembly>().Max(d => d.ChangedOn), ctx.GetQuery <Zetbox.App.Base.BaseParameter>().Max(d => d.ChangedOn), ctx.GetQuery <Zetbox.App.Base.Constraint>().Max(d => d.ChangedOn), ctx.GetQuery <Zetbox.App.Base.DataType>().Max(d => d.ChangedOn), ctx.GetQuery <Zetbox.App.Base.DefaultPropertyValue>().Max(d => d.ChangedOn), ctx.GetQuery <Zetbox.App.Base.EnumerationEntry>().Max(d => d.ChangedOn), ctx.GetQuery <Zetbox.App.Base.Method>().Max(d => d.ChangedOn), ctx.GetQuery <Zetbox.App.Base.Module>().Max(d => d.ChangedOn), ctx.GetQuery <Zetbox.App.Base.Property>().Max(d => d.ChangedOn), ctx.GetQuery <Zetbox.App.Base.Relation>().Max(d => d.ChangedOn), ctx.GetQuery <Zetbox.App.Base.RelationEnd>().Max(d => d.ChangedOn), ctx.GetQuery <Zetbox.App.Base.TypeRef>().Max(d => d.ChangedOn) }.Max(); writer.WriteAttributeString("date", XmlConvert.ToString(lastChanged ?? DateTime.Now, XmlDateTimeSerializationMode.Utc)); }
private static Zetbox.App.Base.Module[] GetModules(IReadOnlyZetboxContext ctx, string[] moduleNames) { var moduleList = new List<Zetbox.App.Base.Module>(); if (moduleNames.Contains("*")) { moduleList.AddRange(ctx.GetQuery<Zetbox.App.Base.Module>()); } else { foreach (var name in moduleNames) { var module = ctx.GetQuery<Zetbox.App.Base.Module>().Where(m => m.Name == name).FirstOrDefault(); if (module == null) { Log.WarnFormat("Module {0} not found, skipping entry", name); continue; } moduleList.Add(module); } } return moduleList.OrderBy(m => m.Name).ToArray(); }
public static TCacheItem TransientState <TCacheItem, TKey>(this IReadOnlyZetboxContext ctx, string transientCacheKey, TKey key, Func <TCacheItem> getter) { if (ctx == null) { throw new ArgumentNullException("ctx"); } if (string.IsNullOrEmpty(transientCacheKey)) { throw new ArgumentNullException("transientCacheKey"); } if (getter == null) { throw new ArgumentNullException("getter"); } // Ensure cache // Ensure transient cache if (!ctx.TransientState.ContainsKey(transientCacheKey)) { ctx.TransientState[transientCacheKey] = new Dictionary <TKey, TCacheItem>(); } Dictionary <TKey, TCacheItem> cache = (Dictionary <TKey, TCacheItem>)ctx.TransientState[transientCacheKey]; TCacheItem result; if (!cache.TryGetValue(key, out result)) { result = getter(); cache[key] = result; return(result); } else { // Cachehit // Maybe count it here return(result); } }
private static List <Zetbox.App.Base.Module> GetModules(IReadOnlyZetboxContext ctx, string[] moduleNames) { var moduleList = new List <Zetbox.App.Base.Module>(); if (moduleNames.Contains("*")) { moduleList.AddRange(ctx.GetQuery <Zetbox.App.Base.Module>()); } else { foreach (var name in moduleNames) { var module = ctx.GetQuery <Zetbox.App.Base.Module>().Where(m => m.Name == name).FirstOrDefault(); if (module == null) { Log.WarnFormat("Module {0} not found, skipping entry", name); continue; } moduleList.Add(module); } } return(moduleList.OrderBy(m => m.Name).ToList()); }
private void ReflectMethods(IReadOnlyZetboxContext metaCtx) { if (metaCtx == null) { throw new ArgumentNullException("metaCtx"); } // Load all Implementor Types and Invocations foreach (var assembly in metaCtx.GetQuery <Zetbox.App.Base.Assembly>()) { try { var restr = assembly.DeploymentRestrictions; if (!_restrictor.IsAcceptableDeploymentRestriction((int)restr)) { continue; } System.Reflection.Assembly a; a = System.Reflection.Assembly.Load(assembly.Name); foreach (var t in a.GetTypes()) { if (t.GetCustomAttributes(typeof(Implementor), false).Length != 0) { if (!t.Name.EndsWith("Actions")) { Log.Warn(string.Format("Type {0} does not end with 'Actions'. Ignoring this type", t.FullName)); continue; } // Found Implementor Type foreach (var m in t.GetMethods(BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance | BindingFlags.DeclaredOnly)) { if (m.GetCustomAttributes(typeof(Invocation), false).Length != 0) { var key = new MethodKey(t.Namespace, t.Name.Substring(0, t.Name.Length - "Actions".Length), m.Name); if (_reflectedMethods.ContainsKey(key)) { _reflectedMethods[key].Add(m); } else { _reflectedMethods[key] = new List <MethodInfo>() { m }; } } else if (m.GetCustomAttributes(typeof(Zetbox.API.Constraint), false).Length != 0) { // TODO: Check if Invoking Constraint is valid } else { Log.Warn(string.Format("Found public method {0}.{1} which has no Invocation attribute. Ignoring this method", t.FullName, m.Name)); } } } } } catch (ReflectionTypeLoadException ex) { if (ex.LoaderExceptions.Count() == 1) { Log.Warn(String.Format("Failed to reflect over Assembly [{0}]. Ignoring and continuing.", assembly.Name), ex.LoaderExceptions.Single()); } else { foreach (var lex in ex.LoaderExceptions) { Log.Warn(String.Format("Failed to reflect over Assembly [{0}]. Ignoring and continuing. Multiple Errors:", assembly.Name), lex); } } } catch (Exception ex) { Log.Warn(String.Format("Error while processing Assembly [{0}]. Ignoring and continuing.", assembly.Name), ex); } } }
/// <summary> /// Initializes caches for the provider of the given Context /// </summary> /// <param name="metaCtx">the context used to access the meta data</param> private void CreateInvokeInfosForDataTypes(IReadOnlyZetboxContext metaCtx) { if (metaCtx == null) { throw new ArgumentNullException("metaCtx"); } foreach (var objClass in metaCtx.GetQuery<CompoundObject>()) { try { CreateInvokeInfosForAssembly(objClass); } catch (Exception ex) { Log.Warn("Exception in CreateInvokeInfosForObjectClasses", ex); } } // put this in separate loop to avoid mono bug #701187 // see https://bugzilla.novell.com/show_bug.cgi?id=701187 foreach (var objClass in metaCtx.GetQuery<ObjectClass>()) { try { CreateInvokeInfosForAssembly(objClass); } catch (Exception ex) { Log.Warn("Exception in CreateInvokeInfosForObjectClasses", ex); } } }
/// <inheritdoc/> public abstract IServerCollectionHandler GetServerCollectionHandler(IReadOnlyZetboxContext ctx, InterfaceType aType, InterfaceType bType, RelationEndRole endRole);
public void Disposed(IReadOnlyZetboxContext ctx) { }
public ViewModelDescriptorCache(IReadOnlyZetboxContext ctx) { _context = ctx; FillCache(); }
public static CompoundObject GetCompoundObjectDefinition(this ICompoundObject obj, IReadOnlyZetboxContext ctx) { if (obj == null) { throw new ArgumentNullException("obj"); } if (ctx == null) { throw new ArgumentNullException("ctx"); } return(GetCompoundObjectDefinition(ctx.GetInterfaceType(obj), ctx)); }
private void ReflectMethods(IReadOnlyZetboxContext metaCtx) { if (metaCtx == null) { throw new ArgumentNullException("metaCtx"); } // Load all Implementor Types and Invocations foreach (var assembly in metaCtx.GetQuery<Zetbox.App.Base.Assembly>()) { try { var restr = assembly.DeploymentRestrictions; if (!_restrictor.IsAcceptableDeploymentRestriction((int)restr)) { continue; } System.Reflection.Assembly a; a = System.Reflection.Assembly.Load(assembly.Name); foreach (var t in a.GetTypes()) { if (t.GetCustomAttributes(typeof(Implementor), false).Length != 0) { if (!t.Name.EndsWith("Actions")) { Log.Warn(string.Format("Type {0} does not end with 'Actions'. Ignoring this type", t.FullName)); continue; } // Found Implementor Type foreach (var m in t.GetMethods(BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance | BindingFlags.DeclaredOnly)) { if (m.GetCustomAttributes(typeof(Invocation), false).Length != 0) { var key = new MethodKey(t.Namespace, t.Name.Substring(0, t.Name.Length - "Actions".Length), m.Name); if (_reflectedMethods.ContainsKey(key)) { _reflectedMethods[key].Add(m); } else { _reflectedMethods[key] = new List<MethodInfo>() { m }; } } else if (m.GetCustomAttributes(typeof(Zetbox.API.Constraint), false).Length != 0) { // TODO: Check if Invoking Constraint is valid } else { Log.Warn(string.Format("Found public method {0}.{1} which has no Invocation attribute. Ignoring this method", t.FullName, m.Name)); } } } } } catch (ReflectionTypeLoadException ex) { if (ex.LoaderExceptions.Count() == 1) { Log.Warn(String.Format("Failed to reflect over Assembly [{0}]. Ignoring and continuing.", assembly.Name), ex.LoaderExceptions.Single()); } else { foreach (var lex in ex.LoaderExceptions) { Log.Warn(String.Format("Failed to reflect over Assembly [{0}]. Ignoring and continuing. Multiple Errors:", assembly.Name), lex); } } } catch (Exception ex) { Log.Warn(String.Format("Error while processing Assembly [{0}]. Ignoring and continuing.", assembly.Name), ex); } } }
/// <summary> /// Initializes this CustomActionsManager. This method is thread-safe and won't do /// anything if the ActionsManager is already initialized. /// </summary> public virtual void Init(IReadOnlyZetboxContext ctx) { lock (_initLock) { var implType = this.GetType(); if (_initImpls.ContainsKey(implType)) return; try { Log.InfoFormat("Initializing Actions for [{0}] by [{1}]", ExtraSuffix, implType.Name); Log.TraceTotalMemory("Before BaseCustomActionsManager.Init()"); ReflectMethods(ctx); CreateInvokeInfosForDataTypes(ctx); foreach (var key in _reflectedMethods.Where(i => !_attachedMethods.ContainsKey(i.Key)).Select(i => i.Key)) { Log.Warn(string.Format("Couldn't find any method for Invocation {0}", key)); } Log.TraceTotalMemory("After BaseCustomActionsManager.Init()"); } finally { _initImpls[implType] = implType; } } }
private static void WriteStartDocument(IPackageProvider s, IReadOnlyZetboxContext ctx, IEnumerable<Zetbox.App.Base.Module> moduleList) { XmlWriter writer = s.Writer; writer.WriteStartDocument(); if (moduleList.Count() == 1) { // use exported module as default namespace writer.WriteStartElement("ZetboxPackaging", "http://dasz.at/Zetbox"); foreach (var module in moduleList) { writer.WriteAttributeString("xmlns", module.Name, null, module.Namespace); } } else { writer.WriteStartElement("ZetboxPackaging", "http://dasz.at/Zetbox"); foreach (var module in moduleList) { writer.WriteAttributeString("xmlns", module.Name, null, module.Namespace); } } DateTime? lastChanged = new DateTime?[] { ctx.GetQuery<Zetbox.App.Base.Assembly>().Max(d => d.ChangedOn), ctx.GetQuery<Zetbox.App.Base.BaseParameter>().Max(d => d.ChangedOn), ctx.GetQuery<Zetbox.App.Base.Constraint>().Max(d => d.ChangedOn), ctx.GetQuery<Zetbox.App.Base.DataType>().Max(d => d.ChangedOn), ctx.GetQuery<Zetbox.App.Base.DefaultPropertyValue>().Max(d => d.ChangedOn), ctx.GetQuery<Zetbox.App.Base.EnumerationEntry>().Max(d => d.ChangedOn), ctx.GetQuery<Zetbox.App.Base.Method>().Max(d => d.ChangedOn), ctx.GetQuery<Zetbox.App.Base.Module>().Max(d => d.ChangedOn), ctx.GetQuery<Zetbox.App.Base.Property>().Max(d => d.ChangedOn), ctx.GetQuery<Zetbox.App.Base.Relation>().Max(d => d.ChangedOn), ctx.GetQuery<Zetbox.App.Base.RelationEnd>().Max(d => d.ChangedOn), ctx.GetQuery<Zetbox.App.Base.TypeRef>().Max(d => d.ChangedOn) }.Max(); writer.WriteAttributeString("date", XmlConvert.ToString(lastChanged ?? DateTime.Now, XmlDateTimeSerializationMode.Utc)); }
public void Init(IReadOnlyZetboxContext ctx) { Reset(); }
public static IZetboxContextInternals Internals(this IReadOnlyZetboxContext ctx) { return((IZetboxContextInternals)ctx); }
private static void PrimeCaches(Toolkit? tk, IReadOnlyZetboxContext ctx) { if (_pmdCache == null) { _pmdCache = new ViewModelDescriptorCache(ctx); } if (tk.HasValue && !_viewCaches.ContainsKey(tk.Value)) { _viewCaches[tk.Value] = ViewDescriptorToolkitCache.Content.CreateCache(tk.Value, ctx); } }
public void Init(IReadOnlyZetboxContext ctx) { // ignore }
public override void SetUp() { base.SetUp(); ctx = GetContext(); }
private static void AddToCache(Type t, TypeRef tr, IReadOnlyZetboxContext ctx) { if (!ctx.TransientState.ContainsKey(transientCacheKey)) { ctx.TransientState[transientCacheKey] = new Dictionary<Type, TypeRef>(); } var cache = (Dictionary<Type, TypeRef>)ctx.TransientState[transientCacheKey]; cache[t] = tr; }
public static CompoundObject GetCompoundObjectDefinition(this InterfaceType ifType, IReadOnlyZetboxContext ctx) { if (ctx == null) { throw new ArgumentNullException("ctx"); } Type type = ifType.Type; CompoundObject result; result = ctx.TransientState("__CompoundObjectExtensions__GetCompoundObjectDefinition__", type, () => ctx.GetQuery <CompoundObject>().First(o => o.Module.Namespace == type.Namespace && o.Name == type.Name)); return(result); }
private static TypeRef LookupByType(IReadOnlyZetboxContext ctx, IQueryable<TypeRef> source, Type t) { // TODO: think about and implement naked types (i.e. without arguments) if (t.IsGenericTypeDefinition) throw new ArgumentOutOfRangeException("t"); if (t.IsGenericType) { string fullName = t.GetGenericTypeDefinition().FullName; var args = t.GetGenericArguments().Select(arg => arg.ToRef(ctx)).ToArray(); var argsCount = args.Count(); foreach (var tRef in source.Where(tRef => tRef.Assembly.Name == t.Assembly.FullName && tRef.FullName == fullName && tRef.GenericArguments.Count == argsCount)) { bool equal = true; for (int i = 0; i < tRef.GenericArguments.Count; i++) { equal &= args[i] == tRef.GenericArguments[i]; if (!equal) break; } if (equal) return tRef; } return null; } else { // ToList: Workaround Case 1212 return source.FirstOrDefault(tRef => tRef.Assembly.Name == t.Assembly.FullName && tRef.FullName == t.FullName && tRef.GenericArguments.Count == 0); } }
/// <summary> /// Exports data from the specified context into the specified package provider. Data is selected by defining /// schema and owning module. /// </summary> /// <remarks> /// <para>For example, exporting {"ZetboxBase", "GUI"}/{"*"} will export all schema information to recreate the /// current database. Exporting {"Calendar"}/{"MyApplication"} will export all calendar data specific to the /// "MyApplication" module. /// </para> /// </remarks> /// <param name="ctx">The data source</param> /// <param name="s">The export target</param> /// <param name="schemaModules">A list of strings naming the schema-defining modules. This selects which data /// (-classes) should be exported. Specify a single asterisk (<code>"*"</code>) to select all available /// modules.</param> /// <param name="ownerModules">A list of strings naming the data-owning modules. This selects whose data should /// be exported. Specify a single asterisk (<code>"*"</code>) to select all available data, independent of /// module-membership. This also includes data that is not member of any module.</param> public static void ExportFromContext(IReadOnlyZetboxContext ctx, IPackageProvider s, string[] schemaModules, string[] ownerModules) { using (Log.DebugTraceMethodCall("ExportFromContext")) { Log.InfoFormat("Starting Export for Modules [{0}], data owned by [{1}]", string.Join(", ", schemaModules), string.Join(", ", ownerModules)); var allData = ownerModules.Contains("*"); var schemaList = GetModules(ctx, schemaModules); var schemaNamespaces = schemaList.Select(m => m.Namespace).ToArray(); WriteStartDocument(s, ctx, schemaList); var iexpIf = ctx.GetIExportableInterface(); foreach (var module in schemaList) { Log.InfoFormat(" exporting module {0}", module.Name); foreach (var objClass in ctx.GetQuery<ObjectClass>().Where(o => o.Module == module).OrderBy(o => o.Name).ToList()) { if (objClass.SubClasses.Count > 0) { Log.DebugFormat(" skipping {0}: not a leaf class", objClass.Name); } else if (!objClass.AndParents(cls => new[] { cls }, cls => cls.BaseObjectClass).SelectMany(cls => cls.ImplementsInterfaces).Contains(iexpIf)) { Log.DebugFormat(" skipping {0}: not exportable", objClass.Name); } else if (allData) { Log.InfoFormat(" exporting class {0}", objClass.Name); foreach (var obj in ctx.Internals().GetAll(objClass.GetDescribedInterfaceType()).OrderBy(obj => ((IExportable)obj).ExportGuid)) { ExportObject(s, obj, schemaNamespaces); } } else if (objClass.ImplementsIModuleMember()) { Log.InfoFormat(" exporting parts of class {0}", objClass.Name); foreach (var obj in ctx.Internals().GetAll(objClass.GetDescribedInterfaceType()) .Cast<IModuleMember>() .Where(mm => mm.Module != null && ownerModules.Contains(mm.Module.Name)) .Cast<IExportable>() .OrderBy(obj => obj.ExportGuid) .Cast<IPersistenceObject>()) { ExportObject(s, obj, schemaNamespaces); } } else { Log.DebugFormat(" skipping {0}", objClass.Name); } } int moduleID = module.ID; // Dont ask foreach (var rel in ctx.GetQuery<Relation>().Where(r => r.Module.ID == moduleID) .OrderBy(r => r.A.Type.Name).ThenBy(r => r.A.RoleName).ThenBy(r => r.B.Type.Name).ThenBy(r => r.B.RoleName).ThenBy(r => r.ExportGuid)) { if (rel.GetRelationType() != RelationType.n_m) continue; if (!rel.A.Type.ImplementsIExportable()) continue; if (!rel.B.Type.ImplementsIExportable()) continue; try { var ifType = rel.GetEntryInterfaceType(); Log.InfoFormat(" {0} ", ifType.Type.Name); MethodInfo mi = ctx.GetType().FindGenericMethod("FetchRelation", new Type[] { ifType.Type }, new Type[] { typeof(Guid), typeof(RelationEndRole), typeof(IDataObject) }); var relations = MagicCollectionFactory.WrapAsCollection<IPersistenceObject>(mi.Invoke(ctx, new object[] { rel.ExportGuid, RelationEndRole.A, null })); foreach (var obj in relations.OrderBy(obj => ((IExportable)obj).ExportGuid)) { ExportObject(s, obj, schemaNamespaces); } } catch (TypeLoadException ex) { var message = String.Format("Failed to load InterfaceType for entries of {0}", rel); Log.Warn(message, ex); } } } s.Writer.WriteEndElement(); s.Writer.WriteEndDocument(); Log.Info("Export finished"); } }
private static TypeRef GetFromCache(Type t, IReadOnlyZetboxContext ctx) { if (!ctx.TransientState.ContainsKey(transientCacheKey)) { ctx.TransientState[transientCacheKey] = new Dictionary<Type, TypeRef>(); } var cache = (Dictionary<Type, TypeRef>)ctx.TransientState[transientCacheKey]; if (cache.ContainsKey(t)) return cache[t]; return null; }
public override void SetUp() { base.SetUp(); ctx = scope.Resolve<IReadOnlyZetboxContext>(); }
/// <summary> /// Exports data from the specified context into the specified package provider. Data is selected by defining /// schema and owning module. /// </summary> /// <remarks> /// <para>For example, exporting {"ZetboxBase", "GUI"}/{"*"} will export all schema information to recreate the /// current database. Exporting {"Calendar"}/{"MyApplication"} will export all calendar data specific to the /// "MyApplication" module. /// </para> /// </remarks> /// <param name="ctx">The data source</param> /// <param name="s">The export target</param> /// <param name="schemaModules">A list of strings naming the schema-defining modules. This selects which data /// (-classes) should be exported. Specify a single asterisk (<code>"*"</code>) to select all available /// modules.</param> /// <param name="ownerModules">A list of strings naming the data-owning modules. This selects whose data should /// be exported. Specify a single asterisk (<code>"*"</code>) to select all available data, independent of /// module-membership. This also includes data that is not member of any module.</param> public static void ExportFromContext(IReadOnlyZetboxContext ctx, IPackageProvider s, string[] schemaModules, string[] ownerModules) { using (Log.DebugTraceMethodCall("ExportFromContext")) { Log.InfoFormat("Starting Export for Modules [{0}], data owned by [{1}]", string.Join(", ", schemaModules), string.Join(", ", ownerModules)); var allData = ownerModules.Contains("*"); var schemaList = GetModules(ctx, schemaModules); var schemaNamespaces = schemaList.Select(m => m.Namespace).ToArray(); WriteStartDocument(s, ctx, schemaList); var iexpIf = ctx.GetIExportableInterface(); foreach (var module in schemaList) { Log.InfoFormat(" exporting module {0}", module.Name); foreach (var objClass in ctx.GetQuery <ObjectClass>().Where(o => o.Module == module).OrderBy(o => o.Name).ToList()) { if (objClass.SubClasses.Count > 0) { Log.DebugFormat(" skipping {0}: not a leaf class", objClass.Name); } else if (!objClass.AndParents(cls => new[] { cls }, cls => cls.BaseObjectClass).SelectMany(cls => cls.ImplementsInterfaces).Contains(iexpIf)) { Log.DebugFormat(" skipping {0}: not exportable", objClass.Name); } else if (allData) { Log.InfoFormat(" exporting class {0}", objClass.Name); foreach (var obj in ctx.Internals().GetAll(objClass.GetDescribedInterfaceType()).OrderBy(obj => ((IExportable)obj).ExportGuid)) { ExportObject(s, obj, schemaNamespaces); } } else if (objClass.ImplementsIModuleMember()) { Log.InfoFormat(" exporting parts of class {0}", objClass.Name); foreach (var obj in ctx.Internals().GetAll(objClass.GetDescribedInterfaceType()) .Cast <IModuleMember>() .Where(mm => mm.Module != null && ownerModules.Contains(mm.Module.Name)) .Cast <IExportable>() .OrderBy(obj => obj.ExportGuid) .Cast <IPersistenceObject>()) { ExportObject(s, obj, schemaNamespaces); } } else { Log.DebugFormat(" skipping {0}", objClass.Name); } } int moduleID = module.ID; // Dont ask foreach (var rel in ctx.GetQuery <Relation>().Where(r => r.Module.ID == moduleID) .OrderBy(r => r.A.Type.Name).ThenBy(r => r.A.RoleName).ThenBy(r => r.B.Type.Name).ThenBy(r => r.B.RoleName).ThenBy(r => r.ExportGuid)) { if (rel.GetRelationType() != RelationType.n_m) { continue; } if (!rel.A.Type.ImplementsIExportable()) { continue; } if (!rel.B.Type.ImplementsIExportable()) { continue; } try { var ifType = rel.GetEntryInterfaceType(); Log.InfoFormat(" {0} ", ifType.Type.Name); MethodInfo mi = ctx.GetType().FindGenericMethod("FetchRelation", new Type[] { ifType.Type }, new Type[] { typeof(Guid), typeof(RelationEndRole), typeof(IDataObject) }); var relations = MagicCollectionFactory.WrapAsCollection <IPersistenceObject>(mi.Invoke(ctx, new object[] { rel.ExportGuid, RelationEndRole.A, null })); foreach (var obj in relations.OrderBy(obj => ((IExportable)obj).ExportGuid)) { ExportObject(s, obj, schemaNamespaces); } } catch (TypeLoadException ex) { var message = String.Format("Failed to load InterfaceType for entries of {0}", rel); Log.Warn(message, ex); } } } s.Writer.WriteEndElement(); s.Writer.WriteEndDocument(); Log.Info("Export finished"); } }
public static ObjectClass GetObjectClass(this IDataObject obj, IReadOnlyZetboxContext ctx) { if (obj == null) { throw new ArgumentNullException("obj"); } if (ctx == null) { throw new ArgumentNullException("ctx"); } return ctx.FindPersistenceObject<ObjectClass>(obj.ObjectClassID); }
public void Created(IReadOnlyZetboxContext ctx) { }
public static ObjectClass GetObjectClass(this Type type, IReadOnlyZetboxContext ctx) { if (type == null) { throw new ArgumentNullException("type"); } if (ctx == null) { throw new ArgumentNullException("ctx"); } ObjectClass result = ctx.TransientState("__ObjectClassExtensions__GetObjectClass__", type.FullName, () => ctx.GetQuery<ObjectClass>().First(o => o.Module.Namespace == type.Namespace && o.Name == type.Name)); return result; }
public static Content CreateCache(Toolkit tk, IReadOnlyZetboxContext ctx) { var result = new Content(); // All View Descriptors for the given Toolkit result._allVDCache = new ReadOnlyCollection<ViewDescriptor>( ctx.GetQuery<ViewDescriptor>().WithEagerLoading().Where(obj => obj.Toolkit == tk).ToList()); // Dictionary by Kind result._vdCache = result._allVDCache.Where(obj => obj.ControlKind != null).GroupBy(obj => obj.ControlKind) .ToDictionary(g => g.Key.ExportGuid, g => new ReadOnlyCollection<ViewDescriptor>(g.ToList())); return result; }
private void CheckScope() { // for now, clear the cache every hour if (_currentScope == null || _clearTime < DateTime.Now) { Logging.Log.Info("(Re-)Initialising BaseIdentityResolver's cache"); _cache.Clear(); if (_currentScope != null) _currentScope.Dispose(); _currentScope = _parentScope.BeginLifetimeScope(); _resolverCtx = _currentScope.Resolve<IReadOnlyZetboxContext>(); _clearTime = DateTime.Now.AddHours(1); } }
public override void SetUp() { base.SetUp(); ctx = scope.Resolve <IReadOnlyZetboxContext>(); }