private void ProcessBatchCode(string batchCode, IWBPosInput target, bool onlyParse, Action <CompleteContext> completedHandler)
{
var batch = GetBatch();
if (batch == null)
{
ShowError("Для принимаемой позиции не удалось определить алгоритм распознования batch-кода.");
return;
}
if (string.IsNullOrEmpty(batch.WorkflowCode))
{
ShowError(string.Format("Для принимаемой позиции найден алгоритм ({0}), но в нём не указана реализация.", batch.GetKey()));
return;
}
var bpContext = new BpContext();
bpContext.Set("BatchCode", batchCode);
bpContext.Set("Target", target);
bpContext.Set("OnlyParse", onlyParse);
bpContext.Set <string>("ParseResult", null);
var executionContext = new ExecutionContext(batch.WorkflowCode,
new Dictionary <string, object> {
{ BpContext.BpContextArgumentName, bpContext }
});
var engine = IoC.Instance.Resolve <IProcessExecutorEngine>(WorkflowProcessExecutorConstants.Workflow);
engine.Run(context: executionContext, completedHandler: completedHandler);
}
private async void ShowHomeMenu()
{
//var bpContext = new BpContext();
//BPProcessManager.RunByCode("RCLMAINMENU", ref bpContext);
try
{
WaitIndicatorVisible = true;
var context = new BpContext();
context.Properties.Add("IsMenuAboutVisible", true);
#if DEBUG
context.Properties.Add("IsTestMenuVisible", true);
#else
context.Properties.Add("IsTestMenuVisible", Properties.Settings.Default.IsTestMenuVisible);
#endif
await RunBpAsync("RCLMAINMENU", context, DefaultCompletedHandler);
}
catch (Exception)
{
WaitIndicatorVisible = false;
throw;
}
}
protected virtual Task RunBpAsync(string bpprocess, BpContext bpContext, Action <CompleteContext> completedHandler)
{
var managerInstance = IoC.Instance.Resolve <IBPProcessManager>();
return(Task.Factory.StartNew(() =>
{
System.Threading.Thread.Sleep(200);
if (bpContext == null)
{
bpContext = new BpContext();
}
//Больше не добавляем Да/нет
//bpContext.Properties.Add("ConfirmKeyHelp", string.Format("{0}" + Resources.StringResources.ConfirmKeyHelp, Environment.NewLine));
managerInstance.Parameters.Add(BpContext.BpContextArgumentName, bpContext);
DispatcherHelper.Invoke(new Action(delegate
{
try
{
managerInstance.Run(code: bpprocess, completedHandler: completedHandler);
}
catch (Exception ex)
{
if (completedHandler != null)
{
completedHandler(new CompleteContext(ex));
}
throw;
}
}));
}));
}
public override void Run()
{
var teIndex = _random.Next(_teCount);
if (teIndex >= _teCount)
{
teIndex = _teCount - 1;
}
_sourceTe = _sourceTeList[teIndex];
var vs = IoC.Instance.Resolve <IViewService>() as RclPackingViewService;
if (vs == null)
{
throw new Exception("IViewService is not RclPackingViewService");
}
vs.CurrentTeCode = _sourceTe.GetKey <string>();
_context = new BpContext();
_context.Set <TE>("SOURCETE", _sourceTe);
_context.Set <TE>("TARGETTE", _targetTe);
_context.Set <bool>("CHECKWHS", _checkWhs);
var inputs = new Dictionary <string, object> {
{ BpContext.BpContextArgumentName, _context }
};
var result = WorkflowInvoker.Invoke(_rclPackingActivity, inputs);
var ctx = (BpContext)result[BpContext.BpContextArgumentName];
Assert.IsTrue(ctx.Get <bool>("PACKED"));
}
private async void OnBPExecute(BusinessProcessCommandParameter parameter)
{
if (!ConnectionManager.Instance.AllowRequest())
{
return;
}
var items = GetItemsParameter().ToArray();
try
{
WaitStart();
_isbusy = true;
// синхронно проверяем возможность запуска данного процесса по триггеру
var res = await CanUseTriggerForItems((BPTrigger)parameter.Trigger, items);
if (!res)
{
var vs = GetViewService();
vs.ShowDialog("Внимание", "Невозможно запустить процесс. Не выполняется условие запуска.",
MessageBoxButton.OK, MessageBoxImage.Warning, MessageBoxResult.OK);
WaitStopInternal();
return;
}
var managerInstance = IoC.Instance.Resolve <IBPProcessManager>();
await Task.Factory.StartNew(() =>
{
// TODO: собираем параметры для процесса
// HACK: сейчас параметры заданы статически
//managerInstance.Parameters.Add("Items", items);
// настраиваем контекст
// TODO: необходимо стандартизировать и вынести параметры в одно место
var context = new BpContext {
Items = items, Name = parameter.Name
};
context.Set("DialogVisible", true); // признак того, что надо показывать диалоги
managerInstance.Parameters.Add(BpContext.BpContextArgumentName, context);
_bpStartTime = DateTime.Now;
_bpCode = parameter.BusinessProcessCode.ToString();
try
{
_log.DebugFormat("Start process: {0}", _bpCode);
managerInstance.Run(code: _bpCode, completedHandler: OnBpProcessEnd);
}
finally
{
_log.DebugFormat("Stop process: {0} in {1}", _bpCode, DateTime.Now - _bpStartTime);
}
});
}
catch (Exception)
{
WaitStopInternal();
throw;
}
}
private async void RunBp(string wfname)
{
try
{
WaitIndicatorVisible = true;
var context = new BpContext();
await RunBpAsync(wfname, context, DefaultCompletedHandler);
}
catch (Exception)
{
WaitIndicatorVisible = false;
throw;
}
}
private string ProcessBP(ImportObject impObj, string xml)
{
if (string.IsNullOrEmpty(impObj.Action))
{
throw new DeveloperException("Action not set.");
}
var bpMgr = IoC.Instance.Resolve <IBPProcessManager>();
if (bpMgr == null)
{
throw new DeveloperException("IBPProcessManager not registered.");
}
var context = new BpContext {
Items = impObj.Content.Items
};
context.Set("DialogVisible", true); // признак того, что надо показывать диалоги
context.Set(RootName, xml);
bpMgr.Parameters.Add(BpContext.BpContextArgumentName, context);
CompleteContext resCtx = null;
bpMgr.Run(code: impObj.Action, completedHandler: ctx => { WaitHandle.Set(); resCtx = ctx; });
WaitHandle.WaitOne();
var result = string.Empty;
if (resCtx != null)
{
if (resCtx.Exception != null)
{
//Избавляемся от & в сообщении об ошибке
var errmessage = resCtx.Exception.Message;
if (!string.IsNullOrEmpty(errmessage))
{
errmessage = errmessage.Replace("&", "&");
}
result = string.Format("<ERROR>{0}</ERROR>", errmessage);
}
else
{
// оставил старую логику
result = resCtx.Parameters.ContainsKey("RESULT") ? resCtx.Parameters["RESULT"].ToString() : null;
}
}
if (result != null)
{
return(result);
}
return("<STATUS>OK</STATUS>");
}
private BpContext CreateContext()
{
var result = new BpContext
{
Items = new object[] { Source },
};
if (_billOperation2Contract != null)
{
result.Properties["CPVL"] = _billOperation2Contract.Operation2ContractCpvL;
}
result.Properties["dateTimeFormats"] = _dateTimeFormats;
result.Properties["WORKACTDATE"] = _defaltCalcDate;
return(result);
}
private async void ShowTransportTaskMenu()
{
try
{
WaitIndicatorVisible = true;
var context = new BpContext();
context.Properties.Add("MenuCommandId", 0);
context.Properties.Add("Restart", true);
await RunBpAsync("RclTransportTaskNotification", context, DefaultCompletedHandler);
}
catch (Exception)
{
WaitIndicatorVisible = false;
throw;
}
}
public void OnPropertyChange(object sender, string propertyName)
{
if (_activity == null)
{
return;
}
var context = new BpContext()
{
Items = new[] { sender }
};
context.Set("PropertyName", propertyName);
var inputs = new Dictionary <string, object> {
{ BpContext.BpContextArgumentName, context }
};
WorkflowInvoker.Invoke(_activity, inputs);
}
bool IActionHandler.DoAction()
{
DialogResult = null;
_exception = null;
if (!OnCanOkClick())
{
return(false);
}
if (!ConnectionManager.Instance.AllowRequest())
{
return(false);
}
try
{
WaitStart();
var bpContext = new BpContext
{
Items = Source.Cast <object>().ToArray(),
DoNotRefresh = true
};
bpContext.Set("UseOneTypeTe", _useOneTypeTe);
var executionContext = new ExecutionContext(ActionWorkflowCode,
new Dictionary <string, object>
{
{ BpContext.BpContextArgumentName, bpContext }
});
var engine = IoC.Instance.Resolve <IProcessExecutorEngine>(WorkflowProcessExecutorConstants.Workflow);
engine.Run(context: executionContext, completedHandler: CompletedBp);
DialogResult = true;
}
catch (Exception ex)
{
WaitStop();
_exception = ex;
}
return(false);
}
private void Run()
{
if (!ConnectionManager.Instance.AllowRequest())
{
return;
}
//var items = GetItemsParameter().ToArray();
var managerInstance = IoC.Instance.Resolve <IBPProcessManager>();
// TODO: собираем параметры для процесса
// HACK: сейчас параметры заданы статически
// настраиваем контекст
// TODO: необходимо стандартизировать и вынести параметры в одно место
//var context = new BpContext { Items = items };
_context = new BpContext();
_context.Set("DialogVisible", true); // признак того, что надо показывать диалоги
managerInstance.Parameters.Add(BpContext.BpContextArgumentName, _context);
// HACK: пока выбираем код БП из ключа WF
var wfCode = _uniqueName.Replace("WF", string.Empty);
WaitStart();
var startTime = DateTime.Now;
try
{
_log.DebugFormat("Start process: {0}", wfCode);
managerInstance.Run(code: wfCode, completedHandler: OnBpProcessEnd);
}
catch (Exception)
{
WaitStop();
throw;
}
finally
{
_log.DebugFormat("End process: {0} in {1}", wfCode, DateTime.Now - startTime);
}
}
private void OnBatchCommand()
{
if (!CanBatchCommand())
{
return;
}
if (!ConnectionManager.Instance.AllowRequest())
{
return;
}
Action <CompleteContext> completedHandler = ctx => WaitStop();
try
{
WaitStart();
var bpContext = new BpContext
{
Items = SelectedItems.ToArray(),
DoNotRefresh = true
};
bpContext.Set("ShowErrorBatchcodeIsNull", true);
var executionContext = new ExecutionContext(BatchcodeWorkflowCode,
new Dictionary <string, object>
{
{ BpContext.BpContextArgumentName, bpContext }
});
var engine = IoC.Instance.Resolve <IProcessExecutorEngine>(WorkflowProcessExecutorConstants.Workflow);
engine.Run(context: executionContext, completedHandler: completedHandler);
}
catch (Exception)
{
WaitStop();
throw;
}
}
private DateTime?ShowDialogWorkerDateTill()
{
const string dateTillPropertyName = "Value";
var wfDialogWorkerDateTill = WfDialogWorkerDateTill.Get(_context);
if (string.IsNullOrEmpty(wfDialogWorkerDateTill))
{
return(null);
}
var workflowXaml = GetWorkflowXaml(wfDialogWorkerDateTill);
DynamicActivity activity;
using (var reader = new StringReader(workflowXaml))
activity = (DynamicActivity)ActivityXamlServices.Load(reader);
var bpContext = new BpContext();
bpContext.Set("WorkerFullName", WorkerFullName.Get(_context));
var inputs = new Dictionary <string, object> {
{ BpContext.BpContextArgumentName, bpContext }
};
WorkflowInvoker.Invoke(activity, inputs);
if (inputs.ContainsKey(BpContext.BpContextArgumentName))
{
var bpCntx = inputs[BpContext.BpContextArgumentName] as BpContext;
if (bpCntx != null && bpCntx.Properties.ContainsKey(dateTillPropertyName))
{
return(bpCntx.Get <DateTime?>(dateTillPropertyName));
}
}
return(null);
}
private void OnChangeOvxSkuCommand()
{
if (!CanChangeOvxSkuCommand())
{
return;
}
if (!ConnectionManager.Instance.AllowRequest())
{
return;
}
Action <CompleteContext> completedHandler = ctx =>
{
try
{
if (ctx.Parameters != null && ctx.Parameters.ContainsKey(BpContext.BpContextArgumentName))
{
var isResultOk = false;
Action <IWBPosInput, string, object> updatePropertyHandler = (iwbPosInputEntity, iwbPosInputPopertyName, skuPopertyValue) =>
{
try
{
iwbPosInputEntity.SuspendNotifications();
iwbPosInputEntity.SetProperty(iwbPosInputPopertyName, skuPopertyValue);
}
finally
{
iwbPosInputEntity.ResumeNotifications();
}
};
var bpcontext = ctx.Parameters[BpContext.BpContextArgumentName] as BpContext;
if (bpcontext != null)
{
isResultOk = bpcontext.Get <bool>("IsResultOk");
}
if (isResultOk && bpcontext.Items != null)
{
var items = bpcontext.Items.OfType <SKU>().ToArray();
if (items.Length > 0)
{
var sku = items[0];
foreach (var item in Source.Where(p => p.SKUID == sku.SKUID))
{
updatePropertyHandler(item, IWBPosInput.VSKUHEIGHTPropertyName,
sku.GetProperty(SKU.SKUHEIGHTPropertyName));
updatePropertyHandler(item, IWBPosInput.VSKULENGTHPropertyName,
sku.GetProperty(SKU.SKULENGTHPropertyName));
updatePropertyHandler(item, IWBPosInput.VSKUWIDTHPropertyName,
sku.GetProperty(SKU.SKUWIDTHPropertyName));
}
}
}
}
}
finally
{
WaitStop();
}
};
try
{
WaitStart();
var skuid = SelectedItems[0].SKUID;
var bpContext = new BpContext
{
Items = new object[] { new SKU {
SKUID = skuid ?? 0
} },
DoNotRefresh = false
};
bpContext.Set("NeedRefreshSku", true);
var executionContext = new ExecutionContext(SkuChangeMpWorkflowCode,
new Dictionary <string, object>
{
{ BpContext.BpContextArgumentName, bpContext }
});
var engine = IoC.Instance.Resolve <IProcessExecutorEngine>(WorkflowProcessExecutorConstants.Workflow);
engine.Run(context: executionContext, completedHandler: completedHandler);
}
catch (Exception)
{
WaitStop();
throw;
}
}
public MeasurementsController(BpContext context)
{
_context = context;
}
