public InputEvents()
{
KeyUpData = null;
KeysDownData = null;
KeyPressData = null;
CopyEventArgs = null;
}
private void DocumentAfterCopy(Document sender, CopyEventArgs e)
{
if (sender.Level > 2 && sender.ContentType.Alias == Order.NodeAlias)
{
Guid currentGuid;
var orderGuid = sender.getProperty("orderGuid").Value.ToString();
Guid.TryParse(orderGuid, out currentGuid);
var order = OrderHelper.GetOrder(currentGuid);
var newOrder = OrderHelper.CreateNewOrderFromExisting(order);
IO.Container.Resolve <IOrderNumberService>().GenerateAndPersistOrderNumber(order);
order.OrderNodeId = e.NewDocument.Id;
order.Save();
e.NewDocument.Text = order.OrderNumber;
e.NewDocument.SetProperty("orderGuid", newOrder.UniqueOrderId.ToString());
e.NewDocument.SetProperty("orderStatusPicker", newOrder.Status.ToString());
e.NewDocument.Save();
BasePage.Current.ClientTools.SyncTree(e.NewDocument.Parent.Path, false);
BasePage.Current.ClientTools.ChangeContentFrameUrl(string.Concat("editContent.aspx?id=", e.NewDocument.Id));
}
}
private void ContentService_Copied(IContentService sender, CopyEventArgs <IContent> e)
{
var signature = GetUserSignature(CurrentUser);
var fromSignature = GetContentSignature(e.Original);
var toSignature = GetContentSignature(e.Copy);
HistoryHelper.AddHistoryItem($"{signature} copied content from {fromSignature} to {toSignature}");
}
private void ContentService_Copying(IContentService sender, CopyEventArgs <IContent> e)
{
// When a content node contains nested content property
// Check if the copied node contains a nested content
var nestedContentProps = e.Copy.Properties.Where(x => x.PropertyType.PropertyEditorAlias == Constants.PropertyEditors.Aliases.NestedContent);
UpdateNestedContentProperties(nestedContentProps, false);
}
private void Service_Copying(Tservice sender, CopyEventArgs <Tentity> e)
{
if (CodeFirstManager.Current.Features.EnableContentEvents)
{
lock (_onCopy)
{
HandleEvent(_onCopy, e.Copy, e, ModelEventDispatcher.OnCopyObject);
}
}
}
#pragma warning restore 0649
public bool OnBytesCopied(int p0, int p1)
{
var __h = Handler;
if (__h == null)
{
return(false);
}
var __e = new CopyEventArgs(true, p0, p1);
__h(sender, __e);
return(__e.Handled);
}
/// <summary>
/// Handles cache refreshing for when content is copied
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
/// <remarks>
/// When an entity is copied new permissions may be assigned to it based on it's parent, if that is the
/// case then we need to clear all user permissions cache.
/// </remarks>
static void ContentService_Copied(IContentService sender, CopyEventArgs <IContent> e)
{
//check if permissions have changed
var permissionsChanged = ((Content)e.Copy).WasPropertyDirty("PermissionsChanged");
if (permissionsChanged)
{
DistributedCache.Instance.RefreshAllUserPermissionsCache();
}
//run the un-published cache refresher since copied content is not published
DistributedCache.Instance.RefreshUnpublishedPageCache(e.Copy);
}
void ContentService_Copying( IContentService sender, CopyEventArgs<IContent> e )
{
Property masterRelationProperty = e.Copy.Properties.SingleOrDefault( p => p.Alias == Api.Constants.ProductPropertyAliases.MasterRelationPropertyAlias );
if ( masterRelationProperty == null || ( masterRelationProperty.Value != null && !string.IsNullOrEmpty( masterRelationProperty.Value.ToString() ) ) ) {
return;
}
//Delete all property data
foreach ( Property property in e.Copy.Properties ) {
property.Value = null;
}
masterRelationProperty.Value = e.Original.Id.ToString( CultureInfo.InvariantCulture );
}
public bool Equals(CopyEventArgs <TEntity>?other)
{
if (ReferenceEquals(null, other))
{
return(false);
}
if (ReferenceEquals(this, other))
{
return(true);
}
return(base.Equals(other) && EqualityComparer <TEntity> .Default.Equals(Copy, other.Copy) &&
ParentId == other.ParentId && RelateToOriginal == other.RelateToOriginal);
}
void ContentService_Copying(IContentService sender, CopyEventArgs <IContent> e)
{
Property masterRelationProperty = e.Copy.Properties.SingleOrDefault(p => p.Alias == Api.Constants.ProductPropertyAliases.MasterRelationPropertyAlias);
if (masterRelationProperty == null || (masterRelationProperty.Value != null && !string.IsNullOrEmpty(masterRelationProperty.Value.ToString())))
{
return;
}
//Delete all property data
foreach (Property property in e.Copy.Properties)
{
property.Value = null;
}
masterRelationProperty.Value = e.Original.Id.ToString(CultureInfo.InvariantCulture);
}
private void _hostInterface_OnCopy(CopyEventArgs e)
{
EventArgs = new InputEvents()
{
CopyEventArgs = e
};
foreach (var filter in _filters.Values)
{
if (filter.IsEngaged)
{
filter.HandleCopy(e);
if (e.Handled)
{
break;
}
}
}
}
/// <summary>
/// Copy relations to media items when a page is copied.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="e">The e.</param>
/// <exception cref="System.NotImplementedException"></exception>
void ContentService_Copied(IContentService sender, CopyEventArgs <IContent> e)
{
try
{
if (_config.ReadBooleanSetting("moveMediaFilesStillInUse"))
{
var fileRelations = uMediaSyncHelper.relationService.GetByParent(e.Original).Where(r => r.RelationType.Alias == Constants.FileRelationTypeAlias);
foreach (var relation in fileRelations)
{
var media = uMediaSyncHelper.mediaService.GetById(relation.ChildId);
var newRelation = uMediaSyncHelper.relationService.Relate(e.Copy, media, Constants.FileRelationTypeAlias);
uMediaSyncHelper.relationService.Save(newRelation);
}
}
}
catch (Exception ex)
{
ex.ToExceptionless().Submit();
throw; // throw to the generic handler that writes to the Umbraco log
}
}
/// <summary>
/// When a page is copied, copy its media folder and all its files too, then set up a relation between the two copies and publish the page
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="e">The e.</param>
void ContentService_Copied(IContentService sender, CopyEventArgs <IContent> e)
{
try
{
if (_config.SyncNode(e.Original))
{
if (_config.ReadBooleanSetting("checkForMissingRelations"))
{
_folderService.EnsureRelatedMediaNodeExists(e.Original);
}
IContent content1 = uMediaSyncHelper.contentService.GetById(e.Original.Id);
IContent content2 = uMediaSyncHelper.contentService.GetById(e.Copy.Id);
IEnumerable <IRelation> uMediaSyncRelationsBefore = uMediaSyncHelper.relationService.GetByParentId(content1.Id).Where(r => r.RelationType.Alias == Constants.FolderRelationTypeAlias);
IRelation uMediaSyncRelation1 = uMediaSyncRelationsBefore.FirstOrDefault();
if (uMediaSyncRelation1 != null)
{
int media1Id = uMediaSyncRelation1.ChildId;
IMedia media1 = uMediaSyncHelper.mediaService.GetById(media1Id);
IEnumerable <IRelation> uMediaSyncRelations2 = uMediaSyncHelper.relationService.GetByParentId(content2.ParentId).Where(r => r.RelationType.Alias == Constants.FolderRelationTypeAlias);
IRelation uMediaSyncRelation2Parent = uMediaSyncRelations2.FirstOrDefault();
if (uMediaSyncRelation2Parent == null && _config.ReadBooleanSetting("checkForMissingRelations"))
{
// parent node doesn't have a media folder yet, probably because uMediaSync was installed after the node was created
_folderService.CreateRelatedMediaNode(content2.Parent());
// get the new relation for the parent
IEnumerable <IRelation> uMediaSyncRelationsAfter = uMediaSyncHelper.relationService.GetByParentId(content2.ParentId).Where(r => r.RelationType.Alias == Constants.FolderRelationTypeAlias);
uMediaSyncRelation2Parent = uMediaSyncRelationsAfter.FirstOrDefault();
}
if (uMediaSyncRelation2Parent != null)
{
int media2ParentId = uMediaSyncRelation2Parent.ChildId;
IMedia media2Parent = uMediaSyncHelper.mediaService.GetById(media2ParentId);
IMedia media2 = uMediaSyncHelper.mediaService.CreateMedia(content1.Name, media2Parent, "Folder", uMediaSyncHelper.userId);
// Create a temp variable to store the original media name before saving.
var originalMediaName = content2.Name;
uMediaSyncHelper.mediaService.Save(media2, uMediaSyncHelper.userId);
// After saving, the media name and the saved folder name might not match, because the folder already existed.
// If they don't match, delete the folder, as it is an unnecesary duplicate.
if (media2.Name != originalMediaName)
{
uMediaSyncHelper.mediaService.Delete(media2);
// After deleting , recreate the media object, get the Id of the existing media folder, and set media2 to this id
// then copy any missing media
media2 = uMediaSyncHelper.mediaService.CreateMedia(content1.Name, media2Parent, "Folder", uMediaSyncHelper.userId);
var originalMedia = uMediaSyncHelper.mediaService.GetChildren(media2ParentId).LastOrDefault(media => media.Name == originalMediaName);
media2.Id = originalMedia.Id;
media2.Name = originalMediaName;
CopyMedia(media1, media2);
}
// if they do match, then the media didn't exist already, so continue as normal.
else
{
CopyMedia(media1, media2);
IRelation relation = uMediaSyncHelper.relationService.Relate(content2, media2, Constants.FolderRelationTypeAlias);
uMediaSyncHelper.relationService.Save(relation);
uMediaSyncHelper.contentService.Save(content2, uMediaSyncHelper.userId);
}
}
}
}
}
catch (Exception ex)
{
ex.ToExceptionless().Submit();
throw; // throw to the generic handler that writes to the Umbraco log
}
}
public void HandleCopy(CopyEventArgs e)
{
e.Handled = true;
}
/// <summary>
/// <see cref="ContentService"/> Copying event handler
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void ContentService_Copying(IContentService sender, CopyEventArgs <IContent> e)
{
var props = e.Copy.GetPropertiesByEditor(_editorAlias);
UpdatePropertyValues(props, false);
}
/// <summary>
/// Handles cache refreshing for when content is copied
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
/// <remarks>
/// When an entity is copied new permissions may be assigned to it based on it's parent, if that is the
/// case then we need to clear all user permissions cache.
/// </remarks>
private void ContentService_Copied(IContentService sender, CopyEventArgs <IContent> e)
{
}
/// <summary>
/// Creates a new document of the same type and copies all data from the current onto it. Due to backwards compatibility we can't return
/// the new Document, but it's included in the CopyEventArgs.Document if you subscribe to the AfterCopy event
/// </summary>
/// <param name="CopyTo"></param>
/// <param name="u"></param>
/// <param name="RelateToOrignal"></param>
public Document Copy(int CopyTo, User u, bool RelateToOrignal)
{
CopyEventArgs e = new CopyEventArgs();
e.CopyTo = CopyTo;
FireBeforeCopy(e);
Document newDoc = null;
if (!e.Cancel)
{
// Make the new document
newDoc = MakeNew(Text, new DocumentType(ContentType.Id), u, CopyTo);
if (newDoc != null)
{
// update template if a template is set
if (this.Template > 0)
newDoc.Template = Template;
//update the trashed property as it could be copied inside the recycle bin
newDoc.IsTrashed = this.IsTrashed;
// Copy the properties of the current document
var props = GenericProperties;
foreach (Property p in props)
{
//copy file if it's an upload property (so it doesn't get removed when original doc get's deleted)
IDataType uploadField = new Factory().GetNewObject(new Guid("5032a6e6-69e3-491d-bb28-cd31cd11086c"));
if (p.PropertyType.DataTypeDefinition.DataType.Id == uploadField.Id
&& p.Value.ToString() != ""
&& File.Exists(IOHelper.MapPath(p.Value.ToString())))
{
int propId = newDoc.getProperty(p.PropertyType.Alias).Id;
System.IO.Directory.CreateDirectory(IOHelper.MapPath(SystemDirectories.Media + "/" + propId.ToString()));
string fileCopy = IOHelper.MapPath(
SystemDirectories.Media + "/" +
propId.ToString() + "/" +
new FileInfo(IOHelper.MapPath(p.Value.ToString())).Name);
File.Copy(IOHelper.MapPath(p.Value.ToString()), fileCopy);
string relFilePath =
SystemDirectories.Media + "/" +
propId.ToString() + "/" +
new FileInfo(IOHelper.MapPath(p.Value.ToString())).Name;
if (SystemDirectories.Root == string.Empty)
relFilePath = relFilePath.TrimStart('~');
newDoc.getProperty(p.PropertyType.Alias).Value = relFilePath;
//copy thumbs
FileInfo origFile = new FileInfo(IOHelper.MapPath(p.Value.ToString()));
foreach(FileInfo thumb in origFile.Directory.GetFiles("*_thumb*"))
{
if (!File.Exists(IOHelper.MapPath(
SystemDirectories.Media + "/" +
propId.ToString() + "/" +
thumb.Name)))
{
thumb.CopyTo(IOHelper.MapPath(
SystemDirectories.Media + "/" +
propId.ToString() + "/" +
thumb.Name));
}
}
}
else
{
newDoc.getProperty(p.PropertyType.Alias).Value = p.Value;
}
}
// Relate?
if (RelateToOrignal)
{
Relation.MakeNew(Id, newDoc.Id, RelationType.GetByAlias("relateDocumentOnCopy"), "");
// Add to audit trail
Log.Add(LogTypes.Copy, u, newDoc.Id, "Copied and related from " + Text + " (id: " + Id.ToString() + ")");
}
// Copy the children
//store children array here because iterating over an Array object is very inneficient.
var c = Children;
foreach (Document d in c)
d.Copy(newDoc.Id, u, RelateToOrignal);
e.NewDocument = newDoc;
}
FireAfterCopy(e);
}
return newDoc;
}
/// <summary>
/// Event handler for the view's copy event.
/// </summary>
/// <param name="sender">Sender object.</param>
/// <param name="e">Event arguments.</param>
private void OnCopy(object sender, CopyEventArgs e)
{
this.explorerPresenter.SetClipboardText(e.Text, "CLIPBOARD");
}
public Document Copy(int CopyTo, User u, bool RelateToOrignal)
{
var e = new CopyEventArgs();
e.CopyTo = CopyTo;
FireBeforeCopy(e);
Document newDoc = null;
if (!e.Cancel)
{
// Make the new document
var content = ApplicationContext.Current.Services.ContentService.Copy(Content, CopyTo, RelateToOrignal, u.Id);
newDoc = new Document(content);
// Have to run the ActionNew handler to do umbEnsureUniqueName (for example)
BusinessLogic.Actions.Action.RunActionHandlers(newDoc, ActionNew.Instance);
// Then save to preserve any changes made by action handlers
newDoc.Save();
e.NewDocument = newDoc;
FireAfterCopy(e);
}
return newDoc;
}
public virtual void Copied(IContentService contentService, CopyEventArgs <IContent> args)
{
}
public static void Copying(IContentService sender, CopyEventArgs <IContent> e)
{
int i = 0;
}
public Document Copy(int CopyTo, User u, bool RelateToOrignal)
{
var e = new CopyEventArgs();
e.CopyTo = CopyTo;
FireBeforeCopy(e);
Document newDoc = null;
if (!e.Cancel)
{
// Make the new document
var content = ApplicationContext.Current.Services.ContentService.Copy(Content, CopyTo, RelateToOrignal, u.Id);
newDoc = new Document(content);
// Then save to preserve any changes made by action handlers
newDoc.Save();
e.NewDocument = newDoc;
FireAfterCopy(e);
}
return newDoc;
}
public void HandleCopy(CopyEventArgs e)
{
}
/// <summary>
/// Raises the <see cref="E:BeforeCopy"/> event.
/// </summary>
/// <param name="e">The <see cref="System.EventArgs"/> instance containing the event data.</param>
protected virtual void FireBeforeCopy(CopyEventArgs e)
{
if (BeforeCopy != null)
BeforeCopy(this, e);
}
/// <summary>
/// Creates a new document of the same type and copies all data from the current onto it. Due to backwards compatibility we can't return
/// the new Document, but it's included in the CopyEventArgs.Document if you subscribe to the AfterCopy event
/// </summary>
/// <param name="CopyTo"></param>
/// <param name="u"></param>
/// <param name="RelateToOrignal"></param>
public Document Copy(int CopyTo, User u, bool RelateToOrignal)
{
var fs = FileSystemProviderManager.Current.GetFileSystemProvider<MediaFileSystem>();
CopyEventArgs e = new CopyEventArgs();
e.CopyTo = CopyTo;
FireBeforeCopy(e);
Document newDoc = null;
if (!e.Cancel)
{
// Make the new document
newDoc = MakeNew(Text, new DocumentType(ContentType.Id), u, CopyTo);
if (newDoc != null)
{
// update template if a template is set
if (this.Template > 0)
newDoc.Template = Template;
//update the trashed property as it could be copied inside the recycle bin
newDoc.IsTrashed = this.IsTrashed;
// Copy the properties of the current document
var props = GenericProperties;
foreach (Property p in props)
{
//copy file if it's an upload property (so it doesn't get removed when original doc get's deleted)
IDataType uploadField = new Factory().GetNewObject(new Guid("5032a6e6-69e3-491d-bb28-cd31cd11086c"));
if (p.PropertyType.DataTypeDefinition.DataType.Id == uploadField.Id
&& p.Value.ToString() != ""
&& fs.FileExists(fs.GetRelativePath(p.Value.ToString())))
{
var currentPath = fs.GetRelativePath(p.Value.ToString());
var propId = newDoc.getProperty(p.PropertyType.Alias).Id;
var newPath = fs.GetRelativePath(propId, System.IO.Path.GetFileName(currentPath));
fs.CopyFile(currentPath, newPath);
newDoc.getProperty(p.PropertyType.Alias).Value = fs.GetUrl(newPath);
//copy thumbs
foreach (var thumbPath in fs.GetThumbnails(currentPath))
{
var newThumbPath = fs.GetRelativePath(propId, System.IO.Path.GetFileName(thumbPath));
fs.CopyFile(thumbPath, newThumbPath);
}
}
else
{
newDoc.getProperty(p.PropertyType.Alias).Value = p.Value;
}
}
// Relate?
if (RelateToOrignal)
{
Relation.MakeNew(Id, newDoc.Id, RelationType.GetByAlias("relateDocumentOnCopy"), "");
// Add to audit trail
Log.Add(LogTypes.Copy, u, newDoc.Id, "Copied and related from " + Text + " (id: " + Id.ToString() + ")");
}
// Copy the children
//store children array here because iterating over an Array object is very inneficient.
var c = Children;
foreach (Document d in c)
d.Copy(newDoc.Id, u, RelateToOrignal);
e.NewDocument = newDoc;
}
FireAfterCopy(e);
}
return newDoc;
}
/// <summary>
/// Raises the <see cref="E:AfterCopy"/> event.
/// </summary>
/// <param name="e">The <see cref="System.EventArgs"/> instance containing the event data.</param>
protected virtual void FireAfterCopy(CopyEventArgs e)
{
if (AfterCopy != null)
AfterCopy(this, e);
}
/// <summary>
/// Handles cache refreshing for when content is copied
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
/// <remarks>
/// When an entity is copied new permissions may be assigned to it based on it's parent, if that is the
/// case then we need to clear all user permissions cache.
/// </remarks>
static void ContentService_Copied(IContentService sender, CopyEventArgs <IContent> e)
{
//run the un-published cache refresher since copied content is not published
DistributedCache.Instance.RefreshUnpublishedPageCache(e.Copy);
}
private void OnCopyStatusChanged(object sender, CopyEventArgs e)
{
dgInfo.Rows[_mapRows[e.Info]].Cells["Status"].Value = e.Info.GetStatusString();
}