Cell manifest data element
Inheritance: DataElementData
Esempio n. 1
0
        private List <RevisionStoreObjectGroup> ParseObjectGroup(CellID objectGroupCellID, MSOneStorePackage package)
        {
            StorageIndexCellMapping         storageIndexCellMapping = package.FindStorageIndexCellMapping(objectGroupCellID);
            CellManifestDataElementData     cellManifest            = this.FindCellManifest(storageIndexCellMapping.CellMappingExtendedGUID);
            List <RevisionStoreObjectGroup> objectGroups            = new List <RevisionStoreObjectGroup>();

            package.CellManifests.Add(cellManifest);
            StorageIndexRevisionMapping revisionMapping =
                package.FindStorageIndexRevisionMapping(cellManifest.CellManifestCurrentRevision.CellManifestCurrentRevisionExtendedGUID);
            RevisionManifestDataElementData revisionManifest =
                this.FindRevisionManifestDataElement(revisionMapping.RevisionMappingExtendedGUID);

            package.RevisionManifests.Add(revisionManifest);
            RevisionManifestRootDeclare encryptionKeyRoot = revisionManifest.RevisionManifestRootDeclareList.Where(r => r.RootExtendedGUID.Equals(new ExGuid(3, Guid.Parse("4A3717F8-1C14-49E7-9526-81D942DE1741")))).SingleOrDefault();
            bool isEncryption = encryptionKeyRoot != null;

            foreach (RevisionManifestObjectGroupReferences objRef in revisionManifest.RevisionManifestObjectGroupReferencesList)
            {
                ObjectGroupDataElementData dataObject = objectGroupDataElements.Where(d => d.DataElementExtendedGUID.Equals(
                                                                                          objRef.ObjectGroupExtendedGUID)).Single().Data as ObjectGroupDataElementData;

                RevisionStoreObjectGroup objectGroup = RevisionStoreObjectGroup.CreateInstance(objRef.ObjectGroupExtendedGUID, dataObject, isEncryption);
                objectGroups.Add(objectGroup);
            }

            return(objectGroups);
        }
        /// <summary>
        /// This method is used to create the cell manifest data element.
        /// </summary>
        /// <param name="revisionId">Specify the revision GUID.</param>
        /// <param name="cellIDMapping">Input/output parameter to represent the mapping of cell manifest.</param>
        /// <returns>Return the cell manifest data element.</returns>
        public static DataElement CreateCellMainifestDataElement(ExGuid revisionId, ref Dictionary <CellID, ExGuid> cellIDMapping)
        {
            CellManifestDataElementData data = new CellManifestDataElementData();

            data.CellManifestCurrentRevision = new CellManifestCurrentRevision()
            {
                CellManifestCurrentRevisionExtendedGUID = new ExGuid(revisionId)
            };
            DataElement dataElement = new DataElement(DataElementType.CellManifestDataElementData, data);

            CellID cellID = new CellID(new ExGuid(1u, RootExGuid), new ExGuid(1u, CellSecondExGuid));

            cellIDMapping.Add(cellID, dataElement.DataElementExtendedGUID);
            return(dataElement);
        }
        /// <summary>
        /// This method is used to get the list of object group data element from a list of data element.
        /// </summary>
        /// <param name="dataElements">Specify the data element list.</param>
        /// <param name="storageIndexExGuid">Specify the storage index extended GUID.</param>
        /// <param name="rootExGuid">Output parameter to represent the root node object.</param>
        /// <returns>Return the list of object group data elements.</returns>
        public static List <ObjectGroupDataElementData> GetDataObjectDataElementData(List <DataElement> dataElements, ExGuid storageIndexExGuid, out ExGuid rootExGuid)
        {
            ExGuid manifestMappingGuid;
            Dictionary <CellID, ExGuid> cellIDMappings;
            Dictionary <ExGuid, ExGuid> revisionIDMappings;

            AnalyzeStorageIndexDataElement(dataElements, storageIndexExGuid, out manifestMappingGuid, out cellIDMappings, out revisionIDMappings);
            StorageManifestDataElementData manifestData = GetStorageManifestDataElementData(dataElements, manifestMappingGuid);

            if (manifestData == null)
            {
                throw new InvalidOperationException("Cannot find the storage manifest data element with ExGuid " + manifestMappingGuid.GUID.ToString());
            }

            CellManifestDataElementData     cellData     = GetCellManifestDataElementData(dataElements, manifestData, cellIDMappings);
            RevisionManifestDataElementData revisionData = GetRevisionManifestDataElementData(dataElements, cellData, revisionIDMappings);

            return(GetDataObjectDataElementData(dataElements, revisionData, out rootExGuid));
        }
        /// <summary>
        /// This method is used to get revision manifest data element from a list of data element.
        /// </summary>
        /// <param name="dataElements">Specify the data element list.</param>
        /// <param name="cellData">Specify the cell data element.</param>
        /// <param name="revisionIDMappings">Specify mapping of revision id.</param>
        /// <returns>Return the revision manifest data element.</returns>
        public static RevisionManifestDataElementData GetRevisionManifestDataElementData(List<DataElement> dataElements, CellManifestDataElementData cellData, Dictionary<ExGuid, ExGuid> revisionIDMappings)
        {
            ExGuid currentRevisionExGuid = cellData.CellManifestCurrentRevision.CellManifestCurrentRevisionExtendedGUID;

            if (!revisionIDMappings.ContainsKey(currentRevisionExGuid))
            {
                throw new InvalidOperationException(string.Format("Cannot find the revision id {0} in the revisionMapping", currentRevisionExGuid.ToString()));
            }
            
            ExGuid revisionMapping = revisionIDMappings[currentRevisionExGuid];

            DataElement dataElement = dataElements.Find(element => element.DataElementExtendedGUID.Equals(revisionMapping));
            if (dataElement == null)
            {
                throw new InvalidOperationException("Cannot find the revision data element with ExGuid " + revisionMapping.GUID.ToString());
            }

            return dataElement.GetData<RevisionManifestDataElementData>();
        }
        /// <summary>
        /// This method is used to create the cell manifest data element.
        /// </summary>
        /// <param name="revisionId">Specify the revision GUID.</param>
        /// <param name="cellIDMapping">Input/output parameter to represent the mapping of cell manifest.</param>
        /// <returns>Return the cell manifest data element.</returns>
        public static DataElement CreateCellMainifestDataElement(ExGuid revisionId, ref Dictionary<CellID, ExGuid> cellIDMapping)
        {
            CellManifestDataElementData data = new CellManifestDataElementData();
            data.CellManifestCurrentRevision = new CellManifestCurrentRevision() { CellManifestCurrentRevisionExtendedGUID = new ExGuid(revisionId) };
            DataElement dataElement = new DataElement(DataElementType.CellManifestDataElementData, data);

            CellID cellID = new CellID(new ExGuid(1u, RootExGuid), new ExGuid(1u, CellSecondExGuid));
            cellIDMapping.Add(cellID, dataElement.DataElementExtendedGUID);
            return dataElement;
        }
        /// <summary>
        /// This method is used to get revision manifest data element from a list of data element.
        /// </summary>
        /// <param name="dataElements">Specify the data element list.</param>
        /// <param name="cellData">Specify the cell data element.</param>
        /// <param name="revisionIDMappings">Specify mapping of revision id.</param>
        /// <returns>Return the revision manifest data element.</returns>
        public static RevisionManifestDataElementData GetRevisionManifestDataElementData(List <DataElement> dataElements, CellManifestDataElementData cellData, Dictionary <ExGuid, ExGuid> revisionIDMappings)
        {
            ExGuid currentRevisionExGuid = cellData.CellManifestCurrentRevision.CellManifestCurrentRevisionExtendedGUID;

            if (!revisionIDMappings.ContainsKey(currentRevisionExGuid))
            {
                throw new InvalidOperationException(string.Format("Cannot find the revision id {0} in the revisionMapping", currentRevisionExGuid.ToString()));
            }

            ExGuid revisionMapping = revisionIDMappings[currentRevisionExGuid];

            DataElement dataElement = dataElements.Find(element => element.DataElementExtendedGUID.Equals(revisionMapping));

            if (dataElement == null)
            {
                throw new InvalidOperationException("Cannot find the revision data element with ExGuid " + revisionMapping.GUID.ToString());
            }

            return(dataElement.GetData <RevisionManifestDataElementData>());
        }
        /// <summary>
        /// This method is used to try to analyze the returned whether data elements are complete.
        /// </summary>
        /// <param name="dataElements">Specify the data elements list.</param>
        /// <param name="storageIndexExGuid">Specify the storage index extended GUID.</param>
        /// <returns>If the data elements start with the specified storage index extended GUID are complete, return true. Otherwise return false.</returns>
        public static bool TryAnalyzeWhetherFullDataElementList(List <DataElement> dataElements, ExGuid storageIndexExGuid)
        {
            ExGuid manifestMappingGuid;
            Dictionary <CellID, ExGuid> cellIDMappings;
            Dictionary <ExGuid, ExGuid> revisionIDMappings;

            if (!AnalyzeStorageIndexDataElement(dataElements, storageIndexExGuid, out manifestMappingGuid, out cellIDMappings, out revisionIDMappings))
            {
                return(false);
            }

            if (cellIDMappings.Count == 0)
            {
                return(false);
            }

            if (revisionIDMappings.Count == 0)
            {
                return(false);
            }

            StorageManifestDataElementData manifestData = GetStorageManifestDataElementData(dataElements, manifestMappingGuid);

            if (manifestData == null)
            {
                return(false);
            }

            foreach (StorageManifestRootDeclare kv in manifestData.StorageManifestRootDeclareList)
            {
                if (!cellIDMappings.ContainsKey(kv.CellID))
                {
                    throw new InvalidOperationException(string.Format("Cannot fin the Cell ID {0} in the cell id mapping", kv.CellID.ToString()));
                }

                ExGuid      cellMappingID = cellIDMappings[kv.CellID];
                DataElement dataElement   = dataElements.Find(element => element.DataElementExtendedGUID.Equals(cellMappingID));
                if (dataElement == null)
                {
                    return(false);
                }

                CellManifestDataElementData cellData = dataElement.GetData <CellManifestDataElementData>();
                ExGuid currentRevisionExGuid         = cellData.CellManifestCurrentRevision.CellManifestCurrentRevisionExtendedGUID;
                if (!revisionIDMappings.ContainsKey(currentRevisionExGuid))
                {
                    throw new InvalidOperationException(string.Format("Cannot find the revision id {0} in the revisionMapping", currentRevisionExGuid.ToString()));
                }

                ExGuid revisionMapping = revisionIDMappings[currentRevisionExGuid];
                dataElement = dataElements.Find(element => element.DataElementExtendedGUID.Equals(revisionMapping));
                if (dataElement == null)
                {
                    return(false);
                }

                RevisionManifestDataElementData revisionData = dataElement.GetData <RevisionManifestDataElementData>();
                foreach (RevisionManifestObjectGroupReferences reference in revisionData.RevisionManifestObjectGroupReferencesList)
                {
                    dataElement = dataElements.Find(element => element.DataElementExtendedGUID.Equals(reference.ObjectGroupExtendedGUID));
                    if (dataElement == null)
                    {
                        return(false);
                    }
                }
            }

            return(true);
        }