/// <summary>
        /// Perform the actual update.
        /// </summary>
        /// <param name="context">Context.</param>
        /// <param name="data">Data.</param>
        public TData Update(SQLiteDataContext context, TData data)
        {
            // JF- Probably no need to do this now
            // Make sure we're updating the right thing
            //if (data.Key.HasValue)
            //{
            //    var cacheItem = ApplicationContext.Current.GetService<IDataCachingService>()?.GetCacheItem(data.GetType(), data.Key.Value);
            //    if (cacheItem != null)
            //    {
            //        cacheItem.CopyObjectData(data);
            //        data = cacheItem as TData;
            //    }
            //}

            var retVal = this.UpdateInternal(context, data);

            //if (retVal != data) System.Diagnostics.Debugger.Break();
            context.AddCacheCommit(retVal);
            return(retVal);
        }
            /// <summary>
            /// Update the specified object
            /// </summary>
            protected override TModel UpdateInternal(SQLiteDataContext context, TModel data)
            {
                if (data.IsEmpty())
                {
                    return(data);
                }

                foreach (var rp in this.m_properties)
                {
                    var instance = rp.GetValue(data);
                    if (instance != null && rp.Name != "SourceEntity") // HACK: Prevent infinite loops on associtive entities
                    {
                        instance = ModelExtensions.TryGetExisting(instance as IIdentifiedEntity, context);
                        if (instance != null)
                        {
                            rp.SetValue(data, instance);
                        }
                        ModelExtensions.UpdateParentKeys(data, rp);
                    }
                }
                return(base.UpdateInternal(context, data));
            }
            /// <summary>
            /// Ensure exists
            /// </summary>
            protected override TModel InsertInternal(SQLiteDataContext context, TModel data)
            {
                foreach (var rp in typeof(TModel).GetRuntimeProperties().Where(o => typeof(IdentifiedData).GetTypeInfo().IsAssignableFrom(o.PropertyType.GetTypeInfo())))
                {
                    if (rp.GetCustomAttribute <DataIgnoreAttribute>() != null)
                    {
                        continue;
                    }

                    var instance = rp.GetValue(data);
                    if (instance != null)
                    {
                        instance = ModelExtensions.TryGetExisting(instance as IIdentifiedEntity, context);
                        if (instance != null)
                        {
                            rp.SetValue(data, instance);
                        }
                        ModelExtensions.UpdateParentKeys(data, rp);
                    }
                }
                return(base.InsertInternal(context, data));
            }
            /// <summary>
            /// Ensure exists
            /// </summary>
            protected override TModel InsertInternal(SQLiteDataContext context, TModel data)
            {
                if (data.IsEmpty())
                {
                    return(data);
                }

                foreach (var rp in this.m_properties)
                {
                    var instance = rp.GetValue(data);
                    if (instance != null)
                    {
                        instance = ModelExtensions.TryGetExisting(instance as IIdentifiedEntity, context);
                        if (instance != null)
                        {
                            rp.SetValue(data, instance);
                        }

                        ModelExtensions.UpdateParentKeys(data, rp);
                    }
                }
                return(base.InsertInternal(context, data));
            }
 /// <summary>
 /// To model instance
 /// </summary>
 object ISQLitePersistenceService.ToModelInstance(object domainInstance, SQLiteDataContext context)
 {
     return(this.ToModelInstance(domainInstance, context));
 }
 /// <summary>
 /// Get the specified data
 /// </summary>
 object ISQLitePersistenceService.Get(SQLiteDataContext context, Guid id)
 {
     return(this.Get(context, id));
 }
 /// <summary>
 /// Obsolete
 /// </summary>
 object ISQLitePersistenceService.Obsolete(SQLiteDataContext context, object data)
 {
     return(this.Obsolete(context, (TData)data));
 }
 /// <summary>
 /// Insert the specified data
 /// </summary>
 object ISQLitePersistenceService.Insert(SQLiteDataContext context, object data)
 {
     return(this.Insert(context, (TData)data));
 }
        /// <summary>
        /// Query internal without caring about limiting
        /// </summary>
        /// <param name="context"></param>
        /// <param name="expr"></param>
        /// <returns></returns>
        public IEnumerable <TData> Query(SQLiteDataContext context, Expression <Func <TData, bool> > expr)
        {
            int t;

            return(this.QueryInternal(context, expr, 0, -1, out t, Guid.Empty, false, null));
        }
 /// <summary>
 /// Performs the actual query
 /// </summary>
 /// <param name="context">Context.</param>
 /// <param name="query">Query.</param>
 protected abstract IEnumerable <TData> QueryInternal(SQLiteDataContext context, String storedQueryName, IDictionary <String, Object> parms, int offset, int count, out int totalResults, Guid queryId, bool countResults, ModelSort <TData>[] orderBy);
 /// <summary>
 /// Performs the actual obsoletion
 /// </summary>
 /// <param name="context">Context.</param>
 /// <param name="data">Data.</param>
 protected abstract TData ObsoleteInternal(SQLiteDataContext context, TData data);
 /// <summary>
 /// Performthe actual insert.
 /// </summary>
 /// <param name="context">Context.</param>
 /// <param name="data">Data.</param>
 protected abstract TData InsertInternal(SQLiteDataContext context, TData data);
 /// <summary>
 /// Froms the model instance.
 /// </summary>
 /// <returns>The model instance.</returns>
 /// <param name="modelInstance">Model instance.</param>
 public abstract Object FromModelInstance(TData modelInstance, SQLiteDataContext context);
 /// <summary>
 /// Maps the data to a model instance
 /// </summary>
 /// <returns>The model instance.</returns>
 /// <param name="dataInstance">Data instance.</param>
 public abstract TData ToModelInstance(Object dataInstance, SQLiteDataContext context);
            /// <summary>
            /// Get all the matching TModel object from source
            /// </summary>
            public IEnumerable GetFromSource(SQLiteDataContext context, Guid sourceId, decimal?versionSequenceId)
            {
                int tr = 0;

                return(this.Query(context, o => o.SourceEntityKey == sourceId, Guid.Empty, 0, 100, out tr, false, null));
            }
Пример #16
0
        /// <summary>
        /// Load specified associations
        /// </summary>
        public static void LoadAssociations <TModel>(this TModel me, SQLiteDataContext context, params string[] excludeProperties) where TModel : IIdentifiedEntity
        {
            //using (context.LockConnection())
            //{
            if (me == null)
            {
                throw new ArgumentNullException(nameof(me));
            }
            else if (me.LoadState == LoadState.FullLoad ||
                     context.DelayLoadMode == LoadState.PartialLoad && context.LoadAssociations == null)
            {
                return;
            }
            else if (context.Connection.IsInTransaction)
            {
                return;
            }

#if DEBUG
            /*
             * Me neez all the timez
             *
             * /\_/\
             * >^.^<.---.
             * _'-`-'     )\
             * (6--\ |--\ (`.`-.
             *   --'  --'  ``-'
             */
            Stopwatch sw = new Stopwatch();
            sw.Start();
#endif

            // Cache get classification property - thiz makez us fasters
            PropertyInfo classProperty = null;
            if (!s_classificationProperties.TryGetValue(typeof(TModel), out classProperty))
            {
                classProperty = typeof(TModel).GetRuntimeProperty(typeof(TModel).GetTypeInfo().GetCustomAttribute <ClassifierAttribute>()?.ClassifierProperty ?? "____XXX");
                if (classProperty != null)
                {
                    classProperty = typeof(TModel).GetRuntimeProperty(classProperty.GetCustomAttribute <SerializationReferenceAttribute>()?.RedirectProperty ?? classProperty.Name);
                }
                lock (s_lockObject)
                    if (!s_classificationProperties.ContainsKey(typeof(TModel)))
                    {
                        s_classificationProperties.Add(typeof(TModel), classProperty);
                    }
            }

            // Classification property?
            String classValue = classProperty?.GetValue(me)?.ToString();

            // Cache the props so future kitties can call it
            IEnumerable <PropertyInfo> properties = null;
            var propertyCacheKey = $"{me.GetType()}.FullName[{classValue}]";
            if (!s_runtimeProperties.TryGetValue(propertyCacheKey, out properties))
            {
                lock (s_runtimeProperties)
                {
                    properties = me.GetType().GetRuntimeProperties().Where(o => o.GetCustomAttribute <DataIgnoreAttribute>() == null && o.GetCustomAttributes <AutoLoadAttribute>().Any(p => p.ClassCode == classValue || p.ClassCode == null) && typeof(IdentifiedData).GetTypeInfo().IsAssignableFrom(o.PropertyType.StripGeneric().GetTypeInfo())).ToList();

                    if (!s_runtimeProperties.ContainsKey(propertyCacheKey))
                    {
                        s_runtimeProperties.Add(propertyCacheKey, properties);
                    }
                }
            }

            // Load fast or lean mode only root associations which will appear on the wire
            if (context.LoadAssociations != null)
            {
                var loadAssociations = context.LoadAssociations.Where(o => o.StartsWith(me.GetType().GetTypeInfo().GetCustomAttribute <XmlTypeAttribute>()?.TypeName))
                                       .Select(la => la.Contains(".") ? la.Substring(la.IndexOf(".") + 1) : la).ToArray();
                if (loadAssociations.Length == 0)
                {
                    return;
                }
                properties = properties.Where(p => loadAssociations.Any(la => la == p.Name)).ToList();
            }

            // Iterate over the properties and load the properties
            foreach (var pi in properties)
            {
                if (excludeProperties?.Contains(pi.Name) == true)
                {
                    continue;
                }
                // Map model type to domain
                var adoPersister = SQLitePersistenceService.GetPersister(pi.PropertyType.StripGeneric());

                // Loading associations, so what is the associated type?
                if (typeof(IList).GetTypeInfo().IsAssignableFrom(pi.PropertyType.GetTypeInfo()) &&
                    adoPersister is ISQLiteAssociativePersistenceService &&
                    me.Key.HasValue) // List so we select from the assoc table where we are the master table
                {
                    // Is there not a value?
                    var assocPersister = adoPersister as ISQLiteAssociativePersistenceService;

                    // We want to que   ry based on our PK and version if applicable
                    decimal?versionSequence = (me as IVersionedEntity)?.VersionSequence;
                    var     assoc           = assocPersister.GetFromSource(context, me.Key.Value, versionSequence);

                    ConstructorInfo ci = null;
                    if (!m_constructors.TryGetValue(pi.PropertyType, out ci))
                    {
                        var type = pi.PropertyType.StripGeneric();
                        while (type != typeof(Object) && ci == null)
                        {
                            ci   = pi.PropertyType.GetTypeInfo().DeclaredConstructors.FirstOrDefault(o => o.GetParameters().Length == 1 && o.GetParameters()[0].ParameterType == typeof(IEnumerable <>).MakeGenericType(type));
                            type = type.GetTypeInfo().BaseType;
                        }
                        if (ci != null)
                        {
                            lock (s_lockObject)
                                if (!m_constructors.ContainsKey(pi.PropertyType))
                                {
                                    m_constructors.Add(pi.PropertyType, ci);
                                }
                        }
                        else
                        {
                            throw new InvalidOperationException($"This is odd, you seem to have a list with no constructor -> {pi.PropertyType}");
                        }
                    }

                    //var listValue = Activator.CreateInstance(pi.PropertyType, assoc);
                    var listValue = ci.Invoke(new object[] { assoc });
                    pi.SetValue(me, listValue);
                }
                else if (typeof(IIdentifiedEntity).GetTypeInfo().IsAssignableFrom(pi.PropertyType.GetTypeInfo())) // Single
                {
                    // Single property, we want to execute a get on the key property
                    var redirectAtt = pi.GetCustomAttribute <SerializationReferenceAttribute>();
                    if (redirectAtt == null)
                    {
                        continue; // cannot get key property
                    }
                    // We want to issue a query
                    var keyProperty = pi.DeclaringType.GetRuntimeProperty(redirectAtt.RedirectProperty);
                    var keyValue    = keyProperty?.GetValue(me);
                    if (keyValue == null ||
                        Guid.Empty.Equals(keyValue))
                    {
                        continue; // No key specified
                    }
                    // This is kinda messy.. maybe iz to be changez
                    object value = null;
                    if (!context.Data.TryGetValue(keyValue.ToString(), out value))
                    {
                        value = adoPersister.Get(context, (Guid)keyValue);
                        context.AddData(keyValue.ToString(), value);
                    }
                    pi.SetValue(me, value);
                }
            }
#if DEBUG
            sw.Stop();
            s_tracer.TraceVerbose("Load associations for {0} took {1} ms", me, sw.ElapsedMilliseconds);
#endif

            me.LoadState = excludeProperties.Length > 0 ? LoadState.PartialLoad : LoadState.FullLoad;

            ApplicationContext.Current.GetService <IDataCachingService>()?.Add(me as IdentifiedData);
            //}
        }
Пример #17
0
        /// <summary>
        /// Try get by classifier
        /// </summary>
        public static IIdentifiedEntity TryGetExisting(this IIdentifiedEntity me, SQLiteDataContext context, bool forceDbSearch = false)
        {
            // Is there a classifier?
            var idpInstance = SQLitePersistenceService.GetPersister(me.GetType()) as ISQLitePersistenceService;

            if (idpInstance == null)
            {
                return(null);
            }
            //if (me.Key?.ToString() == "e4d3350b-b0f5-45c1-80ba-49e3844cbcc8")
            //    System.Diagnostics.Debugger.Break();

            IIdentifiedEntity existing = null;

            if (!forceDbSearch)
            {
                if (me.Key != null)
                {
                    existing = context.TryGetCacheItem(me.Key.Value);
                }
                if (existing != null)
                {
                    return(existing);
                }
                else if (!context.Connection.IsInTransaction)
                {
                    existing = context.TryGetData(me.Key.Value.ToString()) as IdentifiedData;
                }
                else if (me.Key.HasValue)
                {
                    existing = context.FindTransactedItem(me.Key.Value);
                }
                if (forceDbSearch && me.Key.HasValue)
                {
                    ApplicationContext.Current.GetService <IDataCachingService>().Remove(me.Key.Value);
                }
            }

            // Is the key not null?
            if (me.Key != Guid.Empty && me.Key != null && existing == null)
            {
                existing = idpInstance.Get(context, me.Key.Value) as IIdentifiedEntity;
            }
            else
            {
                var classAtt = me.GetType().GetTypeInfo().GetCustomAttribute <KeyLookupAttribute>();
                if (classAtt != null && existing == null)
                {
                    // Get the domain type
                    var dataType = SQLitePersistenceService.Mapper.MapModelType(me.GetType());
                    var tableMap = TableMapping.Get(dataType);

                    // Get the classifier attribute value
                    var    classProperty   = me.GetType().GetRuntimeProperty(classAtt.UniqueProperty);
                    object classifierValue = classProperty.GetValue(me); // Get the classifier

                    // Is the classifier a UUID'd item?
                    if (classifierValue is IIdentifiedEntity)
                    {
                        classifierValue = (classifierValue as IIdentifiedEntity).Key.Value;
                        classProperty   = me.GetType().GetRuntimeProperty(classProperty.GetCustomAttribute <SerializationReferenceAttribute>()?.RedirectProperty ?? classProperty.Name);
                    }

                    // Column
                    var column = tableMap.GetColumn(SQLitePersistenceService.Mapper.MapModelProperty(me.GetType(), dataType, classProperty));
                    // Now we want to query
                    SqlStatement stmt = new SqlStatement().SelectFrom(dataType)
                                        .Where($"{column.Name} = ?", classifierValue).Build();

                    var mapping    = context.Connection.GetMapping(dataType);
                    var dataObject = context.Connection.Query(mapping, stmt.SQL, stmt.Arguments.ToArray()).FirstOrDefault();
                    if (dataObject != null)
                    {
                        existing = idpInstance.ToModelInstance(dataObject, context) as IIdentifiedEntity;
                    }
                }
            }
            if (existing != null && me.Key.HasValue)
            {
                context.AddData(me.Key.Value.ToString(), existing);
            }

            return(existing);
        }
 /// <summary>
 /// Performs the actual query
 /// </summary>
 /// <param name="context">Context.</param>
 /// <param name="query">Query.</param>
 protected abstract IEnumerable <TData> QueryInternal(SQLiteDataContext context, Expression <Func <TData, bool> > query, int offset, int count, out int totalResults, Guid queryId, bool countResults, ModelSort <TData>[] orderBy);