Esempio n. 1
0
        /// <summary>
        /// Performs the actual obsoletion
        /// </summary>
        /// <param name="context">Context.</param>
        /// <param name="data">Data.</param>
        public TData Obsolete(DataContext context, TData data, IPrincipal principal)
        {
            var retVal = this.ObsoleteInternal(context, data, principal);

            //if (retVal != data) System.Diagnostics.Debugger.Break();
            context.AddCacheCommit(retVal);
            return(retVal);
        }
Esempio n. 2
0
        /// <summary>
        /// Performthe actual insert.
        /// </summary>
        /// <param name="context">Context.</param>
        /// <param name="data">Data.</param>
        public TData Insert(DataContext context, TData data)
        {
            var retVal = this.InsertInternal(context, data);

            //if (retVal != data) System.Diagnostics.Debugger.Break();
            context.AddCacheCommit(retVal);
            return(retVal);
        }
Esempio n. 3
0
        /// <summary>
        /// Insert or update contents of the bundle
        /// </summary>
        /// <returns></returns>
        public override AuditBundle InsertInternal(DataContext context, AuditBundle data, IPrincipal principal)
        {
            if (data.Item == null)
            {
                return(data);
            }
            this.m_tracer.TraceInfo("Audit Bundle has {0} objects...", data.Item.Count);

            for (int i = 0; i < data.Item.Count; i++)
            {
                var itm = data.Item[i];
                var svc = AdoAuditPersistenceService.GetPersister(itm.GetType());

                this.ProgressChanged?.Invoke(this, new ProgressChangedEventArgs((float)(i + 1) / data.Item.Count, itm));
                try
                {
                    if (svc == null)
                    {
                        throw new InvalidOperationException($"Cannot find persister for {itm.GetType()}");
                    }
                    if (itm.TryGetExisting(context, principal, true) != null)
                    {
                        this.m_tracer.TraceInfo("Will update {0} object from bundle...", itm);
                        data.Item[i] = svc.Update(context, itm) as IdentifiedData;
                    }
                    else
                    {
                        this.m_tracer.TraceInfo("Will insert {0} object from bundle...", itm);
                        data.Item[i] = svc.Insert(context, itm) as IdentifiedData;
                    }
                }
                catch (TargetInvocationException e)
                {
                    this.m_tracer.TraceError("Error inserting bundle: {0}", e);
                    throw e.InnerException;
                }
                catch (Exception e)
                {
                    throw new Exception($"Could not insert bundle due to sub-object persistence (bundle item {i})", e);
                }
            }

            // Cache items
            foreach (var itm in data.Item)
            {
                itm.LoadState = LoadState.FullLoad;
                context.AddCacheCommit(itm);
            }
            return(data);
        }
        /// <summary>
        /// Insert or update contents of the bundle
        /// </summary>
        /// <returns></returns>
        public override Bundle InsertInternal(DataContext context, Bundle data, IPrincipal principal)
        {
            if (data.Item == null)
            {
                return(data);
            }
            this.m_tracer.TraceInformation("Bundle has {0} objects...", data.Item.Count);
            data = this.ReorganizeForInsert(data);
            this.m_tracer.TraceInformation("After reorganization has {0} objects...", data.Item.Count);

            if (AdoPersistenceService.GetConfiguration().PrepareStatements)
            {
                context.PrepareStatements = true;
            }
            for (int i = 0; i < data.Item.Count; i++)
            {
                var itm    = data.Item[i];
                var idp    = typeof(IDataPersistenceService <>).MakeGenericType(new Type[] { itm.GetType() });
                var svc    = ApplicationContext.Current.GetService(idp);
                var method = "Insert";

                if (itm.TryGetExisting(context, principal, true) != null)
                {
                    method = "Update";
                }

                this.m_tracer.TraceInformation("Will {0} object from bundle {1}...", method, itm);
                this.ProgressChanged?.Invoke(this, new ProgressChangedEventArgs((float)(i + 1) / data.Item.Count, itm));

                var mi = svc.GetType().GetRuntimeMethod(method, new Type[] { typeof(DataContext), itm.GetType(), typeof(IPrincipal) });
                try
                {
                    data.Item[i] = mi.Invoke(svc, new object[] { context, itm, principal }) as IdentifiedData;
                }
                catch (TargetInvocationException e)
                {
                    throw e.InnerException;
                }
            }

            // Cache items
            foreach (var itm in data.Item)
            {
                itm.LoadState = LoadState.FullLoad;
                context.AddCacheCommit(itm);
            }
            return(data);
        }
Esempio n. 5
0
        /// <summary>
        /// Perform the actual update.
        /// </summary>
        /// <param name="context">Context.</param>
        /// <param name="data">Data.</param>
        public TData Update(DataContext context, TData data, IPrincipal principal)
        {
            //// 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, principal);

            //if (retVal != data) System.Diagnostics.Debugger.Break();
            context.AddCacheCommit(retVal);
            return(retVal);
        }
Esempio n. 6
0
        /// <summary>
        /// Performs the actual query
        /// </summary>
        public override IEnumerable <TModel> QueryInternal(DataContext context, Expression <Func <TModel, bool> > query, Guid queryId, int offset, int?count, out int totalResults, ModelSort <TModel>[] orderBy, bool countResults = true)
        {
            int resultCount = 0;
            var results     = this.DoQueryInternal(context, query, queryId, offset, count, out resultCount, orderBy, countResults).ToList();

            totalResults = resultCount;

            if (!this.m_persistenceService.GetConfiguration().SingleThreadFetch)
            {
                return(results.AsParallel().AsOrdered().WithDegreeOfParallelism(2).Select(o =>
                {
                    var subContext = context;
                    var newSubContext = results.Count() > 1;
                    var idx = results.IndexOf(o);
                    try
                    {
                        if (newSubContext)
                        {
                            subContext = subContext.OpenClonedContext();
                        }

                        if (o is Guid)
                        {
                            return this.Get(subContext, (Guid)o);
                        }
                        else
                        {
                            return this.CacheConvert(o, subContext);
                        }
                    }
                    catch (Exception e)
                    {
                        this.m_tracer.TraceEvent(EventLevel.Error, "Error performing sub-query: {0}", e);
                        throw;
                    }
                    finally
                    {
                        if (newSubContext)
                        {
                            foreach (var i in subContext.CacheOnCommit)
                            {
                                context.AddCacheCommit(i);
                            }
                            subContext.Dispose();
                        }
                    }
                }));
            }
            else
            {
                return(results.Select(o =>
                {
                    if (o is Guid)
                    {
                        return this.Get(context, (Guid)o);
                    }
                    else
                    {
                        return this.CacheConvert(o, context);
                    }
                }));
            }
        }
        /// <summary>
        /// Insert or update contents of the bundle
        /// </summary>
        /// <returns></returns>
        public override Bundle InsertInternal(DataContext context, Bundle data)
        {
            this.m_tracer.TraceInfo("Bundle has {0} objects...", data.Item.Count);
            data = this.ReorganizeForInsert(data);
            this.m_tracer.TraceInfo("After reorganization has {0} objects...", data.Item.Count);

            context.PrepareStatements = this.m_persistenceService.GetConfiguration().PrepareStatements;

            // Ensure that provenance objects match
            var operationalItems = data.Item.Where(o => !data.ExpansionKeys.Any(k => o.Key == k)).ToArray();
            var provenance       = operationalItems.OfType <NonVersionedEntityData>().Select(o => o.UpdatedByKey.GetValueOrDefault()).Union(operationalItems.OfType <BaseEntityData>().Select(o => o.CreatedByKey.GetValueOrDefault())).Where(o => o != Guid.Empty);

            if (provenance.Distinct().Count() > 1)
            {
                this.m_tracer.TraceError("PROVENANCE OF OBJECTS DO NOT MATCH. WHEN A BUNDLE IS PERSISTED PROVENANCE DATA MUST BE NULL OR MUST MATCH. {0}", String.Join(",", provenance.Distinct().Select(o => o.ToString())));
            }

            for (int i = 0; i < data.Item.Count; i++)
            {
                var itm = data.Item[i];
                var svc = this.m_persistenceService.GetPersister(itm.GetType());

                if (data.ExpansionKeys.Any(k => itm.Key == k))
                {
                    continue;                                            // skip refs
                }
                this.ProgressChanged?.Invoke(this, new ProgressChangedEventArgs((float)(i + 1) / data.Item.Count, itm));
                try
                {
                    if (svc == null)
                    {
                        throw new InvalidOperationException($"Cannot find persister for {itm.GetType()}");
                    }

                    if (itm.TryGetExisting(context, true) != null)
                    {
                        this.m_tracer.TraceInfo("Will update {0} object from bundle...", itm);
                        data.Item[i] = svc.Update(context, itm) as IdentifiedData;
                    }
                    else
                    {
                        this.m_tracer.TraceInfo("Will insert {0} object from bundle...", itm);
                        data.Item[i] = svc.Insert(context, itm) as IdentifiedData;
                    }
                }
                catch (TargetInvocationException e)
                {
                    this.m_tracer.TraceEvent(EventLevel.Error, "Error inserting bundle: {0}", e);
                    throw new Exception($"Error inserting bundle at item #{i}", e.InnerException);
                }
                catch (DetectedIssueException e)
                {
                    this.m_tracer.TraceError("### Error Inserting Bundle[{0}]:", i);
                    foreach (var iss in e.Issues)
                    {
                        this.m_tracer.TraceError("\t{0}: {1}", iss.Priority, iss.Text);
                    }
                    throw new DetectedIssueException(e.Issues, $"Could not insert bundle due to sub-object persistence (at item {i})", e);
                }
                catch (DbException e)
                {
                    try
                    {
                        this.TranslateDbException(e);
                    }
                    catch (DetectedIssueException e2)
                    {
                        throw new DetectedIssueException(e2.Issues, $"Could not insert bundle due to sub-object persistence (at item {i})", e2);
                    }
                    catch (Exception e2)
                    {
                        throw new Exception($"Could not insert bundle due to sub-object persistence (bundle item {i})", e2);
                    }
                }
                catch (Exception e)
                {
                    throw new Exception($"Could not insert bundle due to sub-object persistence (bundle item {i})", e);
                }
            }

            // Cache items
            foreach (var itm in data.Item)
            {
                itm.LoadState = LoadState.FullLoad;
                context.AddCacheCommit(itm);
            }
            return(data);
        }