private void HandleInactiveDocument(DocumentContent previousDocument)
{
if (previousDocument == null)
{
return;
}
Tracer.Verbose("MainWindow.HandlePreviousActiveDocument", "[{0}] '{1}' becomes inactive",
DateTime.Now.ToLongTimeString(), previousDocument.Title);
//remove the previous doc from event handling
if (previousDocument is ZoomDocument)
{
ZoomDocument zd = (ZoomDocument)previousDocument;
this.MainStatusBar.ZoomChanged -= new EventHandler <ZoomRoutedEventArgs>(zd.OnZoomChanged);
zd.ZoomChanged -= new ZoomDocument.ZoomChangedEventHandler(this.MainStatusBar.OnZoomChanged);
}
//manage the contextual tab in the ribbon
if (previousDocument is QueryDocument)
{
SyntaxedDocumentGroup.Visibility = System.Windows.Visibility.Collapsed;
return;
}
if (previousDocument is TemplateDocument)
{
SyntaxedDocumentGroup.Visibility = System.Windows.Visibility.Collapsed;
return;
}
}
public DocumentContent GetDocument(string documentId)
{
if (string.IsNullOrEmpty(documentId))
{
throw new ArgumentNullException(nameof(documentId));
}
var containerClient = GetDocumentsContainer();
var blobName = $"{documentId}.docx";
var blobClient = containerClient.GetBlobClient(blobName);
DocumentContent document = null;
try
{
var blobDownloadInfo = DownloadContentItem(blobClient);
document = ContentItemFactory.BuildDocument(blobClient.Uri, blobDownloadInfo);
}
catch (RequestFailedException ex)
{
if (ex.Status != 404)
{
throw ex;
}
}
return(document);
}
public IDockDocument ShowDocument(string name, CreateDockDocumentDelegate createDockCallback)
{
IDockDocument doc = null;
var avalonDoc = FindAvalonDocument(name);
if (avalonDoc == null)
{
if (String.CompareOrdinal(name, "startPage") != 0 && StartPageDockDocument.GlobalAutoClose)
{
StartPageDockDocument.GlobalAutoClose = false;
CloseDocument("startPage");
}
avalonDoc = new DocumentContent()
{
Name = name
};
doc = createDockCallback(avalonDoc, name);
BindingExtensions.CreateBinding(doc, "DocumentTitle", avalonDoc, DocumentContent.TitleProperty, BindingMode.OneWay);
avalonDoc.Content = doc;
avalonDoc.Closing += AvalonDoc_Closing;
avalonDoc.Closed += AvalonDoc_Closed;
}
avalonDoc.Show(dockingManager, false);
Dispatcher.BeginInvoke(new NoArgsDelegate(() => { avalonDoc.Manager.ActiveDocument = avalonDoc; }), null);
return(doc);
}
public DocumentContent GetDocumentContent(int resourceId)
{
DocumentContent result = new DocumentContent();
using SqlConnection con = new SqlConnection(m_connectionString);
using SqlCommand cmd = new SqlCommand("select * from [dbo].[v_ResourceVersion] where resourceID= "
+ resourceId + "and status = 'C'", con)
{
CommandType = CommandType.Text
};
con.Open();
using (SqlDataReader reader = cmd.ExecuteReader())
{
while (reader.Read())
{
result.ResourceVersionId = (int)reader["ResourceVersionId"];
result.ProductionStateId = (int)reader["ProductionStateId"];
result.ResourceFolder = (string)reader["Folder"];
result.ResourceName = (string)reader["Name"];
result.ResourceTypeId = (int)reader["ResourceTypeID"];
result.ScopeSubTag = Convert.IsDBNull(reader["ScopeSubTag"]) ? "NULL" : (string)reader["ScopeSubTag"];
result.ScopeTag = Convert.IsDBNull(reader["ScopeTag"]) ? "NULL" : (string)reader["ScopeTag"];
result.TypeTag = Convert.IsDBNull(reader["TypeTag"]) ? "NULL" : (string)reader["TypeTag"];
result.WritingWorkFlowStatusId = Convert.IsDBNull(reader["WritingWorkFlowStateID"]) ? 0 : (int)reader["WritingWorkFlowStateID"];
result.ResourceInformation.Complexity = Convert.IsDBNull(reader["ComplexityName"]) ? "null" : (string)reader["ComplexityName"];
result.ResourceInformation.Synopsis = Convert.IsDBNull(reader["Synopsis"]) ? "null" : (string)reader["Synopsis"];
}
}
con.Close();
return(result);
}
public void RemoveFile(string id)
{
Guid contentId = Guid.Parse(id);
DocumentContent content = _unitOfWork.DocumentContentRepository.GetById(contentId);
_unitOfWork.DocumentContentRepository.Delete(content);
}
private void AssertDocument(DocumentContent content, byte[] buffer)
{
AssertContent(content, DocumentNamePattern, DocumentFilePattern, buffer.Length);
var ms = content.Buffer.ToMemoryStream();
Assert.Equal(buffer, ms.ToArray());
}
public void Should_be_able_to_get_cleared_document_content()
{
var document = _documentFixture.GetDocument(Guid.NewGuid());
var repository = new DocumentRepository(DatabaseGateway, new DocumentQueryFactory());
var query = new DocumentQuery(QueryMapper, new DocumentQueryFactory());
using (TransactionScopeFactory.Create())
using (DatabaseContextFactory.Create())
{
Assert.That(query.FindContent(document.Id), Is.Null);
repository.Save(document);
DocumentContent content = null;
Assert.That(() => content = query.FindContent(document.Id), Throws.Nothing);
Assert.That(content, Is.Not.Null);
Assert.That(content.Status, Is.EqualTo("Registered"));
Assert.That(content.Content, Is.Null);
Assert.That(content.ContentType, Is.EqualTo(document.ContentType));
document.Cleared();
repository.Save(document);
Assert.That(() => content = query.FindContent(document.Id), Throws.Nothing);
Assert.That(content, Is.Not.Null);
Assert.That(content.Status, Is.EqualTo("Cleared"));
Assert.That(content.Content, Is.Not.Null);
Assert.That(content.ContentType, Is.EqualTo(document.ContentType));
}
}
/// <summary>
/// Shows a document. Puts it in the document pane.
/// </summary>
/// <param name="document"></param>
public IDocument ShowDocument(IDocument document, bool switchToOpenedDocument)
{
if (document != null)
{
if (!m_documentLookup.ContainsKey(document))
{
DocumentContent content = new DocumentContent();
content.Content = document;
content.Title = document.Title;
document.PropertyChanged += (sender, args) =>
{
if (args.PropertyName.Equals("Title"))
{
content.Title = (sender as IDocument).Title;
}
};
content.Name = document.Name;
m_documentLookup.Add(document, content);
m_docPane.Items.Add(content);
content.Closing += new EventHandler <CancelEventArgs>(document.OnClosing);
//content.Closing += document.File.FileClosed;
content.Closed += new EventHandler(content_Closed);
content.GotFocus += new RoutedEventHandler(document.OnGotFocus);
content.LostFocus += new RoutedEventHandler(document.OnLostFocus);
document.OnOpened(content, new EventArgs());
}
if (switchToOpenedDocument)
{
DockManager.Show(m_documentLookup[document]);
}
}
return(document);
}
public async Task <IHttpActionResult> Upload(int id)
{
if (!Request.Content.IsMimeMultipartContent("form-data"))
{
return(BadRequest("Unsupported media type"));
}
try
{
var provider = new MultipartFormDataStreamProvider(HttpContext.Current.Server.MapPath("~/uploads/"));
var content = new StreamContent(HttpContext.Current.Request.GetBufferlessInputStream(true));
foreach (var header in Request.Content.Headers)
{
content.Headers.TryAddWithoutValidation(header.Key, header.Value);
}
await content.ReadAsMultipartAsync(provider);
using (var context = new DocumentEntities())
{
foreach (var file in provider.FileData)
{
using (var ts = new TransactionScope())
{
var documentMeta = new DocumentMeta
{
CollectionId = id,
FileName = file.Headers.ContentDisposition.Name.Trim(new char[] { '"' }).Replace("&", "and"),
UploadTime = DateTime.Now
};
context.DocumentMeta.Add(documentMeta);
context.SaveChanges();
var documentContent = new DocumentContent
{
Id = documentMeta.Id,
RowGuid = Guid.NewGuid(),
Data = new Byte[0]
};
context.DocumentContent.Add(documentContent);
context.SaveChanges();
using (var stream = File.OpenRead(file.LocalFileName))
{
DocumentContentHelper.AddContentData(documentContent.Id, context, stream);
}
ts.Complete();
}
}
}
return(Ok());
}
catch (Exception ex)
{
return(BadRequest(ex.GetBaseException().Message));
}
}
private void OnCreateNewDocumentContent(object sender, RoutedEventArgs e)
{
string title = "MainWindow.xml.cs";
DocumentContent[] cnts = this.DockManager.Documents.ToArray();
int i = 1;
while (cnts.FirstOrDefault(c => c.Title == title) != null)
{
title = string.Format("NewDocument{0}", i);
i++;
}
var newContent = new DocumentContent()
{
Title = title, Content = new TextBox()
};
newContent.Icon = new BitmapImage(new Uri(@"Images\database.png", UriKind.Relative));
newContent.ContentTypeDescription = "Base Description of " + title;
newContent.InfoTip = System.IO.Path.GetTempPath();
newContent.FloatingWindowSize = new Size(500.0, 500.0);
newContent.Show(DockManager, true);
newContent.Activate();
}
/// <summary>
/// torna l'elenco dei certificati di firma e il certificato con la scadenza più vicina
/// </summary>
/// <param name="fileName">nome del file</param>
/// <param name="Content">contenuto</param>
/// <param name="FirstCertificate">ritorna il primo certificato in scadenza</param>
/// <returns>elenco dei certificati di firma</returns>
public BindingList <DocumentCertificate> GetAllExpireDates(string fileName, DocumentContent Content, out DocumentCertificate FirstCertificate)
{
BindingList <DocumentCertificate> result = new BindingList <DocumentCertificate>();
using (CompEdLib p7m = new CompEdLib())
{
SimplyCert firstExp = new SimplyCert();
Hashtable SimCrtLst;
String rt = p7m.GetAllExpiryDate(Content.Blob, out firstExp, out SimCrtLst);
if (rt.Length > 0)
{
throw new Exception(rt);
}
FirstCertificate = new DocumentCertificate(firstExp.Level, firstExp.Type,
firstExp.FiscalCode, firstExp.Role, firstExp.Description, firstExp.Issuer,
firstExp.eMail, firstExp.Expiry, firstExp.ValidFrom);
DocumentCertificate certificate;
foreach (System.Collections.DictionaryEntry obj in SimCrtLst)
{
SimplyCert crtlo = (SimplyCert)obj.Value;
certificate = new DocumentCertificate(crtlo.Level, crtlo.Type,
crtlo.FiscalCode, crtlo.Role, crtlo.Description,
crtlo.Issuer, crtlo.eMail, crtlo.Expiry, crtlo.ValidFrom);
certificate.HeaderInfo = crtlo.HeaderInfo;
result.Add(certificate);
}
}
return(result);
}
//TODO
//Chiamo lo storage
//Calcolo la Hash
//Ritorna
//public DocumentContent CalculateBlobHash(Document Document)
/// <summary>
///
/// </summary>
/// <param name="FileName"></param>
/// <param name="SignerCert"></param>
/// <param name="SignedDigest"></param>
/// <param name="Content"></param>
/// <returns>DocumentContent</returns>
public DocumentContent AddRawSignature(string FileName, DocumentContent SignerCert, DocumentContent SignedDigest, DocumentContent Content)
{
using (CompEdObj p7mO = new CompEdObj())
{
int p7kH;
p7mO.P7mNew(out p7kH);
p7mO.VerifyLastError();
p7mO.P7mSetType(p7kH);
p7mO.VerifyLastError();
p7mO.AddRawSignature(p7kH, SignedDigest.Blob, SignerCert.Blob);
p7mO.VerifyLastError();
p7mO.P7mAddTimeFileDescription(p7kH, "", FileName, "");
p7mO.VerifyLastError();
p7mO.P7mContentInit(p7kH);
p7mO.VerifyLastError();
p7mO.P7mAddBlob(p7kH, Content.Blob);
p7mO.VerifyLastError();
p7mO.P7mContentFinish(p7kH);
p7mO.VerifyLastError();
byte[] ret = p7mO.P7kContentReadToBuf(p7kH);
p7mO.VerifyLastError();
return new DocumentContent(ret);
}
}
public ActionResult CreatePDF(int clientId, string title)
{
DocumentContent documentContent = new DocumentContent();
documentContent.title = title;
documentContent.fileName = title + ".pdf";
documentContent.author = "Itransfo";
Client client = db.Clients.Find(clientId);
documentContent.clientFullName = client.getFullName();
documentContent.clientCompany = client.Company;
documentContent.clientPhoneNumber = client.Phone;
documentContent.clientPhoneExtension = client.Extension.ToString();
documentContent.clientEmail = client.Email;
documentContent.date = DateTime.Now.ToString("dd/MM/yyyy");
documentContent.validUntilDate = DateTime.Now.AddDays(90).ToString("dd/MM/yyyy");
documentContent.currency = "Dólares Estadounidenses";
documentContent.changeRate = "15.2000";
documentContent.payConditions = "Contado con la O.C.";
documentContent.deliveryTime = "90 días naturales";
documentContent.deliveryPlace = client.Address != null ? client.Address : string.Empty;
documentContent.totalCurrency = "TOTAL USD.";
documentContent.totalWritten = "IMPORTE CON LETRA:";
documentContent.taxNote = "I.V.A. NO INCLUIDO";
PDFUtil pdfUtil = new PDFUtil(documentContent);
using (MemoryStream stream = new MemoryStream())
{
var document = pdfUtil.getPDFDocument();
document.Save(stream, false);
return(File(stream.ToArray(), "application/pdf"));
}
}
/// <summary>
/// ritorna il numero di firme del documento
/// </summary>
/// <param name="content"></param>
/// <returns></returns>
/// <remarks>Suporta PADES</remarks>
public int GetSignatureCount(DocumentContent content)
{
using (CompEdLib p7m = new CompEdLib())
{
return(p7m.GetSignatureCount(content.Blob));
}
}
/// <summary>
/// Shows a document. Puts it in the document pane.
/// </summary>
/// <param name="document"></param>
public IDocument ShowDocument(IDocument document, string memento, bool makeActive)
{
IDocument doc = document.CreateDocument(memento);
if (doc != null)
{
if (!m_documentLookup.ContainsKey(doc))
{
DocumentContent content = new DocumentContent();
setManagedContentProperties(doc, content);
m_documentLookup.Add(doc, content);
m_docPane.Items.Add(content);
// all these event handlers get unsubscribed in the content_Closing method
doc.PropertyChanged += new PropertyChangedEventHandler(doc_PropertyChanged);
content.Closing += new EventHandler <System.ComponentModel.CancelEventArgs>(doc.OnClosing);
content.Closed += new EventHandler(content_Closed);
content.GotFocus += new RoutedEventHandler(doc.OnGotFocus);
content.LostFocus += new RoutedEventHandler(doc.OnLostFocus);
document.OnOpened(content, new EventArgs());
}
m_documentLookup[doc].Show(DockManager);
if (makeActive)
{
DockManager.ActiveDocument = m_documentLookup[doc];
}
}
return(doc);
}
public ActionResult ViewAwardRDV(Guid id)
{
return(ActionResultHelper.TryCatchWithLogger(() =>
{
AwardBatch awardBatch = _preservationService.GetAwardBatch(id);
if (awardBatch.IdRDVDocument.HasValue)
{
using (DocumentsClient client = new DocumentsClient())
{
DocumentContent content = client.GetDocumentContentById(awardBatch.IdRDVDocument.Value);
if (content != null)
{
return View(new WindowFileContentViewModel()
{
Content = System.Text.Encoding.UTF8.GetString(content.Blob)
});
}
}
_loggerService.Warn(string.Format("ViewAwardRDV -> nessun documento trovato con Id {0}.", awardBatch.IdRDVDocument));
}
WindowFileContentViewModel model = new WindowFileContentViewModel()
{
Content = string.Empty
};
return View(model);
}, _loggerService));
}
public ActionResult ViewAwardPDV(Guid id)
{
return(ActionResultHelper.TryCatchWithLogger(() =>
{
AwardBatch awardBatch = _preservationService.GetAwardBatch(id);
if (awardBatch.IdPDVDocument.HasValue)
{
using (DocumentsClient client = new DocumentsClient())
{
DocumentContent content = client.GetDocumentContentById(awardBatch.IdPDVDocument.Value);
if (content != null)
{
return View(new WindowFileContentViewModel()
{
Content = System.Text.Encoding.UTF8.GetString(content.Blob)
});
}
_loggerService.Warn(string.Format("ViewAwardPDV -> nessun documento trovato con Id {0}. Si procede con una nuova generazione del pacchetto di versamento.", awardBatch.IdPDVDocument));
}
}
string pdv = _preservationService.CreateAwardBatchPDVXml(awardBatch);
SavePDVXml(pdv, awardBatch);
WindowFileContentViewModel model = new WindowFileContentViewModel()
{
Content = pdv
};
return View(model);
}, _loggerService));
}
/// <summary>
/// Reaction on change of active document.
/// Invokes ActiveDiagramChanged event.
/// </summary>
/// <param name="content">New active document</param>
private void DockManager_ActiveTabChanged(DocumentContent content)
{
//if (content is PanelWindow || content == null)
{
MainWindow.InvokeActiveDiagramChanged(content as PanelWindow);
}
}
} // Send
private SignedDoc GetDocuments(Esignature oSignature)
{
this.log.Msg("Loading documents for the key '{0}' started...", oSignature.DocumentKey);
GetDocumentsResult oResult;
try {
oResult = this.echoSign.getDocuments(
this.apiKey,
oSignature.DocumentKey,
new GetDocumentsOptions {
combine = true,
attachSupportingDocuments = true,
}
);
} catch (Exception e) {
this.log.Warn(e, "Failed to load documents for the key '{0}'.", oSignature.DocumentKey);
return(new SignedDoc {
HasValue = false,
});
} // try
if (!oResult.success)
{
this.log.Warn(
"Error while retrieving documents for the key '{0}': code = {1}, message = {2}.",
oSignature.DocumentKey, oResult.errorCode, oResult.errorMessage
);
return(new SignedDoc {
HasValue = false,
});
} // if
int nDocumentCount = oResult.documents == null ? 0 : oResult.documents.Length;
if (nDocumentCount != 1)
{
this.log.Warn(
"No documents received for the key '{0}' (document count = {1}).",
oSignature.DocumentKey,
nDocumentCount
);
return(new SignedDoc {
HasValue = false,
});
} // if
// ReSharper disable once PossibleNullReferenceException
// Can be disabled because of documentCount != 1 check just above.
DocumentContent doc = oResult.documents[0];
this.log.Debug("Document '{0}' of type '{1}', size {2} bytes.", doc.name, doc.mimetype, doc.bytes.Length);
this.log.Msg("Loading documents for the key '{0}' complete.", oSignature.DocumentKey);
return(new SignedDoc {
HasValue = true, MimeType = doc.mimetype, Content = doc.bytes,
});
} // GetDocuments
public (List <DocumentContent>, int) GetInvoicesUid(List <Document> records)
{
List <DocumentContent> documents = new List <DocumentContent>();
int maxUID = 0;
//includeDocument to get base64 of pdf document
string jsonFilter = JsonSerializer.Serialize(new
{
includeDocument = true,
});
foreach (Document record in records)
{
//get document details from resthandler
var task = restHandler.GetDocument(record.documentUid, jsonFilter, api_key);
task.Wait();
DocumentContent obj = JsonSerializer.Deserialize <DocumentContent>(task.Result);
documents.Add(obj);
if (record.documentUid > maxUID)
{
maxUID = record.documentUid;
}
}
return(documents, maxUID);
}
public ContentFormatBuilderResult CreateFromTikaPlain(String tikaFullContent)
{
if (String.IsNullOrEmpty(tikaFullContent))
return new ContentFormatBuilderResult()
{
Content = DocumentContent.NullContent,
SanitizedTikaContent = tikaFullContent,
};
var doc = DocumentBuilder.Html(tikaFullContent);
var allMeta = doc.QuerySelectorAll("meta");
var meta = allMeta.SelectMany(x => x.Attributes.Select(y => new
{
key = y.Name,
value = y.Value
}))
.GroupBy(g => g.key)
.SelectMany(grp => grp.Count() == 1
? grp
: grp.Select((x, i) => new
{
key = x.key + "-" + (i + 1),
value = x.value
}))
.Select(x => new DocumentContent.MetadataHeader(x.key, x.value))
.ToList();
var pages = doc.QuerySelectorAll("div.page");
var pagesList = new List<DocumentContent.DocumentPage>();
for (int i = 0; i < pages.Length; i++)
{
var page = pages[i];
var filteredContent = _filterManager.Filter(page.TextContent);
pagesList.Add(new DocumentContent.DocumentPage(i + 1, filteredContent));
page.TextContent = filteredContent;
}
if (pages.Length == 0)
{
meta.Add(new DocumentContent.MetadataHeader(DocumentContent.MetadataWithoutPageInfo, "true"));
var body = doc.QuerySelector("body");
var documentContent = body.TextContent;
if (!String.IsNullOrEmpty(documentContent))
{
var filteredContent = _filterManager.Filter(documentContent);
pagesList.Add(new DocumentContent.DocumentPage(1, filteredContent));
body.TextContent = filteredContent;
}
}
var content = new DocumentContent(pagesList.ToArray(), meta.ToArray());
var sanitized = doc.ToHtml();
return new ContentFormatBuilderResult()
{
Content = content,
SanitizedTikaContent = sanitized,
};
}
/// <summary>
/// Извлечение текста из документа
/// </summary>
/// <param name="bytes">Файл</param>
/// <param name="extension">Расширение файла</param>
/// <returns></returns>
protected override DocumentContent ExtractTextInternal(byte[] bytes, string extension)
{
var content = new StringBuilder();
var result = new DocumentContent();
try {
using (var ms = new MemoryStream(bytes)) {
var doc = new Document(ms, new LoadOptions(GetLoadFormat(extension), null, null));
var paragraphs = doc.GetChildNodes(NodeType.Paragraph, true);
//NOTE: Не всегда получает только первую страницу. Довольно часто цепляет еще несколько
foreach (var node in paragraphs)
{
var text = node.GetText();
if (text.Contains(ControlChar.PageBreak))
{
var index = text.IndexOf(ControlChar.PageBreak, StringComparison.Ordinal);
content.Append(text.Substring(0, index + 1));
break;
}
content.Append(text);
}
}
} catch (Exception ex) {
_logger.Error(ex, $"При обработке {extension} возникло исключение");
}
result.Content = content.ToString();
return(result);
}
public async Task AddContentTest()
{
var content = new DocumentContent
{
DocumentId = "documentId",
Id = "id",
Value = "value"
};
DocumentContentEntity addedEntity = null;
var documentContentRepositoryMock = new Mock <IDocumentContentRepository>();
documentContentRepositoryMock.Setup(p => p.AddAsync(It.IsAny <DocumentContentEntity>()))
.Callback((DocumentContentEntity e) => { addedEntity = e; })
.Returns(() => Task.FromResult(0));
var contentService = new DocumentContentService(documentContentRepositoryMock.Object, MockObjects.GetMapper());
await contentService.AddAsync(content);
Assert.NotNull(addedEntity);
Assert.Equal(content.DocumentId, addedEntity.DocumentId);
Assert.Equal(content.Id, addedEntity.Id);
Assert.Equal(content.Value, addedEntity.Value);
documentContentRepositoryMock.Verify(p => p.AddAsync(It.IsAny <DocumentContentEntity>()), Times.Once);
}
public async Task AddContentsTest()
{
var content = new DocumentContent
{
DocumentId = "documentId",
Id = "id",
Value = "value"
};
var contents = new List <DocumentContent> {
content
};
List <DocumentContentEntity> addedEntities = null;
var documentContentRepositoryMock = new Mock <IDocumentContentRepository>();
documentContentRepositoryMock.Setup(p => p.AddAsync(It.IsAny <IEnumerable <DocumentContentEntity> >()))
.Callback((IEnumerable <DocumentContentEntity> e) => { addedEntities = e.ToList(); })
.Returns(() => Task.FromResult(0));
var contentService = new DocumentContentService(documentContentRepositoryMock.Object, MockObjects.GetMapper());
await contentService.AddAsync(contents);
Assert.Equal(1, addedEntities.Count);
var addedEntity = addedEntities[0];
Assert.Equal(content.DocumentId, addedEntity.DocumentId);
Assert.Equal(content.Id, addedEntity.Id);
Assert.Equal(content.Value, addedEntity.Value);
documentContentRepositoryMock.Verify(p => p.AddAsync(It.IsAny <IEnumerable <DocumentContentEntity> >()), Times.Once);
}
/// <summary>
/// Adds a UserControl to the main component container
/// </summary>
/// <param name = "control">UserControl element</param>
/// <param name = "controlTabTitle">The title to give the tab element</param>
public void AddMainComponent(UserControl control, string controlTabTitle)
{
try
{
Framework.EventBus.Publish(new PanelEvent(this));
var alreadyOpen = false;
DocumentContent focusThis = null;
foreach (DocumentContent cCtrl in this.MainComponentContainer.Items)
{
if (cCtrl.Tag.ToString().CompareTo(controlTabTitle) == 0)
{
alreadyOpen = true;
focusThis = cCtrl;
}
}
if (alreadyOpen == false)
{
var title = controlTabTitle;
if (controlTabTitle.Contains("\\"))
{
var parts = controlTabTitle.Split('\\');
title = parts[parts.Length - 1];
}
var newContentControl = new ContentControl
{
Margin = new Thickness(0), Content = control
};
var newDocumentContent = new DocumentContent
{
Title = title, Background = Brushes.White, Content = newContentControl, Icon = Framework.Images.GetImage("CutHS", "VS2010ImageLibrary", 12).Source, Tag = controlTabTitle
};
newDocumentContent.Closing += this.NewDocumentContentClosing;
this.MainComponentContainer.Items.Add(newDocumentContent);
newDocumentContent.Show(this.dockManager);
newDocumentContent.Activate();
}
else
{
focusThis.Show(this.dockManager);
focusThis.Activate();
var newWindow = ( IUserControl )control;
newWindow.Dispose();
}
control.Focus();
control.BringIntoView();
}
catch (Exception error)
{
Framework.EventBus.Publish(error);
}
}
public void ShowDockPanelTest()
{
DockingService target = new DockingService(); // TODO: Initialize to an appropriate value
DocumentContent doc = null; // TODO: Initialize to an appropriate value
target.ShowDockPanel(doc);
Assert.Inconclusive("A method that does not return a value cannot be verified.");
}
public void ShowDockPanelTest()
{
IDockingService_Accessor target = CreateIDockingService_Accessor(); // TODO: Initialize to an appropriate value
DocumentContent newFile = null; // TODO: Initialize to an appropriate value
target.ShowDockPanel(newFile);
Assert.Inconclusive("A method that does not return a value cannot be verified.");
}
public ActionResult DownloadFile(Guid idDocument)
{
using (ServiceReferenceDocument.DocumentsClient client = new ServiceReferenceDocument.DocumentsClient())
{
DocumentContent result = client.GetDocumentContent(idDocument, null, Library.Common.Enums.DocumentContentFormat.Binary, null);
return(File(result.Blob, "text/xml"));
}
}
// Handles removing documents from the data structure when closed
void content_Closed(object sender, EventArgs e)
{
DocumentContent content = sender as DocumentContent;
IDocument document = content.Content as IDocument;
m_documentLookup.Remove(document);
document.OnClosed(sender, e);
}
void _pluginManager_DockableContentClosed(FrameworkElement content)
{
DocumentContent doc = dockManager.Documents.First((a) => { return(a.Content == content); });
if (doc != null)
{
doc.Close();
}
}
private void ScriptSectionFormatting()
{
var targetScripts =
DocumentContent.XPathSelectElements(@"//text:script[@script:language = 'Template']", Manager).ToList();
foreach (var script in targetScripts.Where(script => script.Value.Contains("foreach") || script.Value.Contains("if")))
{
CreateControlFlowSection(script);
}
}
/// <summary>
/// Removes the document.
/// </summary>
/// <param name="documentContent">DocumentContent to remove</param>
private void RemoveDocument(DocumentContent documentContent)
{
if (documentContent == null)
{
return;
}
Documents.Remove(documentContent);
documentContent.DockPane.CloseCommand.Execute(null);
if (Documents.Count == 0)
{
State = DocumentContainerState.Empty;
WindowsManager parentWindowsManager = this.GetVisualParent<WindowsManager>();
if (parentWindowsManager != null)
{
ReduceChild(parentWindowsManager.DocumentContainer);
}
}
}
/// <summary>
/// Adds the dock panel as a document
/// </summary>
/// <param name="pane">The pane</param>
public void AddDocument(DockPane pane)
{
DocumentContent documentContent = new DocumentContent(pane, RemoveDocumentCommand);
pane.DockPaneState = DockPaneState.Content;
Documents.Add(documentContent);
if (DocumentsTab != null)
{
DocumentsTab.SelectedItem = documentContent;
}
State = DocumentContainerState.ContainsDocuments;
}
public async void can_add_new_format_with_api_from_object()
{
//Upload original
var handle = new DocumentHandle("Add_Format_Test");
await _documentStoreClient.UploadAsync(TestConfig.PathToOpenDocumentText, handle);
// wait background projection polling
await UpdateAndWaitAsync();
DocumentContent content = new DocumentContent(new DocumentContent.DocumentPage[]
{
new DocumentContent.DocumentPage(1, "TEST"),
}, new DocumentContent.MetadataHeader[] { });
//now add format to document.
AddFormatFromObjectToDocumentModel model = new AddFormatFromObjectToDocumentModel();
model.DocumentHandle = handle;
model.StringContent = JsonConvert.SerializeObject(content);
model.CreatedById = "tika";
model.FileName = "add_format_test.content";
model.Format = new DocumentFormat("content");
await _documentStoreClient.AddFormatToDocument(model, new Dictionary<String, Object>());
// wait background projection polling
await UpdateAndWaitAsync();
var formats = await _documentStoreClient.GetFormatsAsync(handle);
Assert.NotNull(formats);
Assert.IsTrue(formats.HasFormat(new DocumentFormat("original")));
Assert.IsTrue(formats.HasFormat(new DocumentFormat("content")));
Assert.That(formats, Has.Count.EqualTo(2));
await CompareDownloadedStreamToStringContent(
model.StringContent,
_documentStoreClient.OpenRead(handle, new DocumentFormat("content")));
}
private void ExportLayoutToDocument(object sender, RoutedEventArgs e)
{
DocumentContent doc = new DocumentContent()
{
Title = string.Format("Layout_{0}", DateTime.Now.ToString()),
Content = new TextBox()
{
AcceptsReturn = true,
VerticalScrollBarVisibility = ScrollBarVisibility.Auto,
HorizontalScrollBarVisibility = ScrollBarVisibility.Auto,
Text = DockManager.LayoutToString()
}
};
doc.Show(DockManager);
doc.Activate();
}
private void OnCreateNewDocumentContent(object sender, RoutedEventArgs e)
{
string title = "MainWindow.xml.cs";
DocumentContent[] cnts = this.DockManager.Documents.ToArray();
int i = 1;
while (cnts.FirstOrDefault(c => c.Title == title) != null)
{
title = string.Format("NewDocument{0}", i);
i++;
}
var newContent = new DocumentContent() { Title = title, Content = new TextBox() };
newContent.Icon = new BitmapImage(new Uri(@"Images\database.png", UriKind.Relative));
newContent.ContentTypeDescription = "Base Description of " + title;
newContent.InfoTip = System.IO.Path.GetTempPath();
newContent.FloatingWindowSize = new Size(500.0, 500.0);
newContent.Show(DockManager, true);
newContent.Activate();
}
