public static void Setup_GetByDocId(this Mock<IWdDocumentRepository> repo, WdDocument doc, bool isLast = true) { repo.Setup(p => p.GetByDocId(It.IsAny<int>(), doc.DocId, doc.VersionNumber)).Returns(doc); if (isLast) { repo.Setup(p => p.GetByDocId(It.IsAny<int>(), doc.DocId, WdDocumentRepository.LATEST_VERSION)).Returns(doc); } }
void CreateWdDoc(tagWSDOCUMENT wsDoc, ref WdDocument wdDoc) { Logger.LogTrace(string.Format("Create wdDocument from wsDocument {0}", wsDoc.bstrDescription)); wdDoc = wdDoc ?? new WdDocument(); wdDoc.DocId = string.IsNullOrEmpty(wsDoc.bstrDocumentID) ? "" : WsDocumentID.GetWdDocID(wsDoc.bstrDocumentID); wdDoc.Ext = string.IsNullOrEmpty(wsDoc.bstrExtension) ? "" : wsDoc.bstrExtension; wdDoc.FIleName = string.IsNullOrEmpty(wsDoc.bstrDescription) ? "" : Path.GetFileName(wsDoc.bstrDescription); wdDoc.LocalFilePath = string.IsNullOrEmpty(wsDoc.bstrLocalFile) ? "" : wsDoc.bstrLocalFile; }
void UpdateWsDocData(ref tagWSDOCUMENT wsDoc, WdDocument wdDoc) { Logger.LogTrace(string.Format("Update Ws local data from wdDocument. {0}", wdDoc.AsString())); wsDoc.bstrDocumentID = WsDocumentID.Create(wdDoc.DocId, wdDoc.VersionNumber); wsDoc.bstrDescription = wdDoc.FIleName; wsDoc.bstrExtension = wdDoc.Ext; wsDoc.bstrType = FileUtils.GetFileTypeFromExt(wdDoc.Ext); wsDoc.dModifiedTime = wdDoc.ModifiedTime; wsDoc.bstrAuthor = wdDoc.Author; wsDoc.bstrClass = wdDoc.SecurityClassName; wsDoc.bstrOperator = wdDoc.Operator; }
string SimulateSelectionOfFile(DocumentProvider dp, WdDocument wdDocument, string filters) { var module = dp.module; //user selects file Mock.Get(module.Resolve<IOpenFileDialog>()).Setup(a => a.ShowDialog()).Returns(true); Mock.Get(module.Resolve<IOpenFileDialog>()).Setup(a => a.SelectedFile).Returns(wdDocument); string selected; dp.SelectDocumentEx(123, filters, string.Empty, out selected).Assert_Is_S_OK(); Assert.That(selected, Is.EqualTo(WsDocumentID.Create(wdDocument))); //professional asks about selected document tagWSDOCUMENT doc1; dp.GetDocument(selected, (int)wsGetDocFlags.DF_INFO_ONLY, out doc1).Assert_Is_S_OK(); Assert.That(doc1.bstrDocumentID, Is.EqualTo(selected)); Assert.That(doc1.bstrExtension, Is.EqualTo(wdDocument.Ext)); Assert.That(doc1.bstrDescription, Is.EqualTo(wdDocument.FIleName)); Assert.IsNotNullOrEmpty(doc1.bstrType); Assert.That(doc1.bstrLocalFile, (Is.EqualTo(string.Empty) | Is.Null)); dp.CloseDocument(ref doc1, 0).Assert_Is_S_OK(); return doc1.bstrDocumentID; }
tagWSDOCUMENT[] SimulateComparison(DocumentProvider dp, WdDocument wdDoc1, WdDocument wdDoc2) { var res = new List<tagWSDOCUMENT>(); foreach (var wdDoc in new[] { wdDoc1, wdDoc2 }) { tagWSDOCUMENT doc; dp.GetDocument(WsDocumentID.Create(wdDoc), 0, out doc).Assert_Is_S_OK(); Assert.That(doc.bstrDocumentID, Is.EqualTo(WsDocumentID.Create(wdDoc))); Assert.That(doc.bstrExtension, Is.EqualTo(wdDoc.Ext)); Assert.That(doc.bstrDescription, Is.EqualTo(wdDoc.FIleName)); Assert.IsNotNullOrEmpty(doc.bstrType); Assert.IsNotNullOrEmpty(doc.bstrLocalFile); string descr; dp.GetDocIDDescription(WsDocumentID.Create(wdDoc), out descr).Assert_Is_S_OK(); Assert.That(descr, Is.EqualTo(wdDoc.FIleName)); res.Add(doc); } return res.ToArray(); }
public string Add(int sessionhandle, WdDocument wdDoc, string wdBaseDocumentPath) { Logger.LogTrace(string.Format("Add document {0} to repository start. SessionHandle={0}; wdBaseDocumentPath={1}", wdDoc.DocId, sessionhandle, wdBaseDocumentPath)); var sbNewDocumentId = new StringBuilder(MAX_STR); const int hwndParent = 0; const string lpStruct = ""; const string filenameTap = ""; const int dwReserved = 0; const int dwRecNum = 0; var rcResult = _wdApi.WDAPI_GetAutoName(sessionhandle, WORLDOX.WDAPI_GNA_FLAG_NONE, string.Empty, sbNewDocumentId, MAX_STR); if (rcResult != WORLDOX.WDAPI_RC_OK) { throw new WdException(rcResult, "Failed to get the new autoname", "WDAPI_GetAutoName"); } var pathTo = string.Format("{0}{1}", Path.GetDirectoryName(wdBaseDocumentPath), Path.DirectorySeparatorChar); var newDocId = Path.ChangeExtension(sbNewDocumentId.ToString(), wdDoc.Ext).ToUpperInvariant(); rcResult = _wdApi.WDAPI_RenameFile(sessionhandle, hwndParent, WORLDOX.WDAPI_RF_FLAG_COPYNOVERS, lpStruct, wdBaseDocumentPath, filenameTap, pathTo, newDocId, sbNewDocumentId, MAX_STR, dwReserved); switch (rcResult) { case WORLDOX.WDAPI_RC_OK: { break; }; case WORLDOX.WDAPI_RC_FRFILEINVALID: case WORLDOX.WDAPI_RC_FRPATHINVALID: throw new WdFileNotFoundException(wdBaseDocumentPath, rcResult, "WDAPI_RenameFile"); case WORLDOX.WDAPI_RC_FRFILEBUSY: throw new WdFileIsBusyException(wdBaseDocumentPath, rcResult, "WDAPI_RenameFile"); case WORLDOX.WDAPI_RC_TOFILEBUSY: throw new WdFileIsBusyException(Path.Combine(pathTo, newDocId), rcResult, "WDAPI_RenameFile"); default: { throw new WdException(rcResult, string.Format("Failed to Add document {0} to Worldox", wdDoc.FIleName), "WDAPI_RenameFile"); } } try { File.Copy(wdDoc.LocalFilePath, sbNewDocumentId.ToString(), true); } catch (UnauthorizedAccessException ex) { throw new WdFileIsBusyException(ex); } catch (IOException ex) { throw new WdException(ex); } var res = _wdApi.WDAPI_SetProfileField(sbNewDocumentId.ToString(), string.Empty, dwRecNum, WORLDOX.WDAPI_GF_FILE_XNAME, wdDoc.FIleName); if (res == 0) // fail (see wdApi) { throw new WdException(rcResult, string.Format("Failed to change description for document {0}", sbNewDocumentId), "WDAPI_SetProfileField"); } Logger.LogTrace(string.Format("Document {0} added to repository. Path to file: {1}", wdDoc.DocId, sbNewDocumentId)); return sbNewDocumentId.ToString(); }
public WdDocument GetByPath(int sessionhandle, string path) { Logger.LogTrace(string.Format("Try to get file from WD. SessionHandle={0}. Path={1}", sessionhandle, path)); var sbDocId = new StringBuilder(MAX_STR); var sbrealName = new StringBuilder(MAX_STR); var sbExt = new StringBuilder(MAX_STR); var sbFilePath = new StringBuilder(MAX_STR); var sbVersionNumber = new StringBuilder(MAX_STR); var sbUpdated = new StringBuilder(MAX_STR); var sbOwner = new StringBuilder(MAX_STR); var sbClassName = new StringBuilder(MAX_STR); var sbprofileName = new StringBuilder(MAX_STR); var res = 0; foreach (var p in new[] { new Tuple<int, StringBuilder, bool>(WORLDOX.WDAPI_GF_FILE_FILENAME, sbDocId, true), new Tuple<int, StringBuilder, bool>(WORLDOX.WDAPI_GF_FILE_EXTENSION, sbExt, true), new Tuple<int, StringBuilder, bool>(WORLDOX.WDAPI_GF_FILE_XNAME, sbrealName, false), new Tuple<int, StringBuilder, bool>(WORLDOX.WDAPI_GF_FILE_PATHFILE, sbFilePath, true), new Tuple<int, StringBuilder, bool>(WORLDOX.WDAPI_GF_FILE_VERSION, sbVersionNumber, true), new Tuple<int, StringBuilder, bool>(WORLDOX.WDAPI_GF_FILE_OWNER, sbOwner, false), new Tuple<int, StringBuilder, bool>(WORLDOX.WDAPI_GF_FILE_UPDATED, sbUpdated, false), new Tuple<int, StringBuilder, bool>(WORLDOX.WDAPI_GF_FILE_CLASSNAME, sbClassName, false), new Tuple<int, StringBuilder, bool>(WORLDOX.WDAPI_GF_FILE_GROUP, sbprofileName, false), }) { res = _wdApi.WDAPI_GetProfileField(path, null, res, p.Item1, p.Item2, p.Item2.Capacity); if (res == 0) { if (p.Item3) //cannot get field and field is critical { throw new WdFileNotFoundException(path, string.Format("GetProfileField|Cannot get Field={0} for Document={1}", p.Item1, path), res, "WDAPI_GetProfileField"); } else { Logger.LogError(string.Format("Cannot get Field={0} for Document={1}. ErrorCode={2}. Field Skipped as not important.", p.Item1, path, res)); } } } var sVersionNumber = sbVersionNumber.ToString(); DateTime dtUpdated; if (!DateTime.TryParse(sbUpdated.ToString(), out dtUpdated)) { dtUpdated = DateTime.MinValue; Logger.LogError(string.Format("Cannot parse datetime = {0}", sbUpdated.ToString())); } bool isLocked = false; bool isLockedByCurrentUser = true; IsCheckedOut(sessionhandle, sbDocId.ToString(),out isLocked, out isLockedByCurrentUser); var result= new WdDocument { DocId = sbDocId.ToString(), FIleName = sbrealName.ToString(), LocalFilePath = sbFilePath.ToString(), VersionNumber = string.IsNullOrEmpty(sVersionNumber) ? LATEST_VERSION : Convert.ToInt32(sVersionNumber), Ext = sbExt.ToString().Trim('.'), IsLocked = isLocked, IsLockedByCurrentUser = isLockedByCurrentUser, Owner = sbOwner.ToString(), ModifiedTime = dtUpdated, Author = sbOwner.ToString(), SecurityClassName=sbClassName.ToString(), FromLFS = string.Equals(sbprofileName.ToString().ToLowerInvariant(), "<no profile>"), Operator = "Operator" }; Logger.LogTrace(string.Format("Found document : {0}", result.AsString())); return result; }
tagWSDOCUMENT SimulateSaving(DocumentProvider dp, WdDocument newWdDocument,string filters, int filterIndex) { Mock.Get(dp.module.Resolve<ISaveFileDialog>()).Setup(p => p.ShowDialog()).Returns(true); Mock.Get(dp.module.Resolve<ISaveFileDialog>()).Setup(p => p.FilePath).Returns(newWdDocument.LocalFilePath); Mock.Get(dp.module.Resolve<ISaveFileDialog>()).Setup(p => p.FormatIndex).Returns(filterIndex); int index = 0; var wsDoc = new tagWSDOCUMENT(); int ret; dp.GetSaveInfoEx(123, filters, 0, 0, ref index, ref wsDoc, out ret).Assert_Is_S_OK(); wsDoc.bstrLocalFile = Path.GetTempFileName(); dp.SaveDocument(ref wsDoc, 0).Assert_Is_S_OK(); return wsDoc; }
tagWSDOCUMENT SimulateOpeningOfLastVersion(DocumentProvider dp, WdDocument wdDoc) { var res = new List<tagWSDOCUMENT>(); IntPtr ptr=Marshal.AllocHGlobal(Marshal.SizeOf(typeof(IntPtr))); try { int size; dp.GetVersions(WsDocumentID.Create(wdDoc), out size, ptr).Assert_Is_S_OK(); var collectionPtr=MarshallingHelper.GetCollectionFromPtr<IntPtr>(ptr,1).First(); try { var versions = MarshallingHelper.GetCollectionFromPtr<tagWSDOCUMENTVERSION>(collectionPtr, size); var lastVersionDoc = versions.OrderByDescending(p => p.szVersionLabel).First().wsdDocumentDetails; dp.OpenDocument(ref lastVersionDoc).Assert_Is_S_OK(); Mock.Get(dp.module.Resolve<IProcessLauncher>()).Verify(a => a.Launch(wdDoc.LocalFilePath)); return lastVersionDoc; } finally { Marshal.FreeHGlobal(collectionPtr); } } finally { Marshal.FreeHGlobal(ptr); } }
internal void UpdateCache(string szDocumentID, WdDocument wdDoc, tagWSDOCUMENT wsDoc) { UpdateL1Cache(szDocumentID.ToUpper(), wdDoc, wsDoc); UpdateL2Cach(szDocumentID.ToUpper(), wdDoc.LocalFilePath); }
private void UpdateL1Cache(string szDocumentID, WdDocument wdDoc, tagWSDOCUMENT wsDoc) { Logger.LogTrace(string.Format("WsDoc added to L1 cache. WsDocId={0}. wsDesc={1}. WdDocId={2}. WdDocLocalPath={3}", szDocumentID,wsDoc.bstrDescription,wdDoc.DocId,wdDoc.LocalFilePath)); m_docProviderCache[szDocumentID] = new CacheEntity() { wsDoc = wsDoc, wsPath = wdDoc.LocalFilePath }; }
public static WdDocument GetDefaultDoc(string filename="document.doc", int versionNumber=1) { var doc = new WdDocument { DocId = filename.ToUpperInvariant(), FIleName = filename, LocalFilePath = Path.GetTempFileName(), VersionNumber = versionNumber, Ext =Path.GetExtension(filename).TrimStart('.'), Owner = "Demo, Worldox(DEMO)" }; File.Delete(doc.LocalFilePath); return doc; }
public static void Setup_GetByPath(this Mock<IWdDocumentRepository> repo, WdDocument doc) { repo.Setup(p => p.GetByPath(It.IsAny<int>(), doc.LocalFilePath)).Returns(doc); }
internal int RelateDocument(ref tagWSDOCUMENT pNewDocument, string existingDocumentId) { Logger.LogTrace(string.Format("RelateDocument existingDocumentID={0} pNewDocument.bstrDocumentID={1} pNewDocument.bstrLocalFile={2} ", existingDocumentId, pNewDocument.bstrDocumentID, pNewDocument.bstrLocalFile)); try { using (var session = _sessionManager.Create()) { var baseWdDocument = GetWdDocumentByWsId(session.Handle, existingDocumentId); var wdDoc = new WdDocument(); CreateWdDoc(pNewDocument, ref wdDoc); var newDocumentFilePath = _wdDocRepo.Add(session.Handle, wdDoc, baseWdDocument.LocalFilePath); var newWdDocument = _wdDocRepo.GetByPath(session.Handle, newDocumentFilePath); _dpCache.UpdateCache(WsDocumentID.Create(newWdDocument), newDocumentFilePath); _wdDocRepo.RelateDocument(session.Handle, baseWdDocument.LocalFilePath, newDocumentFilePath); return DP_HRESULTS.S_OK; } } catch (WdFileNotFoundException ex) { throw new DPFileNotFoundException(existingDocumentId, ex); } }
void CreateWsDoc(out tagWSDOCUMENT wsDoc, WdDocument wdDoc) { wsDoc = new tagWSDOCUMENT(); UpdateWsDocData(ref wsDoc, wdDoc); }
public static string Create(WdDocument doc) { return Create(doc.DocId, doc.VersionNumber); }