/// <summary>Returns a deep clone of this DCM. Caller is responsible to choose a unique FilePath</summary>
        public DictionaryConfigurationModel DeepClone()
        {
            var clone = new DictionaryConfigurationModel();

            // Copy everything over at first, importantly handling strings and primitives.
            var properties = typeof(DictionaryConfigurationModel).GetProperties();

            foreach (var property in properties.Where(prop => prop.CanWrite))             // Skip any read-only properties
            {
                var originalValue = property.GetValue(this, null);
                property.SetValue(clone, originalValue, null);
            }

            // Deep-clone SharedItems
            if (SharedItems != null)
            {
                clone.SharedItems = SharedItems.Select(node => node.DeepCloneUnderParent(null, true)).ToList();
            }

            // Deep-clone Parts
            if (Parts != null)
            {
                clone.Parts = Parts.Select(node => node.DeepCloneUnderParent(null, true)).ToList();
                SpecifyParentsAndReferences(clone.Parts, clone.SharedItems);
            }

            // Clone Publications
            if (Publications != null)
            {
                clone.Publications = new List <string>(Publications);
            }

            return(clone);
        }
        internal SLCacheField Clone()
        {
            var cf = new SLCacheField();

            cf.Name                = Name;
            cf.Caption             = Caption;
            cf.PropertyName        = PropertyName;
            cf.ServerField         = ServerField;
            cf.UniqueList          = UniqueList;
            cf.NumberFormatId      = NumberFormatId;
            cf.Formula             = Formula;
            cf.SqlType             = SqlType;
            cf.Hierarchy           = Hierarchy;
            cf.Level               = Level;
            cf.DatabaseField       = DatabaseField;
            cf.MappingCount        = MappingCount;
            cf.MemberPropertyField = MemberPropertyField;

            cf.HasSharedItems = HasSharedItems;
            cf.SharedItems    = SharedItems.Clone();

            cf.HasFieldGroup = HasFieldGroup;
            cf.FieldGroup    = FieldGroup.Clone();

            cf.MemberPropertiesMaps = new List <int>();
            foreach (var i in MemberPropertiesMaps)
            {
                cf.MemberPropertiesMaps.Add(i);
            }

            return(cf);
        }
Example #3
0
        /// <summary>
        /// OnMethodBegin callback
        /// </summary>
        /// <typeparam name="TTarget">Type of the target</typeparam>
        /// <typeparam name="TContext">Controller context</typeparam>
        /// <param name="instance">Instance value, aka `this` of the instrumented method.</param>
        /// <param name="controllerContext">The context of the controller</param>
        /// <param name="actionName">Name of the action</param>
        /// <param name="callback">Async callback</param>
        /// <param name="state">The state of the method</param>
        /// <returns>Calltarget state value</returns>
        internal static CallTargetState OnMethodBegin <TTarget, TContext>(TTarget instance, TContext controllerContext, string actionName, AsyncCallback callback, object state)
        {
            Scope scope = null;

            try
            {
                if (HttpContext.Current != null)
                {
                    var duckedControllerContext = controllerContext.DuckCast <ControllerContextStruct>();
                    scope = AspNetMvcIntegration.CreateScope(duckedControllerContext);
                    SharedItems.PushScope(HttpContext.Current, AspNetMvcIntegration.HttpContextKey, scope);
                }
            }
            catch (Exception ex)
            {
                Log.Error(ex, "Error instrumenting method {MethodName}", "System.Web.Mvc.Async.AsyncControllerActionInvoker.BeginInvokeAction()");
            }

            if (scope == null)
            {
                return(CallTargetState.GetDefault());
            }

            return(new CallTargetState(scope));
        }
Example #4
0
        public void TestEmpty()
        {
            // Arrange
            const string key     = "key";
            var          context = CreateContext();

            // Assert
            Assert.Null(SharedItems.TryPopScope(context, key));
        }
Example #5
0
 public bool Equals(SourceField other)
 {
     return(other != null &&
            Index == other.Index &&
            string.Equals(Name, other.Name) &&
            NumberFmtId == other.NumberFmtId &&
            AggregationFunc == other.AggregationFunc &&
            string.Equals(AggregationFormula, other.AggregationFormula) &&
            SharedItems.Equals(Items, other.Items));
 }
Example #6
0
        public void TestOneItem()
        {
            // Arrange
            const string key     = "key";
            var          scope   = new Scope(null, null, null, false);
            var          context = CreateContext();

            // Act
            SharedItems.PushScope(context, key, scope);

            // Assert
            Assert.Equal(scope, SharedItems.TryPopScope(context, key));
        }
        /// <summary>
        /// OnMethodBegin callback
        /// </summary>
        /// <typeparam name="TTarget">Type of the target</typeparam>
        /// <typeparam name="TController">Type of the controller context</typeparam>
        /// <param name="instance">Instance value, aka `this` of the instrumented method.</param>
        /// <param name="controllerContext">The context of the controller</param>
        /// <param name="cancellationToken">The cancellation token</param>
        /// <returns>Calltarget state value</returns>
        internal static CallTargetState OnMethodBegin <TTarget, TController>(TTarget instance, TController controllerContext, CancellationToken cancellationToken)
            where TController : IHttpControllerContext
        {
            // Make sure to box the controllerContext proxy only once
            var boxedControllerContext = (IHttpControllerContext)controllerContext;

            var scope = AspNetWebApi2Integration.CreateScope(boxedControllerContext, out _);

            if (scope != null)
            {
                SharedItems.PushScope(HttpContext.Current, AspNetWebApi2Integration.HttpContextKey, scope);
                return(new CallTargetState(scope, boxedControllerContext));
            }

            return(CallTargetState.GetDefault());
        }
Example #8
0
        public void TestStackingItems()
        {
            // Arrange
            const string key     = "key";
            var          scope1  = new Scope(null, null, null, false);
            var          scope2  = new Scope(scope1, null, null, false);
            var          scope3  = new Scope(scope2, null, null, false);
            var          context = CreateContext();

            // Act
            SharedItems.PushScope(context, key, scope1);
            SharedItems.PushScope(context, key, scope2);
            SharedItems.PushScope(context, key, scope3);

            // Assert
            Assert.Equal(scope3, SharedItems.TryPopScope(context, key));
            Assert.Equal(scope2, SharedItems.TryPopScope(context, key));
            Assert.Equal(scope1, SharedItems.TryPopScope(context, key));
        }
Example #9
0
        public static SourceField GetInstance(CacheField cacheField, int index)
        {
            IList <PivotTableGroup> pivotGroupings  = new List <PivotTableGroup>();
            PivotTableGroup         pivotTableGroup = PivotTableGroup.GetInstance(cacheField, index);

            if (pivotTableGroup != null)
            {
                pivotGroupings.Add(pivotTableGroup);
            }

            return(new SourceField()
            {
                Index = index,
                Name = cacheField.Name,
                NumberFmtId = cacheField.NumberFormatId ?? 0,
                // ECMA-376 Appendix B.2 Line 1284 shows that default value is "false"
                Items = SharedItems.GetInstance(cacheField),
                PivotGrouping = pivotGroupings
            });
        }
        // Generates content of pivotTableCacheDefinitionPart1.
        private void GeneratePivotTableCacheDefinitionPart1Content(PivotTableCacheDefinitionPart pivotTableCacheDefinitionPart1)
        {
            PivotCacheDefinition pivotCacheDefinition1 = new PivotCacheDefinition() { Id = "rId1", RefreshedBy = "Author", RefreshedDate = 40905.65532824074D, CreatedVersion = 4, RefreshedVersion = 4, MinRefreshableVersion = 3, RecordCount = (UInt32Value)3U };

            CacheSource cacheSource1 = new CacheSource() { Type = SourceValues.Worksheet };
            WorksheetSource worksheetSource1 = new WorksheetSource() { Reference = "A1:B4", Sheet = "Sheet2" };

            cacheSource1.Append(worksheetSource1);

            CacheFields cacheFields1 = new CacheFields() { Count = (UInt32Value)2U };

            CacheField cacheField1 = new CacheField() { Name = "id", NumberFormatId = (UInt32Value)0U };

            SharedItems sharedItems1 = new SharedItems() { ContainsSemiMixedTypes = false, ContainsString = false, ContainsNumber = true, ContainsInteger = true, MinValue = 1D, MaxValue = 3D, Count = (UInt32Value)3U };
            NumberItem numberItem1 = new NumberItem() { Val = 1D };
            NumberItem numberItem2 = new NumberItem() { Val = 2D };
            NumberItem numberItem3 = new NumberItem() { Val = 3D };

            sharedItems1.Append(numberItem1);
            sharedItems1.Append(numberItem2);
            sharedItems1.Append(numberItem3);

            cacheField1.Append(sharedItems1);

            CacheField cacheField2 = new CacheField() { Name = "score", NumberFormatId = (UInt32Value)0U };
            SharedItems sharedItems2 = new SharedItems() { ContainsSemiMixedTypes = false, ContainsString = false, ContainsNumber = true, ContainsInteger = true, MinValue = 100D, MaxValue = 132D };

            cacheField2.Append(sharedItems2);

            cacheFields1.Append(cacheField1);
            cacheFields1.Append(cacheField2);

            PivotCacheDefinitionExtensionList pivotCacheDefinitionExtensionList1 = new PivotCacheDefinitionExtensionList();

            pivotCacheDefinition1.Append(cacheSource1);
            pivotCacheDefinition1.Append(cacheFields1);
            pivotCacheDefinition1.Append(pivotCacheDefinitionExtensionList1);

            pivotTableCacheDefinitionPart1.PivotCacheDefinition = pivotCacheDefinition1;
        }
        internal void FromSharedItems(SharedItems sis)
        {
            this.SetAllNull();

            if (sis.ContainsSemiMixedTypes != null) this.ContainsSemiMixedTypes = sis.ContainsSemiMixedTypes.Value;
            if (sis.ContainsNonDate != null) this.ContainsNonDate = sis.ContainsNonDate.Value;
            if (sis.ContainsDate != null) this.ContainsDate = sis.ContainsDate.Value;
            if (sis.ContainsString != null) this.ContainsString = sis.ContainsString.Value;
            if (sis.ContainsBlank != null) this.ContainsBlank = sis.ContainsBlank.Value;
            if (sis.ContainsMixedTypes != null) this.ContainsMixedTypes = sis.ContainsMixedTypes.Value;
            if (sis.ContainsNumber != null) this.ContainsNumber = sis.ContainsNumber.Value;
            if (sis.ContainsInteger != null) this.ContainsInteger = sis.ContainsInteger.Value;
            if (sis.MinValue != null) this.MinValue = sis.MinValue.Value;
            if (sis.MaxValue != null) this.MaxValue = sis.MaxValue.Value;
            if (sis.MinDate != null) this.MinDate = sis.MinDate.Value;
            if (sis.MaxDate != null) this.MaxDate = sis.MaxDate.Value;
            //count
            if (sis.LongText != null) this.LongText = sis.LongText.Value;

            SLMissingItem mi;
            SLNumberItem ni;
            SLBooleanItem bi;
            SLErrorItem ei;
            SLStringItem si;
            SLDateTimeItem dti;
            using (OpenXmlReader oxr = OpenXmlReader.Create(sis))
            {
                while (oxr.Read())
                {
                    // make sure to add to Items first, because of the Count thing.
                    if (oxr.ElementType == typeof(MissingItem))
                    {
                        mi = new SLMissingItem();
                        mi.FromMissingItem((MissingItem)oxr.LoadCurrentElement());
                        this.Items.Add(new SLSharedGroupItemsTypeIndexPair(SLSharedGroupItemsType.Missing, this.MissingItems.Count));
                        this.MissingItems.Add(mi);
                    }
                    else if (oxr.ElementType == typeof(NumberItem))
                    {
                        ni = new SLNumberItem();
                        ni.FromNumberItem((NumberItem)oxr.LoadCurrentElement());
                        this.Items.Add(new SLSharedGroupItemsTypeIndexPair(SLSharedGroupItemsType.Number, this.NumberItems.Count));
                        this.NumberItems.Add(ni);
                    }
                    else if (oxr.ElementType == typeof(BooleanItem))
                    {
                        bi = new SLBooleanItem();
                        bi.FromBooleanItem((BooleanItem)oxr.LoadCurrentElement());
                        this.Items.Add(new SLSharedGroupItemsTypeIndexPair(SLSharedGroupItemsType.Boolean, this.BooleanItems.Count));
                        this.BooleanItems.Add(bi);
                    }
                    else if (oxr.ElementType == typeof(ErrorItem))
                    {
                        ei = new SLErrorItem();
                        ei.FromErrorItem((ErrorItem)oxr.LoadCurrentElement());
                        this.Items.Add(new SLSharedGroupItemsTypeIndexPair(SLSharedGroupItemsType.Error, this.ErrorItems.Count));
                        this.ErrorItems.Add(ei);
                    }
                    else if (oxr.ElementType == typeof(StringItem))
                    {
                        si = new SLStringItem();
                        si.FromStringItem((StringItem)oxr.LoadCurrentElement());
                        this.Items.Add(new SLSharedGroupItemsTypeIndexPair(SLSharedGroupItemsType.String, this.StringItems.Count));
                        this.StringItems.Add(si);
                    }
                    else if (oxr.ElementType == typeof(DateTimeItem))
                    {
                        dti = new SLDateTimeItem();
                        dti.FromDateTimeItem((DateTimeItem)oxr.LoadCurrentElement());
                        this.Items.Add(new SLSharedGroupItemsTypeIndexPair(SLSharedGroupItemsType.DateTime, this.DateTimeItems.Count));
                        this.DateTimeItems.Add(dti);
                    }
                }
            }
        }
Example #12
0
        internal SharedItems ToSharedItems()
        {
            SharedItems sis = new SharedItems();

            if (this.ContainsSemiMixedTypes != true)
            {
                sis.ContainsSemiMixedTypes = this.ContainsSemiMixedTypes;
            }
            if (this.ContainsNonDate != true)
            {
                sis.ContainsNonDate = this.ContainsNonDate;
            }
            if (this.ContainsDate != false)
            {
                sis.ContainsDate = this.ContainsDate;
            }
            if (this.ContainsString != true)
            {
                sis.ContainsString = this.ContainsString;
            }
            if (this.ContainsBlank != false)
            {
                sis.ContainsBlank = this.ContainsBlank;
            }
            if (this.ContainsMixedTypes != false)
            {
                sis.ContainsMixedTypes = this.ContainsMixedTypes;
            }
            if (this.ContainsNumber != false)
            {
                sis.ContainsNumber = this.ContainsNumber;
            }
            if (this.ContainsInteger != false)
            {
                sis.ContainsInteger = this.ContainsInteger;
            }
            if (this.MinValue != null)
            {
                sis.MinValue = this.MinValue.Value;
            }
            if (this.MaxValue != null)
            {
                sis.MaxValue = this.MaxValue.Value;
            }
            if (this.MinDate != null)
            {
                sis.MinDate = new DateTimeValue(this.MinDate.Value);
            }
            if (this.MaxDate != null)
            {
                sis.MaxDate = new DateTimeValue(this.MaxDate.Value);
            }

            // is it the sum of all the various items?
            if (this.Items.Count > 0)
            {
                sis.Count = (uint)this.Items.Count;
            }

            if (this.LongText != false)
            {
                sis.LongText = this.LongText;
            }

            foreach (SLSharedGroupItemsTypeIndexPair pair in this.Items)
            {
                switch (pair.Type)
                {
                case SLSharedGroupItemsType.Missing:
                    sis.Append(this.MissingItems[pair.Index].ToMissingItem());
                    break;

                case SLSharedGroupItemsType.Number:
                    sis.Append(this.NumberItems[pair.Index].ToNumberItem());
                    break;

                case SLSharedGroupItemsType.Boolean:
                    sis.Append(this.BooleanItems[pair.Index].ToBooleanItem());
                    break;

                case SLSharedGroupItemsType.Error:
                    sis.Append(this.ErrorItems[pair.Index].ToErrorItem());
                    break;

                case SLSharedGroupItemsType.String:
                    sis.Append(this.StringItems[pair.Index].ToStringItem());
                    break;

                case SLSharedGroupItemsType.DateTime:
                    sis.Append(this.DateTimeItems[pair.Index].ToDateTimeItem());
                    break;
                }
            }

            return(sis);
        }
Example #13
0
        internal void FromSharedItems(SharedItems sis)
        {
            this.SetAllNull();

            if (sis.ContainsSemiMixedTypes != null)
            {
                this.ContainsSemiMixedTypes = sis.ContainsSemiMixedTypes.Value;
            }
            if (sis.ContainsNonDate != null)
            {
                this.ContainsNonDate = sis.ContainsNonDate.Value;
            }
            if (sis.ContainsDate != null)
            {
                this.ContainsDate = sis.ContainsDate.Value;
            }
            if (sis.ContainsString != null)
            {
                this.ContainsString = sis.ContainsString.Value;
            }
            if (sis.ContainsBlank != null)
            {
                this.ContainsBlank = sis.ContainsBlank.Value;
            }
            if (sis.ContainsMixedTypes != null)
            {
                this.ContainsMixedTypes = sis.ContainsMixedTypes.Value;
            }
            if (sis.ContainsNumber != null)
            {
                this.ContainsNumber = sis.ContainsNumber.Value;
            }
            if (sis.ContainsInteger != null)
            {
                this.ContainsInteger = sis.ContainsInteger.Value;
            }
            if (sis.MinValue != null)
            {
                this.MinValue = sis.MinValue.Value;
            }
            if (sis.MaxValue != null)
            {
                this.MaxValue = sis.MaxValue.Value;
            }
            if (sis.MinDate != null)
            {
                this.MinDate = sis.MinDate.Value;
            }
            if (sis.MaxDate != null)
            {
                this.MaxDate = sis.MaxDate.Value;
            }
            //count
            if (sis.LongText != null)
            {
                this.LongText = sis.LongText.Value;
            }

            SLMissingItem  mi;
            SLNumberItem   ni;
            SLBooleanItem  bi;
            SLErrorItem    ei;
            SLStringItem   si;
            SLDateTimeItem dti;

            using (OpenXmlReader oxr = OpenXmlReader.Create(sis))
            {
                while (oxr.Read())
                {
                    // make sure to add to Items first, because of the Count thing.
                    if (oxr.ElementType == typeof(MissingItem))
                    {
                        mi = new SLMissingItem();
                        mi.FromMissingItem((MissingItem)oxr.LoadCurrentElement());
                        this.Items.Add(new SLSharedGroupItemsTypeIndexPair(SLSharedGroupItemsType.Missing, this.MissingItems.Count));
                        this.MissingItems.Add(mi);
                    }
                    else if (oxr.ElementType == typeof(NumberItem))
                    {
                        ni = new SLNumberItem();
                        ni.FromNumberItem((NumberItem)oxr.LoadCurrentElement());
                        this.Items.Add(new SLSharedGroupItemsTypeIndexPair(SLSharedGroupItemsType.Number, this.NumberItems.Count));
                        this.NumberItems.Add(ni);
                    }
                    else if (oxr.ElementType == typeof(BooleanItem))
                    {
                        bi = new SLBooleanItem();
                        bi.FromBooleanItem((BooleanItem)oxr.LoadCurrentElement());
                        this.Items.Add(new SLSharedGroupItemsTypeIndexPair(SLSharedGroupItemsType.Boolean, this.BooleanItems.Count));
                        this.BooleanItems.Add(bi);
                    }
                    else if (oxr.ElementType == typeof(ErrorItem))
                    {
                        ei = new SLErrorItem();
                        ei.FromErrorItem((ErrorItem)oxr.LoadCurrentElement());
                        this.Items.Add(new SLSharedGroupItemsTypeIndexPair(SLSharedGroupItemsType.Error, this.ErrorItems.Count));
                        this.ErrorItems.Add(ei);
                    }
                    else if (oxr.ElementType == typeof(StringItem))
                    {
                        si = new SLStringItem();
                        si.FromStringItem((StringItem)oxr.LoadCurrentElement());
                        this.Items.Add(new SLSharedGroupItemsTypeIndexPair(SLSharedGroupItemsType.String, this.StringItems.Count));
                        this.StringItems.Add(si);
                    }
                    else if (oxr.ElementType == typeof(DateTimeItem))
                    {
                        dti = new SLDateTimeItem();
                        dti.FromDateTimeItem((DateTimeItem)oxr.LoadCurrentElement());
                        this.Items.Add(new SLSharedGroupItemsTypeIndexPair(SLSharedGroupItemsType.DateTime, this.DateTimeItems.Count));
                        this.DateTimeItems.Add(dti);
                    }
                }
            }
        }
Example #14
0
        // Generates content of pivotTableCacheDefinitionPart1.
        private void GeneratePivotTableCacheDefinitionPart1Content(PivotTableCacheDefinitionPart pivotTableCacheDefinitionPart1)
        {
            PivotCacheDefinition pivotCacheDefinition1 = new PivotCacheDefinition(){ Id = "rId1", RefreshedBy = "Masaki Tamura (Pasona Tech)", RefreshedDate = 40946.731165509256D, CreatedVersion = 4, RefreshedVersion = 5, MinRefreshableVersion = 3, RecordCount = (UInt32Value)4U };
            pivotCacheDefinition1.AddNamespaceDeclaration("r", "http://schemas.openxmlformats.org/officeDocument/2006/relationships");

            CacheSource cacheSource1 = new CacheSource(){ Type = SourceValues.Worksheet };
            WorksheetSource worksheetSource1 = new WorksheetSource(){ Name = "DataTable1" };

            cacheSource1.Append(worksheetSource1);

            CacheFields cacheFields1 = new CacheFields(){ Count = (UInt32Value)7U };

            CacheField cacheField1 = new CacheField(){ Name = "Date", NumberFormatId = (UInt32Value)14U };

            SharedItems sharedItems1 = new SharedItems(){ ContainsSemiMixedTypes = false, ContainsNonDate = false, ContainsDate = true, ContainsString = false, MinDate = System.Xml.XmlConvert.ToDateTime("2000-01-01T15:40:41Z", System.Xml.XmlDateTimeSerializationMode.RoundtripKind), MaxDate = System.Xml.XmlConvert.ToDateTime("2002-12-30T20:50:43Z", System.Xml.XmlDateTimeSerializationMode.RoundtripKind), Count = (UInt32Value)4U };
            DateTimeItem dateTimeItem1 = new DateTimeItem(){ Val = System.Xml.XmlConvert.ToDateTime("2000-01-01T15:40:41Z", System.Xml.XmlDateTimeSerializationMode.RoundtripKind) };
            DateTimeItem dateTimeItem2 = new DateTimeItem(){ Val = System.Xml.XmlConvert.ToDateTime("2000-01-02T03:35:07Z", System.Xml.XmlDateTimeSerializationMode.RoundtripKind) };
            DateTimeItem dateTimeItem3 = new DateTimeItem(){ Val = System.Xml.XmlConvert.ToDateTime("2002-12-30T06:43:15Z", System.Xml.XmlDateTimeSerializationMode.RoundtripKind) };
            DateTimeItem dateTimeItem4 = new DateTimeItem(){ Val = System.Xml.XmlConvert.ToDateTime("2002-12-30T20:50:43Z", System.Xml.XmlDateTimeSerializationMode.RoundtripKind) };

            sharedItems1.Append(dateTimeItem1);
            sharedItems1.Append(dateTimeItem2);
            sharedItems1.Append(dateTimeItem3);
            sharedItems1.Append(dateTimeItem4);

            FieldGroup fieldGroup1 = new FieldGroup(){ ParentId = (UInt32Value)6U, Base = (UInt32Value)0U };
            RangeProperties rangeProperties1 = new RangeProperties(){ GroupBy = GroupByValues.Months, StartDate = System.Xml.XmlConvert.ToDateTime("2000-01-01T15:40:41Z", System.Xml.XmlDateTimeSerializationMode.RoundtripKind), EndDate = System.Xml.XmlConvert.ToDateTime("2002-12-30T20:50:43Z", System.Xml.XmlDateTimeSerializationMode.RoundtripKind) };

            GroupItems groupItems1 = new GroupItems(){ Count = (UInt32Value)14U };
            StringItem stringItem1 = new StringItem(){ Val = "<2000/01/01" };
            StringItem stringItem2 = new StringItem(){ Val = "1月" };
            StringItem stringItem3 = new StringItem(){ Val = "2月" };
            StringItem stringItem4 = new StringItem(){ Val = "3月" };
            StringItem stringItem5 = new StringItem(){ Val = "4月" };
            StringItem stringItem6 = new StringItem(){ Val = "5月" };
            StringItem stringItem7 = new StringItem(){ Val = "6月" };
            StringItem stringItem8 = new StringItem(){ Val = "7月" };
            StringItem stringItem9 = new StringItem(){ Val = "8月" };
            StringItem stringItem10 = new StringItem(){ Val = "9月" };
            StringItem stringItem11 = new StringItem(){ Val = "10月" };
            StringItem stringItem12 = new StringItem(){ Val = "11月" };
            StringItem stringItem13 = new StringItem(){ Val = "12月" };
            StringItem stringItem14 = new StringItem(){ Val = ">2002/12/30" };

            groupItems1.Append(stringItem1);
            groupItems1.Append(stringItem2);
            groupItems1.Append(stringItem3);
            groupItems1.Append(stringItem4);
            groupItems1.Append(stringItem5);
            groupItems1.Append(stringItem6);
            groupItems1.Append(stringItem7);
            groupItems1.Append(stringItem8);
            groupItems1.Append(stringItem9);
            groupItems1.Append(stringItem10);
            groupItems1.Append(stringItem11);
            groupItems1.Append(stringItem12);
            groupItems1.Append(stringItem13);
            groupItems1.Append(stringItem14);

            fieldGroup1.Append(rangeProperties1);
            fieldGroup1.Append(groupItems1);

            cacheField1.Append(sharedItems1);
            cacheField1.Append(fieldGroup1);

            CacheField cacheField2 = new CacheField(){ Name = "Product", NumberFormatId = (UInt32Value)0U };

            SharedItems sharedItems2 = new SharedItems(){ Count = (UInt32Value)10U };
            StringItem stringItem15 = new StringItem(){ Val = "product_A" };
            StringItem stringItem16 = new StringItem(){ Val = "product_D" };
            StringItem stringItem17 = new StringItem(){ Val = "product_E" };
            StringItem stringItem18 = new StringItem(){ Val = "product_C", Unused = true };
            StringItem stringItem19 = new StringItem(){ Val = "product_B", Unused = true };
            StringItem stringItem20 = new StringItem(){ Val = "product_J", Unused = true };
            StringItem stringItem21 = new StringItem(){ Val = "product_I", Unused = true };
            StringItem stringItem22 = new StringItem(){ Val = "product_H", Unused = true };
            StringItem stringItem23 = new StringItem(){ Val = "product_G", Unused = true };
            StringItem stringItem24 = new StringItem(){ Val = "product_F", Unused = true };

            sharedItems2.Append(stringItem15);
            sharedItems2.Append(stringItem16);
            sharedItems2.Append(stringItem17);
            sharedItems2.Append(stringItem18);
            sharedItems2.Append(stringItem19);
            sharedItems2.Append(stringItem20);
            sharedItems2.Append(stringItem21);
            sharedItems2.Append(stringItem22);
            sharedItems2.Append(stringItem23);
            sharedItems2.Append(stringItem24);

            cacheField2.Append(sharedItems2);

            CacheField cacheField3 = new CacheField(){ Name = "Quantity", NumberFormatId = (UInt32Value)0U };
            SharedItems sharedItems3 = new SharedItems(){ ContainsSemiMixedTypes = false, ContainsString = false, ContainsNumber = true, ContainsInteger = true, MinValue = 4D, MaxValue = 29D };

            cacheField3.Append(sharedItems3);

            CacheField cacheField4 = new CacheField(){ Name = "Price", NumberFormatId = (UInt32Value)0U };
            SharedItems sharedItems4 = new SharedItems(){ ContainsSemiMixedTypes = false, ContainsString = false, ContainsNumber = true, ContainsInteger = true, MinValue = 312D, MaxValue = 15990D };

            cacheField4.Append(sharedItems4);

            CacheField cacheField5 = new CacheField(){ Name = "DeliveryDate", NumberFormatId = (UInt32Value)14U };

            SharedItems sharedItems5 = new SharedItems(){ ContainsSemiMixedTypes = false, ContainsNonDate = false, ContainsDate = true, ContainsString = false, MinDate = System.Xml.XmlConvert.ToDateTime("2000-01-06T15:40:41Z", System.Xml.XmlDateTimeSerializationMode.RoundtripKind), MaxDate = System.Xml.XmlConvert.ToDateTime("2003-01-03T06:43:15Z", System.Xml.XmlDateTimeSerializationMode.RoundtripKind), Count = (UInt32Value)4U };
            DateTimeItem dateTimeItem5 = new DateTimeItem(){ Val = System.Xml.XmlConvert.ToDateTime("2000-01-06T15:40:41Z", System.Xml.XmlDateTimeSerializationMode.RoundtripKind) };
            DateTimeItem dateTimeItem6 = new DateTimeItem(){ Val = System.Xml.XmlConvert.ToDateTime("2000-01-07T03:35:07Z", System.Xml.XmlDateTimeSerializationMode.RoundtripKind) };
            DateTimeItem dateTimeItem7 = new DateTimeItem(){ Val = System.Xml.XmlConvert.ToDateTime("2003-01-03T06:43:15Z", System.Xml.XmlDateTimeSerializationMode.RoundtripKind) };
            DateTimeItem dateTimeItem8 = new DateTimeItem(){ Val = System.Xml.XmlConvert.ToDateTime("2002-12-31T20:50:43Z", System.Xml.XmlDateTimeSerializationMode.RoundtripKind) };

            sharedItems5.Append(dateTimeItem5);
            sharedItems5.Append(dateTimeItem6);
            sharedItems5.Append(dateTimeItem7);
            sharedItems5.Append(dateTimeItem8);

            cacheField5.Append(sharedItems5);

            CacheField cacheField6 = new CacheField(){ Name = "Employee", NumberFormatId = (UInt32Value)0U };
            SharedItems sharedItems6 = new SharedItems();

            cacheField6.Append(sharedItems6);

            CacheField cacheField7 = new CacheField(){ Name = "Years", NumberFormatId = (UInt32Value)0U, DatabaseField = false };

            FieldGroup fieldGroup2 = new FieldGroup(){ Base = (UInt32Value)0U };
            RangeProperties rangeProperties2 = new RangeProperties(){ GroupBy = GroupByValues.Years, StartDate = System.Xml.XmlConvert.ToDateTime("2000-01-01T15:40:41Z", System.Xml.XmlDateTimeSerializationMode.RoundtripKind), EndDate = System.Xml.XmlConvert.ToDateTime("2002-12-30T20:50:43Z", System.Xml.XmlDateTimeSerializationMode.RoundtripKind) };

            GroupItems groupItems2 = new GroupItems(){ Count = (UInt32Value)5U };
            StringItem stringItem25 = new StringItem(){ Val = "<2000/01/01" };
            StringItem stringItem26 = new StringItem(){ Val = "2000年" };
            StringItem stringItem27 = new StringItem(){ Val = "2001年" };
            StringItem stringItem28 = new StringItem(){ Val = "2002年" };
            StringItem stringItem29 = new StringItem(){ Val = ">2002/12/30" };

            groupItems2.Append(stringItem25);
            groupItems2.Append(stringItem26);
            groupItems2.Append(stringItem27);
            groupItems2.Append(stringItem28);
            groupItems2.Append(stringItem29);

            fieldGroup2.Append(rangeProperties2);
            fieldGroup2.Append(groupItems2);

            cacheField7.Append(fieldGroup2);

            cacheFields1.Append(cacheField1);
            cacheFields1.Append(cacheField2);
            cacheFields1.Append(cacheField3);
            cacheFields1.Append(cacheField4);
            cacheFields1.Append(cacheField5);
            cacheFields1.Append(cacheField6);
            cacheFields1.Append(cacheField7);

            PivotCacheDefinitionExtensionList pivotCacheDefinitionExtensionList1 = new PivotCacheDefinitionExtensionList();

            PivotCacheDefinitionExtension pivotCacheDefinitionExtension1 = new PivotCacheDefinitionExtension(){ Uri = "{725AE2AE-9491-48be-B2B4-4EB974FC3084}" };
            pivotCacheDefinitionExtension1.AddNamespaceDeclaration("x14", "http://schemas.microsoft.com/office/spreadsheetml/2009/9/main");
            X14.PivotCacheDefinition pivotCacheDefinition2 = new X14.PivotCacheDefinition(){ PivotCacheId = (UInt32Value)2U };

            pivotCacheDefinitionExtension1.Append(pivotCacheDefinition2);

            pivotCacheDefinitionExtensionList1.Append(pivotCacheDefinitionExtension1);

            pivotCacheDefinition1.Append(cacheSource1);
            pivotCacheDefinition1.Append(cacheFields1);
            pivotCacheDefinition1.Append(pivotCacheDefinitionExtensionList1);

            pivotTableCacheDefinitionPart1.PivotCacheDefinition = pivotCacheDefinition1;
        }
Example #15
0
        // Generates content of pivotTableCacheDefinitionPart2.
        private void GeneratePivotTableCacheDefinitionPart2Content(PivotTableCacheDefinitionPart pivotTableCacheDefinitionPart2)
        {
            PivotCacheDefinition pivotCacheDefinition3 = new PivotCacheDefinition(){ Id = "rId1", RefreshedBy = "Masaki Tamura (Pasona Tech)", RefreshedDate = 40946.730963773145D, CreatedVersion = 4, RefreshedVersion = 5, MinRefreshableVersion = 3, RecordCount = (UInt32Value)5U };
            pivotCacheDefinition3.AddNamespaceDeclaration("r", "http://schemas.openxmlformats.org/officeDocument/2006/relationships");

            CacheSource cacheSource2 = new CacheSource(){ Type = SourceValues.Worksheet };
            WorksheetSource worksheetSource2 = new WorksheetSource(){ Name = "DataTable2" };

            cacheSource2.Append(worksheetSource2);

            CacheFields cacheFields2 = new CacheFields(){ Count = (UInt32Value)6U };

            CacheField cacheField8 = new CacheField(){ Name = "Date", NumberFormatId = (UInt32Value)14U };

            SharedItems sharedItems7 = new SharedItems(){ ContainsSemiMixedTypes = false, ContainsNonDate = false, ContainsDate = true, ContainsString = false, MinDate = System.Xml.XmlConvert.ToDateTime("2000-01-01T13:54:32Z", System.Xml.XmlDateTimeSerializationMode.RoundtripKind), MaxDate = System.Xml.XmlConvert.ToDateTime("2002-12-30T22:26:24Z", System.Xml.XmlDateTimeSerializationMode.RoundtripKind), Count = (UInt32Value)5U };
            DateTimeItem dateTimeItem9 = new DateTimeItem(){ Val = System.Xml.XmlConvert.ToDateTime("2000-01-01T13:54:32Z", System.Xml.XmlDateTimeSerializationMode.RoundtripKind) };
            DateTimeItem dateTimeItem10 = new DateTimeItem(){ Val = System.Xml.XmlConvert.ToDateTime("2000-01-01T15:32:03Z", System.Xml.XmlDateTimeSerializationMode.RoundtripKind) };
            DateTimeItem dateTimeItem11 = new DateTimeItem(){ Val = System.Xml.XmlConvert.ToDateTime("2000-01-01T16:56:19Z", System.Xml.XmlDateTimeSerializationMode.RoundtripKind) };
            DateTimeItem dateTimeItem12 = new DateTimeItem(){ Val = System.Xml.XmlConvert.ToDateTime("2000-01-01T18:04:48Z", System.Xml.XmlDateTimeSerializationMode.RoundtripKind) };
            DateTimeItem dateTimeItem13 = new DateTimeItem(){ Val = System.Xml.XmlConvert.ToDateTime("2002-12-30T22:26:24Z", System.Xml.XmlDateTimeSerializationMode.RoundtripKind) };

            sharedItems7.Append(dateTimeItem9);
            sharedItems7.Append(dateTimeItem10);
            sharedItems7.Append(dateTimeItem11);
            sharedItems7.Append(dateTimeItem12);
            sharedItems7.Append(dateTimeItem13);

            cacheField8.Append(sharedItems7);

            CacheField cacheField9 = new CacheField(){ Name = "Product", NumberFormatId = (UInt32Value)0U };

            SharedItems sharedItems8 = new SharedItems(){ Count = (UInt32Value)10U };
            StringItem stringItem34 = new StringItem(){ Val = "product_F" };
            StringItem stringItem35 = new StringItem(){ Val = "product_G" };
            StringItem stringItem36 = new StringItem(){ Val = "product_C" };
            StringItem stringItem37 = new StringItem(){ Val = "product_E", Unused = true };
            StringItem stringItem38 = new StringItem(){ Val = "product_D", Unused = true };
            StringItem stringItem39 = new StringItem(){ Val = "product_B", Unused = true };
            StringItem stringItem40 = new StringItem(){ Val = "product_A", Unused = true };
            StringItem stringItem41 = new StringItem(){ Val = "product_J", Unused = true };
            StringItem stringItem42 = new StringItem(){ Val = "product_I", Unused = true };
            StringItem stringItem43 = new StringItem(){ Val = "product_H", Unused = true };

            sharedItems8.Append(stringItem34);
            sharedItems8.Append(stringItem35);
            sharedItems8.Append(stringItem36);
            sharedItems8.Append(stringItem37);
            sharedItems8.Append(stringItem38);
            sharedItems8.Append(stringItem39);
            sharedItems8.Append(stringItem40);
            sharedItems8.Append(stringItem41);
            sharedItems8.Append(stringItem42);
            sharedItems8.Append(stringItem43);

            cacheField9.Append(sharedItems8);

            CacheField cacheField10 = new CacheField(){ Name = "Quantity", NumberFormatId = (UInt32Value)0U };
            SharedItems sharedItems9 = new SharedItems(){ ContainsSemiMixedTypes = false, ContainsString = false, ContainsNumber = true, ContainsInteger = true, MinValue = 13D, MaxValue = 27D };

            cacheField10.Append(sharedItems9);

            CacheField cacheField11 = new CacheField(){ Name = "Price", NumberFormatId = (UInt32Value)0U };
            SharedItems sharedItems10 = new SharedItems(){ ContainsSemiMixedTypes = false, ContainsString = false, ContainsNumber = true, ContainsInteger = true, MinValue = 800D, MaxValue = 11529D };

            cacheField11.Append(sharedItems10);

            CacheField cacheField12 = new CacheField(){ Name = "DeliveryDate", NumberFormatId = (UInt32Value)14U };
            SharedItems sharedItems11 = new SharedItems(){ ContainsSemiMixedTypes = false, ContainsNonDate = false, ContainsDate = true, ContainsString = false, MinDate = System.Xml.XmlConvert.ToDateTime("2000-01-02T04:31:50Z", System.Xml.XmlDateTimeSerializationMode.RoundtripKind), MaxDate = System.Xml.XmlConvert.ToDateTime("2003-01-01T04:01:28Z", System.Xml.XmlDateTimeSerializationMode.RoundtripKind) };

            cacheField12.Append(sharedItems11);

            CacheField cacheField13 = new CacheField(){ Name = "Employee", NumberFormatId = (UInt32Value)0U };
            SharedItems sharedItems12 = new SharedItems();

            cacheField13.Append(sharedItems12);

            cacheFields2.Append(cacheField8);
            cacheFields2.Append(cacheField9);
            cacheFields2.Append(cacheField10);
            cacheFields2.Append(cacheField11);
            cacheFields2.Append(cacheField12);
            cacheFields2.Append(cacheField13);

            PivotCacheDefinitionExtensionList pivotCacheDefinitionExtensionList2 = new PivotCacheDefinitionExtensionList();

            PivotCacheDefinitionExtension pivotCacheDefinitionExtension2 = new PivotCacheDefinitionExtension(){ Uri = "{725AE2AE-9491-48be-B2B4-4EB974FC3084}" };
            pivotCacheDefinitionExtension2.AddNamespaceDeclaration("x14", "http://schemas.microsoft.com/office/spreadsheetml/2009/9/main");
            X14.PivotCacheDefinition pivotCacheDefinition4 = new X14.PivotCacheDefinition(){ PivotCacheId = (UInt32Value)1U };

            pivotCacheDefinitionExtension2.Append(pivotCacheDefinition4);

            pivotCacheDefinitionExtensionList2.Append(pivotCacheDefinitionExtension2);

            pivotCacheDefinition3.Append(cacheSource2);
            pivotCacheDefinition3.Append(cacheFields2);
            pivotCacheDefinition3.Append(pivotCacheDefinitionExtensionList2);

            pivotTableCacheDefinitionPart2.PivotCacheDefinition = pivotCacheDefinition3;
        }
        internal CacheField ToCacheField()
        {
            var cf = new CacheField();

            cf.Name = Name;
            if ((Caption != null) && (Caption.Length > 0))
            {
                cf.Caption = Caption;
            }
            if ((PropertyName != null) & (PropertyName.Length > 0))
            {
                cf.PropertyName = PropertyName;
            }
            if (ServerField)
            {
                cf.ServerField = ServerField;
            }
            if (UniqueList != true)
            {
                cf.UniqueList = UniqueList;
            }
            if (NumberFormatId != null)
            {
                cf.NumberFormatId = NumberFormatId.Value;
            }
            if ((Formula != null) && (Formula.Length > 0))
            {
                cf.Formula = Formula;
            }
            if (SqlType != 0)
            {
                cf.SqlType = SqlType;
            }
            if (Hierarchy != 0)
            {
                cf.Hierarchy = Hierarchy;
            }
            if (Level != 0)
            {
                cf.Level = Level;
            }
            if (DatabaseField != true)
            {
                cf.DatabaseField = DatabaseField;
            }
            if (MappingCount != null)
            {
                cf.MappingCount = MappingCount.Value;
            }
            if (MemberPropertyField)
            {
                cf.MemberPropertyField = MemberPropertyField;
            }

            if (HasSharedItems)
            {
                cf.SharedItems = SharedItems.ToSharedItems();
            }

            if (HasFieldGroup)
            {
                cf.FieldGroup = FieldGroup.ToFieldGroup();
            }

            foreach (var i in MemberPropertiesMaps)
            {
                if (i != 0)
                {
                    cf.Append(new MemberPropertiesMap {
                        Val = i
                    });
                }
                else
                {
                    cf.Append(new MemberPropertiesMap());
                }
            }

            return(cf);
        }
        internal void FromCacheField(CacheField cf)
        {
            SetAllNull();

            if (cf.Name != null)
            {
                Name = cf.Name.Value;
            }
            if (cf.Caption != null)
            {
                Caption = cf.Caption.Value;
            }
            if (cf.PropertyName != null)
            {
                PropertyName = cf.PropertyName.Value;
            }
            if (cf.ServerField != null)
            {
                ServerField = cf.ServerField.Value;
            }
            if (cf.UniqueList != null)
            {
                UniqueList = cf.UniqueList.Value;
            }
            if (cf.NumberFormatId != null)
            {
                NumberFormatId = cf.NumberFormatId.Value;
            }
            if (cf.Formula != null)
            {
                Formula = cf.Formula.Value;
            }
            if (cf.SqlType != null)
            {
                SqlType = cf.SqlType.Value;
            }
            if (cf.Hierarchy != null)
            {
                Hierarchy = cf.Hierarchy.Value;
            }
            if (cf.Level != null)
            {
                Level = cf.Level.Value;
            }
            if (cf.DatabaseField != null)
            {
                DatabaseField = cf.DatabaseField.Value;
            }
            if (cf.MappingCount != null)
            {
                MappingCount = cf.MappingCount.Value;
            }
            if (cf.MemberPropertyField != null)
            {
                MemberPropertyField = cf.MemberPropertyField.Value;
            }

            if (cf.SharedItems != null)
            {
                SharedItems.FromSharedItems(cf.SharedItems);
                HasSharedItems = true;
            }

            if (cf.FieldGroup != null)
            {
                FieldGroup.FromFieldGroup(cf.FieldGroup);
                HasFieldGroup = true;
            }

            MemberPropertiesMap mpm;

            using (var oxr = OpenXmlReader.Create(cf))
            {
                while (oxr.Read())
                {
                    if (oxr.ElementType == typeof(MemberPropertiesMap))
                    {
                        mpm = (MemberPropertiesMap)oxr.LoadCurrentElement();
                        if (mpm.Val != null)
                        {
                            MemberPropertiesMaps.Add(mpm.Val.Value);
                        }
                        else
                        {
                            MemberPropertiesMaps.Add(0);
                        }
                    }
                }
            }
        }
Example #18
0
        internal SharedItems ToSharedItems()
        {
            var sis = new SharedItems();

            if (ContainsSemiMixedTypes != true)
            {
                sis.ContainsSemiMixedTypes = ContainsSemiMixedTypes;
            }
            if (ContainsNonDate != true)
            {
                sis.ContainsNonDate = ContainsNonDate;
            }
            if (ContainsDate)
            {
                sis.ContainsDate = ContainsDate;
            }
            if (ContainsString != true)
            {
                sis.ContainsString = ContainsString;
            }
            if (ContainsBlank)
            {
                sis.ContainsBlank = ContainsBlank;
            }
            if (ContainsMixedTypes)
            {
                sis.ContainsMixedTypes = ContainsMixedTypes;
            }
            if (ContainsNumber)
            {
                sis.ContainsNumber = ContainsNumber;
            }
            if (ContainsInteger)
            {
                sis.ContainsInteger = ContainsInteger;
            }
            if (MinValue != null)
            {
                sis.MinValue = MinValue.Value;
            }
            if (MaxValue != null)
            {
                sis.MaxValue = MaxValue.Value;
            }
            if (MinDate != null)
            {
                sis.MinDate = new DateTimeValue(MinDate.Value);
            }
            if (MaxDate != null)
            {
                sis.MaxDate = new DateTimeValue(MaxDate.Value);
            }

            // is it the sum of all the various items?
            if (Items.Count > 0)
            {
                sis.Count = (uint)Items.Count;
            }

            if (LongText)
            {
                sis.LongText = LongText;
            }

            foreach (var pair in Items)
            {
                switch (pair.Type)
                {
                case SLSharedGroupItemsType.Missing:
                    sis.Append(MissingItems[pair.Index].ToMissingItem());
                    break;

                case SLSharedGroupItemsType.Number:
                    sis.Append(NumberItems[pair.Index].ToNumberItem());
                    break;

                case SLSharedGroupItemsType.Boolean:
                    sis.Append(BooleanItems[pair.Index].ToBooleanItem());
                    break;

                case SLSharedGroupItemsType.Error:
                    sis.Append(ErrorItems[pair.Index].ToErrorItem());
                    break;

                case SLSharedGroupItemsType.String:
                    sis.Append(StringItems[pair.Index].ToStringItem());
                    break;

                case SLSharedGroupItemsType.DateTime:
                    sis.Append(DateTimeItems[pair.Index].ToDateTimeItem());
                    break;
                }
            }

            return(sis);
        }
        // Generates content of pivotTableCacheDefinitionPart
        private static void GeneratePivotTableCacheDefinitionPartContent(
            PivotTableCacheDefinitionPart pivotTableCacheDefinitionPart, IXLPivotTable pt)
        {
            var source = pt.SourceRange;

            var pivotCacheDefinition = new PivotCacheDefinition
            {
                Id = "rId1",
                SaveData = pt.SaveSourceData,
                RefreshOnLoad = true //pt.RefreshDataOnOpen
            };
            if (pt.ItemsToRetainPerField == XLItemsToRetain.None)
                pivotCacheDefinition.MissingItemsLimit = 0U;
            else if (pt.ItemsToRetainPerField == XLItemsToRetain.Max)
                pivotCacheDefinition.MissingItemsLimit = XLHelper.MaxRowNumber;

            pivotCacheDefinition.AddNamespaceDeclaration("r",
                "http://schemas.openxmlformats.org/officeDocument/2006/relationships");

            var cacheSource = new CacheSource {Type = SourceValues.Worksheet};
            cacheSource.AppendChild(new WorksheetSource {Name = source.ToString()});

            var cacheFields = new CacheFields();

            foreach (var c in source.Columns())
            {
                var columnNumber = c.ColumnNumber();
                var columnName = c.FirstCell().Value.ToString();
                var xlpf = pt.Fields.Add(columnName);

                var field =
                    pt.RowLabels.Union(pt.ColumnLabels).Union(pt.ReportFilters).FirstOrDefault(f => f.SourceName == columnName);
                if (field != null)
                {
                    xlpf.CustomName = field.CustomName;
                    xlpf.Subtotals.AddRange(field.Subtotals);
                }

                var sharedItems = new SharedItems();

                var onlyNumbers =
                    !source.Cells().Any(
                        cell =>
                            cell.Address.ColumnNumber == columnNumber &&
                            cell.Address.RowNumber > source.FirstRow().RowNumber() && cell.DataType != XLCellValues.Number);
                if (onlyNumbers)
                {
                    sharedItems = new SharedItems
                    {ContainsSemiMixedTypes = false, ContainsString = false, ContainsNumber = true};
                }
                else
                {
                    foreach (var cellValue in source.Cells().Where(cell =>
                        cell.Address.ColumnNumber == columnNumber &&
                        cell.Address.RowNumber >
                        source.FirstRow().RowNumber()).Select(
                            cell => cell.Value.ToString())
                        .Where(cellValue => !xlpf.SharedStrings.Contains(cellValue)))
                    {
                        xlpf.SharedStrings.Add(cellValue);
                    }

                    foreach (var li in xlpf.SharedStrings)
                    {
                        sharedItems.AppendChild(new StringItem {Val = li});
                    }
                }

                var cacheField = new CacheField {Name = xlpf.SourceName};
                cacheField.AppendChild(sharedItems);
                cacheFields.AppendChild(cacheField);
            }

            pivotCacheDefinition.AppendChild(cacheSource);
            pivotCacheDefinition.AppendChild(cacheFields);

            pivotTableCacheDefinitionPart.PivotCacheDefinition = pivotCacheDefinition;

            var pivotTableCacheRecordsPart = pivotTableCacheDefinitionPart.AddNewPart<PivotTableCacheRecordsPart>("rId1");

            var pivotCacheRecords = new PivotCacheRecords();
            pivotCacheRecords.AddNamespaceDeclaration("r",
                "http://schemas.openxmlformats.org/officeDocument/2006/relationships");
            pivotTableCacheRecordsPart.PivotCacheRecords = pivotCacheRecords;
        }
        internal SharedItems ToSharedItems()
        {
            SharedItems sis = new SharedItems();
            if (this.ContainsSemiMixedTypes != true) sis.ContainsSemiMixedTypes = this.ContainsSemiMixedTypes;
            if (this.ContainsNonDate != true) sis.ContainsNonDate = this.ContainsNonDate;
            if (this.ContainsDate != false) sis.ContainsDate = this.ContainsDate;
            if (this.ContainsString != true) sis.ContainsString = this.ContainsString;
            if (this.ContainsBlank != false) sis.ContainsBlank = this.ContainsBlank;
            if (this.ContainsMixedTypes != false) sis.ContainsMixedTypes = this.ContainsMixedTypes;
            if (this.ContainsNumber != false) sis.ContainsNumber = this.ContainsNumber;
            if (this.ContainsInteger != false) sis.ContainsInteger = this.ContainsInteger;
            if (this.MinValue != null) sis.MinValue = this.MinValue.Value;
            if (this.MaxValue != null) sis.MaxValue = this.MaxValue.Value;
            if (this.MinDate != null) sis.MinDate = new DateTimeValue(this.MinDate.Value);
            if (this.MaxDate != null) sis.MaxDate = new DateTimeValue(this.MaxDate.Value);

            // is it the sum of all the various items?
            if (this.Items.Count > 0) sis.Count = (uint)this.Items.Count;

            if (this.LongText != false) sis.LongText = this.LongText;

            foreach (SLSharedGroupItemsTypeIndexPair pair in this.Items)
            {
                switch (pair.Type)
                {
                    case SLSharedGroupItemsType.Missing:
                        sis.Append(this.MissingItems[pair.Index].ToMissingItem());
                        break;
                    case SLSharedGroupItemsType.Number:
                        sis.Append(this.NumberItems[pair.Index].ToNumberItem());
                        break;
                    case SLSharedGroupItemsType.Boolean:
                        sis.Append(this.BooleanItems[pair.Index].ToBooleanItem());
                        break;
                    case SLSharedGroupItemsType.Error:
                        sis.Append(this.ErrorItems[pair.Index].ToErrorItem());
                        break;
                    case SLSharedGroupItemsType.String:
                        sis.Append(this.StringItems[pair.Index].ToStringItem());
                        break;
                    case SLSharedGroupItemsType.DateTime:
                        sis.Append(this.DateTimeItems[pair.Index].ToDateTimeItem());
                        break;
                }
            }

            return sis;
        }