public virtual void Execute(TaskActionArgs actionData)
{
try
{
UploadExecutedSettings setting = actionData.GetActionData<UploadExecutedSettings>();
var item = actionData.WorkflowProperties.Item;
DocumentGenerator generator = GeneratorFactory.GetGenerator(item, setting.TemplateFile);
var documentBytes = generator.GenerateDocument();
//TODO: save to Target Lib
SPSecurity.RunWithElevatedPrivileges(delegate()
{
using (SPSite site = new SPSite(actionData.WorkflowProperties.SiteId))
{
using (SPWeb web = site.OpenWeb(actionData.WorkflowProperties.WebId))
{
SPList exportLibrary = Utility.GetListFromURL(setting.DestinationLib, web);
SPList tempLibrary = Utility.GetListFromURL("TempDocs", web);
if (exportLibrary != null && tempLibrary != null)
{
SPFile exportedFile = null;
//byte[] pdfBytes = ConvertDocument(web, documentBytes, item.Title, false, tempLibrary.Title, 240, true);
//exportedFile = exportLibrary.RootFolder.Files.Add(exportLibrary.RootFolder.Url + "/" + item.Title + ".pdf", pdfBytes, true);
if (setting.DocumentFormat.ToLower() == "pdf")
{
byte[] pdfBytes = ConvertDocument(web, documentBytes, item.Title, true, tempLibrary.Title, 240, true);
exportedFile = exportLibrary.RootFolder.Files.Add(exportLibrary.RootFolder.Url + "/" + item.Title + ".pdf", pdfBytes, true);
}
else
{
//is pdf
exportedFile = exportLibrary.RootFolder.Files.Add(exportLibrary.RootFolder.Url + "/" + item.Title + ".docx", documentBytes, true);
}
if (exportedFile != null)
{
SPListItem expItem = exportedFile.Item;
item["Title"] = item.Title;
item.Update();
exportLibrary.Update();
}
}
}
}
});
}
catch (Exception ex)
{
Utility.LogError(ex.Message, "UploadExecuted");
}
}
public virtual void Execute(TaskActionArgs actionData)
{
SendEmailToStaticAddressesSettings emailSettings = actionData.GetActionData<SendEmailToStaticAddressesSettings>();
SPListItem taskItem = null;
if (emailSettings.TaskId > 0)
taskItem = actionData.WorkflowProperties.TaskList.GetItemById(emailSettings.TaskId);
SPListItem emailTemplateItem = SendEmailHelper.GetEmailTemplateItem(actionData.WorkflowProperties, emailSettings.EmailTemplateUrl, emailSettings.EmailTemplateName);
if (emailTemplateItem == null)
{
Utility.LogInfo("Cannot get email template name '" + emailSettings.EmailTemplateName + "' in list " + emailSettings.EmailTemplateUrl, "Task Action");
return;
}
SPSite site = actionData.WorkflowProperties.Site;
SPWeb rootWeb = site.RootWeb;
SPUserCollection allUsers = rootWeb.AllUsers;
string staticUserEmails = string.Empty;
foreach(var userInfo in emailSettings.StaticUsers)
{
//TODO: get user's emails
}
SendEmailHelper.SendEmailbytemplate(actionData.WorkflowProperties.Item, taskItem, emailTemplateItem, emailSettings.EmailAddress + "," + staticUserEmails, emailSettings.AttachTaskLink);
}
public void Execute(TaskActionArgs actionData)
{
UpdateExecutedDocumentMetaDataEditorSettings updateExcuteDocSettings = actionData.GetActionData<UpdateExecutedDocumentMetaDataEditorSettings>();
SPList list = actionData.WorkflowProperties.GetListFromURL(updateExcuteDocSettings.DestinationListUrl);
SPListItem item = list.GetItemById(updateExcuteDocSettings.DestinationItemId);
if (!item.Fields.ContainFieldId(new Guid(updateExcuteDocSettings.FieldId)))
return;
SPField fieldUpdate = item.Fields[new Guid(updateExcuteDocSettings.FieldId)];
if (!fieldUpdate.ReadOnlyField && !fieldUpdate.Hidden)
{
try
{
UpdateWorkflowItemHelper.DoUpdateItem(item, fieldUpdate, updateExcuteDocSettings.Value);
item[SPBuiltInFieldId.WorkflowVersion] = 1;
item.SystemUpdate();
}
catch
{
Utility.LogInfo("Error update workfkow item field " + fieldUpdate.Title + " with data " + updateExcuteDocSettings.Value + " is error", "TVMCORP.TVS.WORKFLOWS");
}
}
}
public void Execute(TaskActionArgs actionData)
{
UpdateWorkflowItemWithKeywordSettings updateWFItemSettings = actionData.GetActionData<UpdateWorkflowItemWithKeywordSettings>();
if (!actionData.WorkflowProperties.Item.Fields.ContainFieldId(new Guid(updateWFItemSettings.FieldId)))
return;
SPField fieldUpdate = actionData.WorkflowProperties.Item.Fields[new Guid(updateWFItemSettings.FieldId)];
if (!fieldUpdate.ReadOnlyField && !fieldUpdate.Hidden)
{
try
{
SPListItem item = actionData.WorkflowProperties.Item;
switch (fieldUpdate.Type)
{
case SPFieldType.DateTime:
bool isConvertSuccessful = false;
DateTime updated = CovnertKeywordToDateTime(updateWFItemSettings.Value, out isConvertSuccessful);
if (isConvertSuccessful)
{
SPFieldDateTime fieldDate = (SPFieldDateTime)fieldUpdate;
item[fieldUpdate.Id] = updated;
}
break;
case SPFieldType.User:
if (updateWFItemSettings.Value.Trim().ToUpper() == "[ME]")
{
//UpdateWorkflowItemHelper.DoUpdateItem(item, fieldUpdate, actionData.WorkflowProperties.OriginatorUser.LoginName);
SPFieldUser fieldUser = (SPFieldUser)fieldUpdate;
SPUser initiator = actionData.WorkflowProperties.OriginatorUser;
SPFieldUserValue userValue = new SPFieldUserValue(item.Web, initiator.ID, initiator.Name);
item[fieldUpdate.Id] = userValue;
}
break;
case SPFieldType.Text:
break;
}
item[SPBuiltInFieldId.WorkflowVersion] = 1;
item.SystemUpdate();
}
catch
{
Utility.LogInfo("Error update workfkow item field " + fieldUpdate.Title + " with data " + updateWFItemSettings.Value + " is error", "TVMCORP.TVS.WORKFLOWS");
}
}
}
public virtual void Execute(TaskActionArgs actionData)
{
SendEmailWithESignMetadataToStaticAddressesSettings emailSettings = actionData.GetActionData<SendEmailWithESignMetadataToStaticAddressesSettings>();
SPListItem taskItem = null;
if (emailSettings.TaskId > 0)
taskItem = actionData.WorkflowProperties.TaskList.GetItemById(emailSettings.TaskId);
SPListItem emailTemplateItem = SendEmailHelper.GetEmailTemplateItem(actionData.WorkflowProperties, emailSettings.EmailTemplateUrl, emailSettings.EmailTemplateName);
if (emailTemplateItem == null)
{
CCIUtility.LogInfo("Cannot get email template name '" + emailSettings.EmailTemplateName + "' in list " + emailSettings.EmailTemplateUrl, "Task Action");
return;
}
SendEmailHelper.SendEmailbytemplate(actionData.WorkflowProperties.Item, taskItem, emailSettings.ESignMetadata, emailTemplateItem, emailSettings.EmailAddress);
}
public virtual void Execute(TaskActionArgs actionData)
{
SendEmailWithESignVariableToStaticAddressesSettings emailSettings = actionData.GetActionData<SendEmailWithESignVariableToStaticAddressesSettings>();
SPListItem taskItem = null;
if (emailSettings.TaskId > 0)
taskItem = actionData.WorkflowProperties.TaskList.GetItemById(emailSettings.TaskId);
SPListItem emailTemplateItem = SendEmailHelper.GetEmailTemplateItem(actionData.WorkflowProperties, emailSettings.EmailTemplateUrl, emailSettings.EmailTemplateName);
if (emailTemplateItem == null)
{
CCIUtility.LogInfo("Cannot get email template name '" + emailSettings.EmailTemplateName + "' in list " + emailSettings.EmailTemplateUrl, "Task Action");
return;
}
SendEmailHelper.SendEmailbytemplateEx(actionData.WorkflowProperties.Item, taskItem, emailSettings.Variables, emailSettings.ESignMetadata, emailTemplateItem, emailSettings.EmailAddress);
actionData.WorkflowProperties.LogToWorkflowHistory(SPWorkflowHistoryEventType.None, "Email template " + emailSettings.EmailTemplateName + " has been successfully sent to " + emailSettings.EmailAddress, string.Empty);
}
public override void Execute(TaskActionArgs actionData)
{
SendEmailtoWorkflowTaskUserColumnSettings emailSettings = actionData.GetActionData<SendEmailtoWorkflowTaskUserColumnSettings>();
SPListItem taskItem = actionData.WorkflowProperties.TaskList.GetItemById(emailSettings.TaskId);
if (!taskItem.Fields.ContainFieldId(new Guid(emailSettings.FieldId)))
{
Utility.LogInfo("Field id " + emailSettings.FieldId + " not exist in workflow task", "Task Action");
return;
}
string emails = SendEmailHelper.GetEmailFromFieldValue(taskItem, emailSettings.FieldId);
if (string.IsNullOrEmpty(emails))
return;
emailSettings.EmailAddress = emails;
base.Execute(actionData);
}
public override void Execute(TaskActionArgs actionData)
{
SendEmailWithESignMetadataToWfItemUserColumnSettings emailSettings = actionData.GetActionData<SendEmailWithESignMetadataToWfItemUserColumnSettings>();
if (!actionData.WorkflowProperties.Item.Fields.ContainFieldId(new Guid(emailSettings.FieldId)))
{
CCIUtility.LogInfo("Field id " + emailSettings.FieldId + " not exist in workflow item", "Task Action");
return;
}
string emails = SendEmailHelper.GetEmailFromFieldValue(actionData.WorkflowProperties.Item, emailSettings.FieldId);
if (string.IsNullOrEmpty(emails))
return;
emailSettings.EmailAddress = emails;
base.Execute(actionData);
}
public void Execute(TaskActionArgs actionData)
{
UpdateTaskItemWithItemPropertySettings updateTaskItemSetting = actionData.GetActionData<UpdateTaskItemWithItemPropertySettings>();
if (!actionData.WorkflowProperties.Item.Fields.ContainFieldId(new Guid(updateTaskItemSetting.ItemFieldId)))
return;
SPListItem taskItem = null;
if (updateTaskItemSetting.TaskId > 0)
taskItem = actionData.WorkflowProperties.TaskList.GetItemById(updateTaskItemSetting.TaskId);
if (taskItem == null || !taskItem.Fields.ContainFieldId(new Guid(updateTaskItemSetting.TaskFieldId)))
return;
SPField updateTaskField = taskItem.Fields[new Guid(updateTaskItemSetting.TaskFieldId)];
SPField itemField = actionData.WorkflowProperties.Item.Fields[new Guid(updateTaskItemSetting.ItemFieldId)];
if (!updateTaskField.ReadOnlyField && !updateTaskField.Hidden)
{
try
{
SPListItem item = actionData.WorkflowProperties.Item;
//UpdateWorkflowItemHelper.DoUpdateItem(item, fieldUpdate, updateWFItemSettings.Value);
if (updateTaskField.Type == itemField.Type)
{
taskItem[new Guid(updateTaskItemSetting.TaskFieldId)] = item[new Guid(updateTaskItemSetting.ItemFieldId)];
}
else
{
if (item[itemField.Id] != null)
{
UpdateWorkflowItemHelper.DoUpdateItem(taskItem, updateTaskField, item[itemField.Id].ToString());
}
}
taskItem[SPBuiltInFieldId.WorkflowVersion] = 1;
taskItem.SystemUpdate();
}
catch
{
// Utility.LogInfo("Error update workfkow item field " + fieldUpdate.Title + " with data " + updateWFItemSettings.Value + " is error", "TVMCORP.TVS.WORKFLOWS");
}
}
}
public virtual void Execute(TaskActionArgs actionData)
{
CreatUnreadTaskSettings setting = actionData.GetActionData<CreatUnreadTaskSettings>();
var item = actionData.WorkflowProperties.Item;
if (setting.UsePredefine)
{
UnreadContentNotificationSetting unreadSetting = item.GetCustomSettings<UnreadContentNotificationSetting>(TVMCORPFeatures.TVS);
if (unreadSetting == null || unreadSetting.Enable == false) return;
if (unreadSetting.EnableEmail)
{
//UnreadContentReciever.SendNotificationEmail(unreadSetting.Template, item);
}
if (unreadSetting.EnableCreateUnreadTask)
{
//UnreadContentReciever.CreateNotificationTask(unreadSetting.TitleFormula, item);
}
}
}
public void Execute(TaskActionArgs actionData)
{
UpdateWorkflowItemMetadataSettings updateWFItemSettings = actionData.GetActionData<UpdateWorkflowItemMetadataSettings>();
if (!actionData.WorkflowProperties.Item.Fields.ContainFieldId(new Guid(updateWFItemSettings.FieldId)))
return;
SPField fieldUpdate = actionData.WorkflowProperties.Item.Fields[new Guid(updateWFItemSettings.FieldId)];
if (!fieldUpdate.ReadOnlyField && !fieldUpdate.Hidden)
{
try
{
SPListItem item = actionData.WorkflowProperties.Item;
UpdateWorkflowItemHelper.DoUpdateItem(item, fieldUpdate, updateWFItemSettings.Value);
item[SPBuiltInFieldId.WorkflowVersion] = 1;
item.SystemUpdate();
}
catch
{
Utility.LogInfo("Error update workfkow item field " + fieldUpdate.Title + " with data " + updateWFItemSettings.Value + " is error", "TVMCORP.TVS.WORKFLOWS");
}
}
}
public void Execute(TaskActionArgs actionData)
{
UpdateWorkflowItemWithESignMetadataSettings updateWFItemSettings = actionData.GetActionData<UpdateWorkflowItemWithESignMetadataSettings>();
Type typeESign = updateWFItemSettings.ESignMetadata.GetType();
PropertyInfo property = typeESign.GetProperties().FirstOrDefault(p => string.Compare(p.Name, updateWFItemSettings.ESignProperty, true) == 0);
if (property == null)
return;
object value = property.GetValue(updateWFItemSettings.ESignMetadata, null);
SPField fieldUpdate = actionData.WorkflowProperties.Item.Fields[new Guid(updateWFItemSettings.FieldId)];
if (!fieldUpdate.ReadOnlyField && !fieldUpdate.Hidden)
{
try
{
SPListItem item = actionData.WorkflowProperties.Item;
item[new Guid(updateWFItemSettings.FieldId)] = value;
item.SystemUpdate();
}
catch
{
CCIUtility.LogInfo("Error update workfkow item field " + fieldUpdate.Title + " with data " + value + " is error", "Hypertek.IOffice.Workflow");
}
}
}
public void Execute(TaskActionArgs actionData)
{
UpdateWorkflowTaskMetadataSettings updateWFTaskSettings = actionData.GetActionData<UpdateWorkflowTaskMetadataSettings>();
SPListItem taskItem = actionData.WorkflowProperties.TaskList.GetItemById(updateWFTaskSettings.TaskId);
if (!taskItem.Fields.ContainFieldId(new Guid(updateWFTaskSettings.FieldId)))
return;
SPField fieldUpdate = taskItem.Fields[new Guid(updateWFTaskSettings.FieldId)];
if (!fieldUpdate.ReadOnlyField && !fieldUpdate.Hidden)
{
try
{
// DoUpdateItem(taskItem, fieldUpdate, updateWFTaskSettings.Value);
taskItem[new Guid(updateWFTaskSettings.FieldId)] = updateWFTaskSettings.Value;
taskItem[SPBuiltInFieldId.WorkflowVersion] = 1;
taskItem.SystemUpdate();
}
catch(Exception ex)
{
Utility.LogInfo("Error when update " + fieldUpdate.Title + " field with value " + updateWFTaskSettings.Value + ": " + ex.Message, "Task Action");
}
}
}
private void updateEECStatus()
{
UpdateWorkflowTaskMetadataSettings updateTaskSettings = new UpdateWorkflowTaskMetadataSettings();
updateTaskSettings.FieldId = SPBuiltInFieldId.TaskStatus.ToString();
updateTaskSettings.TaskId = TaskIdCreated;
updateTaskSettings.Type = TaskActionTypes.UpdateWorkflowTaskMetadata;
updateTaskSettings.Value = _sendEECStatus;
ITaskActionHandler action = TaskActionFactory.CreateTaskActionHandler(TaskActionTypes.UpdateWorkflowTaskMetadata);
TaskActionArgs taskArg = new TaskActionArgs(updateTaskSettings, this.WorkflowProperties);
action.Execute(taskArg);
}
public void Execute(TaskActionArgs actionData)
{
UpdateWorkflowItemWithESignVariablesSettings updateWFItemSettings = actionData.GetActionData<UpdateWorkflowItemWithESignVariablesSettings>();
SPField fieldUpdate = actionData.WorkflowProperties.Item.Fields[new Guid(updateWFItemSettings.FieldId)];
if (!fieldUpdate.ReadOnlyField && !fieldUpdate.Hidden)
{
try
{
var value = updateWFItemSettings.Variables.Where(p => p.Name == updateWFItemSettings.VariableName).FirstOrDefault();
if (value != null)
{
SPListItem item = actionData.WorkflowProperties.Item;
if (fieldUpdate.Type == SPFieldType.Lookup) {
//TODO - Setting value for lookup field.
if (string.IsNullOrEmpty(value.Value))
{
item[new Guid(updateWFItemSettings.FieldId)] = null;
}
else
{
SPFieldLookup lookupField = fieldUpdate as SPFieldLookup;
using (SPSite site = new SPSite(actionData.WorkflowProperties.SiteId))
using (SPWeb web = site.OpenWeb(lookupField.LookupWebId))
{
SPList lookupList = web.Lists[new Guid(lookupField.LookupList)];
if (lookupList != null)
{
SPQuery query = new SPQuery();
query.Query = "<Where>" +
//"<And>" +
"<Eq><FieldRef Name='" + lookupField.LookupField + "'/><Value Type='Text'>" + value.Value + "</Value></Eq>" +
//"</And>" +
"</Where>";
SPListItemCollection items = lookupList.GetItems(query);
SPItem matchedItem = items.Cast<SPListItem>().FirstOrDefault();
if (matchedItem != null)
{
SPFieldLookupValue lookupValue = new SPFieldLookupValue()
{
LookupId = matchedItem.ID
};
item[new Guid(updateWFItemSettings.FieldId)] = lookupValue;
}
}
}
}
}
else
{
item[new Guid(updateWFItemSettings.FieldId)] = value.Value;
}
item.SystemUpdate();
}
}
catch
{
CCIUtility.LogError("Error update workfkow item field " + fieldUpdate.Title + " with data " + updateWFItemSettings.VariableName + " is error", "Hypertek.IOffice.Workflow");
}
CCIUtility.LogError("Exit UpdateWorkflowItemWithESignVariables", Model.IOfficeFeatures.CCIappDocuSign);
}
}
private void updateOnHoldTask_ExecuteCode(object sender, EventArgs e)
{
UpdateWorkflowTaskMetadataSettings updateTaskSettings = new UpdateWorkflowTaskMetadataSettings();
updateTaskSettings.FieldId = SPBuiltInFieldId.TaskStatus.ToString();
updateTaskSettings.TaskId = TaskIdCreated;
updateTaskSettings.Type = TaskActionTypes.UpdateWorkflowTaskMetadata;
updateTaskSettings.Value = Constants.Workflow.STATUS_ON_HOLD_TEXT;
ITaskActionHandler action = TaskActionFactory.CreateTaskActionHandler(TaskActionTypes.UpdateWorkflowTaskMetadata);
TaskActionArgs taskArg = new TaskActionArgs(updateTaskSettings, this.WorkflowProperties);
action.Execute(taskArg);
}
public virtual void Execute(TaskActionArgs actionData)
{
try
{
UpdateTaskPermissionSettings setting = actionData.GetActionData<UpdateTaskPermissionSettings>();
SPListItem taskItem = null;
if (setting.TaskId > 0)
taskItem = actionData.WorkflowProperties.TaskList.GetItemById(setting.TaskId);
if (taskItem == null )
return;
if (!taskItem.HasUniqueRoleAssignments)
{
taskItem.BreakRoleInheritance(setting.KeepExisting);
}
else if (!setting.KeepExisting)
{
taskItem.RemoveAllPermissions();
}
List<string> loginNames = new List<string>();
if (setting.AllParticipiants)
{
SPWorkflow workflowInstance = actionData.WorkflowProperties.Workflow;
SPWorkflowTaskCollection taskCollection = GetWorkflowTasks(workflowInstance);
for (int i = 0; i <= taskCollection.Count; i++)
{
var task = taskCollection[i];
string assignedToValue = task[SPBuiltInFieldId.AssignedTo].ToString();
SPFieldUserValue userField = (SPFieldUserValue)task.Fields[SPBuiltInFieldId.AssignedTo].GetFieldValue(assignedToValue);
SPUser user = userField.User;
loginNames.Add(taskCollection[i][SPBuiltInFieldId.AssignedTo].ToString());
}
}
foreach (var col in setting.Columns)
{
if (taskItem[new Guid(col)] != null)
{
var field = (SPFieldUser)taskItem.Fields[new Guid(col)];
if (field.AllowMultipleValues)
{
SPFieldUserValueCollection userCollection = (SPFieldUserValueCollection)taskItem[field.Id];
foreach (SPFieldUserValue user in userCollection)
{
loginNames.Add(user.User.LoginName);
}
}
else
{
var user = new SPFieldUserValue(taskItem.Web, taskItem[field.Id].ToString());
loginNames.Add(user.User.LoginName);
}
}
}
loginNames.AddRange(setting.StaticUsers);
var role = taskItem.Web.RoleDefinitions.Cast<SPRoleDefinition>().FirstOrDefault(p => p.Id.ToString() == setting.RoleId);
if (role != null)
{
taskItem.SetPermissions(role.Name, loginNames);
}
}
catch (Exception ex)
{
Utility.LogError(ex);
}
}
private void ExecuteActions(TaskEventSetting taskEvent)
{
if (taskEvent == null) return;
foreach (TaskActionSettings taskAction in taskEvent.Actions)
{
ITaskActionHandler action = TaskActionFactory.CreateTaskActionHandler(taskAction.Type);
switch (taskAction.Type)
{
case TaskActionTypes.UpdateTaskItemWithItemProperty:
((UpdateTaskItemWithItemPropertySettings)taskAction).TaskId = this.Parameter.TaskId;
break;
case TaskActionTypes.UpdateWorkflowItemWithTaskProperty:
((UpdateWorkflowItemWithTaskPropertySettings)taskAction).TaskId = this.Parameter.TaskId;
break;
case TaskActionTypes.SendEmailToStaticAddresses:
case TaskActionTypes.SendEmailToWorkflowItemUserColumn:
case TaskActionTypes.SendEmailToWorkflowTaskUserColumn:
((SendEmailToStaticAddressesSettings)taskAction).TaskId = this.Parameter.TaskId;
break;
//case TaskActionTypes.SendEmailWithESignMetadataToStaticAddresses:
//case TaskActionTypes.SendEmailWithESignMetadataToWorkflowItemUserColumn:
// ((SendEmailWithESignMetadataToStaticAddressesSettings)taskAction).ESignMetadata = this.Parameter.ESignMetadata;
// break;
case TaskActionTypes.UpdateWorkflowTaskMetadata:
((UpdateWorkflowTaskMetadataSettings)taskAction).TaskId = this.Parameter.TaskId;
break;
//case TaskActionTypes.UpdateWorkflowItemWithESignMetadata:
// ((UpdateWorkflowItemWithESignMetadataSettings)taskAction).ESignMetadata = this.Parameter.ESignMetadata;
// break;
//case TaskActionTypes.SendEmailWithESignVariableToStaticAddresses:
// ((SendEmailWithESignVariableToStaticAddressesSettings)taskAction).Variables = this.Parameter.Variables;
// ((SendEmailWithESignVariableToStaticAddressesSettings)taskAction).ESignMetadata = this.Parameter.ESignMetadata;
// break;
//case TaskActionTypes.SendEmailWithESignVariableToWfItemUserColumn:
// ((SendEmailWithESignVariableToWfItemUserColumnSettings)taskAction).Variables = this.Parameter.Variables;
// ((SendEmailWithESignVariableToWfItemUserColumnSettings)taskAction).ESignMetadata = this.Parameter.ESignMetadata;
// break;
//case TaskActionTypes.UpdateWorkflowItemWithEsignVariables:
// ((UpdateWorkflowItemWithESignVariablesSettings)taskAction).Variables = this.Parameter.Variables;
// ((UpdateWorkflowItemWithESignVariablesSettings)taskAction).ESignMetadata = this.Parameter.ESignMetadata;
// break;
case TaskActionTypes.UpdateExecutedDocumentMetadata:
((UpdateExecutedDocumentMetaDataEditorSettings)taskAction).DestinationListUrl = this.Parameter.DestinationListUrl;
((UpdateExecutedDocumentMetaDataEditorSettings)taskAction).DestinationItemId = this.Parameter.DestinationItemId;
break;
case TaskActionTypes.UpdateWFPermission:
break;
case TaskActionTypes.UpdateTaskPermission:
((UpdateTaskPermissionSettings)taskAction).TaskId = this.Parameter.TaskId;
break;
}
TaskActionArgs taskArg = new TaskActionArgs(taskAction, this.Parameter.WorkflowProperties);
try
{
action.Execute(taskArg);
}
catch (System.Exception)
{
Utility.LogInfo("There is an error occur when execute action", TVMCORPFeatures.TVS);
//throw;
}
}
}
