private void OpenAttachment()
{
if (_selectedAttachmentIndex == -1)
{
return;
}
LEADDocument currentDocument = _documentViewer.Document;
// The attachment has a document ID if it is already saved into the cache, if so, just load it
int attachmentIndex = _selectedAttachmentIndex;
DocumentAttachment attachment = currentDocument.Attachments[attachmentIndex];
if (!string.IsNullOrEmpty(attachment.DocumentId))
{
LoadDocumentFromCache(attachment.DocumentId);
}
else
{
// If our document is cached, then save the attachment to cache and open it from there
// Otherwise, load it into a stream as a brand new document
if (IsDocumentInCache(currentDocument))
{
CreateAttachmentDocumentFromCache(currentDocument, attachment);
}
else
{
CreateAttachmentDocument(currentDocument, attachment);
}
}
}
private DocumentAttachment ParseDocAttachment(JObject _jDoc)
{
try
{
if (_jDoc[PAttachmentsDocument] is JObject jDoc)
{
var docAttachment = new DocumentAttachment();
docAttachment.Id = jDoc[PId].Value <int>();
docAttachment.OwnerId = jDoc[PAttachmentOwnerId].Value <int>();
docAttachment.Title = jDoc[PTitle]?.Value <string>();
docAttachment.Date = EpochTimeConverter.ConvertToDateTime(jDoc[PDate].Value <long>());
docAttachment.Url = jDoc[PUrl].Value <string>();
docAttachment.AccessKey = jDoc[PAttachmentAccessKey]?.Value <string>();
return(docAttachment);
}
}
catch (Exception ex)
{
throw new InvalidOperationException($"Failed to parse doc attachment \n {_jDoc.ToString()}", ex);
}
throw new DeserializerException($"Failed recognize jObject as document attachment \n {_jDoc?.ToString()}");
}
private static void SaveAttachmentToStream(LEADDocument document, DocumentAttachment attachment, Stream stream)
{
using (var inputStream = document.Attachments.CreateAttachmentStream(attachment.AttachmentNumber, null))
{
inputStream.CopyTo(stream);
}
}
protected void ctlRemove_OnClick(object sender, ImageClickEventArgs e)
{
#region Old Code Comment By AO 5-Mar-2009
//IList<DocumentAttachment> documentAttachmentList = new List<DocumentAttachment>();
//foreach (GridViewRow row in ctlAttachmentGrid.Rows)
//{
// if ((row.RowType == DataControlRowType.DataRow) && (((CheckBox)row.FindControl("ctlSelect")).Checked))
// {
// long attachmentID = UIHelper.ParseLong(ctlAttachmentGrid.DataKeys[row.RowIndex].Values["AttachmentID"].ToString());
// // Remove from transaction service.
// }
//}
#endregion
foreach (GridViewRow row in ctlAttachmentGrid.Rows)
{
if ((row.RowType == DataControlRowType.DataRow) && (((CheckBox)row.FindControl("ctlSelect")).Checked))
{
long attachmentID = UIHelper.ParseLong(ctlAttachmentGrid.DataKeys[row.RowIndex].Values["AttachmentID"].ToString());
// Remove from transaction.
DocumentAttachment documentAttachment = new DocumentAttachment(attachmentID);
DocumentAttachmentService.DeleteAttachmentFromTransaction(this.TransactionID, documentAttachment);
}
}
this.BindControl();
ctlUpdateAttachmentGrid.Update();
}
#pragma warning restore 1998
private void DownloadAttachment(DocumentAttachment attachment, IExecutionContext context)
{
var fileName = $"{StatiqHelper.AttachmentPath}/{attachment.AttachmentName}";
var destination = context.FileSystem.GetOutputFile(fileName);
if (!destination.Exists)
{
var thread = new CMSThread(() =>
{
try
{
var binary = AttachmentBinaryHelper.GetAttachmentBinary(attachment);
using (Stream fileStream = destination.OpenWrite(true))
{
long initialPosition = fileStream.Position;
fileStream.Write(binary, 0, binary.Length);
long length = fileStream.Position - initialPosition;
fileStream.SetLength(length);
}
}
catch (Exception e) {
Console.WriteLine(e.Message);
}
});
thread.Start();
}
}
public ActionResult SoftwareUploadClick(string version, string type, string plistUrl)
{
var result = new DirectResult();
var fileUploadField = this.GetCmp <FileUploadField>("fileUploadField");
if (fileUploadField.HasFile)
{
try
{
string postedFileName = GetPostedFileName(fileUploadField.PostedFile.FileName);
postedFileName = ChinesePinYin.GetPinYin(postedFileName);
var documentAttachment = new DocumentAttachment(GetFilePath(type, GetSoftwareBaseFolder()));
string filePath = documentAttachment.GetFileName(postedFileName);
string url = GetUrl(type, GetSoftwareMuLu(), postedFileName);
fileUploadField.PostedFile.SaveAs(filePath);
SaveSoftwareFilePathToDbstring(version, type, url, plistUrl);
X.Msg.Show(MessageBoxConfig(Success, TiShi, MessageBox.Icon.INFO));
}
catch (Exception ex)
{
X.Msg.Show(MessageBoxConfig(ex.ToString(), Fail, MessageBox.Icon.INFO));
}
finally
{
PushMessageToTag(type.ToLower(), version, "all", 1, -1, string.Empty, string.Empty, 0);
}
}
else
{
result.IsUpload = true;
X.Msg.Show(MessageBoxConfig(NoFile, TiShi, MessageBox.Icon.ERROR));
}
return(result);
}
// Returns the relative path to the first attachment selected via the page attachment selector component
private string GetAttachmentUrl(IEnumerable <AttachmentSelectorItem> attachments)
{
Guid attachmentGuid = attachments.FirstOrDefault()?.FileGuid ?? Guid.Empty;
DocumentAttachment attachment = DocumentHelper.GetAttachment(attachmentGuid, siteService.CurrentSite.SiteName);
return(attachmentUrlRetriever.Retrieve(attachment).RelativePath);
}
private static string GetFileTypeFromContentTypeValue(DocumentAttachment control)
{
if (control.FileType.Equals("application/vnd.openxmlformats-officedocument.presentationml.presentation"))
{
return("ppx");
}
return(control.FileType.Substring(control.FileType.IndexOf("/") + 1));
}
/// <summary>
/// Generates an IMG tag for an attachment.
/// </summary>
/// <param name="htmlHelper">HTML helper.</param>
/// <param name="attachment">Attachment object.</param>
/// <param name="title">Title.</param>
/// <param name="cssClassName">CSS class.</param>
/// <param name="constraint">Size constraint.</param>
public static MvcHtmlString AttachmentImage(this HtmlHelper htmlHelper, DocumentAttachment attachment, string title = "", string cssClassName = "", SizeConstraint?constraint = null)
{
if (attachment == null)
{
return(MvcHtmlString.Empty);
}
return(Image(htmlHelper, attachment.GetPath(), title, cssClassName, constraint));
}
private static string GetDisplayedName(DocumentAttachment attachment)
{
var displayedName = TextHelper.LimitLength(attachment.AttachmentName, AttachmentsControl.ATTACHMENT_NAME_LIMIT);
if (!String.IsNullOrEmpty(attachment.AttachmentVariantDefinitionIdentifier))
{
displayedName = ResHelper.GetAPIString("AttachmentVariant." + attachment.AttachmentVariantDefinitionIdentifier, attachment.AttachmentVariantDefinitionIdentifier);
}
return(displayedName);
}
private ActionResult AuthenticationCallback()
{
Session[EXACT_AUTH_STATE] = client.ProcessUserAuthorization(this.Request);
// Call ExactOnline SDK
ExactOnlineClient exact = new ExactOnlineClient(ConfigurationManager.AppSettings["exactOnlineUrl"], AccessTokenManager);
UserLogin token = Session[DropboxController.DROPBOX_ACCESS_TOKEN] as UserLogin;
List <DocumentCategory> categories = exact.For <DocumentCategory>().Select(new string[] { "ID", "Description" }).Get();
Dropbox dropbox = new Dropbox(token, true);
IEnumerable <string> fileNames = dropbox.GetNewDocumentNames();
Dictionary <Guid, string> newReferences = new Dictionary <Guid, string>();
foreach (string fileName in fileNames)
{
byte[] file = dropbox.GetFileBytes(fileName);
string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(fileName);
Document document = new Document()
{
Subject = fileNameWithoutExtension,
Body = fileNameWithoutExtension,
Type = 55,
DocumentDate = DateTime.Now.Date,
Category = categories[3].ID
};
bool createdDocument = exact.For <Document>().Insert(ref document);
DocumentAttachment attachment = new DocumentAttachment()
{
Document = document.ID,
FileName = fileName,
FileSize = (double)file.Length,
Attachment = file
};
bool createdAttachment = exact.For <DocumentAttachment>().Insert(ref attachment);
newReferences.Add(document.ID, fileName);
}
Dictionary <Guid, string> existingReferences = dropbox.GetExactOnlineReferences();
dropbox.UpdateExactOnlineReferences(existingReferences, newReferences);
return(View());
// Later, if necessary:
// bool success = client.RefreshAuthorization(auth);
}
private void SaveDocumentAttachment()
{
// Ensure automatic check-in/ check-out
bool autoCheck = false;
var wm = WorkflowManager.GetInstance(baseImageEditor.Tree);
if (node != null)
{
// Get workflow info
var wi = wm.GetNodeWorkflow(node);
if (wi != null)
{
autoCheck = !wi.UseCheckInCheckOut(CurrentSiteName);
}
// Check out the document
if (autoCheck)
{
var nextStep = node.VersionManager.CheckOut(node, node.IsPublished, true);
VersionHistoryID = node.DocumentCheckedOutVersionHistoryID;
if (IsWorkflowFinished(nextStep))
{
attachment = (DocumentAttachment)AttachmentInfoProvider.GetAttachmentInfo(attachmentGuid, CurrentSiteName);
}
}
var extension = attachment.AttachmentExtension;
// If extension changed update file extension
if (node.IsFile() && (node.DocumentExtensions != extension))
{
// Update document extensions if no custom are used
if (!node.DocumentUseCustomExtensions)
{
node.DocumentExtensions = extension;
}
node.SetValue("DocumentType", extension);
DocumentHelper.UpdateDocument(node, baseImageEditor.Tree);
}
}
DocumentHelper.UpdateAttachment(node, attachment);
// Check in the document
if (autoCheck && (VersionHistoryID > 0))
{
node.VersionManager.CheckIn(node, null);
}
}
public void ConnectToExactOnline2Upload(string srcFolder, string srcFilename)
{
try
{
// To make this work set the authorisation properties of your test app in the testapp.config.
var testApp = new TestApp();
var connector = new Connector(testApp.ClientId.ToString(), testApp.ClientSecret, testApp.CallbackUrl);
var client = new ExactOnlineClient(connector.EndPoint, connector.GetAccessToken);
//Create document which to relate documentattachment to
ExactOnline.Client.Models.Documents.Document document = new ExactOnline.Client.Models.Documents.Document
{
Subject = Path.GetFileNameWithoutExtension(srcFilename),
Body = Path.GetFileNameWithoutExtension(srcFilename),
Category = GeneralCategory,
Type = MiscDocType,
DocumentDate = DateTime.Now.Date
};
bool created = client.For <ExactOnline.Client.Models.Documents.Document>().Insert(ref document);
if (created)
{
//convert attachment into byte array
byte[] attachment = System.IO.File.ReadAllBytes(srcFolder + "/" + srcFilename);
//Create DocumentAttachment
DocumentAttachment documentAttachment = new DocumentAttachment
{
Document = document.ID, //relate DocumentAttachment to previously created document
Attachment = attachment,
FileName = srcFilename
};
created = client.For <DocumentAttachment>().Insert(ref documentAttachment);
Console.WriteLine("Saved to ExactOnline {0} attachmentID {1}", srcFilename, documentAttachment.ID);
}
else
{
Console.WriteLine("Unable to create document");
}
}
catch (Exception ex)
{
Console.WriteLine("Error occured: {0}", ex.Message);
}
}
public void InsertOrUpdate(DocumentAttachment docattach)
{
//ToDo Context initialization
if (docattach.DocAttachId == default(int))
{
// New entity
_context.DocumentAttachment.Add(docattach);
}
else
{
// Update existing entity
_context.Entry(docattach).State = EntityState.Modified;
}
}
public void Is_Passed_An_Object_Of_Attachment_Then_Render_Returns_The_Html(AttachmentControlRenderer renderer)
{
var attachment = new DocumentAttachment()
{
Url = "http://image.url",
Description = "description",
Title = "title",
FileSize = 1000,
FileType = "application/pdf"
};
var actual = renderer.Render(attachment);
actual.Value.Should().NotBeNullOrWhiteSpace();
actual.Value.Should().Be("<div class=\"fiu-attachment\"><h2 class=\"govuk-heading-m fiu-attachment__heading\">title</h2><dl class=\"fiu-attachment__meta\"><dt class=\"fiu-attachment__meta-title\">File type</dt><dd class=\"fiu-attachment__meta-description\">pdf</dd><dt class=\"fiu-attachment__meta-title\">File size</dt><dd class=\"fiu-attachment__meta-description\">1KB</dd></dl><p class=\"govuk-body fiu-attachment__description\">description</p><p class=\"govuk-body fiu-attachment__link-wrap\"><a href=\"http://image.url\" class=\"govuk-link fiu-attachment__link\" target=\"_blank\">Download <span class=\"fiu-vh\">title</span></a></p><span class=\"fiu-attachment__icon\"><span class=\"fiu-attachment__icon-label\">pdf</span></span></div>");
}
private void LoadAttachment()
{
if (attachment == null)
{
baseImageEditor.Tree = new TreeProvider(MembershipContext.AuthenticatedUser);
attachment = DocumentHelper.GetAttachment(attachmentGuid, CurrentSiteName, true, out node);
if ((attachment != null) && (attachment.AttachmentFormGUID != Guid.Empty))
{
// Get parent node ID in case attachment is edited for document not created yet (temporary attachment)
int parentNodeId = QueryHelper.GetInteger("parentId", 0);
node = baseImageEditor.Tree.SelectSingleNode(parentNodeId);
}
}
}
private void ShowAttachmentProperties()
{
if (_selectedAttachmentIndex == -1)
{
return;
}
int attachmentIndex = _selectedAttachmentIndex;
LEADDocument currentDocument = this._documentViewer.Document;
DocumentAttachment attachment = currentDocument.Attachments[attachmentIndex];
using (var dlg = new UI.AttachmentPropertiesDialog())
{
dlg.Attachment = attachment;
dlg.ShowDialog(this);
}
}
/// <summary>Builds a custom token dictionary for a document attachment.</summary>
/// <param name="attachment">The attachment.</param>
/// <returns>The custom token dictinoary for a document attachment.</returns>
private Dictionary <string, string> BuildAttachmentTokenDictionary(DocumentAttachment attachment)
{
return(new Dictionary <string, string>
{
{ "Attachment:DocumentAttachmentKey", attachment.DocumentAttachmentKey.ToString() },
{ "Attachment:DocumentKey", attachment.DocumentKey.ToString() },
{ "Attachment:FileName", attachment.FileName },
{ "Attachment:UploadedByContact", attachment.UploadedByContact.ToString() },
{ "Attachment:CreatedOn", attachment.CreatedOn.ToString(this.DateFormat, CultureInfo.CurrentCulture) },
{ "Attachment:FileExtension", attachment.FileExtension },
{ "Attachment:FileSizeInBytes", attachment.FileSizeInBytes.ToString() },
{ "Attachment:Width", attachment.Width.ToString() },
{ "Attachment:Height", attachment.Height.ToString() },
{ "Attachment:DurationSeconds", attachment.DurationSeconds.ToString() },
{ "Attachment:DownloadUrl", attachment.DownloadUrl },
{ "Attachment:IconUrl", attachment.IconUrl },
});
}
/// <summary>
/// Checks whether the name is unique.
/// </summary>
private bool IsAttachmentNameUnique(DocumentAttachment attachment)
{
// Check that the name is unique in the document or version context
Guid attachmentFormGuid = QueryHelper.GetGuid("formguid", Guid.Empty);
bool nameIsUnique;
if (attachmentFormGuid == Guid.Empty)
{
// Get the node
nameIsUnique = DocumentHelper.AttachmentHasUniqueName(Node, attachment);
}
else
{
nameIsUnique = AttachmentInfoProvider.IsUniqueTemporaryAttachmentName(attachmentFormGuid, attachment.AttachmentName, attachment.AttachmentExtension, attachment.AttachmentID);
}
return(nameIsUnique);
}
private static string GetTooltip(DocumentAttachment attachment, string attachmentUrl, string name)
{
string title = null;
string description = null;
var imageWidth = attachment.AttachmentImageWidth;
var imageHeight = attachment.AttachmentImageHeight;
if (String.IsNullOrEmpty(attachment.AttachmentVariantDefinitionIdentifier))
{
title = attachment.AttachmentTitle;
description = attachment.AttachmentDescription;
}
var tooltip = UIHelper.GetTooltipAttributes(attachmentUrl, imageWidth, imageHeight, title, name, attachment.AttachmentExtension, description, null, 300);
return(tooltip);
}
private void CreateAttachmentDocumentFromCache(LEADDocument currentDocument, DocumentAttachment attachment)
{
try
{
// Save it int the cache
var options = new SaveAttachmentToCacheOptions();
options.AttachmentNumber = attachment.AttachmentNumber;
options.UploadDocumentOptions.Cache = this._cache;
// This will update DocumentAttachment.DocumentId
currentDocument.SaveAttachmentToCache(options);
string attachmentDocumentId = attachment.DocumentId;
this.LoadDocumentFromCache(attachmentDocumentId);
}
catch (Exception ex)
{
UI.Helper.ShowError(this, ex);
}
}
public ActionResult Index()
{
// Retrieves the GUID of the first selected attachment from the 'Attachments' property
Guid guid = propertiesRetriever.Retrieve <CustomWidgetProperties>().Attachments.FirstOrDefault()?.FileGuid ?? Guid.Empty;
// Retrieves the DocumentAttachment object that corresponds to the selected attachment GUID
DocumentAttachment attachment = DocumentHelper.GetAttachment(guid, siteService.CurrentSite.SiteID);
string url = String.Empty;
if (attachment != null)
{
// Retrieves the relative URL of the selected attachment
url = attachmentUrlRetriever.Retrieve(attachment).RelativePath;
}
// Custom logic...
return(View());
}
public ActionResult AttachDocument(DocumentAttachmentViewModel vm)
{
if (Request.Files[0] != null && Request.Files[0].ContentLength > 0)
{
UploadDocument ud = new UploadDocument();
string FileNames = "";
for (int i = 0; i < Request.Files.Count; i++)
{
string FileName = "";
string FolderName = "";
ud.UploadFile(i, new Dictionary <string, string>(), vm.DocTypeId + "_" + vm.DocId, Constants.FileTypeConstants.Other, out FolderName, out FileName);
DocumentAttachment da = new DocumentAttachment();
da.DocId = vm.DocId;
da.DocTypeId = vm.DocTypeId;
da.FileFolderName = FolderName;
da.FileName = FileName;
da.CreatedBy = User.Identity.Name;
da.CreatedDate = DateTime.Now;
da.ModifiedBy = User.Identity.Name;
da.ModifiedDate = DateTime.Now;
da.ObjectState = Model.ObjectState.Added;
db.DocumentAttachment.Add(da);
FileNames += da.FileName + ", ";
}
db.SaveChanges();
//LogActivity.LogActivityDetail(LogVm.Map(new ActiivtyLogViewModel
//{
// DocTypeId = vm.DocTypeId,
// DocId = vm.DocId,
// ActivityType = (int)ActivityTypeContants.FileAdded,
// DocNo = FileNames,
//}));
}
return(RedirectToAction("AttachDocument", new { DocId = vm.DocId, DocTypeId = vm.DocTypeId }));
}
protected override void PerformRunCommand(string[] args)
{
var newMsg = NewMessage.ReadFromConsole();
var msg = new MessageToPost
{
FromBoxId = ConsoleContext.CurrentBoxId,
ToBoxId = InputHelpers.AutocompleteBoxId(ConsoleContext, newMsg.ToBoxId),
};
msg.DocumentAttachments.AddRange(newMsg.DocumentsToPost
.Select(e =>
{
var document = new DocumentAttachment
{
TypeNamedId = e.TypeNamedId,
Function = e.Function,
Version = e.Version,
SignedContent = new SignedContent
{
Content = e.Content,
Signature = ConsoleContext.Crypt.Sign(e.Content, ConsoleContext.CurrentCert.RawData)
},
Comment = e.Comment,
NeedRecipientSignature = e.NeedRecipientSignature,
};
foreach (var m in e.Metadata)
{
document.AddMetadataItem(new MetadataItem
{
Key = m.Key,
Value = m.Value
});
}
return(document);
}));
var messagePosted = ConsoleContext.DiadocApi.PostMessage(ConsoleContext.CurrentToken, msg, Guid.NewGuid().ToString("N"));
System.Console.WriteLine("Было отправлено следующее письмо:");
messagePosted.WriteToConsole();
}
private void CreateAttachmentDocument(LEADDocument currentDocument, DocumentAttachment attachment)
{
try
{
// Load it as a document
var loadAttachmentOptions = new LoadAttachmentOptions();
loadAttachmentOptions.AttachmentNumber = attachment.AttachmentNumber;
loadAttachmentOptions.UpdateAttachmentDocumentId = false;
loadAttachmentOptions.LoadDocumentOptions.RenderAnnotations = _preferences.LastRenderAnnotations;
loadAttachmentOptions.LoadDocumentOptions.LoadAttachmentsMode = _preferences.LastLoadAttachmentsMode;
loadAttachmentOptions.LoadDocumentOptions.LoadEmbeddedAnnotations = _preferences.LastFileLoadEmbeddedAnnotations;
loadAttachmentOptions.LoadDocumentOptions.Cache = _cache;
loadAttachmentOptions.LoadDocumentOptions.Name = attachment.DisplayName;
this.LoadDocumentFromAttachment(currentDocument, loadAttachmentOptions);
}
catch (Exception ex)
{
UI.Helper.ShowError(this, ex);
}
}
public override void Do(UploadAttachmentEvent events)
{
UploadData d = JsonConvert.DeserializeObject <UploadData>(events.Data);
long _id = Convert.ToInt64(d.Id);
Document entity = Db.Document.Find(_id);
if (entity == null)
{
throw new Exception("保存附件时查无此Document信息");
}
DocumentAttachment _attachment = new DocumentAttachment();
_attachment.DocumentId = entity.Id;
_attachment.FileName = events.FileName;
_attachment.DisplayName = events.DisplayName;
Db.DocumentAttachment.Add(_attachment);
Db.SaveChanges();
}
/// <summary>
/// Creates a DocumentAttachment with the provided binary content and adds it the existing attchments of the given Document ID.
/// </summary>
/// <param name="documentId">The Document ID for which to add the Attachment to it.</param>
/// <param name="fileName">The name to be disolayed as the original File name.</param>
/// <param name="content">The binary data representing the content of uploaded file as the attachment.</param>
/// <returns>The created DocumentAttachment.</returns>
public DocumentAttachment Add(Guid documentId, string fileName, byte[] content)
{
var attachment = new DocumentAttachment
{
Document = documentId,
Attachment = content,
FileName = fileName,
FileSize = content.Length
};
var operationResult = Client.For <DocumentAttachment>().Insert(ref attachment);
if (operationResult)
{
return(attachment);
}
else
{
throw new Exception("DocumentAttachment failed to create.");
}
}
public Response UpdateDocumentAttachment(int id, List<string> fileName, List<byte[]> files)
{
try
{
using (DGAMilDocEntities ctx = new DGAMilDocEntities())
{
foreach (var file in fileName.Where(o => !o.Contains("mainFile")))
{
var i = 0;
DocumentAttachment att = new DocumentAttachment()
{
DocumentId = id,
AttachmentName = file,
AttachmentBinary = files[i],
MimeCode = Util.ConvertContentType(System.IO.Path.GetExtension(file)),
State = "บันทึก",
Type = "1",
FileSize = Util.ConvertBytesToMegabytes(files[i].Length).ToString("N5") + " mb",
};
ctx.DocumentAttachment.Add(att);
i++;
}
ctx.SaveChanges();
resp.Status = true;
}
}
catch (Exception ex)
{
resp.Status = false;
resp.Description = ex.Message;
}
return resp;
}
protected override void OnLoad(EventArgs e)
{
if (!DesignMode)
{
DocumentAttachment attachment = this.Attachment;
if (attachment != null)
{
_propertiesListView.Items.Add(new ListViewItem(new string[] { "Document ID", attachment.DocumentId }));
_propertiesListView.Items.Add(new ListViewItem(new string[] { "File name", attachment.FileName }));
_propertiesListView.Items.Add(new ListViewItem(new string[] { "Display name", attachment.DisplayName }));
_propertiesListView.Items.Add(new ListViewItem(new string[] { "File length", attachment.FileLength.ToString() }));
_propertiesListView.Items.Add(new ListViewItem(new string[] { "Mime type", attachment.MimeType }));
_propertiesListView.Items.Add(new ListViewItem(new string[] { "Is embedded", attachment.IsEmbedded ? "Yes" : "No" }));
var sortedMetadata = new SortedDictionary <string, string>(attachment.Metadata);
foreach (var item in sortedMetadata)
{
string value = item.Value;
if (item.Key == "TimeCreated" || item.Key == "TimeModified")
{
DateTime time;
if (DateTime.TryParse(item.Value, out time))
{
value = time.ToString();
}
}
_propertiesListView.Items.Add(new ListViewItem(new string[] { item.Key, value }));
}
_propertiesListView.AutoResizeColumns(ColumnHeaderAutoResizeStyle.ColumnContent);
_propertiesListView.AutoResizeColumns(ColumnHeaderAutoResizeStyle.HeaderSize);
}
}
base.OnLoad(e);
}
protected string GetAttachmentHtml(DocumentAttachment attachment, DocumentAttachment mainAttachment, int versionHistoryId)
{
if (mainAttachment == null)
{
mainAttachment = attachment;
}
var attachmentUrl = GetAttachmentUrl(attachment, mainAttachment, versionHistoryId);
var displayedName = GetDisplayedName(attachment);
var tooltip = GetTooltip(attachment, attachmentUrl, displayedName);
var fileIcon = UIHelper.GetFileIcon(Page, attachment.AttachmentExtension);
if (ImageHelper.IsImage(mainAttachment.AttachmentExtension))
{
return(String.Format("<a class=\"cms-icon-link\" href=\"#\" onclick=\"javascript: window.open('{0}'); return false;\"><span id=\"{1}\" {2}>{3}{4}</span></a>", attachmentUrl, mainAttachment.AttachmentGUID, tooltip, fileIcon, displayedName));
}
attachmentUrl = URLHelper.AddParameterToUrl(attachmentUrl, "disposition", "attachment");
// NOTE: OnClick here is needed to avoid loader to show because even for download links, the pageUnload event is fired
return(String.Format("<a class=\"cms-icon-link\" onclick=\"javascript: {5}\" href=\"{0}\"><span id=\"{1}\" {2}>{3}{4}</span></a>", attachmentUrl, mainAttachment.AttachmentGUID, tooltip, fileIcon, displayedName, ScriptHelper.GetDisableProgressScript()));
}
public void FromCashe(XElement element)
{
CasheStatus = CasheStatus.FromCashe;
XAttribute attr;
if ((attr = element.Attribute(TypePropertyName)) != null)
Type = attr.Value;
XElement attachmentElement;
switch (AttachmentType)
{
case AttachmentType.Photo:
if ((attachmentElement = element.Element(PhotoAttachment.ElementNameStatic)) != null)
{
if (Photo == null)
Photo = new PhotoAttachment();
Photo.FromCashe(attachmentElement);
}
break;
case AttachmentType.Doc:
if ((attachmentElement = element.Element(DocumentAttachment.ElementNameStatic)) != null)
{
if (Document == null)
Document = new DocumentAttachment();
Document.FromCashe(attachmentElement);
}
break;
case AttachmentType.Video:
break;
case AttachmentType.Audio:
break;
case AttachmentType.Map:
break;
default:
throw new ArgumentOutOfRangeException();
}
}
public void FromService(object obj)
{
CasheStatus = CasheStatus.Sync;
Attachment attachment = (Attachment) obj;
Type = attachment.Type;
switch (AttachmentType)
{
case AttachmentType.Photo:
if (Photo == null)
Photo = new PhotoAttachment();
Photo.FromService(attachment.Photo);
break;
case AttachmentType.Doc:
if (Document == null)
Document = new DocumentAttachment();
Document.FromService(attachment.Document);
break;
case AttachmentType.Video:
break;
case AttachmentType.Audio:
break;
case AttachmentType.Map:
break;
default:
throw new ArgumentOutOfRangeException();
}
}
