private void finalizeCodeActivity_Finalize_ExecuteCode(object sender, EventArgs e)
{
IPageTypeDefaultPageContent defaultPageContent = this.GetBinding <IPageTypeDefaultPageContent>("DefaultPageContent");
Dictionary <string, string> piggybag = PiggybagSerializer.Deserialize(this.ExtraPayload);
DataEntityToken dataEntityToken = piggybag.GetParentEntityTokens().FindDataEntityToken(typeof(IPageType));
IPageType parentPageType = (IPageType)dataEntityToken.Data;
defaultPageContent.PageTypeId = parentPageType.Id;
defaultPageContent.Content = " ";
defaultPageContent = DataFacade.AddNew <IPageTypeDefaultPageContent>(defaultPageContent);
this.CloseCurrentView();
this.RefreshCurrentEntityToken();
if (!AnyTemplatesContainingPlaceholderId())
{
ShowMessage(C1Console.Events.DialogType.Message,
string.Format(RS.GetString("Composite.Plugins.PageTypeElementProvider", "PageType.AddPageTypeDefaultPageContentWorkflow.NonExistingPlaceholderId.Title"), defaultPageContent.PlaceHolderId),
string.Format(RS.GetString("Composite.Plugins.PageTypeElementProvider", "PageType.AddPageTypeDefaultPageContentWorkflow.NonExistingPlaceholderId.Message"), defaultPageContent.PlaceHolderId));
}
this.ExecuteWorklow(defaultPageContent.GetDataEntityToken(), WorkflowFacade.GetWorkflowType("Composite.Plugins.Elements.ElementProviders.PageTypeElementProvider.EditPageTypeDefaultPageContentWorkflow"));
}
private void initialCodeActivity_ExecuteCode(object sender, EventArgs e)
{
var entityToken = EntityToken as AssociatedDataElementProviderHelperEntityToken;
if (!string.IsNullOrEmpty(entityToken?.Payload))
{
var type = TypeManager.GetType(entityToken.Payload);
var id = type.GetImmutableTypeId();
var dataTypeDescriptor = DataMetaDataFacade.GetDataTypeDescriptor(id);
UpdateBinding("DataTypeDescriptor", dataTypeDescriptor);
UpdateBinding(BindingNames.PageId, new Guid(entityToken.Id));
if (!PermissionsFacade.GetPermissionsForCurrentUser(EntityToken).Contains(PermissionType.Publish) || !typeof(IPublishControlled).IsAssignableFrom(type))
{
var formData = WorkflowFacade.GetFormData(InstanceId, true);
if (formData.ExcludedEvents == null)
{
formData.ExcludedEvents = new List <string>();
}
formData.ExcludedEvents.Add("SaveAndPublish");
}
}
}
private static ElementAction CreateFunctionTesterAction(string functionName = "")
{
WorkflowActionToken actionToken = new WorkflowActionToken(WorkflowFacade.GetWorkflowType("Composite.Workflows.Plugins.Elements.ElementProviders.AllFunctionsElementProvider.FunctionTesterWorkflow"))
{
Payload = functionName
};
return(new ElementAction(new ActionHandle(actionToken))
{
VisualData = new ActionVisualizedData
{
Label = StringResourceSystemFacade.GetString("Composite.Plugins.AllFunctionsElementProvider", "AllFunctionsElementProvider.FunctionTester.Label"),
ToolTip = StringResourceSystemFacade.GetString("Composite.Plugins.AllFunctionsElementProvider", "AllFunctionsElementProvider.FunctionTester.ToolTip"),
Icon = TestFunctionIcon,
Disabled = false,
ActionLocation = new ActionLocation
{
ActionType = ActionType.Other,
IsInFolder = false,
IsInToolbar = true,
ActionGroup = PrimaryActionGroup
}
}
});
}
/// <exclude />
protected void LogMessage(LogLevel logLevel, string message)
{
FlowControllerServicesContainer container = WorkflowFacade.GetFlowControllerServicesContainer(WorkflowEnvironment.WorkflowInstanceId);
IManagementConsoleMessageService service = container.GetService <IManagementConsoleMessageService>();
service.ShowLogEntry(this.GetType(), logLevel, message);
switch (logLevel)
{
case LogLevel.Info:
case LogLevel.Debug:
case LogLevel.Fine:
LoggingService.LogVerbose(this.GetType().Name, message);
break;
case LogLevel.Warning:
LoggingService.LogWarning(this.GetType().Name, message);
break;
case LogLevel.Error:
LoggingService.LogError(this.GetType().Name, message);
break;
case LogLevel.Fatal:
LoggingService.LogCritical(this.GetType().Name, message);
break;
default:
throw new NotImplementedException();
}
}
/// <exclude />
protected void CollapseAndRefresh()
{
FlowControllerServicesContainer container = WorkflowFacade.GetFlowControllerServicesContainer(WorkflowEnvironment.WorkflowInstanceId);
IManagementConsoleMessageService service = container.GetService <IManagementConsoleMessageService>();
service.CollapseAndRefresh();
}
protected override void OnAddAction(Action <ElementAction> actionAdder, EntityToken entityToken, TreeNodeDynamicContext dynamicContext, DynamicValuesHelperReplaceContext dynamicValuesHelperReplaceContext)
{
actionAdder(new ElementAction(new ActionHandle(new WorkflowActionToken(WorkflowFacade.GetWorkflowType("Composite.C1Console.Trees.Workflows.GenericDeleteDataWorkflow"), this.PermissionTypes)))
{
VisualData = CreateActionVisualizedData(dynamicValuesHelperReplaceContext)
});
}
private void codeActivity_ExecuteCode(object sender, EventArgs e)
{
var type = StringConversionServices.DeserializeValueType(StringConversionServices.ParseKeyValueCollection(Payload)["ActionToken"]);
ActionToken actionToken = (ActionToken)Activator.CreateInstance(type);
ActionExecutorFacade.Execute(this.EntityToken, actionToken, WorkflowFacade.GetFlowControllerServicesContainer(WorkflowEnvironment.WorkflowInstanceId));
}
private void editPreviewCodeActivity_ExecuteCode(object sender, EventArgs e)
{
var serviceContainer = WorkflowFacade.GetFlowControllerServicesContainer(WorkflowEnvironment.WorkflowInstanceId);
var webRenderService = serviceContainer.GetService <IFormFlowWebRenderingService>();
try
{
var selectedPage = GetBinding <IPage>("SelectedPage");
var contents = new List <IPagePlaceholderContent>();
var namedXhtmlFragments = GetBinding <Dictionary <string, string> >("NamedXhtmlFragments");
foreach (var placeHolderContent in namedXhtmlFragments)
{
var content = DataFacade.BuildNew <IPagePlaceholderContent>();
content.PageId = selectedPage.Id;
content.VersionId = selectedPage.VersionId;
content.PlaceHolderId = placeHolderContent.Key;
content.Content = placeHolderContent.Value;
contents.Add(content);
}
var output = PagePreviewBuilder.RenderPreview(selectedPage, contents);
webRenderService.SetNewPageOutput(new LiteralControl(output));
}
catch (Exception ex)
{
Control errOutput = new LiteralControl("<pre>" + ex + "</pre>");
webRenderService.SetNewPageOutput(errOutput);
}
}
private void saveCodeActivity_ExecuteCode(object sender, EventArgs e)
{
UpdateTreeRefresher updateTreeRefresher = this.CreateUpdateTreeRefresher(this.EntityToken);
ISqlFunctionInfo info;
try
{
info = this.GetBinding <ISqlFunctionInfo>("SqlQuery");
var parameters = this.GetBinding <IEnumerable <ManagedParameterDefinition> >("Parameters");
ManagedParameterManager.Save(info.Id, parameters);
DataFacade.Update(info);
}
catch (Exception ex)
{
LoggingService.LogCritical("SQL Function Save", ex);
FlowControllerServicesContainer serviceContainer = WorkflowFacade.GetFlowControllerServicesContainer(WorkflowEnvironment.WorkflowInstanceId);
var consoleMsgService = serviceContainer.GetService <IManagementConsoleMessageService>();
consoleMsgService.ShowMessage(DialogType.Error, "Error", ex.Message);
SetSaveStatus(false);
return;
}
updateTreeRefresher.PostRefreshMesseges(info.GetDataEntityToken());
SetSaveStatus(true);
}
protected override void DoValidate(object objectToValidate, object currentTarget, string key,
ValidationResults validationResults)
{
var tag = (string)objectToValidate;
if (tag.Contains(","))
{
LogValidationResult(validationResults, "A comma is not supported", currentTarget, key);
return;
}
using (var conn = new DataConnection())
{
List <Tags> tags = conn.Get <Tags>().Where(t => t.Tag == tag).ToList();
if (tags.Any())
{
Guid workflowInstanceId = WorkflowEnvironment.WorkflowInstanceId;
var id = (Guid)WorkflowFacade.GetFormData(workflowInstanceId).Bindings["Id"];
if (tags.Find(t => t.Id == id) == null)
{
LogValidationResult(validationResults, "The tag with the same name already exists",
currentTarget, key);
}
}
}
}
private void saveInfoCodeActivity_ExecuteCode(object sender, EventArgs e)
{
var package = this.GetBinding <PackageInformation>("Package");
PackageCreatorFacade.SavePackageInformation(package);
if (!string.IsNullOrEmpty(Payload))
{
var type = StringConversionServices.DeserializeValueString(StringConversionServices.ParseKeyValueCollection(Payload)["ActionToken"]);
ActionToken actionToken = ActionTokenSerializer.Deserialize(type);
ActionExecutorFacade.Execute(package.GetEntityToken(), actionToken, WorkflowFacade.GetFlowControllerServicesContainer(WorkflowEnvironment.WorkflowInstanceId));
}
else
{
ActionExecutorFacade.Execute(
package.GetEntityToken(),
new SetActivePackageActionToken(),
WorkflowFacade.GetFlowControllerServicesContainer(WorkflowEnvironment.WorkflowInstanceId));
}
SpecificTreeRefresher treeRefresher = this.CreateSpecificTreeRefresher();
treeRefresher.PostRefreshMesseges(new PackageCreatorElementProviderEntityToken());
}
/// <exclude />
protected void SetSaveStatus(bool succeeded, string serializedEntityToken)
{
SaveWorklowTaskManagerEvent saveWorklowTaskManagerEvent = new SaveWorklowTaskManagerEvent
(
new WorkflowFlowToken(this.InstanceId),
this.WorkflowInstanceId,
succeeded
);
FlowControllerServicesContainer container = WorkflowFacade.GetFlowControllerServicesContainer(WorkflowEnvironment.WorkflowInstanceId);
ITaskManagerFlowControllerService service = container.GetService <ITaskManagerFlowControllerService>();
service.OnStatus(saveWorklowTaskManagerEvent);
var flowRenderingService = container.GetService <IFormFlowRenderingService>();
if (flowRenderingService != null)
{
flowRenderingService.SetSaveStatus(succeeded);
}
IManagementConsoleMessageService managementConsoleMessageService = container.GetService <IManagementConsoleMessageService>();
managementConsoleMessageService.SaveStatus(succeeded); // TO BE REMOVED
if (serializedEntityToken != null)
{
managementConsoleMessageService = container.GetService <IManagementConsoleMessageService>();
managementConsoleMessageService.BindEntityTokenToView(serializedEntityToken);
}
}
/// <exclude />
protected void RerenderView()
{
FlowControllerServicesContainer flowControllerServicesContainer = WorkflowFacade.GetFlowControllerServicesContainer(WorkflowEnvironment.WorkflowInstanceId);
IFormFlowRenderingService formFlowRenderingService = flowControllerServicesContainer.GetService <IFormFlowRenderingService>();
formFlowRenderingService.RerenderView();
}
public static void OnInitialized()
{
Composite.GlobalInitializerFacade.InitializeTheSystem();
try
{
var config = XElement.Load(PathUtil.Resolve("~/App_Data/Composite.Community.Twitter.FeedAggregator/Config.xml"));
int delay;
if (int.TryParse(config.AttributeValue("autoRefresh"), out delay))
{
var queries = config.Elements("Search").Select(d => d.AttributeValue("term")).NotNull().ToList();
var refreshWorkflow = WorkflowFacade.CreateNewWorkflow(
typeof(RefreshWorkflow),
new Dictionary <string, object> {
{ "Delay", delay },
{ "Queries", queries }
}
);
refreshWorkflow.Start();
LoggingService.LogInformation("FeedAggregator", "Run RefreshWorkflow");
WorkflowFacade.RunWorkflow(refreshWorkflow);
}
else
{
throw new InvalidOperationException("Wrong autoRefresh config value");
}
}
catch (Exception e)
{
LoggingService.LogError("FeedAggregator", e);
}
}
/// <summary>
/// To Retun the Delegation List Based on the Type
/// </summary>
/// <param name="Type">Delegation or Sharing</param>
/// <returns></returns>
public string WorklistAction(string UserId, string SN, string ActionName, string Comment, string forwardUserID)
{
string result = "";
try
{
if (!string.IsNullOrEmpty(forwardUserID))
{
int underScorePos = SN.IndexOf("_");
string procInstID = SN.Substring(0, underScorePos);
var forwardUserInfo = Db.VW_EMPLOYEE.Where(p => p.UserID == forwardUserID).FirstOrDefault();
var actionTakerRecord = Db.RequestFormTaskActioners.Where(p => p.ProcInstID.ToString() == procInstID).FirstOrDefault();
if (!string.IsNullOrEmpty(actionTakerRecord.ActionTakerUserID))
{
actionTakerRecord.ActionTakerUserID = forwardUserInfo.UserID;
actionTakerRecord.ActionTakerEmployeeID = forwardUserInfo.EmployeeID;
actionTakerRecord.ActionTakerFullName = forwardUserInfo.FullName;
actionTakerRecord.ActionTakerDeptName = forwardUserInfo.DEPT;
Db.SaveChanges();
}
}
WorkflowFacade workfacade = new WorkflowFacade();
workfacade.ExecuteAction(UserId, SN, ActionName, Comment);
result = "Success";
}
catch (Exception ex)
{
result = "Failed";
throw ex;
}
return(result);
}
protected override IEnumerable <ElementAction> OnGetFolderActions()
{
return(new ElementAction[]
{
new ElementAction(new ActionHandle(
new WorkflowActionToken(
WorkflowFacade.GetWorkflowType("Composite.Plugins.Elements.ElementProviders.VisualFunctionProviderElementProvider.AddNewVisualFunctionWorkflow"),
new PermissionType[] { PermissionType.Add }
)))
{
VisualData = new ActionVisualizedData
{
Label = StringResourceSystemFacade.GetString("Composite.Plugins.VisualFunction", "VisualFunctionElementProvider.AddNewLabel"),
ToolTip = StringResourceSystemFacade.GetString("Composite.Plugins.VisualFunction", "VisualFunctionElementProvider.AddNewToolTip"),
Icon = VisualFunctionProviderElementProvider.AddFunction,
Disabled = false,
ActionLocation = new ActionLocation
{
ActionType = ActionType.Add,
IsInFolder = false,
IsInToolbar = true,
ActionGroup = PrimaryActionGroup
}
}
}
});
}
public string RecallAction(string UserId, string ProcInstID, string ActionName, string Comment)
{
string result = "";
try
{
WorkflowFacade workfacade = new WorkflowFacade();
WorklistItem worklist = workfacade.GetWorklistItemsWithRecallByProcess(UserId, ProcInstID, "Applicant Recall");
if (worklist != null)
{
workfacade.ExecuteAction(UserId, worklist.SN, ActionName, Comment);
result = "Success";
}
else
{
result = "Failed";
throw new System.ArgumentException("Unable to recall the task");
}
}
catch (Exception ex)
{
result = "Failed";
throw ex;
}
return(result);
}
private void step5CodeActivity_RefreshTree_ExecuteCode(object sender, EventArgs e)
{
if (this.GetBinding <bool>("ReloadConsoleOnCompletion"))
{
ConsoleMessageQueueFacade.Enqueue(new RebootConsoleMessageQueueItem(), null);
}
if (this.GetBinding <bool>("FlushOnCompletion"))
{
GlobalEventSystemFacade.FlushTheSystem();
}
SpecificTreeRefresher specificTreeRefresher = this.CreateSpecificTreeRefresher();
specificTreeRefresher.PostRefreshMesseges(new PackageElementProviderRootEntityToken());
if (this.GetBinding <bool>("ReloadConsoleOnCompletion") == false)
{
PackageElementProviderAvailablePackagesItemEntityToken castedEntityToken = (PackageElementProviderAvailablePackagesItemEntityToken)this.EntityToken;
InstalledPackageInformation installedPackage = PackageManager.GetInstalledPackages().FirstOrDefault(f => f.Id == castedEntityToken.PackageId);
var installedPackageEntityToken = new PackageElementProviderInstalledPackageItemEntityToken(
installedPackage.Id,
installedPackage.GroupName,
installedPackage.IsLocalInstalled,
installedPackage.CanBeUninstalled);
ExecuteWorklow(installedPackageEntityToken, WorkflowFacade.GetWorkflowType("Composite.Plugins.Elements.ElementProviders.PackageElementProvider.ViewInstalledPackageInfoWorkflow"));
}
}
private void Initialize()
{
if (_dataTypeDescriptorFormsHelper == null)
{
if (String.IsNullOrEmpty(this.Payload))
{
throw new InvalidOperationException("The interface type should be a part of the workflows payload");
}
Dictionary <string, string> serializedValues = StringConversionServices.ParseKeyValueCollection(this.Payload);
_dataPayload = serializedValues;
}
if (!PermissionsFacade.GetPermissionsForCurrentUser(EntityToken).Contains(PermissionType.Publish) ||
!typeof(IPublishControlled).IsAssignableFrom(InterfaceType))
{
FormData formData = WorkflowFacade.GetFormData(InstanceId, true);
if (formData.ExcludedEvents == null)
{
formData.ExcludedEvents = new List <string>();
}
formData.ExcludedEvents.Add("SaveAndPublish");
}
}
private void finalizecodeActivity_ExecuteCode(object sender, EventArgs e)
{
AddNewTreeRefresher addNewTreeRefresher = this.CreateAddNewTreeRefresher(this.EntityToken);
IXsltFunction xslt = this.GetBinding <IXsltFunction>("NewXslt");
Guid copyFromFunctionId = this.GetBinding <Guid>(Binding_CopyFromFunctionId);
IXsltFunction copyFromFunction = null;
if (copyFromFunctionId != Guid.Empty)
{
copyFromFunction = DataFacade.GetData <IXsltFunction>().First(f => f.Id == copyFromFunctionId);
}
xslt.XslFilePath = xslt.CreateXslFilePath();
IFile file = IFileServices.TryGetFile <IXsltFile>(xslt.XslFilePath);
using (TransactionScope transactionScope = TransactionsFacade.CreateNewScope())
{
if (file == null)
{
IXsltFile xsltfile = DataFacade.BuildNew <IXsltFile>();
xsltfile.FolderPath = System.IO.Path.GetDirectoryName(xslt.XslFilePath);
xsltfile.FileName = System.IO.Path.GetFileName(xslt.XslFilePath);
string xslTemplate = _newXsltMarkup;
if (copyFromFunction != null)
{
IFile copyFromFile = IFileServices.GetFile <IXsltFile>(copyFromFunction.XslFilePath);
xslTemplate = copyFromFile.ReadAllText();
}
xsltfile.SetNewContent(xslTemplate);
DataFacade.AddNew <IXsltFile>(xsltfile, "XslFileProvider");
}
xslt = DataFacade.AddNew <IXsltFunction>(xslt);
UserSettings.LastSpecifiedNamespace = xslt.Namespace;
if (copyFromFunction != null)
{
CloneFunctionParameters(copyFromFunction, xslt);
CloneFunctionCalls(copyFromFunction, xslt);
}
transactionScope.Complete();
}
addNewTreeRefresher.PostRefreshMesseges(xslt.GetDataEntityToken());
FlowControllerServicesContainer container = WorkflowFacade.GetFlowControllerServicesContainer(WorkflowEnvironment.WorkflowInstanceId);
var executionService = container.GetService <IActionExecutionService>();
executionService.Execute(xslt.GetDataEntityToken(), new WorkflowActionToken(typeof(EditXsltFunctionWorkflow)), null);
}
private FormData GetFormData()
{
var formData = WorkflowFacade.GetFormData(WorkflowId);
Verify.IsNotNull(formData, "Failed to get form data, workflow may have been aborted!");
return(formData);
}
/// <exclude />
protected void SelectElement(EntityToken entityToken)
{
FlowControllerServicesContainer container = WorkflowFacade.GetFlowControllerServicesContainer(WorkflowEnvironment.WorkflowInstanceId);
IManagementConsoleMessageService service = container.GetService <IManagementConsoleMessageService>();
service.SelectElement(EntityTokenSerializer.Serialize(entityToken, true));
}
/// <exclude />
protected string GetCurrentConsoleId()
{
FlowControllerServicesContainer flowControllerServicesContainer = WorkflowFacade.GetFlowControllerServicesContainer(WorkflowEnvironment.WorkflowInstanceId);
IManagementConsoleMessageService managementConsoleMessageService = flowControllerServicesContainer.GetService <IManagementConsoleMessageService>();
return(managementConsoleMessageService.CurrentConsoleId);
}
/// <exclude />
protected void ShowFieldMessage(string fieldBindingPath, string message)
{
FlowControllerServicesContainer flowControllerServicesContainer = WorkflowFacade.GetFlowControllerServicesContainer(WorkflowEnvironment.WorkflowInstanceId);
IFormFlowRenderingService formFlowRenderingService = flowControllerServicesContainer.GetService <IFormFlowRenderingService>();
formFlowRenderingService.ShowFieldMessage(fieldBindingPath, StringResourceSystemFacade.ParseString(message));
}
/// <exclude />
protected void LockTheSystem()
{
FlowControllerServicesContainer flowControllerServicesContainer = WorkflowFacade.GetFlowControllerServicesContainer(WorkflowEnvironment.WorkflowInstanceId);
IManagementConsoleMessageService managementConsoleMessageService = flowControllerServicesContainer.GetService <IManagementConsoleMessageService>();
managementConsoleMessageService.LockSystem();
}
/// <exclude />
public static FlowToken ExecuteSecurityViolation(ActionToken actionToken, EntityToken entityToken, FlowControllerServicesContainer flowControllerServicesContainer)
{
EntityToken newEntityToken = new SecurityViolationWorkflowEntityToken();
WorkflowActionToken newActionToken = new WorkflowActionToken(WorkflowFacade.GetWorkflowType("Composite.C1Console.Actions.Workflows.SecurityViolationWorkflow"));
return(Execute(newEntityToken, newActionToken, flowControllerServicesContainer));
}
private void AppendFolderManagementActions(string websiteFolderPath, IEnumerable <IFolderWhiteList> manageableFolderWhiteLists, IList <ElementAction> folderActions)
{
for (int i = 0; i < _manageableKeyNames.Count; i++)
{
string keyName = _manageableKeyNames[i];
string itemLabel = StringResourceSystemFacade.ParseString(_manageableKeyNameLabels[i]);
ResourceHandle icon = null;
string label = null;
string tooltip = null;
WorkflowActionToken workflowActionToken = null;
ActionCheckedStatus checkedStatus = ActionCheckedStatus.Uncheckable;
if (manageableFolderWhiteLists.Where(f => f.KeyName == keyName && f.TildeBasedPath == IFolderWhiteListExtensions.GetTildePath(websiteFolderPath)).Any())
{
workflowActionToken = new WorkflowActionToken(WorkflowFacade.GetWorkflowType("Composite.Plugins.Elements.ElementProviders.WebsiteFileElementProvider.RemoveWebsiteFolderFromWhiteListWorkflow"), _changeWhiteListPermissionTypes);
label = StringResourceSystemFacade.GetString("Composite.Plugins.WebsiteFileElementProvider", "RemoveFolderFromWhiteListTitle");
tooltip = StringResourceSystemFacade.GetString("Composite.Plugins.WebsiteFileElementProvider", "RemoveFolderFromWhiteListToolTip");
icon = WebsiteFileElementProvider.RemoveFolderFromWhiteList;
checkedStatus = ActionCheckedStatus.Checked;
}
else
{
workflowActionToken = new WorkflowActionToken(WorkflowFacade.GetWorkflowType("Composite.Plugins.Elements.ElementProviders.WebsiteFileElementProvider.AddWebsiteFolderToWhiteListWorkflow"), _changeWhiteListPermissionTypes);
label = StringResourceSystemFacade.GetString("Composite.Plugins.WebsiteFileElementProvider", "AddFolderToWhiteListTitle");
tooltip = StringResourceSystemFacade.GetString("Composite.Plugins.WebsiteFileElementProvider", "AddFolderToWhiteListToolTip");
icon = WebsiteFileElementProvider.AddFolderToWhiteList;
checkedStatus = ActionCheckedStatus.Unchecked;
}
label = string.Format(label, itemLabel);
tooltip = string.Format(tooltip, itemLabel);
workflowActionToken.Payload = keyName;
folderActions.Add(
new ElementAction(new ActionHandle(workflowActionToken))
{
VisualData = new ActionVisualizedData
{
Label = label,
ToolTip = tooltip,
Icon = icon,
Disabled = false,
ActionLocation = new ActionLocation
{
ActionType = ActionType.Other,
IsInFolder = false,
IsInToolbar = false,
ActionGroup = PrimaryFolderToolsActionGroup
},
ActionCheckedStatus = checkedStatus
}
});
}
}
internal void AddWorkflowAction(string workflowType, IEnumerable <PermissionType> permissionType, ActionVisualizedData visualizedData)
{
Type type = WorkflowFacade.GetWorkflowType(workflowType);
this.AddAction(new ElementAction(new ActionHandle(new WorkflowActionToken(type, permissionType)))
{
VisualData = visualizedData
});
}
private void MissingActiveLanguageCodeActivity_ExecuteCode(object sender, EventArgs e)
{
FlowControllerServicesContainer flowControllerServicesContainer = WorkflowFacade.GetFlowControllerServicesContainer(WorkflowEnvironment.WorkflowInstanceId);
var managementConsoleMessageService = flowControllerServicesContainer.GetService <IManagementConsoleMessageService>();
managementConsoleMessageService.ShowMessage(
DialogType.Message,
GetText("UserElementProvider.MissingActiveLanguageTitle"),
GetText("UserElementProvider.MissingActiveLanguageMessage"));
}
/// <exclude />
protected sealed override ActivityExecutionStatus Execute(ActivityExecutionContext executionContext)
{
FlowControllerServicesContainer container = WorkflowFacade.GetFlowControllerServicesContainer(WorkflowEnvironment.WorkflowInstanceId);
IFormFlowRenderingService service = container.GetService <IFormFlowRenderingService>();
service.ShowFieldMessage(this.FieldBindingPath, this.Message);
return(ActivityExecutionStatus.Closed);
}
