protected override void OnInit(EventArgs e)
{
base.OnInit(e);
// Disable confirm changes checking
DocumentManager.RegisterSaveChangesScript = false;
// Init node
workflowElem.Node = Node;
workflow = DocumentManager.Workflow;
if (workflow != null)
{
menuElem.OnClientStepChanged = ClientScript.GetPostBackEventReference(pnlUp, null);
// Backward compatibility - Display Archive button for all steps
menuElem.ForceArchive = workflow.IsBasic;
}
// Enable split mode
EnableSplitMode = true;
// Mark selected tab
UIContext.ProductTab = ProductTabEnum.Workflow;
}
protected override void OnInit(EventArgs e)
{
base.OnInit(e);
if (!MembershipContext.AuthenticatedUser.IsAuthorizedPerUIElement("CMS.Content", "Properties.Workflow"))
{
RedirectToUIElementAccessDenied("CMS.Content", "Properties.Workflow");
}
DocumentManager.OnCheckPermissions += DocumentManager_OnCheckPermissions;
// Disable confirm changes checking
DocumentManager.RegisterSaveChangesScript = false;
// Init node
workflowElem.Node = Node;
workflow = DocumentManager.Workflow;
if (workflow != null)
{
menuElem.OnClientStepChanged = ClientScript.GetPostBackEventReference(pnlUp, null);
// Backward compatibility - Display Archive button for all steps
menuElem.ForceArchive = workflow.IsBasic;
}
// Enable split mode
EnableSplitMode = true;
SetPropertyTab(TAB_WORKFLOW);
}
protected void btnNewFolder_OnComplete(object source, WorkflowInfo info)
{
int selectedFolderId = -1;
if (chkTreeview.Checked) {
if (contentTree.GetSelectedCount() > 0) {
selectedFolderId = new CKeyNLR(contentTree.GetSelectedValues().GetFirst()).NodeId;
}
}
CKeyNLRC key = (CKeyNLRC)info.OutputParameters["NewContentKeyC"];
if (key != null) {
ContentBase newContent = WAFContext.Session.GetContent<ContentBase>(key);
if (newContent is ContentFile && selectedFolderId > -1) {
((ContentFile)newContent).Folder.Set(selectedFolderId);
newContent.UpdateChanges();
}
if (newContent is FileFolder && selectedFolderId > -1) {
((FileFolder)newContent).ParentFolder.Set(selectedFolderId);
contentTree.DataBind();
newContent.UpdateChanges();
}
contentTree.SetSelected(key.NodeId);
contentTree.DataBind();
}
}
protected override void OnInit(EventArgs e)
{
base.OnInit(e);
// Check UIProfile
if (!CMSContext.CurrentUser.IsAuthorizedPerUIElement("CMS.OnlineMarketing", new string[] { "OMCMGroup", "ContactsFrameset", "PendingContacts" }, CMSContext.CurrentSiteName))
{
RedirectToCMSDeskUIElementAccessDenied("CMS.OnlineMarketing", "OMCMGroup;ContactsFrameset;PendingContacts");
}
bool dialogMode = QueryHelper.GetBoolean("dialogmode", false);
if (dialogMode)
{
RegisterModalPageScripts();
}
autoMan.OnAfterAction += AutomationManager_OnAfterAction;
autoMan.StateObjectID = QueryHelper.GetInteger("stateid", 0);
workflow = autoMan.Process;
if (workflow != null)
{
menuElem.OnClientStepChanged = ClientScript.GetPostBackEventReference(pnlUp, null);
}
}
/// <summary>
/// Saves new wokflow's data into DB.
/// </summary>
/// <returns>Returns ID of created wokflow</returns>
protected int SaveNewWorkflow()
{
WorkflowInfo wi = new WorkflowInfo();
wi.WorkflowDisplayName = txtWorkflowDisplayName.Text;
wi.WorkflowName = txtWorkflowCodeName.Text;
WorkflowInfoProvider.SetWorkflowInfo(wi);
return wi.WorkflowID;
}
bool WorkflowStatusChanged(WorkflowInfo workflow)
{
var changed = _workflowsPerId[workflow.Id].IsRunning != workflow.IsRunning || _workflowsPerId[workflow.Id].IsPaused != workflow.IsPaused;
_workflowsPerId[workflow.Id].IsRunning = workflow.IsRunning;
_workflowsPerId[workflow.Id].IsPaused = workflow.IsPaused;
return(changed);
}
/// <summary>
/// Moves the document to the previous step in the workflow process. Called when the "Move to previous step" button is pressed.
/// Expects the "CreateExampleObjects" and "MoveToNextStep" method to be run first.
/// </summary>
private bool MoveToPreviousStep()
{
TreeProvider tree = new TreeProvider(CMSContext.CurrentUser);
// Prepare parameters
string siteName = CMSContext.CurrentSiteName;
string aliasPath = "/API-Example";
string culture = "en-us";
bool combineWithDefaultCulture = false;
string classNames = TreeProvider.ALL_CLASSNAMES;
string where = null;
string orderBy = null;
int maxRelativeLevel = -1;
bool selectOnlyPublished = false;
string columns = null;
// Get the document
TreeNode node = DocumentHelper.GetDocument(siteName, aliasPath, culture, combineWithDefaultCulture, classNames, where, orderBy, maxRelativeLevel, selectOnlyPublished, columns, tree);
if (node != null)
{
WorkflowManager workflowManager = WorkflowManager.GetInstance(tree);
WorkflowInfo workflow = workflowManager.GetNodeWorkflow(node);
// Check if the document uses workflow
if (workflow != null)
{
// Check if the workflow doesn't use automatic publishing, otherwise, documents can't change workflow steps.
if (!workflow.WorkflowAutoPublishChanges)
{
// Check if the current user can move the document to the next step
if (workflowManager.CheckStepPermissions(node, WorkflowActionEnum.Reject))
{
// Move the document to the previous step
workflowManager.MoveToPreviousStep(node, null);
return(true);
}
else
{
apiMoveToPreviousStep.ErrorMessage = "You are not authorized to reject the document.";
}
}
else
{
apiMoveToPreviousStep.ErrorMessage = "The document uses versioning without workflow, changes are published automatically.";
}
}
else
{
apiMoveToPreviousStep.ErrorMessage = "The document doesn't use workflow.";
}
}
return(false);
}
/// <summary>
/// 验证
/// </summary>
/// <param name="returnInfo">返回信息</param>
/// <param name="workflow">工作流</param>
/// <param name="comData">通用数据</param>
protected override void Vali(ReturnInfo <bool> returnInfo, WorkflowInfo workflow, CommonUseData comData = null)
{
var user = UserTool <int> .GetCurrUser(comData);
if (workflow.CreaterId != user.Id)
{
returnInfo.SetFailureMsg("Sorry，您不是此流程的发起者，故不能撤消");
return;
}
switch (workflow.FlowStatus)
{
case FlowStatusEnum.DRAFT:
returnInfo.SetFailureMsg("Sorry，此流程是草稿状态不能撤消");
return;
case FlowStatusEnum.REVERSED:
returnInfo.SetFailureMsg("Sorry，此流程已经撤消，不能重复撤消");
return;
case FlowStatusEnum.AUDIT_PASS:
returnInfo.SetFailureMsg("Sorry，此流程已经审核通过，不能撤消");
return;
case FlowStatusEnum.AUDIT_NOPASS:
returnInfo.SetFailureMsg("Sorry，此流程已经审核不通过，不能撤消");
return;
case FlowStatusEnum.AUDITING:
// 只有所有审核者未读才允许撤消
foreach (var h in workflow.Handles)
{
// 本人处理忽略
if (h.HandlerId == user.Id)
{
continue;
}
if (h.IsReaded)
{
returnInfo.SetFailureMsg("Sorry，此流程已经被审核者读过，不能撤消");
return;
}
}
return;
default:
returnInfo.SetFailureMsg("Sorry，此流程未知状态，不能撤消");
return;
}
}
public static string ExtractWorkflowInfoJson(Diagram diagram)
{
var info = new WorkflowInfo()
{
Key = diagram.Tag.ToString()
};
return(JsonConvert.SerializeObject(info));
}
/// <summary>
/// Saves new wokflow's data into DB.
/// </summary>
/// <returns>Returns ID of created wokflow</returns>
protected int SaveNewWorkflow()
{
WorkflowInfo wi = new WorkflowInfo();
wi.WorkflowDisplayName = txtWorkflowDisplayName.Text;
wi.WorkflowName = txtWorkflowCodeName.Text;
WorkflowInfoProvider.SetWorkflowInfo(wi);
return(wi.WorkflowID);
}
//更新工作流
public int UpdateWorkflow(WorkflowInfo flow)
{
if (flow.CreateTime < DateTime.Now.AddYears(-10))
{
flow.CreateTime = DateTime.Now;
}
flow.LastUpdateTime = DateTime.Now;
if (flow.AuditSteps != null && flow.AuditSteps.Count > 0)
{
if (SqlHelper.Update(flow) > 0)
{
DeleteWorkfowSteps(flow.FlowType);
foreach (var step in flow.AuditSteps)
{
step.FlowType = flow.FlowType;
if (step.AuditUserId < 1 && step.AuditUser != null)
{
step.AuditUserId = step.AuditUser.UserId;
}
if (step.AuditRoleId < 1 && step.AuditRole != null)
{
step.AuditRoleId = step.AuditRole.RoleId;
}
if (string.IsNullOrEmpty(step.AuditOrgId) && step.AuditOrganization != null)
{
step.AuditOrgId = step.AuditOrganization.Id;
}
if (step.AuditType == AuditType.JointCheckup)
{
if (step.JcUsers != null && step.JcUsers.Count > 0)
{
SqlHelper.Insert(step);
foreach (var jcu in step.JcUsers)
{
jcu.StepId = step.StepId;
if (jcu.UserId < 1 && jcu.UserInfo != null)
{
jcu.UserId = jcu.UserInfo.UserId;
}
SqlHelper.Insert(jcu);
}
}
}
else
{
SqlHelper.Insert(step);
}
}
return(1);
}
return(-1);
}
return(-2);
}
//删除工作流
public int DeleteWorkflow(WorkflowInfo flow)
{
if (flow != null)
{
flow.LastUpdateTime = DateTime.Now;
flow.Status = ActiveStatus.Deleted;
return(SqlHelper.Update(flow));
}
return(-2);
}
/// <summary>
/// Deletes process. Called when the "Delete process" button is pressed.
/// Expects the CreateProcess method to be run first.
/// </summary>
private bool DeleteProcess()
{
// Get the process
WorkflowInfo deleteProcess = WorkflowInfoProvider.GetWorkflowInfo("MyNewProcess", WorkflowTypeEnum.Automation);
// Delete the process
WorkflowInfoProvider.DeleteWorkflowInfo(deleteProcess);
return(deleteProcess != null);
}
/// <summary>
/// 将 流程图形 信息转化成 info 信息
/// </summary>
/// <param name="link"></param>
/// <returns></returns>
public static WorkflowInfo ExtractWorkflowInfo(DiagramPageViewModel diagram)
{
WorkflowInfo wfInfo = new WorkflowInfo()
{
Key = diagram.Key,
Name = diagram.Name
};
return(wfInfo);
}
public void Test_GettersSetters()
{
const string file = "test-file";
var actionWorkflow = new ActionWorkflow();
var wfi = new WorkflowInfo(file, actionWorkflow);
Assert.NotNull(wfi.File);
Assert.Equal(file, wfi.File.FilePath);
Assert.Same(actionWorkflow, wfi.Workflow);
}
/// <summary>
/// Deletes workflow. Called when the "Delete workflow" button is pressed.
/// Expects the CreateWorkflow method to be run first.
/// </summary>
private bool DeleteWorkflow()
{
// Get the workflow
WorkflowInfo deleteWorkflow = WorkflowInfoProvider.GetWorkflowInfo("MyNewWorkflow", WorkflowTypeEnum.Approval);
// Delete the workflow
WorkflowInfoProvider.DeleteWorkflowInfo(deleteWorkflow);
return(deleteWorkflow != null);
}
public static void ProcessDatetime(WorkflowInfo wfInfo)
{
wfInfo.StartTime = wfInfo.StartTime.ToLocalTime();
wfInfo.EndTime = wfInfo.EndTime.ToLocalTime();
foreach (ActivityInfo act in wfInfo.Activities)
{
act.StartTime = act.StartTime.ToLocalTime();
act.EndTime = act.EndTime.ToLocalTime();
}
}
private static string GetWorkflowID(Item item)
{
Assert.ArgumentNotNull(item, "item");
WorkflowInfo workflowInfo = item.Database.DataManager.GetWorkflowInfo(item);
if (workflowInfo != null)
{
return(workflowInfo.WorkflowID);
}
return(string.Empty);
}
private static void DoProcessCallbackAction(WorkflowInfo workflowInfo, Action <IWfProcess> action)
{
(workflowInfo != null).FalseThrow(Translator.Translate(Define.DefaultCulture, "不能获取到当前流程信息"));
IWfProcess currentProcess = WfRuntime.GetProcessByProcessID(workflowInfo.Key);
WfClientContext.Current.ChangeTo(currentProcess.CurrentActivity);
WfClientContext.Current.InAdminMode.FalseThrow(Translator.Translate(Define.DefaultCulture, "您没有权限执行此操作"));
action(currentProcess);
}
private bool WorkflowStatusChanged(WorkflowInfo workflow)
{
if (_workflowsPerId.ContainsKey(workflow.Id))
{
var changed = _workflowsPerId[workflow.Id].IsRunning != workflow.IsRunning || _workflowsPerId[workflow.Id].IsPaused != workflow.IsPaused;
_workflowsPerId[workflow.Id].IsRunning = workflow.IsRunning;
_workflowsPerId[workflow.Id].IsPaused = workflow.IsPaused;
return(changed);
}
return(false);
}
public override bool Equals(object obj)
{
WorkflowInfo other = obj as WorkflowInfo;
if (other != null)
{
return(other.AssemblyFullName.Equals(this.AssemblyFullName) && other.TypeFullName.Equals(this.TypeFullName));
}
else
{
return(false);
}
}
protected override void OnInit(EventArgs e)
{
base.OnInit(e);
autoMan.OnAfterAction += AutomationManager_OnAfterAction;
autoMan.StateObjectID = QueryHelper.GetInteger("stateid", 0);
workflow = autoMan.Process;
if (workflow != null)
{
menuElem.OnClientStepChanged = ClientScript.GetPostBackEventReference(pnlUp, null);
}
}
protected override void OnInit(EventArgs e)
{
base.OnInit(e);
autoMan.OnAfterAction += AutomationManager_OnAfterAction;
autoMan.StateObjectID = QueryHelper.GetInteger("stateid", 0);
workflow = autoMan.Process;
if (workflow != null)
{
menuElem.OnClientStepChanged = ClientScript.GetPostBackEventReference(pnlUp, null);
}
}
private WorkflowInfo GetPostedProcessInfo()
{
string data = this.Page.Request.Form[this.WfRuntimeViewerWorkflowInfoHiddenFieldID];
WorkflowInfo result = null;
if (data.IsNotEmpty())
{
result = JSONSerializerExecute.Deserialize <WorkflowInfo>(data);
}
return(result);
}
void IInitializeWorkflowManager.Initialize(WorkflowInfo input)
{
if (WorkflowNotContainsWithoutParametersConstructor(input))
{
throw new Exception("У типа задающего ворклфоу должен быть безпараметрический конструктор");
}
var services = input.WorkflowName.GetNestedTypes().Select(_serviceProvider.GetService).ToList();
var chainMethodParameter = services.Select(x => new
{
method = x.GetType().GetMethod("Handle"),
parameter = x.GetType().GetParametersByMethodName("Handle").FirstOrDefault()
})
.Where(x => x.parameter != default)
.ToList();
var parameterInfosList = chainMethodParameter.ToList();
ChainTypes = chainMethodParameter.SkipLast(1)
.Aggregate(new[] { typeof(TIn) }.AsEnumerable(), (a, c) =>
{
var currentHandlerInChain = parameterInfosList.First(x => x.parameter == a.Last());
return(a.Concat(currentHandlerInChain.method.GetGenericTypesReturnValue()));
})
.Concat(new[] { typeof(TOut) })
.ToList();
foreach (var service in services)
{
var voidHandler = _voidHandlersFactory.Create((dynamic)service);
if (voidHandler != null)
{
_voidHandlersExecutor.AddHandler(voidHandler);
continue;
}
var rollBackHandler = _rollBackHandlerFactory.Create((dynamic)service);
if (rollBackHandler != null)
{
_rollBackHandlersExecutor.AddHandler(rollBackHandler);
}
var resultHandler = _resultHandlersFactory.Create((dynamic)service);
if (resultHandler != null)
{
_resultHandlersExecutor.AddHandler(resultHandler);
}
}
}
/// <summary>
/// Reverts back the changes made in the latest version if check-in/check-out is used. Called when the "Undo check-out" button is pressed.
/// Expects the "CreateExampleObjects" and "CheckOut" methods to be run first.
/// </summary>
private bool UndoCheckout()
{
TreeProvider tree = new TreeProvider(CMSContext.CurrentUser);
// Prepare parameters
string siteName = CMSContext.CurrentSiteName;
string aliasPath = "/API-Example";
string culture = "en-us";
bool combineWithDefaultCulture = false;
string classNames = TreeProvider.ALL_CLASSNAMES;
string where = null;
string orderBy = null;
int maxRelativeLevel = -1;
bool selectOnlyPublished = false;
string columns = null;
// Get the document
TreeNode node = DocumentHelper.GetDocument(siteName, aliasPath, culture, combineWithDefaultCulture, classNames, where, orderBy, maxRelativeLevel, selectOnlyPublished, columns, tree);
if (node != null)
{
WorkflowManager workflowmanager = WorkflowManager.GetInstance(tree);
// Make sure the document uses workflow
WorkflowInfo workflow = workflowmanager.GetNodeWorkflow(node);
if (workflow != null)
{
if (node.IsCheckedOut)
{
VersionManager versionmanager = VersionManager.GetInstance(tree);
// Undo the checkout
versionmanager.UndoCheckOut(node);
return(true);
}
else
{
apiUndoCheckout.ErrorMessage = "The document hasn't been checked out.";
}
}
else
{
apiUndoCheckout.ErrorMessage = "The document doesn't use workflow.";
}
}
return(false);
}
public ResultModel <WorkflowInfo> GetLastVersionWorkflow(int id)
{
var result = new ResultModel <WorkflowInfo>();
try
{
var workflowEngine = new WorkflowEngine(_configuration, _workflowConfig, true);
var wf = workflowEngine.GetLastVersionWorkflow(id);
if (wf != null)
{
var workflowInfo = new WorkflowInfo
{
Id = wf.Id,
Name = wf.Name,
LaunchType = (workflow.Core.Service.Contracts.LaunchType)wf.LaunchType,
IsEnabled = wf.IsEnabled,
Description = wf.Description,
IsRunning = wf.IsRunning,
IsPaused = wf.IsPaused,
Period = wf.Period.ToString(@"dd\.hh\:mm\:ss"),
Path = wf.WorkflowFilePath,
IsExecutionGraphEmpty = wf.IsExecutionGraphEmpty,
DeadLine = wf.DeadLine,
Version = wf.Version,
VersionDescription = wf.VersionDescription,
Graph = workflowEngine.GetJsonGraph(wf.Name + "_" + wf.Version + ".json"),
Tasks = wf.Tasks.Select(x => new TaskInfo
{
Description = x.Description,
Id = x.Id,
IsCommon = x.IsCommon,
IsEnabled = x.IsEnabled,
Name = x.Name,
DeadLine = x.DeadLine,
Settings = x.Settings.Select(y => new SettingInfo
{
Name = y.Name,
Value = y.Value
}).ToList()
}).ToList()
};
result.Data = workflowInfo;
}
}
catch (Exception ex)
{
result.Succeed = false;
result.ErrorMessage = ex.Message.ToString();
}
return(result);
}
private static void DoProcessCallbackOp(WorkflowInfo workflowInfo, Func <IWfProcess, WfExecutorBase> getExecutor)
{
(workflowInfo != null).FalseThrow(Translator.Translate(Define.DefaultCulture, "不能获取到当前流程信息"));
IWfProcess currentProcess = WfRuntime.GetProcessByProcessID(workflowInfo.Key);
WfClientContext.Current.ChangeTo(currentProcess.CurrentActivity);
WfClientContext.Current.InAdminMode.FalseThrow(Translator.Translate(Define.DefaultCulture, "您没有权限执行此操作"));
WfExecutorBase executor = getExecutor(currentProcess);
WfClientContext.Current.Execute(executor);
}
public string GetSelectedProcessInfo()
{
string strResult = "";
TabItem selectedItem = this.tabControl.SelectedItem as TabItem;
if (selectedItem != null)
{
WorkflowInfo selectedInfo = (selectedItem.DataContext as DiagramPageViewModel).WfInfo;
strResult = JsonConvert.SerializeObject(selectedInfo);
}
return(strResult);
}
private void CreateWorkflow(int wfId)
{
var w1 = new WorkflowInfo();
w1.Name = $"workflow{wfId}";
w1.ConfigFile = $"workflow{wfId}.xml";
var evlog1 = new EVLogInfo()
{
Description = "EV1 Description ",
ConfigFilePath = "",
};
w1.EVLogs.Add(evlog1);
}
private void AddNewCommandExecuted(WorkflowInfo info)
{
if (info == null)
{
throw new ArgumentNullException("WorkflowInfo不能为空");
}
WorkflowUtils.ProcessDatetime(info);
DiagramPageViewModel vw = new DiagramPageViewModel(info);
vw.RequestClose += this.Item_RequestClose;
this.DiagramDataSource.Add(vw);
this.OnPropertyChanged("DiagramDataSource");
}
private void ExecuteCreateAction(int templateId)
{
if (templateId == CREATE_FROM_SCRATCH_ID)
{
mWorkflow = AutomationHelper.CreateEmptyWorkflow();
}
else
{
var template = AutomationTemplateInfo.Provider.Get(templateId);
if (template != null)
{
mWorkflow = AutomationTemplateManager.CreateAutomationProcessFromTemplate(template, MacroIdentityOption.FromUserInfo(CurrentUser));
}
}
}
public string GetSelectedCurrentProcessWfInfo()
{
string strResult = "";
TabItem selectedItem = this.tabControl.SelectedItem as TabItem;
if (selectedItem != null)
{
WorkflowInfo selectedInfo = (selectedItem.DataContext as DiagramPageViewModel).WfInfo;
strResult = string.Format("{0},{1}", selectedInfo.ResourceID, selectedInfo.Key);
//strResult = JsonConvert.SerializeObject(selectedInfo);
}
return(strResult);
}
private void AddNewCommandExecuted(WorkflowInfo info)
{
if (info == null)
{
throw new ArgumentNullException("WorkflowInfo不能为空");
}
DiagramPageViewModel vw = new DiagramPageViewModel(info, WebInterAct);
vw.RequestClose += this.Item_RequestClose;
this.DiagramDataSource.Add(vw);
WebInterAct.LoadProperty(WorkflowUtils.CLIENTSCRIPT_PARAM_WORKFLOW,
vw.Key,
WorkflowUtils.ExtractWorkflowInfoJson(vw));
}
/// <summary>
/// Converts existing workflow to advanced workflow. Called when the "Convert to advanced workflow" button is pressed.
/// Expects the CreateWorkflow method to be run first.
/// </summary>
private bool ConvertToAdvancedWorkflow()
{
// Get the workflow
WorkflowInfo convertWorkflow = WorkflowInfoProvider.GetWorkflowInfo("MyNewWorkflow");
if (convertWorkflow != null)
{
// Convert to advanced workflow
WorkflowInfoProvider.ConvertToAdvancedWorkflow(convertWorkflow.WorkflowID);
return(true);
}
return(false);
}
/// <summary>
/// 验证
/// </summary>
/// <param name="returnInfo">返回信息</param>
/// <param name="workflow">工作流</param>
protected override void Vali(ReturnInfo <bool> returnInfo, WorkflowInfo workflow)
{
if (workflow.CreaterId != UserTool.CurrUser.Id)
{
returnInfo.SetFailureMsg("Sorry，您不是此流程的发起者，故不能移除");
return;
}
if (workflow.FlowStatus != FlowStatusEnum.DRAFT)
{
returnInfo.SetFailureMsg("Sorry，只有草稿状态才能移除");
return;
}
}
protected override void OnInit(EventArgs e)
{
base.OnInit(e);
// Check UIProfile
if (!MembershipContext.AuthenticatedUser.IsAuthorizedPerUIElement("cms.onlinemarketing", "MyContacts" , SiteContext.CurrentSiteName))
{
RedirectToUIElementAccessDenied("cms.onlinemarketing", "MyContacts");
}
autoMan.OnAfterAction += AutomationManager_OnAfterAction;
autoMan.StateObjectID = QueryHelper.GetInteger("stateid", 0);
workflow = autoMan.Process;
if (workflow != null)
{
menuElem.OnClientStepChanged = ClientScript.GetPostBackEventReference(pnlUp, null);
}
}
protected override void OnInit(EventArgs e)
{
base.OnInit(e);
// Init node
workflowElem.Node = Node;
workflow = DocumentManager.Workflow;
if (workflow != null)
{
menuElem.OnClientStepChanged = ClientScript.GetPostBackEventReference(pnlUp, null);
// Backward compatibility - Display Archive button for all steps
menuElem.ForceArchive = workflow.IsBasic;
}
// Enable split mode
EnableSplitMode = true;
}
protected override void OnInit(EventArgs e)
{
base.OnInit(e);
// Check UIProfile
if (!CMSContext.CurrentUser.IsAuthorizedPerUIElement("CMS.MyDesk", new string[] { "MyDeskDocuments", "Pending", "Contacts" }, CMSContext.CurrentSiteName))
{
RedirectToCMSDeskUIElementAccessDenied("CMS.MyDesk", "MyDeskDocuments;Pending;Contacts");
}
autoMan.OnAfterAction += AutomationManager_OnAfterAction;
autoMan.StateObjectID = QueryHelper.GetInteger("stateid", 0);
workflow = autoMan.Process;
if (workflow != null)
{
menuElem.OnClientStepChanged = ClientScript.GetPostBackEventReference(pnlUp, null);
}
}
/// <summary>
/// Creates workflow. Called when the "Create workflow" button is pressed.
/// </summary>
private bool CreateWorkflow()
{
// Create new workflow object
WorkflowInfo newWorkflow = new WorkflowInfo();
// Set the properties
newWorkflow.WorkflowDisplayName = "My new workflow";
newWorkflow.WorkflowName = "MyNewWorkflow";
// Save the workflow
WorkflowInfoProvider.SetWorkflowInfo(newWorkflow);
// Create the three default workflow steps
WorkflowStepInfoProvider.CreateDefaultWorkflowSteps(newWorkflow);
return true;
}
/// <summary>
/// Gets and bulk updates workflows. Called when the "Get and bulk update workflows" button is pressed.
/// Expects the CreateWorkflow method to be run first.
/// </summary>
private bool GetAndBulkUpdateWorkflows()
{
// Prepare the parameters
string where = "WorkflowName LIKE N'MyNewWorkflow%'";
// Get the data
DataSet workflows = WorkflowInfoProvider.GetWorkflows(where, null, 0, null);
if (!DataHelper.DataSourceIsEmpty(workflows))
{
// Loop through the individual items
foreach (DataRow workflowDr in workflows.Tables[0].Rows)
{
// Create object from DataRow
WorkflowInfo modifyWorkflow = new WorkflowInfo(workflowDr);
// Update the properties
modifyWorkflow.WorkflowDisplayName = modifyWorkflow.WorkflowDisplayName.ToUpper();
// Save the changes
WorkflowInfoProvider.SetWorkflowInfo(modifyWorkflow);
}
return true;
}
return false;
}
protected void Page_Load(object sender, EventArgs e)
{
// Initialize form and controls
Title = "Workflow Edit - General";
rfvCodeName.ErrorMessage = GetString("Development-Workflow_New.RequiresCodeName");
RequiredFieldValidatorDisplayName.ErrorMessage = GetString("Development-Workflow_New.RequiresDisplayName");
if (QueryHelper.GetInteger("saved", 0) == 1)
{
lblInfo.Visible = true;
lblInfo.Text = GetString("General.ChangesSaved");
}
// Get ID of workflow from querystring
workflowId = QueryHelper.GetInteger("workflowid", 0);
if (workflowId > 0)
{
currentWorkflow = WorkflowInfoProvider.GetWorkflowInfo(workflowId);
// Set edited object
EditedObject = currentWorkflow;
}
if (!RequestHelper.IsPostBack() && (currentWorkflow != null))
{
txtCodeName.Text = currentWorkflow.WorkflowName;
TextBoxWorkflowDisplayName.Text = currentWorkflow.WorkflowDisplayName;
chkAutoPublish.Checked = currentWorkflow.WorkflowAutoPublishChanges;
bool? useCheckInCheckOut = currentWorkflow.WorkflowUseCheckinCheckout;
// Is enabled or disabled check-in/check-out
if (useCheckInCheckOut.HasValue)
{
radYes.Checked = useCheckInCheckOut.Value;
radNo.Checked = !useCheckInCheckOut.Value;
}
// Inherit from global settings
else
{
radSiteSettings.Checked = true;
}
}
}
public void StartWorkflow(Type workflowType,Dictionary<string,object> inparms,Guid caller,IComparable qn)
{
WorkflowRuntime wr = this.Runtime;
WorkflowInstance wi = wr.CreateWorkflow(workflowType,inparms);
wi.Start();
var instanceId = wi.InstanceId;
_WorkflowQueue[instanceId] = new WorkflowInfo { Caller = caller, qn = qn };
ManualWorkflowSchedulerService ss = wr.GetService<ManualWorkflowSchedulerService>();
if (ss != null)
ss.RunWorkflow(wi.InstanceId);
}
protected void openContent_Complete(object sender, WorkflowInfo info)
{
if (info.OutputParameters.ContainsKey("SelectedValues")) {
UniqueList<CKeyNLRC> selectedValues = (UniqueList<CKeyNLRC>)info.OutputParameters["SelectedValues"];
if (selectedValues.Count > 0) {
CKeyNLRC key = selectedValues.GetFirst();
contentForm.NodeId = key.NodeId;
contentForm.Refresh();
}
}
}
public override DataUri[] GetItemsInWorkflowState(WorkflowInfo info, CallContext context)
{
Guid workflowStateId;
if (Guid.TryParse(info.StateID, out workflowStateId))
{
var items = Provider.GetItemsInWorkflowState(workflowStateId);
var result = items.Select(x => x.FieldValues
.Where(y => y.Id == FieldIDs.WorkflowState.Guid)
.Select(y => new DataUri(new ID(x.Id), LanguageManager.GetLanguage(y.Language), new Version(y.Version ?? 1)))
).ToList();
if (result.Any())
{
return result.Aggregate((x, y) => (x ?? new DataUri[] {}).Concat(y ?? new DataUri[] {})).ToArray();
}
return new DataUri[] {};
}
return new DataUri[] {};
}
public override bool SetWorkflowInfo(ItemDefinition item, VersionUri version, WorkflowInfo info, CallContext context)
{
return base.SetWorkflowInfo(item, version, info, context);
}
/// <summary>
/// Provides operations necessary to create and store new cms file.
/// </summary>
/// <param name="args">Upload arguments.</param>
/// <param name="context">HttpContext instance.</param>
private void HandleContentUpload(UploaderHelper args, HttpContext context)
{
bool newDocumentCreated = false;
string name = args.Name;
try
{
if (args.FileArgs.NodeID == 0)
{
throw new Exception(ResHelper.GetString("dialogs.document.parentmissing"));
}
// Check license limitations
if (!LicenseHelper.LicenseVersionCheck(URLHelper.GetCurrentDomain(), FeatureEnum.Documents, VersionActionEnum.Insert))
{
throw new Exception(ResHelper.GetString("cmsdesk.documentslicenselimits"));
}
// Check user permissions
if (!CMSContext.CurrentUser.IsAuthorizedToCreateNewDocument(args.FileArgs.NodeID, "CMS.File"))
{
throw new Exception(string.Format(ResHelper.GetString("dialogs.newfile.notallowed"), "CMS.File"));
}
// Check if class exists
DataClassInfo ci = DataClassInfoProvider.GetDataClass("CMS.File");
if (ci == null)
{
throw new Exception(string.Format(ResHelper.GetString("dialogs.newfile.classnotfound"), "CMS.File"));
}
#region "Check permissions"
// Get the node
using (TreeNode parentNode = TreeProvider.SelectSingleNode(args.FileArgs.NodeID, args.FileArgs.Culture, true))
{
if (parentNode != null)
{
if (!DataClassInfoProvider.IsChildClassAllowed(ValidationHelper.GetInteger(parentNode.GetValue("NodeClassID"), 0), ci.ClassID))
{
throw new Exception(ResHelper.GetString("Content.ChildClassNotAllowed"));
}
}
// Check user permissions
if (!CMSContext.CurrentUser.IsAuthorizedToCreateNewDocument(parentNode, "CMS.File"))
{
throw new Exception(string.Format(ResHelper.GetString("dialogs.newfile.notallowed"), args.AttachmentArgs.NodeClassName));
}
}
#endregion
args.IsExtensionAllowed();
if (args.FileArgs.IncludeExtension)
{
name += args.Extension;
}
// Make sure the file name with extension respects maximum file name
name = TreePathUtils.EnsureMaxFileNameLength(name, ci.ClassName);
node = TreeNode.New("CMS.File", TreeProvider);
node.DocumentCulture = args.FileArgs.Culture;
node.DocumentName = name;
if (args.FileArgs.NodeGroupID > 0)
{
node.SetValue("NodeGroupID", args.FileArgs.NodeGroupID);
}
// Load default values
FormHelper.LoadDefaultValues(node.NodeClassName, node);
node.SetValue("FileDescription", "");
node.SetValue("FileName", name);
node.SetValue("FileAttachment", Guid.Empty);
node.SetValue("DocumentType", args.Extension);
node.SetDefaultPageTemplateID(ci.ClassDefaultPageTemplateID);
// Insert the document
DocumentHelper.InsertDocument(node, args.FileArgs.NodeID, TreeProvider);
newDocumentCreated = true;
// Add the attachment data
DocumentHelper.AddAttachment(node, "FileAttachment", args.FilePath, TreeProvider, args.ResizeToWidth, args.ResizeToHeight, args.ResizeToMaxSide);
// Create default SKU if configured
if (ModuleEntry.CheckModuleLicense(ModuleEntry.ECOMMERCE, URLHelper.GetCurrentDomain(), FeatureEnum.Ecommerce, VersionActionEnum.Insert))
{
node.CreateDefaultSKU();
}
DocumentHelper.UpdateDocument(node, TreeProvider);
// Get workflow info
wi = node.GetWorkflow();
// Check if auto publish changes is allowed
if ((wi != null) && wi.WorkflowAutoPublishChanges && !wi.UseCheckInCheckOut(CMSContext.CurrentSiteName))
{
// Automatically publish document
node.MoveToPublishedStep(null);
}
}
catch (Exception ex)
{
// Delete the document if something failed
if (newDocumentCreated && (node != null) && (node.DocumentID > 0))
{
DocumentHelper.DeleteDocument(node, TreeProvider, false, true, true);
}
args.Message = ex.Message;
// Log the error
EventLogProvider.LogException("MultiFileUploader", "UPLOADATTACHMENT", ex);
}
finally
{
// Create node info string
string nodeInfo = ((node != null) && (node.NodeID > 0) && args.IncludeNewItemInfo) ? String.Format("'{0}', ", node.NodeID) : "";
// Ensure message text
args.Message = HTMLHelper.EnsureLineEnding(args.Message, " ");
// Call function to refresh parent window
if (!string.IsNullOrEmpty(args.AfterSaveJavascript))
{
// Calling javascript function with parameters attachments url, name, width, height
args.AfterScript += string.Format(@"
if (window.{0} != null)
{{
window.{0}();
}}
else if((window.parent != null) && (window.parent.{0} != null))
{{
window.parent.{0}();
}}", args.AfterSaveJavascript);
}
// Create after script and return it to the silverlight application, this script will be evaluated by the SL application in the end
args.AfterScript += string.Format(@"
if (window.InitRefresh_{0} != null)
{{
window.InitRefresh_{0}('{1}', false, false, {2});
}}
else {{
if ('{1}' != '') {{
alert('{1}');
}}
}}",
args.ParentElementID,
ScriptHelper.GetString(args.Message.Trim(), false),
nodeInfo + (args.IsInsertMode ? "'insert'" : "'update'"));
args.AddEventTargetPostbackReference();
context.Response.Write(args.AfterScript);
context.Response.Flush();
}
}
/// <summary>
/// Gets a list of matching commands
/// </summary>
/// <param name="pattern">command pattern</param>
/// <param name="commandOrigin"></param>
/// <param name="context"></param>
/// <param name="rediscoverImportedModules"></param>
/// <param name="moduleVersionRequired"></param>
/// <returns></returns>
internal static IEnumerable<CommandInfo> GetMatchingCommands(string pattern, ExecutionContext context, CommandOrigin commandOrigin, bool rediscoverImportedModules = false, bool moduleVersionRequired = false)
{
// Otherwise, if it had wildcards, just return the "AvailableCommand"
// type of command info.
WildcardPattern commandPattern = WildcardPattern.Get(pattern, WildcardOptions.IgnoreCase);
CmdletInfo cmdletInfo = context.SessionState.InvokeCommand.GetCmdlet("Microsoft.PowerShell.Core\\Get-Module");
PSModuleAutoLoadingPreference moduleAutoLoadingPreference = CommandDiscovery.GetCommandDiscoveryPreference(context, SpecialVariables.PSModuleAutoLoadingPreferenceVarPath, "PSModuleAutoLoadingPreference");
if ((moduleAutoLoadingPreference != PSModuleAutoLoadingPreference.None) &&
((commandOrigin == CommandOrigin.Internal) || ((cmdletInfo != null) && (cmdletInfo.Visibility == SessionStateEntryVisibility.Public))
)
)
{
foreach (string modulePath in GetDefaultAvailableModuleFiles(true, false, context))
{
// Skip modules that have already been loaded so that we don't expose private commands.
string moduleName = Path.GetFileNameWithoutExtension(modulePath);
var modules = context.Modules.GetExactMatchModules(moduleName, all: false, exactMatch: true);
PSModuleInfo tempModuleInfo = null;
if (modules.Count != 0)
{
// 1. We continue to the next module path if we don't want to re-discover those imported modules
// 2. If we want to re-discover the imported modules, but one or more commands from the module were made private,
// then we don't do re-discovery
if (!rediscoverImportedModules || modules.Exists(module => module.ModuleHasPrivateMembers))
{
continue;
}
if (modules.Count == 1)
{
PSModuleInfo psModule = modules[0];
tempModuleInfo = new PSModuleInfo(psModule.Name, psModule.Path, null, null);
tempModuleInfo.SetModuleBase(psModule.ModuleBase);
foreach (var entry in psModule.ExportedCommands)
{
if (commandPattern.IsMatch(entry.Value.Name))
{
CommandInfo current = null;
switch (entry.Value.CommandType)
{
case CommandTypes.Alias:
current = new AliasInfo(entry.Value.Name, null, context);
break;
case CommandTypes.Workflow:
current = new WorkflowInfo(entry.Value.Name, ScriptBlock.EmptyScriptBlock, context);
break;
case CommandTypes.Function:
current = new FunctionInfo(entry.Value.Name, ScriptBlock.EmptyScriptBlock, context);
break;
case CommandTypes.Filter:
current = new FilterInfo(entry.Value.Name, ScriptBlock.EmptyScriptBlock, context);
break;
case CommandTypes.Configuration:
current = new ConfigurationInfo(entry.Value.Name, ScriptBlock.EmptyScriptBlock, context);
break;
case CommandTypes.Cmdlet:
current = new CmdletInfo(entry.Value.Name, null, null, null, context);
break;
default:
Dbg.Assert(false, "cannot be hit");
break;
}
current.Module = tempModuleInfo;
yield return current;
}
}
continue;
}
}
string moduleShortName = System.IO.Path.GetFileNameWithoutExtension(modulePath);
var exportedCommands = AnalysisCache.GetExportedCommands(modulePath, false, context);
if (exportedCommands == null) { continue; }
tempModuleInfo = new PSModuleInfo(moduleShortName, modulePath, null, null);
if (InitialSessionState.IsEngineModule(moduleShortName))
{
tempModuleInfo.SetModuleBase(Utils.GetApplicationBase(Utils.DefaultPowerShellShellID));
}
//moduleVersionRequired is bypassed by FullyQualifiedModule from calling method. This is the only place where guid will be involved.
if (moduleVersionRequired && modulePath.EndsWith(StringLiterals.PowerShellDataFileExtension, StringComparison.OrdinalIgnoreCase))
{
tempModuleInfo.SetVersion(ModuleIntrinsics.GetManifestModuleVersion(modulePath));
tempModuleInfo.SetGuid(ModuleIntrinsics.GetManifestGuid(modulePath));
}
foreach (var pair in exportedCommands)
{
var commandName = pair.Key;
var commandTypes = pair.Value;
if (commandPattern.IsMatch(commandName))
{
bool shouldExportCommand = true;
// Verify that we don't already have it represented in the initial session state.
if ((context.InitialSessionState != null) && (commandOrigin == CommandOrigin.Runspace))
{
foreach (SessionStateCommandEntry commandEntry in context.InitialSessionState.Commands[commandName])
{
string moduleCompareName = null;
if (commandEntry.Module != null)
{
moduleCompareName = commandEntry.Module.Name;
}
else if (commandEntry.PSSnapIn != null)
{
moduleCompareName = commandEntry.PSSnapIn.Name;
}
if (String.Equals(moduleShortName, moduleCompareName, StringComparison.OrdinalIgnoreCase))
{
if (commandEntry.Visibility == SessionStateEntryVisibility.Private)
{
shouldExportCommand = false;
}
}
}
}
if (shouldExportCommand)
{
if ((commandTypes & CommandTypes.Alias) == CommandTypes.Alias)
{
yield return new AliasInfo(commandName, null, context)
{
Module = tempModuleInfo
};
}
if ((commandTypes & CommandTypes.Cmdlet) == CommandTypes.Cmdlet)
{
yield return new CmdletInfo(commandName, implementingType: null, helpFile: null, PSSnapin: null, context: context)
{
Module = tempModuleInfo
};
}
if ((commandTypes & CommandTypes.Function) == CommandTypes.Function)
{
yield return new FunctionInfo(commandName, ScriptBlock.EmptyScriptBlock, context)
{
Module = tempModuleInfo
};
}
if ((commandTypes & CommandTypes.Configuration) == CommandTypes.Configuration)
{
yield return new ConfigurationInfo(commandName, ScriptBlock.EmptyScriptBlock, context)
{
Module = tempModuleInfo
};
}
if ((commandTypes & CommandTypes.Workflow) == CommandTypes.Workflow)
{
yield return new WorkflowInfo(commandName, ScriptBlock.EmptyScriptBlock, context)
{
Module = tempModuleInfo
};
}
}
}
}
}
}
}
private void ReloadForm()
{
lblWorkflowInfo.Text = "";
if ((node != null) && !newdocument && !newculture)
{
// Check read permissions
if (CMSContext.CurrentUser.IsAuthorizedPerDocument(node, NodePermissionsEnum.Read) == AuthorizationResultEnum.Denied)
{
RedirectToAccessDenied(String.Format(GetString("cmsdesk.notauthorizedtoreaddocument"), node.NodeAliasPath));
}
// Check modify permissions
else if (CMSContext.CurrentUser.IsAuthorizedPerDocument(node, NodePermissionsEnum.Modify) == AuthorizationResultEnum.Denied)
{
formElem.Enabled = false;
lblWorkflowInfo.Text = String.Format(GetString("cmsdesk.notauthorizedtoeditdocument"), node.NodeAliasPath);
}
else
{
// Setup the workflow information
wi = WorkflowManager.GetNodeWorkflow(node);
if ((wi != null) && (!newculture))
{
// Get current step info, do not update document
WorkflowStepInfo si = null;
if (node.IsPublished && (node.DocumentCheckedOutVersionHistoryID <= 0))
{
si = WorkflowStepInfoProvider.GetWorkflowStepInfo("published", wi.WorkflowID);
}
else
{
si = WorkflowManager.GetStepInfo(node, false) ??
WorkflowManager.GetFirstWorkflowStep(node, wi);
}
bool canApprove = WorkflowManager.CanUserApprove(node, CMSContext.CurrentUser);
string stepName = si.StepName.ToLower();
if (!(canApprove || (stepName == "edit") || (stepName == "published") || (stepName == "archived")))
{
formElem.Enabled = false;
}
bool useCheckInCheckOut = wi.UseCheckInCheckOut(CMSContext.CurrentSiteName);
if (!node.IsCheckedOut)
{
// Check-in, Check-out
if (useCheckInCheckOut)
{
// If not checked out, add the check-out information
if (canApprove || (stepName == "edit") || (stepName == "published") || (stepName == "archived"))
{
lblWorkflowInfo.Text = GetString("EditContent.DocumentCheckedIn");
}
formElem.Enabled = newculture;
}
}
else
{
// If checked out by current user, add the check-in button
int checkedOutBy = node.DocumentCheckedOutByUserID;
if (checkedOutBy == CMSContext.CurrentUser.UserID)
{
// Document is checked out
lblWorkflowInfo.Text = GetString("EditContent.DocumentCheckedOut");
}
else
{
// Checked out by somebody else
string userName = UserInfoProvider.GetUserNameById(checkedOutBy);
lblWorkflowInfo.Text = String.Format(GetString("EditContent.DocumentCheckedOutByAnother"), userName);
formElem.Enabled = newculture;
}
}
// Document approval
switch (stepName)
{
case "edit":
case "published":
case "archived":
break;
default:
// If the user is authorized to perform the step, display the approve and reject buttons
if (!canApprove)
{
lblWorkflowInfo.Text += " " + GetString("EditContent.NotAuthorizedToApprove");
}
break;
}
// If workflow isn't auto publish or step name isn't 'published' or 'check-in/check-out' is allowed then show current step name
if (!wi.WorkflowAutoPublishChanges || (stepName != "published") || useCheckInCheckOut)
{
lblWorkflowInfo.Text += " " + String.Format(GetString("EditContent.CurrentStepInfo"), HTMLHelper.HTMLEncode(ResHelper.LocalizeString(si.StepDisplayName)));
}
}
}
}
pnlWorkflowInfo.Visible = (lblWorkflowInfo.Text != "");
}
/// <summary>
/// Creates process. Called when the "Create process" button is pressed.
/// </summary>
private bool CreateProcess()
{
// Create new process object and set its properties
WorkflowInfo newProcess = new WorkflowInfo()
{
WorkflowDisplayName = "My new process",
WorkflowName = "MyNewProcess",
WorkflowType = WorkflowTypeEnum.Automation,
WorkflowRecurrenceType = ProcessRecurrenceTypeEnum.Recurring
};
// Save the process
WorkflowInfoProvider.SetWorkflowInfo(newProcess);
// Create default steps
WorkflowStepInfoProvider.CreateDefaultWorkflowSteps(newProcess);
// Get the step with codename 'Finished' and allow Move to previous
WorkflowStepInfo finishedStep = WorkflowStepInfoProvider.GetWorkflowStepInfo("Finished", newProcess.WorkflowID);
finishedStep.StepAllowReject = true;
// Save the 'Finished' step
WorkflowStepInfoProvider.SetWorkflowStepInfo(finishedStep);
return true;
}
/// <summary>
/// Initializes a new instance of the <see cref="Workflow" /> class.
/// </summary>
/// <param name="client"><see cref="T:TcmCoreService.Client" /></param>
/// <param name="workflowInfo"><see cref="T:Tridion.ContentManager.CoreService.Client.WorkflowInfo" /></param>
internal Workflow(Client client, WorkflowInfo workflowInfo)
: base(client)
{
mWorkflowInfo = workflowInfo;
}
/// <summary>
/// Provides operations necessary to create and store new content file.
/// </summary>
private void HandleContentUpload()
{
string message = string.Empty;
bool newDocumentCreated = false;
try
{
if (NodeParentNodeID == 0)
{
throw new Exception(GetString("dialogs.document.parentmissing"));
}
// Check license limitations
if (!LicenseHelper.LicenseVersionCheck(RequestContext.CurrentDomain, FeatureEnum.Documents, ObjectActionEnum.Insert))
{
throw new Exception(GetString("cmsdesk.documentslicenselimits"));
}
// Check if class exists
DataClassInfo ci = DataClassInfoProvider.GetDataClassInfo(SystemDocumentTypes.File);
if (ci == null)
{
throw new Exception(string.Format(GetString("dialogs.newfile.classnotfound"), SystemDocumentTypes.File));
}
#region "Check permissions"
// Get the node
TreeNode parentNode = TreeProvider.SelectSingleNode(NodeParentNodeID, LocalizationContext.PreferredCultureCode, true);
if (parentNode != null)
{
// Check whether node class is allowed on site and parent node
if (!DocumentHelper.IsDocumentTypeAllowed(parentNode, ci.ClassID) || (ClassSiteInfoProvider.GetClassSiteInfo(ci.ClassID, parentNode.NodeSiteID) == null))
{
throw new Exception(GetString("Content.ChildClassNotAllowed"));
}
}
// Check user permissions
if (!RaiseOnCheckPermissions("Create", this))
{
if (!MembershipContext.AuthenticatedUser.IsAuthorizedToCreateNewDocument(parentNode, SystemDocumentTypes.File))
{
throw new Exception(string.Format(GetString("dialogs.newfile.notallowed"), NodeClassName));
}
}
#endregion
// Check the allowed extensions
CheckAllowedExtensions();
// Create new document
string fileName = Path.GetFileNameWithoutExtension(ucFileUpload.FileName);
string ext = Path.GetExtension(ucFileUpload.FileName);
if (IncludeExtension)
{
fileName += ext;
}
// Make sure the file name with extension respects maximum file name
fileName = TreePathUtils.EnsureMaxFileNameLength(fileName, ci.ClassName);
node = TreeNode.New(SystemDocumentTypes.File, TreeProvider);
node.DocumentCulture = LocalizationContext.PreferredCultureCode;
node.DocumentName = fileName;
if (NodeGroupID > 0)
{
node.SetValue("NodeGroupID", NodeGroupID);
}
// Load default values
FormHelper.LoadDefaultValues(node.NodeClassName, node);
node.SetValue("FileDescription", "");
node.SetValue("FileName", fileName);
node.SetValue("FileAttachment", Guid.Empty);
// Set default template ID
node.SetDefaultPageTemplateID(ci.ClassDefaultPageTemplateID);
// Insert the document
DocumentHelper.InsertDocument(node, parentNode, TreeProvider);
newDocumentCreated = true;
// Add the file
DocumentHelper.AddAttachment(node, "FileAttachment", ucFileUpload.PostedFile, TreeProvider, ResizeToWidth, ResizeToHeight, ResizeToMaxSideSize);
// Create default SKU if configured
if (ModuleManager.CheckModuleLicense(ModuleName.ECOMMERCE, RequestContext.CurrentDomain, FeatureEnum.Ecommerce, ObjectActionEnum.Insert))
{
node.CreateDefaultSKU();
}
// Update the document
DocumentHelper.UpdateDocument(node, TreeProvider);
// Get workflow info
wi = node.GetWorkflow();
// Check if auto publish changes is allowed
if ((wi != null) && wi.WorkflowAutoPublishChanges && !wi.UseCheckInCheckOut(SiteContext.CurrentSiteName))
{
// Automatically publish document
node.MoveToPublishedStep(null);
}
}
catch (Exception ex)
{
// Delete the document if something failed
if (newDocumentCreated && (node != null) && (node.DocumentID > 0))
{
DocumentHelper.DeleteDocument(node, TreeProvider, false, true);
}
message = ex.Message;
}
finally
{
// Create node info string
string nodeInfo = "";
if ((node != null) && (node.NodeID > 0) && (IncludeNewItemInfo))
{
nodeInfo = node.NodeID.ToString();
}
// Ensure message text
message = HTMLHelper.EnsureLineEnding(message, " ");
string containerId = QueryHelper.GetString("containerid", "");
// Call function to refresh parent window
string afterSaveScript = null;
if (!string.IsNullOrEmpty(AfterSaveJavascript))
{
afterSaveScript = String.Format(
@"
if (window.{0} != null){{
window.{0}(files);
}} else if ((window.parent != null) && (window.parent.{0} != null)){{
window.parent.{0}(files);
}}",
AfterSaveJavascript
);
}
afterSaveScript += String.Format(
@"
if (typeof(parent.DFU) !== 'undefined') {{
parent.DFU.OnUploadCompleted({0});
}}
if ((window.parent != null) && (/parentelemid={1}/i.test(window.location.href)) && (window.parent.InitRefresh_{1} != null)){{
window.parent.InitRefresh_{1}({2}, false, false{3}{4});
}}
",
ScriptHelper.GetString(containerId),
ParentElemID,
ScriptHelper.GetString(message.Trim()),
((nodeInfo != "") ? ", '" + nodeInfo + "'" : ""),
(InsertMode ? ", 'insert'" : ", 'update'")
);
ScriptHelper.RegisterStartupScript(this, typeof(string), "afterSaveScript_" + ClientID, ScriptHelper.GetScript(afterSaveScript));
}
}
private void LoadFromStore_Load(object sender, EventArgs e)
{
if (WorkflowProfiles.Rows.Count > 0)
{
foreach (DataRow row in WorkflowProfiles.Rows)
{
//Add a row for each workflow type found in the store
WorkflowInfo wi = new WorkflowInfo();
wi.AssemblyFullName = (string)row["AssemblyFullName"];
wi.TypeFullName = (string)row["TypeFullName"];
if (!workflowList.Items.Contains(wi))
{
workflowList.Items.Add(wi);
}
}
}
else
{
workflowList.Items.Add(NoWorkflowsAvailable);
}
}
protected void btnNewContent_OnComplete(object source, WorkflowInfo info)
{
contentTree.DataBind();
contentList.DataBind();
}
