private void Jump(object sender, Message message, int offset)
{
string control = Context.ClientPage.ClientRequest.Control;
string workflowID = ShortID.Decode(control.Substring(0, 0x20));
string stateID = ShortID.Decode(control.Substring(0x21, 0x20));
control = control.Substring(0, 0x41);
IWorkflowProvider workflowProvider = Context.ContentDatabase.WorkflowProvider;
Error.Assert(workflowProvider != null, "Workflow provider for database \"" + Context.ContentDatabase.Name + "\" not found.");
IWorkflow workflow = workflowProvider.GetWorkflow(workflowID);
Error.Assert(workflow != null, "Workflow \"" + workflowID + "\" not found.");
Assert.IsNotNull(workflow, "workflow");
WorkflowState state = workflow.GetState(stateID);
Error.Assert(state != null, "Workflow state \"" + stateID + "\" not found.");
Border border = new Border
{
ID = control + "_content"
};
DataUri[] items = this.GetItems(state, workflow);
this.DisplayState(workflow, state, items, border, offset, this.PageSize);
Context.ClientPage.ClientResponse.SetOuterHtml(control + "_content", border);
}
public bool IsWorkflowEditable(Item item)
{
bool editable = false;
SettingsController settings = new SettingsController();
List <string> validStates = settings.GetValidWorkflowStates();
if (item != null)
{
IWorkflow workflow = item.Database.WorkflowProvider.GetWorkflow(item);
if (workflow == null)
{
editable = true;
}
else if (validStates.Count > 0)
{
WorkflowState state = workflow.GetState(item);
if (state != null && validStates.Any(t => t == state.StateID))
{
editable = true;
}
}
}
return(editable);
}
public override bool Filter(object element)
{
Debug.ArgumentNotNull(element, "element");
Item item = element as Item;
if (item == null)
{
return(true);
}
IWorkflow wf = Sitecore.Context.Workflow.GetWorkflow(item);
if (wf == null)
{
return(false);
}
WorkflowState state = wf.GetState(item);
if (state == null || state.FinalState)
{
return(false);
}
WorkflowEvent[] wevents = wf.GetHistory(item);
if (wevents == null || wevents.Length == 0)
{
return(false);
}
return((System.DateTime.Now - wevents[wevents.Length - 1].Date).Days > Age);
}
public override void Process(GetPageEditorNotificationsArgs arguments)
{
Assert.ArgumentNotNull((object)arguments, "arguments");
Item contextItem = arguments.ContextItem;
Database database = contextItem.Database;
IWorkflowProvider workflowProvider = database.WorkflowProvider;
if (workflowProvider == null)
{
return;
}
IWorkflow workflow = workflowProvider.GetWorkflow(contextItem);
if (workflow == null)
{
return;
}
WorkflowState state = workflow.GetState(contextItem);
if (state == null)
{
return;
}
var repository = new WorxboxItemsRepository(workflow);
var worxBoxIcon = "/~/icon/worxbox/32x32/worxbox.png";
var displayIcon =
$"<span><img src='{worxBoxIcon}' style='vertical-align:middle; padding-right: 1px;'/></span>";
string description = GetDescription(workflow, state, database);
string icon = state.Icon;
PageEditorNotification editorNotification = new PageEditorNotification(description, PageEditorNotificationType.Information)
{
Icon = icon
};
var commands = WorkflowFilterer.FilterVisibleCommands(workflow.GetCommands(contextItem));
foreach (WorkflowCommand filterVisibleCommand in commands)
{
PageEditorNotificationOption notificationOption = new PageEditorNotificationOption(filterVisibleCommand.DisplayName, new WorkflowCommandBuilder(contextItem, workflow, filterVisibleCommand).ToString());
editorNotification.Options.Add(notificationOption);
}
editorNotification.Options.Add(new PageEditorNotificationOption("|", ""));
foreach (WorkflowCommand command in commands)
{
if (repository.IsWorxboxItem(state, new DataUri(contextItem.Uri)) &&
repository.GetWorkflowCommandIDs().Contains(ID.Parse(command.CommandID)))
{
var notificationOption = new PageEditorNotificationOption(displayIcon + command.DisplayName, new WorxBoxWorkflowCommandBuilder(contextItem, workflow, command).ToString());
editorNotification.Options.Add(notificationOption);
}
}
arguments.Notifications.Add(editorNotification);
}
void DriveWorkflow()
{
string st;
do
{
System.Threading.Thread.Sleep(1000);
st = _wf.GetState("TestMachine");
} while (st != "NoMore");
_host.OnStop();
}
private void SendSelected(Message message)
{
IWorkflowProvider workflowProvider = Context.ContentDatabase.WorkflowProvider;
if (workflowProvider != null)
{
string workflowID = message["wf"];
string str2 = message["ws"];
IWorkflow workflow = workflowProvider.GetWorkflow(workflowID);
if (workflow != null)
{
int num = 0;
bool flag = false;
foreach (string str3 in Context.ClientPage.ClientRequest.Form.Keys)
{
if ((str3 != null) && str3.StartsWith("check_"))
{
string str4 = "hidden_" + str3.Substring(6);
string[] strArray = Context.ClientPage.ClientRequest.Form[str4].Split(new char[] { ',' });
Item item = Context.ContentDatabase.Items[strArray[0], Language.Parse(strArray[1]), Version.Parse(strArray[2])];
if (item != null)
{
WorkflowState state = workflow.GetState(item);
if (state.StateID == str2)
{
try
{
workflow.Execute(message["command"], item, state.DisplayName, true, new object[0]);
}
catch (WorkflowStateMissingException)
{
flag = true;
}
num++;
}
}
}
}
if (flag)
{
SheerResponse.Alert("One or more items could not be processed because their workflow state does not specify the next step.", new string[0]);
}
if (num == 0)
{
Context.ClientPage.ClientResponse.Alert("There are no selected items.");
}
else
{
Context.ClientPage.ClientResponse.SetLocation(string.Empty);
}
}
}
}
private static bool CheckWorkflow(ClientPipelineArgs args, Item item)
{
Assert.ArgumentNotNull((object)args, "args");
Assert.ArgumentNotNull((object)item, "item");
if (args.Parameters["workflow"] == "1")
{
return(true);
}
args.Parameters["workflow"] = "1";
if (args.IsPostBack)
{
if (args.Result == "yes")
{
args.IsPostBack = false;
return(true);
}
args.AbortPipeline();
return(false);
}
SiteContext site = Factory.GetSite("publisher");
if (site != null && !site.EnableWorkflow)
{
return(true);
}
IWorkflowProvider workflowProvider = Context.ContentDatabase.WorkflowProvider;
if (workflowProvider == null || workflowProvider.GetWorkflows().Length <= 0)
{
return(true);
}
IWorkflow workflow = workflowProvider.GetWorkflow(item);
if (workflow == null)
{
return(true);
}
WorkflowState state = workflow.GetState(item);
if (state == null || state.FinalState)
{
return(true);
}
args.Parameters["workflow"] = "0";
if (state.PreviewPublishingTargets.Any <string>())
{
return(true);
}
SheerResponse.Confirm(Translate.Text("The current item \"{0}\" is in the workflow state \"{1}\"\nand will not be published.\n\nAre you sure you want to publish?", (object)item.DisplayName, (object)state.DisplayName));
args.WaitForPostBack();
return(false);
}
/// <summary>Gets the icon.</summary>
/// <param name="item">The item.</param>
/// <returns>The icon.</returns>
protected override GutterIconDescriptor GetIconDescriptor(Item item)
{
Assert.ArgumentNotNull((object)item, nameof(item));
string str1 = item[FieldIDs.Workflow];
string str2 = item[FieldIDs.WorkflowState];
if (!Settings.Workflows.Enabled || !item.Access.CanWrite())
{
return((GutterIconDescriptor)null);
}
if (string.IsNullOrEmpty(str1) || string.IsNullOrEmpty(str2))
{
return((GutterIconDescriptor)null);
}
IWorkflowProvider workflowProvider = item.Database.WorkflowProvider;
if (workflowProvider == null)
{
return((GutterIconDescriptor)null);
}
IWorkflow workflow = workflowProvider.GetWorkflow(item);
if (workflow == null)
{
return((GutterIconDescriptor)null);
}
Sitecore.Workflows.WorkflowState state = workflow.GetState(item);
if (state == null)
{
return((GutterIconDescriptor)null);
}
if (state.FinalState)
{
return((GutterIconDescriptor)null);
}
GutterIconDescriptor gutterIconDescriptor = new GutterIconDescriptor();
gutterIconDescriptor.Icon = state.Icon;
gutterIconDescriptor.Tooltip = state.DisplayName;
WorkflowCommand[] workflowCommandArray = WorkflowFilterer.FilterVisibleCommands(workflow.GetCommands(item), item);
if (workflowCommandArray != null && workflowCommandArray.Length != 0)
{
//Modify the event subscribed to the gutterIconDescriptor to call custom command, found at ExtendedShowWorkflowCommands.cs
gutterIconDescriptor.Click = "ss:extendedshowworkflowcommands(id=" + (object)item.ID + ",language=" + (object)item.Language + ",version=" + (object)item.Version + ",database=" + item.Database.Name + ")";
}
return(gutterIconDescriptor);
}
public void Process(WorkflowPipelineArgs args)
{
if (args.DataItem == null)
{
return;
}
Item dataItem = args.DataItem;
IWorkflow dataItemWorkflow = dataItem.Database.WorkflowProvider.GetWorkflow(dataItem);
if (dataItemWorkflow != null)
{
WorkflowState dataItemWorkflowState = dataItemWorkflow.GetState(dataItem);
List <Item> relatedItems = new List <Item>();
relatedItems.AddRange(GetItemsFromRenderingDatasources(dataItem));
//todo: get related items from personalization rules data sources
//todo: get related items from tests
List <ID> processedItems = new List <ID>();
foreach (Item relatedItem in relatedItems)
{
IWorkflow relatedItemWorkflow = relatedItem.Database.WorkflowProvider.GetWorkflow(relatedItem);
if (relatedItemWorkflow == null)
{
// start the same workflow for the related item as the main item
dataItemWorkflow.Start(relatedItem);
relatedItemWorkflow = dataItemWorkflow;
}
if (relatedItemWorkflow.WorkflowID == dataItemWorkflow.WorkflowID &&
!processedItems.Contains(relatedItem.ID))
{
// only process related items in the same workflow as the main item
// if the related item already belongs to a different workflow, we'll ignore it
AdvanceWorkflow(args, dataItemWorkflowState, relatedItem, dataItemWorkflow);
processedItems.Add(relatedItem.ID);
}
}
}
}
public ItemWorkflowModel(Item i)
{
if (i != null)
{
_contextItem = i;
_database = i.Database;
if (_database != null)
{
_workflowProvider = _database.WorkflowProvider;
if (_workflowProvider != null)
{
_workflow = _workflowProvider.GetWorkflow(ContextItem);
if (_workflow != null)
{
_workflowState = _workflow.GetState(ContextItem);
}
}
}
}
}
public ItemWorkflowModel(Item i)
{
if (i != null)
{
_contextItem = i;
_database = i.Database;
if (_database != null)
{
_workflowProvider = _database.WorkflowProvider;
if (_workflowProvider != null)
{
_workflow = _workflowProvider.GetWorkflow(ContextItem);
if (_workflow != null)
{
_workflowState = _workflow.GetState(ContextItem);
}
}
}
}
}
/// <summary>Gets the commands.</summary>
/// <param name="items">The items to get commands for.</param>
/// <param name="workflow">The workflow.</param>
/// <param name="commands">The commands.</param>
private static void GetCommands(Item[] items, out IWorkflow workflow, out WorkflowCommand[] commands)
{
Assert.ArgumentNotNull((object)items, "items");
Item obj = items[0];
if (obj != null)
{
IWorkflowProvider workflowProvider = Context.ContentDatabase.WorkflowProvider;
if (workflowProvider != null && workflowProvider.GetWorkflows().Length > 0)
{
workflow = workflowProvider.GetWorkflow(obj);
if (workflow != null && workflow.GetState(obj) != null)
{
commands = WorkflowFilterer.FilterVisibleCommands(workflow.GetCommands(obj), obj);
return;
}
}
}
workflow = (IWorkflow)null;
commands = (WorkflowCommand[])null;
}
public void Process(WorkflowPipelineArgs args)
{
// Item being workflowed
Item workflowItem = args.DataItem;
IWorkflow wf = this.master.WorkflowProvider.GetWorkflow(workflowItem);
if (workflowItem.IsProjectItem())
{
// Move item to the project workflow
using (new SecurityDisabler())
{
workflowItem.Editing.BeginEdit();
workflowItem["__Workflow"] = Data.ProjectWorkflow.ToString();
workflowItem["__Workflow state"] = Data.ProjectWorkflowReadytoGoLiveState.ToString();
workflowItem["OrigionalWorkflow"] = wf.WorkflowID;
workflowItem.Editing.EndEdit();
}
wf = this.master.WorkflowProvider.GetWorkflow(Data.ProjectWorkflow.ToString());
wf.Start(workflowItem);
}
else
{
// get current state
var state = wf.GetState(workflowItem);
var cmds = wf.GetCommands(state.StateID);
foreach (var cmd in cmds)
{
if (cmd.SuppressComment)
{
wf.Execute(cmd.CommandID, workflowItem, "", false);
return;
}
}
}
return;
}
private void SendAll(Message message)
{
IWorkflowProvider workflowProvider = Context.ContentDatabase.WorkflowProvider;
if (workflowProvider != null)
{
string workflowID = message["wf"];
string stateID = message["ws"];
IWorkflow workflow = workflowProvider.GetWorkflow(workflowID);
if (workflow != null)
{
WorkflowState state = workflow.GetState(stateID);
DataUri[] items = this.GetItems(state, workflow);
string comments = (state != null) ? state.DisplayName : string.Empty;
bool flag = false;
foreach (DataUri uri in items)
{
Item item = Context.ContentDatabase.Items[uri];
if (item != null)
{
try
{
workflow.Execute(message["command"], item, comments, true, new object[0]);
}
catch (WorkflowStateMissingException)
{
flag = true;
}
}
}
if (flag)
{
SheerResponse.Alert("One or more items could not be processed because their workflow state does not specify the next step.", new string[0]);
}
Context.ClientPage.ClientResponse.SetLocation(string.Empty);
}
}
}
protected void Run(ClientPipelineArgs args)
{
Assert.ArgumentNotNull((object)args, "args");
bool flag1 = args.IsPostBack;
if (args.Parameters["checkmodified"] == "1")
{
if (!flag1)
{
if (Context.ClientPage.Modified)
{
SheerResponse.CheckModified(true);
args.WaitForPostBack();
return;
}
}
else if (args.Result == "cancel")
{
return;
}
args.Parameters["checkmodified"] = (string)null;
flag1 = false;
}
string comments = string.Empty;
bool flag2 = StringUtil.GetString(new string[1]
{
args.Parameters["ui"]
}) != "1";
bool flag3 = StringUtil.GetString(new string[1]
{
args.Parameters["suppresscomment"]
}) == "1";
if (!flag1 && flag2 && !flag3)
{
SheerResponse.Input("Enter a comment:", "");
args.WaitForPostBack();
}
else
{
if (flag1)
{
if (args.Result == "null")
{
return;
}
comments = args.Result;
}
IWorkflowProvider workflowProvider = Sitecore.Client.ContentDatabase.WorkflowProvider;
if (workflowProvider != null)
{
IWorkflow workflow = workflowProvider.GetWorkflow(args.Parameters["workflowid"]);
if (workflow != null)
{
Item obj = Sitecore.Client.ContentDatabase.Items[args.Parameters["id"],
Language.Parse(args.Parameters["language"]),
Sitecore.Data.Version.Parse(args.Parameters["version"])];
if (obj != null)
{
var workflowState = workflow.GetState(obj);
var repository = new WorxboxItemsRepository(workflow);
try
{
if (repository.IsWorxboxItem(workflowState, new DataUri(obj.Uri)) && repository.GetWorkflowCommandIDs().Any(x => x == ID.Parse(args.Parameters["commandid"])))
{
var items =
repository.GetWorxboxItems(
repository.GetWorxboxWorkflowStates(workflow)
.First(x => x.WorkflowCommands.Any(y => y.CommandID == args.Parameters["commandid"])), obj);
foreach (var compositeItem in items)
{
var compositeWorkflowResult = workflow.Execute(args.Parameters["commandid"], compositeItem, comments, true);
if (!compositeWorkflowResult.Succeeded)
{
if (!string.IsNullOrEmpty(compositeWorkflowResult.Message))
{
SheerResponse.Alert(compositeWorkflowResult.Message);
}
}
}
}
WorkflowResult workflowResult = workflow.Execute(args.Parameters["commandid"], obj, comments, true);
if (!workflowResult.Succeeded)
{
if (!string.IsNullOrEmpty(workflowResult.Message))
{
SheerResponse.Alert(workflowResult.Message);
}
}
}
catch (WorkflowStateMissingException ex)
{
SheerResponse.Alert("One or more items could not be processed because their workflow state does not specify the next step.");
}
}
}
}
Context.ClientPage.SendMessage((object)this, "item:refresh");
SheerResponse.Eval("window.top.location.reload();");
}
}
/// <summary>
/// Loads data for the Incremental Publish Queue report (includes all item languages). Utilizes Sitecore.Publishing.Pipelines.Publish.GetPublishQueue(PublishOptions) method as a source of data, then augments it based on item workflow state: only returns items in a final workflow state.
/// </summary>
/// <param name="languageCode">Language code to load. Default is "en". Must otherwise use fully-qualified language code (example: "ja-JP").</param>
/// <returns>Enumerable of publish candidate items.</returns>
public IEnumerable <PublishQueueItem> IncrementalPublishQueue_GetData()
{
Database masterDB = Database.GetDatabase(Sitecore.Configuration.Settings.GetSetting("SitecoreSpark.SPRK.SourceDatabase"));
Database webDB = Database.GetDatabase(Sitecore.Configuration.Settings.GetSetting("SitecoreSpark.SPRK.TargetDatabase"));
List <PublishQueueItem> model = new List <PublishQueueItem>();
// Note on language: the actual publish pipeline uses the language parameter; it doesn't matter what we pass in for this usage
PublishOptions options = new PublishOptions(masterDB, webDB, PublishMode.Incremental, Language.Parse("en"), DateTime.Now.AddDays(1));
IEnumerable <PublishingCandidate> candidateList = PublishQueue.GetPublishQueue(options);
if (candidateList != null && candidateList.Count() > 0)
{
foreach (PublishingCandidate candidate in candidateList)
{
// Get detailed item information (including workflow info for inclusion/exclusion on report)
Item scItem = masterDB.GetItem(itemId: candidate.ItemId);
// If scItem is null, it likely means an item was deleted from 'master' before a publish (and still exists in the PublishQueue table); safe to ignore
if (scItem == null)
{
Sitecore.Diagnostics.Log.Warn($"[SPRK] PublishQueue item not found in '{masterDB.Name}' database: {candidate.ItemId}.", this);
continue;
}
// Check for all language versions (Workflow is shared, but Workflow State may be unique across languages)
foreach (Language language in scItem.Languages)
{
Item scLanguageItem = masterDB.GetItem(itemId: scItem.ID, language: language);
// Alt language versions do not automatically have a version number, so it's worth a check before proceeded
if (scLanguageItem.Versions.Count == 0)
{
continue;
}
IWorkflow itemWorkflow = masterDB.WorkflowProvider.GetWorkflow(scLanguageItem);
if (itemWorkflow == null)
{
continue;
}
WorkflowState state = itemWorkflow.GetState(scLanguageItem);
if (state != null && state.FinalState)
{
// Map to domain model
model.Add(new PublishQueueItem()
{
ItemID = candidate.ItemId.Guid,
ItemName = scItem.Name,
Language = language.Name,
Action = candidate.PublishAction.ToString(),
SourceDatabase = candidate.PublishOptions.SourceDatabase.Name,
TargetDatabase = candidate.PublishOptions.TargetDatabase.Name
});
}
}
}
}
return(model);
}
