public void Setup()
{
_auditFormatter = new AuditFormatter();
_nameValueCollection = new NameValueCollection();
_nameValueProviderCollection = new NameValueCollectionValueProvider(_nameValueCollection, null);
}
/// <summary>
/// Responds to Sitecore item updates
/// </summary>
/// <param name="sender"></param>
/// <param name="args">Param index 0 contains the Item being saved</param>
protected void OnItemSaving(object sender, EventArgs args)
{
Assert.IsTrue(args != null, "args != null");
if (args != null && _auditItemSaving)
{
using (new SecurityDisabler())
{
Item item = Event.ExtractParameter(args, 0) as Item;
Assert.IsTrue(item != null, "item != null");
if (item != null && ShouldAudit(item))
{
Item originalItem = item.Database.GetItem(item.ID, item.Language, item.Version);
var differences = FindDifferences(item, originalItem);
if (differences.Any())
{
TimeSpan createdTS = item.Statistics.Updated - item.Statistics.Created;
TimeSpan sinceLastSave = item.Statistics.Updated - originalItem.Statistics.Updated;
if (createdTS.TotalSeconds > 2 && sinceLastSave.TotalSeconds > 2)
{
Log(string.Format("SAVE: {0}", AuditFormatter.FormatItem(item)));
}
foreach (string f in differences)
{
Log(string.Format("SAVE: {0}, ** [{1}]: new: {2}, old: {3}", AuditFormatter.FormatItem(item), item.Fields[f].DisplayName, item[f], string.IsNullOrWhiteSpace(originalItem[f]) ? "": originalItem[f]));
}
}
}
}
}
}
public Item Duplicate(ClientPipelineArgs args, Item sourceItem)
{
Item result = null;
if (sourceItem == null)
{
SheerResponse.Alert(Translate.Text("Item not found."));
}
else
{
Item parent = sourceItem.Parent;
if (parent == null)
{
SheerResponse.Alert(Translate.Text("Cannot duplicate the root item."));
}
else if (parent.Access.CanCreate())
{
Log.Audit(this, "Duplicate item: {0}", new string[1] {
AuditFormatter.FormatItem(sourceItem)
});
var bucketItemOrSiteRoot = sourceItem.GetParentBucketItemOrSiteRoot();
if (BucketManager.IsBucket(bucketItemOrSiteRoot) && BucketManager.IsBucketable(sourceItem))
{
if (!EventDisabler.IsActive)
{
EventResult eventResult = Event.RaiseEvent("item:bucketing:duplicating", args, this);
if (eventResult != null && eventResult.Cancel)
{
Log.Info(string.Format("Event {0} was cancelled", "item:bucketing:duplicating"), this);
args.AbortPipeline();
return(null);
}
}
result = Context.Workflow.DuplicateItem(sourceItem, args.Parameters["name"]);
Item destination = CreateAndReturnBucketFolderDestination(bucketItemOrSiteRoot, DateUtil.ToUniversalTime(DateTime.Now), sourceItem);
if (!IsBucketTemplateCheck(sourceItem))
{
destination = bucketItemOrSiteRoot;
}
ItemManager.MoveItem(result, destination);
if (!EventDisabler.IsActive)
{
Event.RaiseEvent("item:bucketing:duplicated", args, this);
}
}
else
{
result = Context.Workflow.DuplicateItem(sourceItem, args.Parameters["name"]);
}
}
else
{
SheerResponse.Alert(Translate.Text("You do not have permission to duplicate \"{0}\".", sourceItem.DisplayName));
}
}
args.AbortPipeline();
return(result);
}
private bool CreateNewAliases(Item target, string customAliases, Item destinationFolder, out ID createdItemId)
{
var customAliasesTemplateId = Context.ContentDatabase.GetTemplate(MultiSiteAliases.Constants.Template.AliasesTemplateId);
using (new SecurityDisabler())
{
Item newItem = null;
try
{
newItem = destinationFolder.Add(customAliases, customAliasesTemplateId);
if (newItem != null)
{
newItem.Editing.BeginEdit();
var linkValue = (target.Paths.IsMediaItem) ?
string.Format(MultiSiteAliases.Constants.AliasesMediaLinkFieldValue, (object)target.ID)
: string.Format(MultiSiteAliases.Constants.AliasesItemLinkFieldValue, target.Paths.ContentPath, (object)target.ID);
newItem[MultiSiteAliases.Constants.Fields.LinkedField] = linkValue;
newItem.Editing.EndEdit();
Log.Audit((object)this, MultiSiteAliases.Constants.Log.AliasesCreated, AuditFormatter.FormatItem(newItem));
createdItemId = newItem.ID;
return(true);
}
}
catch (Exception ex)
{
newItem?.Editing?.CancelEdit();
Log.Error(MultiSiteAliases.Constants.Log.AliasesFailed + AuditFormatter.FormatItem(newItem), ex, this);
}
}
createdItemId = null;
return(false);
}
/// <summary>
/// Creates the Site root using the branch template
/// </summary>
/// <param name="parentItem"></param>
/// <param name="database"></param>
/// <returns></returns>
private Item CreateWebsiteRoot(Item parentItem, Database database)
{
Item newWebRootItem = null;
BranchItem siteRootBranchItem = siteRootBranchTemplateID.Length > 0 ? database.Branches[siteRootBranchTemplateID] : database.Branches[TemplateIDs.Folder];
//Check if branch template exists, else abort pipeline
if (siteRootBranchItem != null)
{
Log.Audit((object)this, "Create Website Root: {0}", new string[1] {
AuditFormatter.FormatItem(parentItem)
});
using (new SecurityDisabler())
{
//txtSiteName will replace the $name standard value defined under branch template when the site is created
newWebRootItem = siteRootBranchItem.AddTo(parentItem, txtSiteName.Value);
}
}
else
{
Context.ClientPage.ClientResponse.Alert(Translate.Text("{0} branch was not found.", (object)siteRootBranchTemplateID));
}
return(newWebRootItem);
}
/// <summary>
/// Archive specific versions.
///
/// </summary>
/// <param name="item">The item.
/// </param>
private void ArchiveItemVersion(Item item, ListString list)
{
string databaseName = item.Database.Name;
Database database = Database.GetDatabase(databaseName);
Assert.IsNotNull((object)database, "Database \"{0}\" not found", (object)databaseName);
Language language = Language.Parse(item.Language.Name);
foreach (var v in list)
{
Sitecore.Data.Version version = Sitecore.Data.Version.Parse(item.Versions.GetVersionNumbers().Where(n => n.Number.ToString() == v.ToString()).FirstOrDefault());
Item obj = database.GetItem(item.ID, language, version);
if (obj == null)
{
return;
}
Sitecore.Data.Archiving.Archive archive = ArchiveManager.GetArchive("archive", database);
Log.Audit(new object(), "Archive version: {0}", new string[1]
{
AuditFormatter.FormatItem(obj)
});
archive.ArchiveVersion(obj);
}
}
protected virtual Item CopyItem(Item target, Item itemToCopy)
{
Assert.ArgumentNotNull((object)target, nameof(target));
Assert.ArgumentNotNull((object)itemToCopy, nameof(itemToCopy));
string str = target.Uri.ToString();
string copyOfName = ItemUtil.GetCopyOfName(target, itemToCopy.Name);
Item obj = Context.Workflow.CopyItem(itemToCopy, target, copyOfName);
Log.Audit((object)this, "Copy item from: {0} to {1}", AuditFormatter.FormatItem(itemToCopy), AuditFormatter.FormatItem(obj), str);
return(obj);
}
public new void Execute(ClientPipelineArgs args)
{
Assert.ArgumentNotNull(args, "args");
var database = Factory.GetDatabase(args.Parameters["database"]);
Assert.IsNotNull(database, args.Parameters["database"]);
var str = args.Parameters["id"];
var item = database.Items[str];
if (item.IsNull())
{
SheerResponse.Alert("Item not found.", new string[0]);
args.AbortPipeline();
}
else
{
var parent = item.Parent;
if (parent.IsNull())
{
SheerResponse.Alert("Cannot duplicate the root item.", new string[0]);
args.AbortPipeline();
}
else if (parent.Access.CanCreate())
{
Log.Audit(this, "Duplicate item: {0}", new[] { AuditFormatter.FormatItem(item) });
var parentBucketOfItem = item.GetParentBucketItemOrSiteRoot();
if (BucketManager.IsBucket(parentBucketOfItem))
{
var duplicatedItem = Context.Workflow.DuplicateItem(item, args.Parameters["name"]);
var newDestination = BucketManager.CreateAndReturnDateFolderDestination(parentBucketOfItem, DateTime.Now);
if (!item.Template.IsBucketTemplateCheck())
{
newDestination = parentBucketOfItem;
}
Event.RaiseEvent("item:bucketing:duplicating", args, this);
ItemManager.MoveItem(duplicatedItem, newDestination);
Event.RaiseEvent("item:bucketing:duplicated", args, this);
Log.Info("Item " + duplicatedItem.ID + " has been duplicated to another bucket", this);
}
else
{
Context.Workflow.DuplicateItem(item, args.Parameters["name"]);
}
}
else
{
SheerResponse.Alert(Translate.Text("You do not have permission to duplicate \"{0}\".", new object[] { item.DisplayName }), new string[0]);
args.AbortPipeline();
}
}
args.AbortPipeline();
}
/// <summary>
/// Create site definition
/// </summary>
/// <param name="parentItem"></param>
/// <param name="database"></param>
/// <param name="language"></param>
/// <param name="websiteRootItem"></param>
private void CreateSiteDefinition(Item parentItem, Database database, string language, Item websiteRootItem)
{
BranchItem siteDefinitionBranchItem = siteDefinitionBranchTemplateID.Length > 0 ? database.Branches[siteDefinitionBranchTemplateID] : database.Branches[TemplateIDs.Folder];
if (siteDefinitionBranchItem != null)
{
Log.Audit((object)this, "Create Site Definition:{0}", new string[1] {
AuditFormatter.FormatItem(parentItem)
});
Item newSiteDefinition = siteDefinitionBranchItem.AddTo(parentItem, txtSiteName.Value);
//Add values based on site root under site defintion
using (new SecurityDisabler())
{
/*BEGIN EDIT*/
newSiteDefinition.Editing.BeginEdit();
//setting the hostnames and language
newSiteDefinition.Fields["hostName"].Value = txtHostNames.Value;
//setting the primary language for the site from the list of languages under system/languages
var primaryLanguageItem = database.GetItem(LanguagesItemId).Axes.GetDescendants().FirstOrDefault(x => x.Name.ToLower().Equals(language.ToLower()));
if (primaryLanguageItem != null)
{
ID primaryLanguageId = primaryLanguageItem.ID;
newSiteDefinition.Fields["language"].Value = primaryLanguageId.ToString();
}
/*END EDIT*/
newSiteDefinition.Editing.EndEdit();
//updating the siteSettings reference
var siteSettingsItem = newSiteDefinition.Children.FirstOrDefault(x => x.Name.Equals("siteSettings"));
if (siteSettingsItem != null)
{
siteSettingsItem.Editing.BeginEdit();
var siteSettings = websiteRootItem.Children.FirstOrDefault(x => x.TemplateID.ToString().Equals(SiteSettingsTemplateId));
if (siteSettings != null)
{
siteSettingsItem.Fields["Value"].Value = siteSettings.ID.ToString();
}
siteSettingsItem.Editing.EndEdit();
}
}
}
else
{
Context.ClientPage.ClientResponse.Alert(Translate.Text("{0} branch was not found.", (object)siteDefinitionBranchTemplateID));
}
}
public override void Process(PublishItemContext context)
{
if (context == null)
{
return;
}
if (context.Aborted)
{
return;
}
var sourceItem = context.PublishHelper.GetSourceItem(context.ItemId);
if (sourceItem == null)
{
return;
}
if (!sourceItem.Paths.IsContentItem)
{
return;
}
sourceItem.Fields.ReadAll();
var validators = ValidationHelpers.GetValidatorCollection(sourceItem);
if (validators == null)
{
return;
}
var invalidFields = ValidationHelpers.AreFieldsValid(validators).Select(i => sourceItem.Database.GetItem(i).Name).ToList();
if (!invalidFields.Any())
{
return;
}
if (invalidFields.Any())
{
Log.Info(string.Format(
"{0}: Item '{1}' in '{4}' will not be publised to database '{2}' because '{3}' field values are not valid",
GetType().Name,
AuditFormatter.FormatItem(sourceItem),
context.PublishContext.PublishOptions.TargetDatabase,
string.Join(", ", invalidFields), sourceItem.Language.Name),
this);
}
context.Action = PublishAction.Skip;
}
private void StartProcess(params object[] parameters)
{
var contextItem = (Item)parameters[0];
var topParent = (Item)parameters[1];
var recurse = (bool)parameters[2];
var args = (ClientPipelineArgs)parameters[3];
using (new EditContext(contextItem, SecurityCheck.Disable))
{
Log.Audit(this, "Copy item: {0} to {1}", new string[] { AuditFormatter.FormatItem(contextItem), AuditFormatter.FormatItem(topParent) });
ItemManager.CopyItem(contextItem, topParent, recurse);
args.AbortPipeline();
}
}
private void StartMoveProcess(params object[] parameters)
{
var item = (Item)parameters[0];
var topParent = (Item)parameters[1];
var args = (ClientPipelineArgs)parameters[2];
using (new EditContext(item, SecurityCheck.Disable))
{
Log.Audit(this, "Drag item: {0} to {1}", new string[] { AuditFormatter.FormatItem(item), AuditFormatter.FormatItem(topParent) });
ItemManager.MoveItem(item, topParent);
args.AbortPipeline();
}
}
protected void RunSchedule(params object[] parameters)
{
var schedule = parameters[0] as ScheduleItem;
if (schedule == null)
{
throw new Exception("Schedule item not found: " + schedule.InnerItem.Paths.Path);
}
else
{
Log.Audit(this, "Run scheduled command: {0}", new string[] { AuditFormatter.FormatItem(schedule.InnerItem) });
JobMessage("Run scheduled command: " + schedule.InnerItem.Paths.Path);
schedule.Execute();
JobMessage("Finished.");
}
}
/// <summary>
/// Archives the old version.
/// </summary>
/// <param name="version">The old version to archive.</param>
public override void HandleVersion(Item version)
{
Assert.ArgumentNotNull(version, "version");
Archive archive = version.Database.Archives["archive"];
if (archive != null)
{
Log.Audit(new object(), "Archive version: {0}", AuditFormatter.FormatItem(version));
archive.ArchiveVersion(version);
}
else
{
Log.Audit(this, "Recycle version : {0}", AuditFormatter.FormatItem(version));
version.RecycleVersion();
}
}
public void Process(SaveArgs args)
{
foreach (SaveArgs.SaveItem item in args.Items)
{
Item item2 = Context.ContentDatabase.Items[item.ID, item.Language, item.Version];
if (item2 != null)
{
item2.Editing.BeginEdit();
string newValue = String.Empty;
foreach (SaveArgs.SaveField field in item.Fields)
{
Field field2 = item2.Fields[field.ID];
if (field2 != null && field2.Type.Equals("Classification", StringComparison.InvariantCultureIgnoreCase))
{
HtmlDocument doc = new HtmlDocument();
doc.LoadHtml(field2.Value);
if (doc.DocumentNode.SelectSingleNode("//span[@class='tagSet' or @class='tagNotFound']") != null)
{
foreach (HtmlNode span in doc.DocumentNode.SelectNodes("//span[@class='tagSet' or @class='tagNotFound']"))
{
string tagId = span.Attributes["tagid"].Value;
if ((tagId == "Null") || (tagId == ID.Null.ToString()))
{
continue;
}
string weightId = span.Attributes["weightid"].Value;
newValue = newValue + tagId + ":" + weightId + "|";
}
newValue = newValue.Trim('|');
}
else
{
List <string> listValue = field2.Value.Split("|".ToCharArray(), StringSplitOptions.RemoveEmptyEntries).ToList();
listValue.RemoveAll(fielV => fielV.Contains(Sitecore.Data.ID.Null.ToString()));
newValue = String.Join("|", listValue.ToArray <string>());
}
field2.Value = newValue;
field.OriginalValue = newValue;
}
}
item2.Editing.EndEdit();
Log.Audit(this, "Save item: {0}", new[] { AuditFormatter.FormatItem(item2) });
args.SavedItems.Add(item2);
}
}
}
/// <summary>
/// Responds to Sitecore item deletions
/// </summary>
/// <param name="sender"></param>
/// <param name="args">Param index 0 contains the Item being deleted</param>
protected void OnItemDeleting(object sender, EventArgs args)
{
Assert.IsTrue(args != null, "args != null");
if (args != null && _auditItemDeleting)
{
using (new SecurityDisabler())
{
Item item = Event.ExtractParameter(args, 0) as Item;
Assert.IsTrue(item != null, "item != null");
if (item != null && ShouldAudit(item))
{
Log(string.Format("DELETE: {0}", AuditFormatter.FormatItem(item)));
}
}
}
}
private Item TransferItem(Item sourceItem, Item destinationItem, string leafName, bool recurse)
{
using (new ProxyDisabler())
{
if (destinationItem.Database.GetTemplate(sourceItem.TemplateID) == null)
{
WriteError(new ErrorRecord(new TemplateNotFoundException(
$"The data contains a reference to a template \"{sourceItem.Template.FullName}\" that does not exist in the destination database.\nYou must transfer the template first."), ErrorIds.TemplateNotFound.ToString(), ErrorCategory.InvalidData, sourceItem));
return(null);
}
var dic = DynamicParameters as RuntimeDefinedParameterDictionary;
var transferOptions = TransferOptions.ChangeId;
if (dic != null && dic[TransferOptionsParam].IsSet)
{
transferOptions = (TransferOptions)dic[TransferOptionsParam].Value;
}
var outerXml = string.Empty;
SitecoreVersion.V72.OrNewer(() =>
{
var options = ItemSerializerOptions.GetDefaultOptions();
options.AllowDefaultValues = transferOptions.HasFlag(TransferOptions.AllowDefaultValues);
options.AllowStandardValues = transferOptions.HasFlag(TransferOptions.AllowStandardValues);
options.ProcessChildren = recurse;
outerXml = sourceItem.GetOuterXml(options);
}).Else(() =>
{
outerXml = sourceItem.GetOuterXml(recurse);
});
var transferedItem = destinationItem.PasteItem(outerXml,
transferOptions.HasFlag(TransferOptions.ChangeId),
Force ? PasteMode.Overwrite : PasteMode.Undefined);
Event.RaiseEvent("item:transferred", sourceItem, destinationItem);
PowerShellLog.Audit("Transfer from database: {0}, to:{1}", AuditFormatter.FormatItem(sourceItem),
AuditFormatter.FormatItem(destinationItem));
if (transferedItem.Name != leafName)
{
transferedItem.Edit(args => transferedItem.Name = leafName);
}
return(transferedItem);
}
}
protected void Run(ClientPipelineArgs args)
{
Assert.ArgumentNotNull(args, "args");
string[] uris = StringUtil.Split(args.Parameters["uris"], '|', false);
if (args.IsPostBack)
{
if (args.HasResult)
{
string result = args.Result;
if (result == "-")
{
result = string.Empty;
}
foreach (var uri in uris)
{
if (ItemUri.IsItemUri(uri))
{
Item item = Database.GetItem(ItemUri.Parse(uri));
item.Editing.BeginEdit();
item[FieldIDs.Owner] = result;
item.Editing.EndEdit();
Log.Audit(this, "Set owner: {0}", new string[] { AuditFormatter.FormatItem(item) });
}
}
}
}
else
{
if (ItemUri.IsItemUri(uris[0]))
{
ItemUri uri = ItemUri.Parse(uris[0]);
UrlString str6 = new UrlString("/sitecore/shell/~/xaml/Sitecore.Shell.Applications.Security.SetOwner.aspx");
str6.Append("id", uri.Path);
str6.Append("la", uri.Language.ToString());
str6.Append("vs", uri.Version.ToString());
str6.Append("db", uri.DatabaseName);
SheerResponse.ShowModalDialog(str6.ToString(), "450", "180", string.Empty, true);
args.WaitForPostBack();
}
}
}
public void Execute(ClientPipelineArgs args)
{
Assert.ArgumentNotNull(args, "args");
//Move only subitems
List <Item> items = GetSubItems(args);
Assert.IsNotNull(items, typeof(List <Item>));
Item target = GetTarget(args);
Assert.IsNotNull(target, typeof(Item));
string str = target.Uri.ToString();
foreach (Item item2 in items)
{
Log.Audit(this, "Move sub item: {0} to {1}", new string[] { AuditFormatter.FormatItem(item2), str });
item2.MoveTo(target);
}
}
public override void Execute(CommandContext context)
{
var item = context.Items[0];
if (!item.Access.CanWriteLanguage() || !item.Locking.IsLocked())
{
return;
}
var user = Context.User;
Log.Info(string.Format("{0} has unlocked {1}", user.Name, AuditFormatter.FormatItem(item)), this);
using (new SecurityDisabler())
{
item.Editing.BeginEdit();
item.Locking.Unlock();
item.Editing.EndEdit();
Context.ClientPage.SendMessage(this, "item:checkedin");
}
}
public override void Execute(CommandContext context)
{
if (JobNotRunningOrQueued(_JobName))
{
Item contextItem = context.Items[0];
if (contextItem != null)
{
Log.Audit(this, "Check in {0}", new[] { AuditFormatter.FormatItem(contextItem) });
JobService service = new JobService();
service.StartJob(contextItem);
}
if (IsJobFinished(_JobName))
{
sc.Context.ClientPage.ClientResponse.Alert("Job completed!...");
}
}
else
{
sc.Context.ClientPage.ClientResponse.Confirm("Job with this name is already running or queued!..");
}
}
/// <summary>Runs the specified args.</summary>
/// <param name="args">The arguments.</param>
protected void Run(ClientPipelineArgs args)
{
Assert.ArgumentNotNull((object)args, "args");
if (!SheerResponse.CheckModified())
{
return;
}
Item itemNotNull = Client.GetItemNotNull(args.Parameters["id"], Language.Parse(args.Parameters["language"]), Sitecore.Data.Version.Parse(args.Parameters["version"]));
if (!itemNotNull.Locking.HasLock() && !Context.IsAdministrator)
{
return;
}
Log.Audit((object)this, "Check in: {0}", new string[1]
{
AuditFormatter.FormatItem(itemNotNull)
});
itemNotNull.Editing.BeginEdit();
itemNotNull.Locking.Unlock();
itemNotNull.Editing.EndEdit();
Context.ClientPage.SendMessage((object)this, "item:checkedin");
}
public virtual void Execute(CopyItemsArgs args)
{
Assert.ArgumentNotNull(args, "args");
Item item = GetDatabase(args).GetItem(args.Parameters["destination"]);
Assert.IsNotNull(item, args.Parameters["destination"]);
ArrayList list = new ArrayList();
List <Item> items = GetSubItems(args);
string str = item.Uri.ToString();
foreach (Item item2 in items)
{
if (item2 != null)
{
Log.Audit(this, "Copy sub items: {0}", new string[] { AuditFormatter.FormatItem(item2), str });
string copyOfName = ItemUtil.GetCopyOfName(item, item2.Name);
Item item3 = Context.Workflow.CopyItem(item2, item, copyOfName);
list.Add(item3);
}
}
args.Copies = list.ToArray(typeof(Item)) as Item[];
}
protected void Run(ClientPipelineArgs args)
{
string master = StringUtil.GetString(args.Parameters["master"]);
string template = StringUtil.GetString(args.Parameters["template"]);
Database database = Factory.GetDatabase(StringUtil.GetString(args.Parameters["database"]));
if (args.IsPostBack)
{
if (!args.HasResult)
{
return;
}
Item parent = database.Items[args.Parameters["id"]];
if (parent != null)
{
if (master.Length > 0)
{
BranchItem branch = database.Branches[master];
Log.Audit((object)this, "Add item : {0}", AuditFormatter.FormatItem(Context.Workflow.AddItem(args.Result, branch, parent)));
}
else
{
Log.Audit((object)this, "Add item : {0}", AuditFormatter.FormatItem(database.Templates[template].AddTo(parent, args.Result)));
}
}
else
{
Context.ClientPage.ClientResponse.ShowError("Parent item not found.", "");
args.AbortPipeline();
}
}
else
{
string str = string.Empty;
Context.ClientPage.ClientResponse.Input("Enter a name for the new item ***:", master.Length <= 0 ? database.Templates[template].Name : database.Branches[master].Name, Settings.ItemNameValidation, "'$Input' is not a valid name.", Settings.MaxItemNameLength);
args.WaitForPostBack();
}
}
public void Process(ClientPipelineArgs args)
{
Assert.ArgumentNotNull(args, "args");
Database database = Factory.GetDatabase(args.Parameters["database"]);
Assert.IsNotNull(database, typeof(Database), "Name: {0}", args.Parameters["database"]);
ListString listStrings = new ListString(args.Parameters["items"], '|');
Database target = Factory.GetDatabase("web");
foreach (string listString in listStrings)
{
Item item = database.GetItem(listString, Language.Parse(args.Parameters["language"]));
if (item == null)
{
continue;
}
Log.Audit(this, "Unpublish item: {0}", new string[] { AuditFormatter.FormatItem(item) });
item.Editing.BeginEdit();
item.Publishing.NeverPublish = true;
item.Editing.EndEdit();
PublishManager.PublishItem(item.Parent, new [] { target }, item.Languages, true, false);
}
}
protected void Run(ClientPipelineArgs args)
{
Assert.ArgumentNotNull(args, "args");
if (SheerResponse.CheckModified())
{
string itemPath = args.Parameters["id"];
string name = args.Parameters["language"];
string str3 = args.Parameters["version"];
Item item = Client.GetItemNotNull(itemPath, Language.Parse(name), Sitecore.Data.Version.Parse(str3));
string unlockerRole = Sitecore.Configuration.Settings.GetSetting(Constants.SETTING_CHECKIN_ROLE);
bool userCanUnlock = Context.User.IsInRole(unlockerRole);
if (item.Locking.HasLock() || Context.IsAdministrator || userCanUnlock)
{
Log.Audit(this, "Check in: {0}", new string[] { AuditFormatter.FormatItem(item) });
item.Editing.BeginEdit();
using (new SecurityDisabler())
{
item.Locking.Unlock();
}
item.Editing.EndEdit();
Context.ClientPage.SendMessage(this, "item:checkedin");
}
}
}
public static void PublishItemChanges(Item item)
{
if (!DynamicSiteSettings.AutoPublish)
{
return;
}
var targets = GetPublishingTargets();
if (targets.Length == 0)
{
return;
}
var languages = LanguageManager.GetLanguages(DynamicSiteSettings.GetCurrentDatabase);
if (languages == null || languages.Count == 0)
{
return;
}
Log.Audit(string.Format("Publish item now: {0}", AuditFormatter.FormatItem(item)), typeof(DynamicSiteManager));
PublishManager.PublishItem(item, targets, languages.ToArray(), false, true);
}
private string GetJobName()
{
return($"Resolving item references between source {AuditFormatter.FormatItem(this.Source)} and target {AuditFormatter.FormatItem(this.Target)}.");
}
public void OnItemAdded([CanBeNull] object sender, [NotNull] EventArgs args)
{
Assert.ArgumentNotNull(args, "args");
var contentItem = Event.ExtractParameter(args, 0) as Item;
Assert.IsNotNull(contentItem, "targetItem");
var branchItem = contentItem.Branch;
if (branchItem == null)
{
return;
}
var item = branchItem.InnerItem;
Assert.IsTrue(item.Children.Count == 1, "branch item structure is corrupted: {0}".FormatWith(AuditFormatter.FormatItem(item)));
var branch = item.Children[0];
if (this.isAsync)
{
ReferenceReplacementJob.StartAsync(branch, contentItem);
}
else
{
ReferenceReplacementJob.Start(branch, contentItem);
}
}
protected void Remove_Click()
{
Item itemFromQueryString = UIUtil.GetItemFromQueryString(Context.ContentDatabase);
Error.AssertItemFound(itemFromQueryString);
ArrayList arrayList = new ArrayList();
foreach (System.Web.UI.Control control in this.ExistingAliases.Selected)
{
string path = ShortID.Decode(StringUtil.Mid(control.ID.Split(MultiSiteAliases.Constants.HypenSplitChar).LastOrDefault(), 0));
Item obj = itemFromQueryString.Database.GetItem(path);
if (obj != null)
{
arrayList.Add((object)obj);
}
}
if (arrayList.Count == 0)
{
SheerResponse.Alert(MultiSiteAliases.Constants.AliasesNotSelected);
}
else
{
foreach (Item obj in arrayList)
{
obj.Delete();
Log.Audit((object)this, MultiSiteAliases.Constants.RemoveAliases, AuditFormatter.FormatItem(obj));
}
RefreshPostDeletion(itemFromQueryString);
}
}
