/// <summary>
///
/// </summary>
/// <returns></returns>
static public string getXmlTaskURL(TaskDefinitionIdsManager taskIdsManager, TaskDefinitionId taskDefinitionId)
{
MGDataCollection mgDataTab = MGDataCollection.Instance;
string taskFileName = taskIdsManager.GetXmlId(taskDefinitionId);
if (taskFileName == null)
{
return(null);
}
string defaultTagList = taskIdsManager.GetDefaultTagList(taskDefinitionId);
StringBuilder response = new StringBuilder();
response.Append("<");
response.Append(ConstInterface.MG_TAG_TASKURL);
response.Append(" xmlId=\"");
response.Append(taskFileName);
response.Append("\" ");
response.Append("tagList");
response.Append("=\"");
response.Append(defaultTagList);
response.Append("\">");
response.Append("</");
response.Append(ConstInterface.MG_TAG_TASKURL);
response.Append(">");
return(response.ToString());
}
///<summary> get executionRightIdx </summary>
///<param name="taskDefinitionId">!!.</param>
///<returns>!!.</returns>
internal int GetExecutionRight(TaskDefinitionId taskDefinitionId)
{
Debug.Assert(IsOfflineTask(taskDefinitionId));
TaskDefinitionIdInfo TaskDefinitionIdInfo = _TaskDefinitionIdsCache[taskDefinitionId];
return(TaskDefinitionIdInfo.ExecutionRightIdx);
}
public TaskDefinitionId TaskCalledByMenu(int menuId, TaskBase mainProg)
{
//fixed bug#:431559, the menu need to be take from menuCtlIndex main program.
ApplicationMenus applicationMenus = getApplicationMenus(mainProg);
MenuEntryProgram menuEntry = applicationMenus.menuByUid(menuId) as MenuEntryProgram;
TaskDefinitionId taskDefinitionId = new TaskDefinitionId(menuEntry.CtlIndex, menuEntry.ProgramIsn, 0, true);
return(taskDefinitionId);
}
/// <summary>
/// add task definition id
/// </summary>
/// <param name="taskDefinitionId"></param>
/// <param name="xmlId"></param>
/// <param name="defaultTagList"></param>
/// <param name="executionRightIdx"></param>
internal void AddTaskDefinitionId(TaskDefinitionId taskDefinitionId, string xmlId, string defaultTagList, int executionRightIdx)
{
lock (_TaskDefinitionIdsCache)
{
TaskDefinitionIdInfo taskDefinitionIdInfo = new TaskDefinitionIdInfo(xmlId, defaultTagList, executionRightIdx);
_TaskDefinitionIdsCache.Add(taskDefinitionId, taskDefinitionIdInfo);
// get the task's file from server to client
ApplicationSourcesManager.GetInstance().ReadSource(xmlId, false, false);
}
}
/// <summary>
/// get the CommandsProcessor to use for executing the defined task
/// </summary>
/// <param name="taskDefinitionId"></param>
/// <returns></returns>
internal static CommandsProcessorBase GetCommandsProcessor(TaskDefinitionId taskDefinitionId)
{
if (ClientManager.Instance.LocalManager.ApplicationDefinitions.TaskDefinitionIdsManager.IsOfflineTask(taskDefinitionId))
{
return(LocalCommandsProcessor.GetInstance());
}
else
{
return(RemoteCommandsProcessor.GetInstance());
}
}
/// <summary>
/// get the file name
/// </summary>
/// <param name="taskDefinitionId"></param>
/// <returns></returns>
internal string GetXmlId(TaskDefinitionId taskDefinitionId)
{
if (_TaskDefinitionIdsCache.ContainsKey(taskDefinitionId))
{
TaskDefinitionIdInfo TaskDefinitionIdInfo = _TaskDefinitionIdsCache[taskDefinitionId];
return(TaskDefinitionIdInfo.XmlId);
}
else
{
return(null);
}
}
/// <summary> returns TaskDefinitionId of a MainProgram of cltIdx</summary>
/// <param name="ctlIdx"></param>
/// <returns></returns>
internal TaskDefinitionId GetMainPrgTaskDefinitionIdByCtlIdx(int ctlIdx)
{
TaskDefinitionId taskDefinitionId = null;
foreach (TaskDefinitionId taskDefinitionKey in _TaskDefinitionIdsCache.Keys)
{
if (taskDefinitionKey.CtlIndex == ctlIdx && taskDefinitionKey.IsMainProgram())
{
taskDefinitionId = taskDefinitionKey;
break;
}
}
return(taskDefinitionId);
}
/// <summary>
/// CTOR
/// </summary>
/// <param name="taskDefinitionId"></param>
/// <param name="command"></param>
public LocalRunTimeCommandSelectProgram(TaskDefinitionId taskDefinitionId, IClientCommand command)
: base(taskDefinitionId)
{
ExecOperCommand cmd = command as ExecOperCommand;
Debug.Assert(cmd != null);
Task task = Manager.MGDataTable.GetTaskByID(cmd.TaskTag) as Task;
MgForm form = task.getForm() as MgForm;
mgControl = form.CtrlTab.getCtrl(cmd.DitIdx) as MgControl;
CallingTaskTag = cmd.TaskTag;
PathParentTaskTag = CallingTaskTag;
ForceModal = true;
}
/// <summary>
/// Create an open task command from a menu command
/// </summary>
/// <param name="command"></param>
/// <returns></returns>
internal LocalRunTimeCommandBase CreateMenuExecuteOperationCommand(MenuCommand command)
{
// Get the relevant menu entry
// QCR #283731. Use MenuComp on command for the relevant Ctl.
Task mainProg = MGDataCollection.Instance.GetMainProgByCtlIdx(command.MenuComp);
ApplicationMenus applicationMenus = Manager.MenuManager.getApplicationMenus(mainProg);
MenuEntryProgram menuEntry = applicationMenus.menuByUid(command.MenuUid) as MenuEntryProgram;
TaskDefinitionId taskDefinitionId = new TaskDefinitionId(menuEntry.CtlIndex, menuEntry.ProgramIsn, 0, true);
ArgumentsList argList = GetCommandArgumentList(command, menuEntry, mainProg);
return(new LocalRunTimeCommandOpenTask(taskDefinitionId)
{
ArgList = argList, CallingTaskTag = command.TaskTag, PathParentTaskTag = command.TaskTag
});
}
/// <summary>
///
/// </summary>
/// <param name="command"></param>
/// <returns></returns>
private LocalRunTimeCommandBase CreateExecuteOperaion(ExecOperCommand command)
{
if (command.Operation != null)
{
if (command.Operation.IsLocalCall)
{
string calcCallingTaskTag = "";
string pathParentTaskTag = command.Operation.getTaskTag(); // PathParentTask will be a task containing Call operation.
// Call with a destination
if (!String.IsNullOrEmpty(command.Operation.GetSubformControlName()))
{
return(new LocalRunTimeCommandCallWithDestination(command.Operation.CalledTaskDefinitionId)
{
CallingTaskTag = pathParentTaskTag,
PathParentTaskTag = pathParentTaskTag,
SubformCtrlName = command.Operation.GetSubformControlName(),
ArgList = command.Operation.GetArgList(),
});
}
else
{
// pathParentTask must be ContextTask of PathParent Task.
Task pathParentTask = MGDataCollection.Instance.GetTaskByID(pathParentTaskTag) as Task;
calcCallingTaskTag = pathParentTask.ContextTask.getTaskTag();
return(new LocalRunTimeCommandOpenTask(command.Operation.CalledTaskDefinitionId)
{
ArgList = command.Operation.GetArgList(),
ReturnValueField = command.Operation.GetReturnValueField(),
CallingTaskTag = calcCallingTaskTag,
PathParentTaskTag = pathParentTaskTag
});
}
}
}
else if (command.DitIdx != Int32.MinValue)
{
TaskDefinitionId taskDefinitionId = GetTaskIdFromCommandCtrlProp(command);
return(new LocalRunTimeCommandSelectProgram(taskDefinitionId, command));
}
throw new NotImplementedException();
}
///<summary>
/// Check whether the task can be executed or not.
/// Currently this method check whether user is authorized to execute the task or not.
///</summary>
///<param name="taskDefinitionId">!!.</param>
///<returns>true - if task can be executed.</returns>
internal bool CanExecuteTask(TaskDefinitionId taskDefinitionId)
{
bool canExecute = true;
if (taskDefinitionId.IsProgram) // Rights shouldn't be checked for SubTasks.
{
// Get the task's execution right and if it is not available then get GlobalExecution rights from MP.
int executionRightIdx = GetExecutionRight(taskDefinitionId);
if (executionRightIdx <= 0)
{
TaskDefinitionId mainPrgTaskDefinitionId = GetMainPrgTaskDefinitionIdByCtlIdx(taskDefinitionId.CtlIndex);
executionRightIdx = GetExecutionRight(mainPrgTaskDefinitionId);
}
if (executionRightIdx > 0)
{
canExecute = ClientManager.Instance.getUserRights().getRight(taskDefinitionId.CtlIndex, executionRightIdx);
}
}
return(canExecute);
}
/// <summary>
/// checks if a task, identified by taskId, is an off-line task, by checking if it exists in the task IDs cache
/// </summary>
/// <param name="taskId"></param>
/// <returns></returns>
internal bool IsOfflineTask(TaskDefinitionId taskId)
{
return(_TaskDefinitionIdsCache.ContainsKey(taskId));
}
public LocalRunTimeCommandOpenTask(TaskDefinitionId taskDefinitionId)
{
this.TaskDefinitionId = taskDefinitionId;
ForceModal = false;
SubformDitIdx = Int32.MinValue;
}
/// <summary>
/// callback to internal handler, to get the TaskDefinitionID
/// </summary>
/// <param name="taskDefinitionId"></param>
void SetTaskDefinitionId(TaskDefinitionId taskDefinitionId)
{
this.taskDefinitionId = taskDefinitionId;
}
/// <summary>
/// CTOR
/// </summary>
/// <param name="taskDefinitionId"></param>
internal LocalRunTimeCommandCallWithDestination(TaskDefinitionId taskDefinitionId) : base(taskDefinitionId)
{
}
/// <summary>
/// get the default tag list
/// </summary>
/// <param name="taskDefinitionId"></param>
/// <returns></returns>
internal string GetDefaultTagList(TaskDefinitionId taskDefinitionId)
{
TaskDefinitionIdInfo TaskDefinitionIdInfo = _TaskDefinitionIdsCache[taskDefinitionId];
return(TaskDefinitionIdInfo.DefaultTagList);
}
/// <summary>
/// Delegate method for the startup sequence sax parser see: <see cref="ParseStartupProgram"/> above.
/// </summary>
/// <param name="taskId">The task identifier created by the sax handler.</param>
/// <param name="taskUrl">Ignored</param>
/// <param name="defaultTags">Ignored</param>
void HandleTaskDefinitionId(TaskDefinitionId taskId)
{
startupProgram = taskId;
}
