/// <summary> /// This method is used to analyze the storage index data element to get all the mappings. /// </summary> /// <param name="dataElements">Specify the data element list.</param> /// <param name="storageIndexExGuid">Specify the storage index extended GUID.</param> /// <param name="manifestMappingGuid">Output parameter to represent the storage manifest mapping GUID.</param> /// <param name="cellIDMappings">Output parameter to represent the mapping of cell id.</param> /// <param name="revisionIDMappings">Output parameter to represent the revision id.</param> /// <returns>Return true if analyze the storage index succeeds, otherwise return false.</returns> public static bool AnalyzeStorageIndexDataElement( List <DataElement> dataElements, ExGuid storageIndexExGuid, out ExGuid manifestMappingGuid, out Dictionary <CellID, ExGuid> cellIDMappings, out Dictionary <ExGuid, ExGuid> revisionIDMappings) { manifestMappingGuid = null; cellIDMappings = null; revisionIDMappings = null; if (storageIndexExGuid == null) { return(false); } DataElement storageIndexDataElement = dataElements.Find(element => element.DataElementExtendedGUID.Equals(storageIndexExGuid)); StorageIndexDataElementData storageIndexData = storageIndexDataElement.GetData <StorageIndexDataElementData>(); manifestMappingGuid = storageIndexData.StorageIndexManifestMapping.ManifestMappingExtendedGUID; cellIDMappings = new Dictionary <CellID, ExGuid>(); foreach (StorageIndexCellMapping kv in storageIndexData.StorageIndexCellMappingList) { cellIDMappings.Add(kv.CellID, kv.CellMappingExtendedGUID); } revisionIDMappings = new Dictionary <ExGuid, ExGuid>(); foreach (StorageIndexRevisionMapping kv in storageIndexData.StorageIndexRevisionMappingList) { revisionIDMappings.Add(kv.RevisionExtendedGUID, kv.RevisionMappingExtendedGUID); } return(true); }
/// <summary> /// This method is used to build a root node object from an data element list with the specified storage index extended GUID. /// </summary> /// <param name="dataElements">Specify the data element list.</param> /// <param name="storageIndexExGuid">Specify the storage index extended GUID.</param> /// <returns>Return a root node object build from the data element list.</returns> public IntermediateNodeObject Build(List <DataElement> dataElements, ExGuid storageIndexExGuid) { if (DataElementUtils.TryAnalyzeWhetherFullDataElementList(dataElements, storageIndexExGuid) && DataElementUtils.TryAnalyzeWhetherConfirmSchema(dataElements, storageIndexExGuid)) { ExGuid rootObjectExGUID; List <ObjectGroupDataElementData> objectGroupList = DataElementUtils.GetDataObjectDataElementData(dataElements, storageIndexExGuid, out rootObjectExGUID); // If the root object extend GUID can be found, then the root node can be build. if (rootObjectExGUID != null) { // If can analyze for here, then can directly capture all the GUID values related requirements if (SharedContext.Current.IsMsFsshttpRequirementsCaptured) { MsfsshttpdCapture.VerifyDefinedGUID(SharedContext.Current.Site); } return(this.Build(objectGroupList, rootObjectExGUID)); } else { throw new InvalidOperationException(string.Format("There is no root extended GUID value {0}", DataElementUtils.RootExGuid.ToString())); } } return(null); }
/// <summary> /// This method is used to create the revision manifest data element. /// </summary> /// <param name="rootObjectExGuid">Specify the root node object extended GUID.</param> /// <param name="baseRevisionID">Specify the base revision Id.</param> /// <param name="refferenceObjectDataExGuidList">Specify the reference object data extended list.</param> /// <param name="revisionMapping">Input/output parameter to represent the mapping of revision manifest.</param> /// <param name="currentRevisionID">Output parameter to represent the revision GUID.</param> /// <returns>Return the revision manifest data element.</returns> public static DataElement CreateRevisionManifestDataElement(ExGuid rootObjectExGuid, ExGuid baseRevisionID, List <ExGuid> refferenceObjectDataExGuidList, ref Dictionary <ExGuid, ExGuid> revisionMapping, out ExGuid currentRevisionID) { RevisionManifestDataElementData data = new RevisionManifestDataElementData(); data.RevisionManifest.RevisionID = new ExGuid(1u, Guid.NewGuid()); data.RevisionManifest.BaseRevisionID = new ExGuid(baseRevisionID); // Set the root object data ExGuid data.RevisionManifestRootDeclareList.Add(new RevisionManifestRootDeclare() { RootExtendedGUID = new ExGuid(2u, RootExGuid), ObjectExtendedGUID = new ExGuid(rootObjectExGuid) }); // Set all the reference object data if (refferenceObjectDataExGuidList != null) { foreach (ExGuid dataGuid in refferenceObjectDataExGuidList) { data.RevisionManifestObjectGroupReferencesList.Add(new RevisionManifestObjectGroupReferences(dataGuid)); } } DataElement dataElement = new DataElement(DataElementType.RevisionManifestDataElementData, data); revisionMapping.Add(data.RevisionManifest.RevisionID, dataElement.DataElementExtendedGUID); currentRevisionID = data.RevisionManifest.RevisionID; return(dataElement); }
/// <summary> /// This method is used to create the storage index data element. /// </summary> /// <param name="manifestExGuid">Specify the storage manifest data element extended GUID.</param> /// <param name="cellIDMappings">Specify the mapping of cell manifest.</param> /// <param name="revisionIDMappings">Specify the mapping of revision manifest.</param> /// <returns>Return the storage index data element.</returns> public static DataElement CreateStorageIndexDataElement(ExGuid manifestExGuid, Dictionary <CellID, ExGuid> cellIDMappings, Dictionary <ExGuid, ExGuid> revisionIDMappings) { StorageIndexDataElementData data = new StorageIndexDataElementData(); data.StorageIndexManifestMapping = new StorageIndexManifestMapping(); data.StorageIndexManifestMapping.ManifestMappingExtendedGUID = new ExGuid(manifestExGuid); data.StorageIndexManifestMapping.ManifestMappingSerialNumber = new SerialNumber(System.Guid.NewGuid(), SequenceNumberGenerator.GetCurrentSerialNumber()); foreach (KeyValuePair <CellID, ExGuid> kv in cellIDMappings) { StorageIndexCellMapping cellMapping = new StorageIndexCellMapping(); cellMapping.CellID = kv.Key; cellMapping.CellMappingExtendedGUID = kv.Value; cellMapping.CellMappingSerialNumber = new SerialNumber(System.Guid.NewGuid(), SequenceNumberGenerator.GetCurrentSerialNumber()); data.StorageIndexCellMappingList.Add(cellMapping); } foreach (KeyValuePair <ExGuid, ExGuid> kv in revisionIDMappings) { StorageIndexRevisionMapping revisionMapping = new StorageIndexRevisionMapping(); revisionMapping.RevisionExtendedGUID = kv.Key; revisionMapping.RevisionMappingExtendedGUID = kv.Value; revisionMapping.RevisionMappingSerialNumber = new SerialNumber(Guid.NewGuid(), SequenceNumberGenerator.GetCurrentSerialNumber()); data.StorageIndexRevisionMappingList.Add(revisionMapping); } return(new DataElement(DataElementType.StorageIndexDataElementData, data)); }
/// <summary> /// This method is used to get cell manifest data element from a list of data element. /// </summary> /// <param name="dataElements">Specify the data element list.</param> /// <param name="manifestDataElementData">Specify the manifest data element.</param> /// <param name="cellIDMappings">Specify mapping of cell id.</param> /// <returns>Return the cell manifest data element.</returns> public static CellManifestDataElementData GetCellManifestDataElementData(List <DataElement> dataElements, StorageManifestDataElementData manifestDataElementData, Dictionary <CellID, ExGuid> cellIDMappings) { CellID cellID = new CellID(new ExGuid(1u, RootExGuid), new ExGuid(1u, CellSecondExGuid)); foreach (StorageManifestRootDeclare kv in manifestDataElementData.StorageManifestRootDeclareList) { if (kv.RootExtendedGUID.Equals(new ExGuid(2u, RootExGuid)) && kv.CellID.Equals(cellID)) { if (!cellIDMappings.ContainsKey(kv.CellID)) { throw new InvalidOperationException(string.Format("Cannot fin the Cell ID {0} in the cell id mapping", cellID.ToString())); } ExGuid cellMappingID = cellIDMappings[kv.CellID]; DataElement dataElement = dataElements.Find(element => element.DataElementExtendedGUID.Equals(cellMappingID)); if (dataElement == null) { throw new InvalidOperationException("Cannot find the cell data element with ExGuid " + cellMappingID.GUID.ToString()); } return(dataElement.GetData <CellManifestDataElementData>()); } } throw new InvalidOperationException("Cannot find the CellManifestDataElement"); }
private HeaderCell ParseHeaderCell(RevisionManifestDataElementData headerCellRevisionManifest) { ExGuid rootObjectId = headerCellRevisionManifest.RevisionManifestObjectGroupReferencesList[0].ObjectGroupExtendedGUID; DataElement element = this.objectGroupDataElements .Where(d => d.DataElementExtendedGUID.Equals(rootObjectId)).SingleOrDefault(); return(HeaderCell.CreateInstance((ObjectGroupDataElementData)element.Data)); }
/// <summary> /// This method is used to deserialize the CellID basic object from the specified byte array and start index. /// </summary> /// <param name="byteArray">Specify the byte array.</param> /// <param name="startIndex">Specify the start index from the byte array.</param> /// <returns>Return the length in byte of the CellID basic object.</returns> protected override int DoDeserializeFromByteArray(byte[] byteArray, int startIndex) { int index = startIndex; this.ExtendGUID1 = BasicObject.Parse <ExGuid>(byteArray, ref index); this.ExtendGUID2 = BasicObject.Parse <ExGuid>(byteArray, ref index); return(index - startIndex); }
/// <summary> /// This method is used to find the Storage Index Revision Mapping that matches the Revision Mapping Extended GUID. /// </summary> /// <param name="revisionExtendedGUID">Specify the Revision Mapping Extended GUID.</param> /// <returns>Return the instance of Storage Index Revision Mapping.</returns> public StorageIndexRevisionMapping FindStorageIndexRevisionMapping(ExGuid revisionExtendedGUID) { StorageIndexRevisionMapping instance = null; if (this.StorageIndex != null) { instance = this.StorageIndex.StorageIndexRevisionMappingList.Where(r => r.RevisionExtendedGUID.Equals(revisionExtendedGUID)).SingleOrDefault(); } return(instance); }
/// <summary> /// Used to de-serialize the element. /// </summary> /// <param name="byteArray">A Byte array</param> /// <param name="currentIndex">Start position</param> /// <param name="lengthOfItems">The length of the items</param> protected override void DeserializeItemsFromByteArray(byte[] byteArray, ref int currentIndex, int lengthOfItems) { int index = currentIndex; this.CellManifestCurrentRevisionExtendedGUID = BasicObject.Parse<ExGuid>(byteArray, ref index); if (index - currentIndex != lengthOfItems) { throw new StreamObjectParseErrorException(currentIndex, "CellManifestCurrentRevision", "Stream object over-parse error", null); } currentIndex = index; }
/// <summary> /// Used to de-serialize the element. /// </summary> /// <param name="byteArray">A Byte array</param> /// <param name="currentIndex">Start position</param> /// <param name="lengthOfItems">The length of the items</param> protected override void DeserializeItemsFromByteArray(byte[] byteArray, ref int currentIndex, int lengthOfItems) { int index = currentIndex; this.ObjectGroupExtendedGUID = BasicObject.Parse <ExGuid>(byteArray, ref index); if (index - currentIndex != lengthOfItems) { throw new StreamObjectParseErrorException(currentIndex, "RevisionManifestObjectGroupReferences", "Stream object over-parse error", null); } currentIndex = index; }
/// <summary> /// This method is used to create object group data/blob element list. /// </summary> /// <param name="fileContent">Specify the file content in byte array format.</param> /// <param name="rootNodeExGuid">Output parameter to represent the root node extended GUID.</param> /// <param name="objectDataExGuidList">Input/Output parameter to represent the list of extended GUID for the data object data.</param> /// <returns>Return the list of data element which will represent the file content.</returns> public static List<DataElement> CreateObjectGroupDataElement(byte[] fileContent, out ExGuid rootNodeExGuid, ref List<ExGuid> objectDataExGuidList) { NodeObject rootNode = new RootNodeObject.RootNodeObjectBuilder().Build(fileContent); // Storage the root object node ExGuid rootNodeExGuid = new ExGuid(rootNode.ExGuid); List<DataElement> elements = new ObjectGroupDataElementData.Builder().Build(rootNode); objectDataExGuidList.AddRange( elements.Where(element => element.DataElementType == DataElementType.ObjectGroupDataElementData) .Select(element => element.DataElementExtendedGUID) .ToArray()); return elements; }
/// <summary> /// This method is used to create object group data/blob element list. /// </summary> /// <param name="fileContent">Specify the file content in byte array format.</param> /// <param name="rootNodeExGuid">Output parameter to represent the root node extended GUID.</param> /// <param name="objectDataExGuidList">Input/Output parameter to represent the list of extended GUID for the data object data.</param> /// <returns>Return the list of data element which will represent the file content.</returns> public static List <DataElement> CreateObjectGroupDataElement(byte[] fileContent, out ExGuid rootNodeExGuid, ref List <ExGuid> objectDataExGuidList) { NodeObject rootNode = new RootNodeObject.RootNodeObjectBuilder().Build(fileContent); // Storage the root object node ExGuid rootNodeExGuid = new ExGuid(rootNode.ExGuid); List <DataElement> elements = new ObjectGroupDataElementData.Builder().Build(rootNode); objectDataExGuidList.AddRange( elements.Where(element => element.DataElementType == DataElementType.ObjectGroupDataElementData) .Select(element => element.DataElementExtendedGUID) .ToArray()); return(elements); }
/// <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 deserialize the ExGUIDArray basic object from the specified byte array and start index. /// </summary> /// <param name="byteArray">Specify the byte array.</param> /// <param name="startIndex">Specify the start index from the byte array.</param> /// <returns>Return the length in byte of the ExGUIDArray basic object.</returns> protected override int DoDeserializeFromByteArray(byte[] byteArray, int startIndex) // return the length consumed { int index = startIndex; this.Count = BasicObject.Parse <Compact64bitInt>(byteArray, ref index); this.Content.Clear(); for (uint i = 0; i < this.Count.DecodedValue; i++) { ExGuid temp = BasicObject.Parse <ExGuid>(byteArray, ref index); this.Content.Add(temp); } return(index - startIndex); }
/// <summary> /// Used to de-serialize the element. /// </summary> /// <param name="byteArray">A Byte array</param> /// <param name="currentIndex">Start position</param> /// <param name="lengthOfItems">The length of the items</param> protected override void DeserializeItemsFromByteArray(byte[] byteArray, ref int currentIndex, int lengthOfItems) { int index = currentIndex; this.ObjectExtendedGUIDArray = BasicObject.Parse <ExGUIDArray>(byteArray, ref index); this.CellIDArray = BasicObject.Parse <CellIDArray>(byteArray, ref index); this.BLOBExtendedGUID = BasicObject.Parse <ExGuid>(byteArray, ref index); if (index - currentIndex != lengthOfItems) { throw new StreamObjectParseErrorException(currentIndex, "ObjectGroupObjectDataBLOBReference", "Stream object over-parse error", null); } currentIndex = index; }
/// <summary> /// Override the Equals method. /// </summary> /// <param name="obj">Specify the object.</param> /// <returns>Return true if equals, otherwise return false.</returns> public override bool Equals(object obj) { ExGuid another = obj as ExGuid; if (another == null) { return(false); } if (this.GUID != null && another.GUID != null) { return(another.GUID.Equals(this.GUID) && another.Value == this.Value); } return(false); }
/// <summary> /// Initializes a new instance of the PutChangesCellSubRequest class /// </summary> /// <param name="subRequestID">Specify the sub request id</param> /// <param name="storageIndexExGuid">Specify the storage index ExGuid.</param> public PutChangesCellSubRequest(ulong subRequestID, ExGuid storageIndexExGuid) { this.RequestID = subRequestID; this.RequestType = Convert.ToUInt64(RequestTypes.PutChanges); this.StorageIndexExtendedGUID = storageIndexExGuid; this.ExpectedStorageIndexExtendedGUID = new ExGuid(); this.ImplyNullExpectedIfNoMapping = 0; this.Partial = 0; this.PartialLast = 0; this.FavorCoherencyFailureOverNotFound = 1; this.AbortRemainingPutChangesOnFailure = 0; this.MultiRequestPutHint = 0; this.ReturnCompleteKnowledgeIfPossible = 1; this.LastWriterWinsOnNextChange = 0; this.IsAdditionalFlagsUsed = false; this.IsLockIdUsed = false; }
/// <summary> /// Initializes a new instance of the QueryChangesCellSubRequest class /// </summary> /// <param name="subRequestID">Specify the sub request id</param> public QueryChangesCellSubRequest(ulong subRequestID) { this.RequestID = subRequestID; this.RequestType = Convert.ToUInt64(RequestTypes.QueryChanges); this.QueryChangesRequest = new StreamObjectHeaderStart32bit(StreamObjectTypeHeaderStart.QueryChangesRequest, 1); this.Reserved = 0; this.AllowFragments = 0; this.Reserved1 = 0; this.IncludeStorageManifest = 0; this.IncludeCellChanges = 0; this.Reserved2 = 0; // CellId ExGuid extendGuid1 = new ExGuid(0x0, Guid.Empty); ExGuid extendGuid2 = new ExGuid(0x0, Guid.Empty); this.CellId = new CellID(extendGuid1, extendGuid2); this.QueryChangeFilters = new List<Filter>(); }
/// <summary> /// Initializes a new instance of the QueryChangesCellSubRequest class /// </summary> /// <param name="subRequestID">Specify the sub request id</param> public QueryChangesCellSubRequest(ulong subRequestID) { this.RequestID = subRequestID; this.RequestType = Convert.ToUInt64(RequestTypes.QueryChanges); this.QueryChangesRequest = new StreamObjectHeaderStart32bit(StreamObjectTypeHeaderStart.QueryChangesRequest, 1); this.Reserved = 0; this.AllowFragments = 0; this.Reserved1 = 0; this.IncludeStorageManifest = 0; this.IncludeCellChanges = 0; this.Reserved2 = 0; // CellId ExGuid extendGuid1 = new ExGuid(0x0, Guid.Empty); ExGuid extendGuid2 = new ExGuid(0x0, Guid.Empty); this.CellId = new CellID(extendGuid1, extendGuid2); this.QueryChangeFilters = new List <Filter>(); }
/// <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 build a list of data elements to represent a file. /// </summary> /// <param name="fileContent">Specify the file content byte array.</param> /// <param name="storageIndexExGuid">Output parameter to represent the storage index GUID.</param> /// <returns>Return the list of data elements.</returns> public static List<DataElement> BuildDataElements(byte[] fileContent, out ExGuid storageIndexExGuid) { List<DataElement> dataElementList = new List<DataElement>(); ExGuid rootNodeObjectExGuid; List<ExGuid> objectDataExGuidList = new List<ExGuid>(); dataElementList.AddRange(CreateObjectGroupDataElement(fileContent, out rootNodeObjectExGuid, ref objectDataExGuidList)); ExGuid baseRevisionID = new ExGuid(0u, Guid.Empty); Dictionary<ExGuid, ExGuid> revisionMapping = new Dictionary<ExGuid, ExGuid>(); ExGuid currentRevisionID; dataElementList.Add(CreateRevisionManifestDataElement(rootNodeObjectExGuid, baseRevisionID, objectDataExGuidList, ref revisionMapping, out currentRevisionID)); Dictionary<CellID, ExGuid> cellIDMapping = new Dictionary<CellID, ExGuid>(); dataElementList.Add(CreateCellMainifestDataElement(currentRevisionID, ref cellIDMapping)); dataElementList.Add(CreateStorageManifestDataElement(cellIDMapping)); dataElementList.Add(CreateStorageIndexDataElement(dataElementList.Last().DataElementExtendedGUID, cellIDMapping, revisionMapping)); storageIndexExGuid = dataElementList.Last().DataElementExtendedGUID; return dataElementList; }
/// <summary> /// This method is used to analyze whether the data elements are confirmed to the schema defined in MS-FSSHTTPD. /// </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 confirms to the schema defined in the MS-FSSHTTPD returns true, otherwise false.</returns> public static bool TryAnalyzeWhetherConfirmSchema(List <DataElement> dataElements, ExGuid storageIndexExGuid) { DataElement storageIndexDataElement = dataElements.Find(element => element.DataElementExtendedGUID.Equals(storageIndexExGuid)); if (storageIndexExGuid == null) { return(false); } StorageIndexDataElementData storageIndexData = storageIndexDataElement.GetData <StorageIndexDataElementData>(); ExGuid manifestMappingGuid = storageIndexData.StorageIndexManifestMapping.ManifestMappingExtendedGUID; DataElement storageManifestDataElement = dataElements.Find(element => element.DataElementExtendedGUID.Equals(manifestMappingGuid)); if (storageManifestDataElement == null) { return(false); } return(SchemaGuid.Equals(storageManifestDataElement.GetData <StorageManifestDataElementData>().StorageManifestSchemaGUID.GUID)); }
/// <summary> /// This method is used to create the revision manifest data element. /// </summary> /// <param name="rootObjectExGuid">Specify the root node object extended GUID.</param> /// <param name="baseRevisionID">Specify the base revision Id.</param> /// <param name="refferenceObjectDataExGuidList">Specify the reference object data extended list.</param> /// <param name="revisionMapping">Input/output parameter to represent the mapping of revision manifest.</param> /// <param name="currentRevisionID">Output parameter to represent the revision GUID.</param> /// <returns>Return the revision manifest data element.</returns> public static DataElement CreateRevisionManifestDataElement(ExGuid rootObjectExGuid, ExGuid baseRevisionID, List<ExGuid> refferenceObjectDataExGuidList, ref Dictionary<ExGuid, ExGuid> revisionMapping, out ExGuid currentRevisionID) { RevisionManifestDataElementData data = new RevisionManifestDataElementData(); data.RevisionManifest.RevisionID = new ExGuid(1u, Guid.NewGuid()); data.RevisionManifest.BaseRevisionID = new ExGuid(baseRevisionID); // Set the root object data ExGuid data.RevisionManifestRootDeclareList.Add(new RevisionManifestRootDeclare() { RootExtendedGUID = new ExGuid(2u, RootExGuid), ObjectExtendedGUID = new ExGuid(rootObjectExGuid) }); // Set all the reference object data if (refferenceObjectDataExGuidList != null) { foreach (ExGuid dataGuid in refferenceObjectDataExGuidList) { data.RevisionManifestObjectGroupReferencesList.Add(new RevisionManifestObjectGroupReferences(dataGuid)); } } DataElement dataElement = new DataElement(DataElementType.RevisionManifestDataElementData, data); revisionMapping.Add(data.RevisionManifest.RevisionID, dataElement.DataElementExtendedGUID); currentRevisionID = data.RevisionManifest.RevisionID; return dataElement; }
/// <summary> /// This method is used to build a list of data elements to represent a file. /// </summary> /// <param name="fileContent">Specify the file content byte array.</param> /// <param name="storageIndexExGuid">Output parameter to represent the storage index GUID.</param> /// <returns>Return the list of data elements.</returns> public static List <DataElement> BuildDataElements(byte[] fileContent, out ExGuid storageIndexExGuid) { List <DataElement> dataElementList = new List <DataElement>(); ExGuid rootNodeObjectExGuid; List <ExGuid> objectDataExGuidList = new List <ExGuid>(); dataElementList.AddRange(CreateObjectGroupDataElement(fileContent, out rootNodeObjectExGuid, ref objectDataExGuidList)); ExGuid baseRevisionID = new ExGuid(0u, Guid.Empty); Dictionary <ExGuid, ExGuid> revisionMapping = new Dictionary <ExGuid, ExGuid>(); ExGuid currentRevisionID; dataElementList.Add(CreateRevisionManifestDataElement(rootNodeObjectExGuid, baseRevisionID, objectDataExGuidList, ref revisionMapping, out currentRevisionID)); Dictionary <CellID, ExGuid> cellIDMapping = new Dictionary <CellID, ExGuid>(); dataElementList.Add(CreateCellMainifestDataElement(currentRevisionID, ref cellIDMapping)); dataElementList.Add(CreateStorageManifestDataElement(cellIDMapping)); dataElementList.Add(CreateStorageIndexDataElement(dataElementList.Last().DataElementExtendedGUID, cellIDMapping, revisionMapping)); storageIndexExGuid = dataElementList.Last().DataElementExtendedGUID; return(dataElementList); }
/// <summary> /// This method is used to build a root node object from an object group data element list with the specified root extended GUID. /// </summary> /// <param name="objectGroupList">Specify the object group data element list.</param> /// <param name="rootExGuid">Specify the root extended GUID.</param> /// <returns>Return a root node object build from the object group data element list.</returns> private IntermediateNodeObject Build(List <ObjectGroupDataElementData> objectGroupList, ExGuid rootExGuid) { ObjectGroupObjectDeclare rootDeclare; ObjectGroupObjectData root = this.FindByExGuid(objectGroupList, rootExGuid, out rootDeclare); if (SharedContext.Current.IsMsFsshttpRequirementsCaptured) { MsfsshttpdCapture.VerifyObjectCount(root, SharedContext.Current.Site); } int index = 0; IntermediateNodeObject rootNode = null; if (StreamObject.TryGetCurrent <IntermediateNodeObject>(root.Data.Content.ToArray(), ref index, out rootNode)) { rootNode.ExGuid = rootExGuid; foreach (ExGuid extGuid in root.ObjectExGUIDArray.Content) { ObjectGroupObjectDeclare intermediateDeclare; ObjectGroupObjectData intermediateData = this.FindByExGuid(objectGroupList, extGuid, out intermediateDeclare); rootNode.IntermediateNodeObjectList.Add(new LeafNodeObject.IntermediateNodeObjectBuilder().Build(objectGroupList, intermediateData, extGuid)); // Capture the intermediate related requirements if (SharedContext.Current.IsMsFsshttpRequirementsCaptured) { MsfsshttpdCapture.VerifyObjectGroupObjectDataForIntermediateNode(intermediateData, intermediateDeclare, objectGroupList, SharedContext.Current.Site); MsfsshttpdCapture.VerifyLeafNodeObject(rootNode.IntermediateNodeObjectList.Last(), SharedContext.Current.Site); } } if (SharedContext.Current.IsMsFsshttpRequirementsCaptured) { // Capture the root node related requirements. MsfsshttpdCapture.VerifyObjectGroupObjectDataForRootNode(root, rootDeclare, objectGroupList, SharedContext.Current.Site); MsfsshttpdCapture.VerifyIntermediateNodeObject(rootNode, SharedContext.Current.Site); } } else { // If there is only one object in the file, SharePoint Server 2010 does not return the Root Node Object, but an Intermediate Node Object at the beginning. // At this case, we will add the root node object for the further parsing. rootNode = new IntermediateNodeObject(); rootNode.ExGuid = rootExGuid; rootNode.IntermediateNodeObjectList.Add(new LeafNodeObject.IntermediateNodeObjectBuilder().Build(objectGroupList, root, rootExGuid)); rootNode.DataSize = new DataSizeObject(); rootNode.DataSize.DataSize = (ulong)rootNode.IntermediateNodeObjectList.Sum(o => (float)o.DataSize.DataSize); } // Capture all the signature related requirements. if (SharedContext.Current.IsMsFsshttpRequirementsCaptured) { AbstractChunking chunking = ChunkingFactory.CreateChunkingInstance(rootNode); if (chunking != null) { chunking.AnalyzeChunking(rootNode, SharedContext.Current.Site); } } return(rootNode); }
/// <summary> /// Initializes a new instance of the ExGuid class, this is the copy constructor. /// </summary> /// <param name="guid2">Specify the ExGuid instance where copies from.</param> public ExGuid(ExGuid guid2) { this.Value = guid2.Value; this.GUID = guid2.GUID; this.Type = guid2.Type; }
/// <summary> /// This method is used to build a root node object from an data element list with the specified storage index extended GUID. /// </summary> /// <param name="dataElements">Specify the data element list.</param> /// <param name="storageIndexExGuid">Specify the storage index extended GUID.</param> /// <returns>Return a root node object build from the data element list.</returns> public RootNodeObject Build(List<DataElement> dataElements, ExGuid storageIndexExGuid) { if (DataElementUtils.TryAnalyzeWhetherFullDataElementList(dataElements, storageIndexExGuid) && DataElementUtils.TryAnalyzeWhetherConfirmSchema(dataElements, storageIndexExGuid)) { ExGuid rootObjectExGUID; List<ObjectGroupDataElementData> objectGroupList = DataElementUtils.GetDataObjectDataElementData(dataElements, storageIndexExGuid, out rootObjectExGUID); // If the root object extend GUID can be found, then the root node can be build. if (rootObjectExGUID != null) { // If can analyze for here, then can directly capture all the GUID values related requirements if (SharedContext.Current.IsMsFsshttpRequirementsCaptured) { MsfsshttpdCapture.VerifyDefinedGUID(SharedContext.Current.Site); } return this.Build(objectGroupList, rootObjectExGUID); } else { throw new InvalidOperationException(string.Format("There is no root extended GUID value {0}", DataElementUtils.RootExGuid.ToString())); } } return null; }
/// <summary> /// Find the Revision Manifest from Data Elements. /// </summary> /// <param name="revisionMappingExtendedGUID">The Revision Mapping Extended GUID.</param> /// <returns>Returns the instance of RevisionManifestDataElementData</returns> private RevisionManifestDataElementData FindRevisionManifestDataElement(ExGuid revisionMappingExtendedGUID) { return((RevisionManifestDataElementData)revisionManifestDataElements .Where(d => d.DataElementExtendedGUID.Equals(revisionMappingExtendedGUID)).SingleOrDefault().Data); }
/// <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 find the object group data element using the specified extended GUID. /// </summary> /// <param name="objectGroupList">Specify the object group data element list.</param> /// <param name="extendedGuid">Specify the extended GUID.</param> /// <param name="declare">Specify the output of ObjectGroupObjectDeclare.</param> /// <returns>Return the object group data element if found.</returns> /// <exception cref="InvalidOperationException">If not found, throw the InvalidOperationException exception.</exception> private ObjectGroupObjectData FindByExGuid(List<ObjectGroupDataElementData> objectGroupList, ExGuid extendedGuid, out ObjectGroupObjectDeclare declare) { foreach (ObjectGroupDataElementData objectGroup in objectGroupList) { int findIndex = objectGroup.ObjectGroupDeclarations.ObjectDeclarationList.FindIndex(objDeclare => objDeclare.ObjectExtendedGUID.Equals(extendedGuid)); if (findIndex == -1) { continue; } declare = objectGroup.ObjectGroupDeclarations.ObjectDeclarationList[findIndex]; return objectGroup.ObjectGroupData.ObjectGroupObjectDataList[findIndex]; } throw new InvalidOperationException("Cannot find the " + extendedGuid.GUID.ToString()); }
/// <summary> /// This method is used to build a root node object from an object group data element list with the specified root extended GUID. /// </summary> /// <param name="objectGroupList">Specify the object group data element list.</param> /// <param name="rootExGuid">Specify the root extended GUID.</param> /// <returns>Return a root node object build from the object group data element list.</returns> private RootNodeObject Build(List<ObjectGroupDataElementData> objectGroupList, ExGuid rootExGuid) { ObjectGroupObjectDeclare rootDeclare; ObjectGroupObjectData root = this.FindByExGuid(objectGroupList, rootExGuid, out rootDeclare); if (SharedContext.Current.IsMsFsshttpRequirementsCaptured) { MsfsshttpdCapture.VerifyObjectCount(root, SharedContext.Current.Site); } int index = 0; RootNodeObject rootNode = null; if (StreamObject.TryGetCurrent<RootNodeObject>(root.Data.Content.ToArray(), ref index, out rootNode)) { rootNode.ExGuid = rootExGuid; foreach (ExGuid extGuid in root.ObjectExGUIDArray.Content) { ObjectGroupObjectDeclare intermediateDeclare; ObjectGroupObjectData intermediateData = this.FindByExGuid(objectGroupList, extGuid, out intermediateDeclare); rootNode.IntermediateNodeObjectList.Add(new IntermediateNodeObject.IntermediateNodeObjectBuilder().Build(objectGroupList, intermediateData, extGuid)); // Capture the intermediate related requirements if (SharedContext.Current.IsMsFsshttpRequirementsCaptured) { MsfsshttpdCapture.VerifyObjectGroupObjectDataForIntermediateNode(intermediateData, intermediateDeclare, objectGroupList, SharedContext.Current.Site); MsfsshttpdCapture.VerifyIntermediateNodeObject(rootNode.IntermediateNodeObjectList.Last(), SharedContext.Current.Site); } } if (SharedContext.Current.IsMsFsshttpRequirementsCaptured) { // Capture the root node related requirements. MsfsshttpdCapture.VerifyObjectGroupObjectDataForRootNode(root, rootDeclare, objectGroupList, SharedContext.Current.Site); MsfsshttpdCapture.VerifyRootNodeObject(rootNode, SharedContext.Current.Site); } } else { // If there is only one object in the file, SharePoint Server 2010 does not return the Root Node Object, but an Intermediate Node Object at the beginning. // At this case, we will add the root node object for the further parsing. rootNode = new RootNodeObject(); rootNode.ExGuid = rootExGuid; rootNode.IntermediateNodeObjectList.Add(new IntermediateNodeObject.IntermediateNodeObjectBuilder().Build(objectGroupList, root, rootExGuid)); rootNode.DataSize = new DataSizeObject(); rootNode.DataSize.DataSize = (ulong)rootNode.IntermediateNodeObjectList.Sum(o => (float)o.DataSize.DataSize); } // Capture all the signature related requirements. if (SharedContext.Current.IsMsFsshttpRequirementsCaptured) { AbstractChunking chunking = ChunkingFactory.CreateChunkingInstance(rootNode); if (chunking != null) { chunking.AnalyzeChunking(rootNode, SharedContext.Current.Site); } } return rootNode; }
/// <summary> /// This method is used to get storage manifest data element from a list of data element. /// </summary> /// <param name="dataElements">Specify the data element list.</param> /// <param name="manifestMapping">Specify the manifest mapping GUID.</param> /// <returns>Return the storage manifest data element.</returns> public static StorageManifestDataElementData GetStorageManifestDataElementData(List <DataElement> dataElements, ExGuid manifestMapping) { DataElement storageManifestDataElement = dataElements.Find(element => element.DataElementExtendedGUID.Equals(manifestMapping)); if (storageManifestDataElement == null) { return(null); } return(storageManifestDataElement.GetData <StorageManifestDataElementData>()); }
/// <summary> /// This method is used to get storage manifest data element from a list of data element. /// </summary> /// <param name="dataElements">Specify the data element list.</param> /// <param name="manifestMapping">Specify the manifest mapping GUID.</param> /// <returns>Return the storage manifest data element.</returns> public static StorageManifestDataElementData GetStorageManifestDataElementData(List<DataElement> dataElements, ExGuid manifestMapping) { DataElement storageManifestDataElement = dataElements.Find(element => element.DataElementExtendedGUID.Equals(manifestMapping)); if (storageManifestDataElement == null) { return null; } return storageManifestDataElement.GetData<StorageManifestDataElementData>(); }
/// <summary> /// This method is used to get a list of object group data element from a list of data element. /// </summary> /// <param name="dataElements">Specify the data element list.</param> /// <param name="revisionData">Specify the revision data.</param> /// <param name="rootExGuid">Specify the root node object extended GUID.</param> /// <returns>Return the list of object group data element.</returns> public static List<ObjectGroupDataElementData> GetDataObjectDataElementData(List<DataElement> dataElements, RevisionManifestDataElementData revisionData, out ExGuid rootExGuid) { rootExGuid = null; foreach (RevisionManifestRootDeclare kv in revisionData.RevisionManifestRootDeclareList) { if (kv.RootExtendedGUID.Equals(new ExGuid(2u, RootExGuid))) { rootExGuid = kv.ObjectExtendedGUID; break; } } List<ObjectGroupDataElementData> dataList = new List<ObjectGroupDataElementData>(); foreach (RevisionManifestObjectGroupReferences kv in revisionData.RevisionManifestObjectGroupReferencesList) { DataElement dataElement = dataElements.Find(element => element.DataElementExtendedGUID.Equals(kv.ObjectGroupExtendedGUID)); if (dataElement == null) { throw new InvalidOperationException("Cannot find the object group data element with ExGuid " + kv.ObjectGroupExtendedGUID.GUID.ToString()); } dataList.Add(dataElement.GetData<ObjectGroupDataElementData>()); } return dataList; }
/// <summary> /// This method is used to create the storage index data element. /// </summary> /// <param name="manifestExGuid">Specify the storage manifest data element extended GUID.</param> /// <param name="cellIDMappings">Specify the mapping of cell manifest.</param> /// <param name="revisionIDMappings">Specify the mapping of revision manifest.</param> /// <returns>Return the storage index data element.</returns> public static DataElement CreateStorageIndexDataElement(ExGuid manifestExGuid, Dictionary<CellID, ExGuid> cellIDMappings, Dictionary<ExGuid, ExGuid> revisionIDMappings) { StorageIndexDataElementData data = new StorageIndexDataElementData(); data.StorageIndexManifestMapping = new StorageIndexManifestMapping(); data.StorageIndexManifestMapping.ManifestMappingExtendedGUID = new ExGuid(manifestExGuid); data.StorageIndexManifestMapping.ManifestMappingSerialNumber = new SerialNumber(System.Guid.NewGuid(), SequenceNumberGenerator.GetCurrentSerialNumber()); foreach (KeyValuePair<CellID, ExGuid> kv in cellIDMappings) { StorageIndexCellMapping cellMapping = new StorageIndexCellMapping(); cellMapping.CellID = kv.Key; cellMapping.CellMappingExtendedGUID = kv.Value; cellMapping.CellMappingSerialNumber = new SerialNumber(System.Guid.NewGuid(), SequenceNumberGenerator.GetCurrentSerialNumber()); data.StorageIndexCellMappingList.Add(cellMapping); } foreach (KeyValuePair<ExGuid, ExGuid> kv in revisionIDMappings) { StorageIndexRevisionMapping revisionMapping = new StorageIndexRevisionMapping(); revisionMapping.RevisionExtendedGUID = kv.Key; revisionMapping.RevisionMappingExtendedGUID = kv.Value; revisionMapping.RevisionMappingSerialNumber = new SerialNumber(Guid.NewGuid(), SequenceNumberGenerator.GetCurrentSerialNumber()); data.StorageIndexRevisionMappingList.Add(revisionMapping); } return new DataElement(DataElementType.StorageIndexDataElementData, data); }
/// <summary> /// This method is used to deserialize the CellID basic object from the specified byte array and start index. /// </summary> /// <param name="byteArray">Specify the byte array.</param> /// <param name="startIndex">Specify the start index from the byte array.</param> /// <returns>Return the length in byte of the CellID basic object.</returns> protected override int DoDeserializeFromByteArray(byte[] byteArray, int startIndex) { int index = startIndex; this.ExtendGUID1 = BasicObject.Parse<ExGuid>(byteArray, ref index); this.ExtendGUID2 = BasicObject.Parse<ExGuid>(byteArray, ref index); return index - startIndex; }
/// <summary> /// This method is used to build intermediate node object from an list of object group data element. /// </summary> /// <param name="objectGroupList">Specify the list of object group data elements.</param> /// <param name="dataObj">Specify the object group object.</param> /// <param name="intermediateGuid">Specify the intermediate extended GUID.</param> /// <returns>Return the intermediate node object.</returns> public IntermediateNodeObject Build(List<ObjectGroupDataElementData> objectGroupList, ObjectGroupObjectData dataObj, ExGuid intermediateGuid) { IntermediateNodeObject node = null; RootNodeObject rootNode = null; int index = 0; if (StreamObject.TryGetCurrent<IntermediateNodeObject>(dataObj.Data.Content.ToArray(), ref index, out node)) { if (dataObj.ObjectExGUIDArray == null) { throw new InvalidOperationException("Failed to build intermediate node because the object extend GUID array does not exist."); } node.ExGuid = intermediateGuid; // Contain a single Data Node Object. if (dataObj.ObjectExGUIDArray.Count.DecodedValue == 1u) { ObjectGroupObjectDeclare dataNodeDeclare; ObjectGroupObjectData dataNodeData = this.FindByExGuid(objectGroupList, dataObj.ObjectExGUIDArray.Content[0], out dataNodeDeclare); BinaryItem data = dataNodeData.Data; node.DataNodeObjectData = new DataNodeObjectData(data.Content.ToArray(), 0, (int)data.Length.DecodedValue); node.DataNodeObjectData.ExGuid = dataObj.ObjectExGUIDArray.Content[0]; node.IntermediateNodeObjectList = null; if (SharedContext.Current.IsMsFsshttpRequirementsCaptured) { MsfsshttpdCapture.VerifyObjectGroupObjectDataForDataNodeObject(dataNodeData, dataNodeDeclare, objectGroupList, SharedContext.Current.Site); } } else { // Contain a list of IntermediateNodeObject node.IntermediateNodeObjectList = new List<IntermediateNodeObject>(); node.DataNodeObjectData = null; foreach (ExGuid extGuid in dataObj.ObjectExGUIDArray.Content) { ObjectGroupObjectDeclare intermediateDeclare; ObjectGroupObjectData intermediateData = this.FindByExGuid(objectGroupList, extGuid, out intermediateDeclare); node.IntermediateNodeObjectList.Add(new IntermediateNodeObjectBuilder().Build(objectGroupList, intermediateData, extGuid)); if (SharedContext.Current.IsMsFsshttpRequirementsCaptured) { MsfsshttpdCapture.VerifyObjectGroupObjectDataForIntermediateNode(intermediateData, intermediateDeclare, objectGroupList, SharedContext.Current.Site); } } } } else if (StreamObject.TryGetCurrent<RootNodeObject>(dataObj.Data.Content.ToArray(), ref index, out rootNode)) { // In Sub chunking for larger than 1MB zip file, MOSS2010 could return RootNodeObject. // For easy further process, the rootNode will be replaced by intermediate node instead. node = new IntermediateNodeObject(); node.IntermediateNodeObjectList = new List<IntermediateNodeObject>(); node.DataSize = rootNode.DataSize; node.ExGuid = rootNode.ExGuid; node.Signature = rootNode.Signature; node.DataNodeObjectData = null; foreach (ExGuid extGuid in dataObj.ObjectExGUIDArray.Content) { ObjectGroupObjectDeclare intermediateDeclare; ObjectGroupObjectData intermediateData = this.FindByExGuid(objectGroupList, extGuid, out intermediateDeclare); node.IntermediateNodeObjectList.Add(new IntermediateNodeObjectBuilder().Build(objectGroupList, intermediateData, extGuid)); if (SharedContext.Current.IsMsFsshttpRequirementsCaptured) { MsfsshttpdCapture.VerifyObjectGroupObjectDataForIntermediateNode(intermediateData, intermediateDeclare, objectGroupList, SharedContext.Current.Site); } } } else { throw new InvalidOperationException("In the ObjectGroupDataElement cannot only contain the RootNodeObject or IntermediateNodeOBject."); } return node; }
/// <summary> /// This method is used to build intermediate node object from an list of object group data element. /// </summary> /// <param name="objectGroupList">Specify the list of object group data elements.</param> /// <param name="dataObj">Specify the object group object.</param> /// <param name="intermediateGuid">Specify the intermediate extended GUID.</param> /// <returns>Return the intermediate node object.</returns> public LeafNodeObject Build(List <ObjectGroupDataElementData> objectGroupList, ObjectGroupObjectData dataObj, ExGuid intermediateGuid) { LeafNodeObject node = null; IntermediateNodeObject rootNode = null; int index = 0; if (StreamObject.TryGetCurrent <LeafNodeObject>(dataObj.Data.Content.ToArray(), ref index, out node)) { if (dataObj.ObjectExGUIDArray == null) { throw new InvalidOperationException("Failed to build intermediate node because the object extend GUID array does not exist."); } node.ExGuid = intermediateGuid; // Contain a single Data Node Object. if (dataObj.ObjectExGUIDArray.Count.DecodedValue == 1u) { ObjectGroupObjectDeclare dataNodeDeclare; ObjectGroupObjectData dataNodeData = this.FindByExGuid(objectGroupList, dataObj.ObjectExGUIDArray.Content[0], out dataNodeDeclare); BinaryItem data = dataNodeData.Data; node.DataNodeObjectData = new DataNodeObjectData(data.Content.ToArray(), 0, (int)data.Length.DecodedValue); node.DataNodeObjectData.ExGuid = dataObj.ObjectExGUIDArray.Content[0]; node.IntermediateNodeObjectList = null; if (SharedContext.Current.IsMsFsshttpRequirementsCaptured) { MsfsshttpdCapture.VerifyObjectGroupObjectDataForDataNodeObject(dataNodeData, dataNodeDeclare, objectGroupList, SharedContext.Current.Site); } } else { // Contain a list of LeafNodeObjectData node.IntermediateNodeObjectList = new List <LeafNodeObject>(); node.DataNodeObjectData = null; foreach (ExGuid extGuid in dataObj.ObjectExGUIDArray.Content) { ObjectGroupObjectDeclare intermediateDeclare; ObjectGroupObjectData intermediateData = this.FindByExGuid(objectGroupList, extGuid, out intermediateDeclare); node.IntermediateNodeObjectList.Add(new IntermediateNodeObjectBuilder().Build(objectGroupList, intermediateData, extGuid)); if (SharedContext.Current.IsMsFsshttpRequirementsCaptured) { MsfsshttpdCapture.VerifyObjectGroupObjectDataForIntermediateNode(intermediateData, intermediateDeclare, objectGroupList, SharedContext.Current.Site); } } } } else if (StreamObject.TryGetCurrent <IntermediateNodeObject>(dataObj.Data.Content.ToArray(), ref index, out rootNode)) { // In Sub chunking for larger than 1MB zip file, MOSS2010 could return IntermediateNodeObject. // For easy further process, the rootNode will be replaced by intermediate node instead. node = new LeafNodeObject(); node.IntermediateNodeObjectList = new List <LeafNodeObject>(); node.DataSize = rootNode.DataSize; node.ExGuid = rootNode.ExGuid; node.Signature = rootNode.Signature; node.DataNodeObjectData = null; foreach (ExGuid extGuid in dataObj.ObjectExGUIDArray.Content) { ObjectGroupObjectDeclare intermediateDeclare; ObjectGroupObjectData intermediateData = this.FindByExGuid(objectGroupList, extGuid, out intermediateDeclare); node.IntermediateNodeObjectList.Add(new IntermediateNodeObjectBuilder().Build(objectGroupList, intermediateData, extGuid)); if (SharedContext.Current.IsMsFsshttpRequirementsCaptured) { MsfsshttpdCapture.VerifyObjectGroupObjectDataForIntermediateNode(intermediateData, intermediateDeclare, objectGroupList, SharedContext.Current.Site); } } } else { throw new InvalidOperationException("In the ObjectGroupDataElement cannot only contain the IntermediateNodeObject or IntermediateNodeOBject."); } return(node); }
public static RevisionStoreObjectGroup CreateInstance(ExGuid objectGroupId, ObjectGroupDataElementData dataObject, bool isEncryption) { RevisionStoreObjectGroup objectGroup = new RevisionStoreObjectGroup(objectGroupId); Dictionary <ExGuid, RevisionStoreObject> objectDict = new Dictionary <ExGuid, RevisionStoreObject>(); if (isEncryption == false) { RevisionStoreObject revisionObject = null; for (int i = 0; i < dataObject.ObjectGroupDeclarations.ObjectDeclarationList.Count; i++) { ObjectGroupObjectDeclare objectDeclaration = dataObject.ObjectGroupDeclarations.ObjectDeclarationList[i]; ObjectGroupObjectData objectData = dataObject.ObjectGroupData.ObjectGroupObjectDataList[i]; if (!objectDict.ContainsKey(objectDeclaration.ObjectExtendedGUID)) { revisionObject = new RevisionStoreObject(); revisionObject.ObjectGroupID = objectGroupId; revisionObject.ObjectID = objectDeclaration.ObjectExtendedGUID; objectDict.Add(objectDeclaration.ObjectExtendedGUID, revisionObject); } else { revisionObject = objectDict[objectDeclaration.ObjectExtendedGUID]; } if (objectDeclaration.ObjectPartitionID.DecodedValue == 4) { revisionObject.JCID = new JCIDObject(objectDeclaration, objectData); } else if (objectDeclaration.ObjectPartitionID.DecodedValue == 1) { revisionObject.PropertySet = new PropertySetObject(objectDeclaration, objectData); if (Convert.ToBoolean(revisionObject.JCID.JCID.IsFileData) == false) { revisionObject.ReferencedObjectID = objectData.ObjectExGUIDArray; revisionObject.ReferencedObjectSpacesID = objectData.CellIDArray; } } } for (int i = 0; i < dataObject.ObjectGroupDeclarations.ObjectGroupObjectBLOBDataDeclarationList.Count; i++) { ObjectGroupObjectBLOBDataDeclaration objectGroupObjectBLOBDataDeclaration = dataObject.ObjectGroupDeclarations.ObjectGroupObjectBLOBDataDeclarationList[i]; ObjectGroupObjectDataBLOBReference objectGroupObjectDataBLOBReference = dataObject.ObjectGroupData.ObjectGroupObjectDataBLOBReferenceList[i]; if (!objectDict.ContainsKey(objectGroupObjectBLOBDataDeclaration.ObjectExGUID)) { revisionObject = new RevisionStoreObject(); objectDict.Add(objectGroupObjectBLOBDataDeclaration.ObjectExGUID, revisionObject); } else { revisionObject = objectDict[objectGroupObjectBLOBDataDeclaration.ObjectExGUID]; } if (objectGroupObjectBLOBDataDeclaration.ObjectPartitionID.DecodedValue == 2) { revisionObject.FileDataObject = new FileDataObject(); revisionObject.FileDataObject.ObjectDataBLOBDeclaration = objectGroupObjectBLOBDataDeclaration; revisionObject.FileDataObject.ObjectDataBLOBReference = objectGroupObjectDataBLOBReference; } } objectGroup.Objects.AddRange(objectDict.Values.ToArray()); } else { for (int i = 0; i < dataObject.ObjectGroupDeclarations.ObjectDeclarationList.Count; i++) { ObjectGroupObjectDeclare objectDeclaration = dataObject.ObjectGroupDeclarations.ObjectDeclarationList[i]; ObjectGroupObjectData objectData = dataObject.ObjectGroupData.ObjectGroupObjectDataList[i]; if (objectDeclaration.ObjectPartitionID.DecodedValue == 1) { EncryptionObject encrypObject = new EncryptionObject(); encrypObject.ObjectDeclaration = objectDeclaration; encrypObject.ObjectData = objectData.Data.Content.ToArray(); objectGroup.EncryptionObjects.Add(encrypObject); } } } return(objectGroup); }
/// <summary> /// This method is used to find the object group data element using the specified extended GUID. /// </summary> /// <param name="objectGroupList">Specify the object group data element list.</param> /// <param name="extendedGuid">Specify the extended GUID.</param> /// <param name="declare">Specify the output of ObjectGroupObjectDeclare.</param> /// <returns>Return the object group data element if found.</returns> /// <exception cref="InvalidOperationException">If not found, throw the InvalidOperationException exception.</exception> private ObjectGroupObjectData FindByExGuid(List <ObjectGroupDataElementData> objectGroupList, ExGuid extendedGuid, out ObjectGroupObjectDeclare declare) { foreach (ObjectGroupDataElementData objectGroup in objectGroupList) { int findIndex = objectGroup.ObjectGroupDeclarations.ObjectDeclarationList.FindIndex(objDeclare => objDeclare.ObjectExtendedGUID.Equals(extendedGuid)); if (findIndex == -1) { continue; } declare = objectGroup.ObjectGroupDeclarations.ObjectDeclarationList[findIndex]; return(objectGroup.ObjectGroupData.ObjectGroupObjectDataList[findIndex]); } throw new InvalidOperationException("Cannot find the " + extendedGuid.GUID.ToString()); }
/// <summary> /// Used to de-serialize the element. /// </summary> /// <param name="byteArray">A Byte array</param> /// <param name="currentIndex">Start position</param> /// <param name="lengthOfItems">The length of the items</param> protected override void DeserializeItemsFromByteArray(byte[] byteArray, ref int currentIndex, int lengthOfItems) { int index = currentIndex; this.ObjectExtendedGUIDArray = BasicObject.Parse<ExGUIDArray>(byteArray, ref index); this.CellIDArray = BasicObject.Parse<CellIDArray>(byteArray, ref index); this.BLOBExtendedGUID = BasicObject.Parse<ExGuid>(byteArray, ref index); if (index - currentIndex != lengthOfItems) { throw new StreamObjectParseErrorException(currentIndex, "ObjectGroupObjectDataBLOBReference", "Stream object over-parse error", null); } currentIndex = index; }
/// <summary> /// This method is used to check whether the extended GUID is unique in the object group data element data list. /// </summary> /// <param name="currentObjectExGuid">Specify the object extended GUID.</param> /// <param name="objectGroupList">Specify the object group data element data list. </param> /// <returns>Return true if the GUID is unique, otherwise return false.</returns> private static bool IsGuidUnique(ExGuid currentObjectExGuid, List<ObjectGroupDataElementData> objectGroupList) { return objectGroupList.SelectMany(dataEle => dataEle.ObjectGroupDeclarations.ObjectDeclarationList).Where(declare => declare.ObjectExtendedGUID.Equals(currentObjectExGuid)).Count() == 1; }
/// <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); }
public RevisionStoreObjectGroup(ExGuid objectGroupId) { this.Objects = new List <RevisionStoreObject>(); this.EncryptionObjects = new List <EncryptionObject>(); this.ObjectGroupID = objectGroupId; }
/// <summary> /// This method is used to get a list of object group data element from a list of data element. /// </summary> /// <param name="dataElements">Specify the data element list.</param> /// <param name="revisionData">Specify the revision data.</param> /// <param name="rootExGuid">Specify the root node object extended GUID.</param> /// <returns>Return the list of object group data element.</returns> public static List <ObjectGroupDataElementData> GetDataObjectDataElementData(List <DataElement> dataElements, RevisionManifestDataElementData revisionData, out ExGuid rootExGuid) { rootExGuid = null; foreach (RevisionManifestRootDeclare kv in revisionData.RevisionManifestRootDeclareList) { if (kv.RootExtendedGUID.Equals(new ExGuid(2u, RootExGuid))) { rootExGuid = kv.ObjectExtendedGUID; break; } } List <ObjectGroupDataElementData> dataList = new List <ObjectGroupDataElementData>(); foreach (RevisionManifestObjectGroupReferences kv in revisionData.RevisionManifestObjectGroupReferencesList) { DataElement dataElement = dataElements.Find(element => element.DataElementExtendedGUID.Equals(kv.ObjectGroupExtendedGUID)); if (dataElement == null) { throw new InvalidOperationException("Cannot find the object group data element with ExGuid " + kv.ObjectGroupExtendedGUID.GUID.ToString()); } dataList.Add(dataElement.GetData <ObjectGroupDataElementData>()); } return(dataList); }
/// <summary> /// Initializes a new instance of the CellID class with specified ExGuids. /// </summary> /// <param name="extendGuid1">Specify the first ExGuid.</param> /// <param name="extendGuid2">Specify the second ExGuid.</param> public CellID(ExGuid extendGuid1, ExGuid extendGuid2) { this.ExtendGUID1 = extendGuid1; this.ExtendGUID2 = extendGuid2; }
/// <summary> /// Initializes a new instance of the RevisionManifestObjectGroupReferences class. /// </summary> /// <param name="objectGroupExtendedGUID">Extended GUID</param> public RevisionManifestObjectGroupReferences(ExGuid objectGroupExtendedGUID) : this() { this.ObjectGroupExtendedGUID = objectGroupExtendedGUID; }
/// <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; }
/// <summary> /// Find the CellManifestDataElementData /// </summary> /// <param name="cellMappingExtendedGUID">The ExGuid of Cell Mapping Extended GUID.</param> /// <returns>Return the CellManifestDataElementData instance.</returns> private CellManifestDataElementData FindCellManifest(ExGuid cellMappingExtendedGUID) { return((CellManifestDataElementData)this.cellManifestDataElements .Where(d => d.DataElementExtendedGUID.Equals(cellMappingExtendedGUID)).SingleOrDefault().Data); }
/// <summary> /// This method is used to analyze whether the data elements are confirmed to the schema defined in MS-FSSHTTPD. /// </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 confirms to the schema defined in the MS-FSSHTTPD returns true, otherwise false.</returns> public static bool TryAnalyzeWhetherConfirmSchema(List<DataElement> dataElements, ExGuid storageIndexExGuid) { DataElement storageIndexDataElement = dataElements.Find(element => element.DataElementExtendedGUID.Equals(storageIndexExGuid)); if (storageIndexExGuid == null) { return false; } StorageIndexDataElementData storageIndexData = storageIndexDataElement.GetData<StorageIndexDataElementData>(); ExGuid manifestMappingGuid = storageIndexData.StorageIndexManifestMapping.ManifestMappingExtendedGUID; DataElement storageManifestDataElement = dataElements.Find(element => element.DataElementExtendedGUID.Equals(manifestMappingGuid)); if (storageManifestDataElement == null) { return false; } return SchemaGuid.Equals(storageManifestDataElement.GetData<StorageManifestDataElementData>().StorageManifestSchemaGUID.GUID); }
/// <summary> /// This method is used to analyze the storage index data element to get all the mappings. /// </summary> /// <param name="dataElements">Specify the data element list.</param> /// <param name="storageIndexExGuid">Specify the storage index extended GUID.</param> /// <param name="manifestMappingGuid">Output parameter to represent the storage manifest mapping GUID.</param> /// <param name="cellIDMappings">Output parameter to represent the mapping of cell id.</param> /// <param name="revisionIDMappings">Output parameter to represent the revision id.</param> /// <returns>Return true if analyze the storage index succeeds, otherwise return false.</returns> public static bool AnalyzeStorageIndexDataElement( List<DataElement> dataElements, ExGuid storageIndexExGuid, out ExGuid manifestMappingGuid, out Dictionary<CellID, ExGuid> cellIDMappings, out Dictionary<ExGuid, ExGuid> revisionIDMappings) { manifestMappingGuid = null; cellIDMappings = null; revisionIDMappings = null; if (storageIndexExGuid == null) { return false; } DataElement storageIndexDataElement = dataElements.Find(element => element.DataElementExtendedGUID.Equals(storageIndexExGuid)); StorageIndexDataElementData storageIndexData = storageIndexDataElement.GetData<StorageIndexDataElementData>(); manifestMappingGuid = storageIndexData.StorageIndexManifestMapping.ManifestMappingExtendedGUID; cellIDMappings = new Dictionary<CellID, ExGuid>(); foreach (StorageIndexCellMapping kv in storageIndexData.StorageIndexCellMappingList) { cellIDMappings.Add(kv.CellID, kv.CellMappingExtendedGUID); } revisionIDMappings = new Dictionary<ExGuid, ExGuid>(); foreach (StorageIndexRevisionMapping kv in storageIndexData.StorageIndexRevisionMappingList) { revisionIDMappings.Add(kv.RevisionExtendedGUID, kv.RevisionMappingExtendedGUID); } return true; }