public void InsertNetworkUtilization(ServiceTask NICTask)
{
if (NICTask == null)
{
return;
}
mNetworkUtilization = new NetworkUtilization();
mNetworkUtilization.PlannedWorkPattern = BehaviorExecutePattern.Asynchronization;
NICTask.Add(mNetworkUtilization);
}
public void InsertMessagePort(ServiceTask communicationTask, object singletonInstance, params Uri[] baseAddresses)
{
if (communicationTask == null || singletonInstance == null)
{
return;
}
var messagePort = new MessagePort(singletonInstance, baseAddresses);
messagePort.PlannedWorkPattern = BehaviorExecutePattern.Asynchronization;
communicationTask.Add(messagePort);
}
public void should_update_storage()
{
storage.AddTask(new ServiceTask {
DueDate = DateTime.Today, Name = "Misha"
});
var task = new ServiceTask {
Id = 1, DueDate = DateTime.Today, IsCompleted = false, Name = "Sasha"
};
storage.UpdateChanges();
saver.ReceivedWithAnyArgs().SaveToFile("bla-bla");
}
public void Execute()
{
var handledMissedSlot = false;
while (!CancellationToken.IsCancellationRequested)
{
bool missedSlot;
var run = Scheduler.RunTask(LastRunTime, dateTimeProvider.Now, out missedSlot);
if (!handledMissedSlot && missedSlot)
{
logger.InfoFormat("Previous execution slot missed. Please check for consistency issues.");
handledMissedSlot = true;
}
if (run)
{
try
{
logger.InfoFormat("Executing task");
var watch = Stopwatch.StartNew();
ServiceTask.ExecuteTask();
if (CancellationToken.IsCancellationRequested)
{
return;
}
watch.Stop();
logger.InfoFormat("Execution completed in {0}", watch.Elapsed);
LastRunTime = dateTimeProvider.Now;
handledMissedSlot = false;
PersistLastExecutionTime(LastRunTime, watch.Elapsed);
ResetFailureCount();
}
catch (Exception ex)
{
LogException(ex);
IncrementFailureCount();
}
}
Sleep();
}
logger.InfoFormat("Shut down");
}
public void should_throw_exception_on_set_date_to_completed_task()
{
const int id = 5;
var dueDate = DateTime.Today;
var task = new ServiceTask {
Id = id, DueDate = dueDate, IsCompleted = true
};
extractor.SelectTaskById(id).Returns(task);
Action action = () => todoList.SetTaskDate(id, dueDate);
action.ShouldThrow <CouldNotSetDateException>().WithMessage("Could not set due date to completed task.");
}
public async Task <IHttpActionResult> DeleteServiceTask(int id)
{
ServiceTask serviceTask = await db.ServiceTask.FindAsync(id);
if (serviceTask == null)
{
return(NotFound());
}
db.ServiceTask.Remove(serviceTask);
await db.SaveChangesAsync();
return(Ok(serviceTask));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Before public void parseModel()
public virtual void parseModel()
{
modelInstance = Bpmn.readModelFromStream(this.GetType().getResourceAsStream(this.GetType().Name + ".xml"));
collaboration = modelInstance.getModelElementById(COLLABORATION_ID);
participant = modelInstance.getModelElementById(PARTICIPANT_ID + 1);
process = modelInstance.getModelElementById(PROCESS_ID + 1);
serviceTask = modelInstance.getModelElementById(SERVICE_TASK_ID);
exclusiveGateway = modelInstance.getModelElementById(EXCLUSIVE_GATEWAY);
startEvent = modelInstance.getModelElementById(START_EVENT_ID + 2);
sequenceFlow = modelInstance.getModelElementById(SEQUENCE_FLOW_ID + 3);
messageFlow = modelInstance.getModelElementById(MESSAGE_FLOW_ID);
dataInputAssociation = modelInstance.getModelElementById(DATA_INPUT_ASSOCIATION_ID);
association = modelInstance.getModelElementById(ASSOCIATION_ID);
endEvent = modelInstance.getModelElementById(END_EVENT_ID + 2);
}
private void LogException(Exception ex)
{
ex.Data.SafeAdd("Task name", Name);
ex.Data.SafeAdd("Task type", ServiceTask.GetType().AssemblyQualifiedName);
if (LastRunTime != DateTime.MinValue)
{
ex.Data.SafeAdd("Last run time", LastRunTime);
}
else
{
ex.Data.SafeAdd("Last run time", "[Never]");
}
exceptionLogger.Log(ex);
}
public void should_return_task_with_given_id()
{
const int id = 5;
var serviceTask = new ServiceTask {
Id = id
};
repo.GetTasks(Arg.Any <ListSingleServiceSpecification>()).Returns(new List <ServiceTask> {
serviceTask
});
var selectTaskById = extractor.SelectTaskById(id);
selectTaskById.Id.Should().Be(id);
}
public void doWorkEvery(ServiceTask task)
{
while (true)
{
uint startTicks;
int workTicks, remainingTicks;
startTicks = (uint)Environment.TickCount;
ExecuteServiceTask(task);
workTicks = (int)((uint)Environment.TickCount - startTicks);
remainingTicks = (task.Frequency) * 1000 - workTicks;
if (remainingTicks > 0)
{
Thread.Sleep(remainingTicks);
}
}
}
/// <summary>
/// Sends a service request.
/// </summary>
/// <param name="request">An <see cref="IServiceRequest"/>.</param>
/// <returns>A <see cref="Task"/> representing the asynchronous operation that returns an <see cref="IServiceResponse"/>.</returns>
public async Task <IServiceResponse> RequestAsync(IServiceRequest request)
{
this.UpdateTimestamp(request);
var task = new ServiceTask(request);
using (var timeoutCts = new CancellationTokenSource((int)request.RequestHeader.TimeoutHint))
using (var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(timeoutCts.Token, this.clientCts.Token))
using (var registration = linkedCts.Token.Register(this.CancelTask, task, false))
{
if (this.pendingRequests.Post(task))
{
return(await task.Task.ConfigureAwait(false));
}
throw new ServiceResultException(StatusCodes.BadSecureChannelClosed);
}
}
public async Task <IAsyncResult> CreateAsync(ServiceTask task)
{
StringBuilder safeQuery = new StringBuilder(@"INSERT INTO ServiceTask (TargetId, Criticality, DateIssued, Description, Closed) VALUES ");
safeQuery.Append("(@TargetId, @Criticality, @Date, @Description, @Closed);");
DynamicParameters dynamicParameters = new DynamicParameters();
dynamicParameters.Add("TargetId", task.TargetId);
dynamicParameters.Add("Criticality", task.Criticality);
dynamicParameters.Add("Date", FormatDate(task.DateIssued));
dynamicParameters.Add("Description", task.Description);
dynamicParameters.Add("Closed", task.Closed);
return(await Task.FromResult(RunQuerySafe(safeQuery.ToString(), dynamicParameters)));
}
protected internal override BaseElement ConvertXMLToElement(XMLStreamReader xtr, BpmnModel model)
{
ServiceTask serviceTask = new ServiceTask();
BpmnXMLUtil.AddXMLLocation(serviceTask, xtr);
if (!string.IsNullOrWhiteSpace(xtr.GetAttributeValue(BpmnXMLConstants.ACTIVITI_EXTENSIONS_NAMESPACE, BpmnXMLConstants.ATTRIBUTE_TASK_SERVICE_CLASS)))
{
serviceTask.ImplementationType = ImplementationType.IMPLEMENTATION_TYPE_CLASS;
serviceTask.Implementation = xtr.GetAttributeValue(BpmnXMLConstants.ACTIVITI_EXTENSIONS_NAMESPACE, BpmnXMLConstants.ATTRIBUTE_TASK_SERVICE_CLASS);
}
else if (!string.IsNullOrWhiteSpace(xtr.GetAttributeValue(BpmnXMLConstants.ACTIVITI_EXTENSIONS_NAMESPACE, BpmnXMLConstants.ATTRIBUTE_TASK_SERVICE_EXPRESSION)))
{
serviceTask.ImplementationType = ImplementationType.IMPLEMENTATION_TYPE_EXPRESSION;
serviceTask.Implementation = xtr.GetAttributeValue(BpmnXMLConstants.ACTIVITI_EXTENSIONS_NAMESPACE, BpmnXMLConstants.ATTRIBUTE_TASK_SERVICE_EXPRESSION);
}
else if (!string.IsNullOrWhiteSpace(xtr.GetAttributeValue(BpmnXMLConstants.ACTIVITI_EXTENSIONS_NAMESPACE, BpmnXMLConstants.ATTRIBUTE_TASK_SERVICE_DELEGATEEXPRESSION)))
{
serviceTask.ImplementationType = ImplementationType.IMPLEMENTATION_TYPE_DELEGATEEXPRESSION;
serviceTask.Implementation = xtr.GetAttributeValue(BpmnXMLConstants.ACTIVITI_EXTENSIONS_NAMESPACE, BpmnXMLConstants.ATTRIBUTE_TASK_SERVICE_DELEGATEEXPRESSION);
}
else if ("##WebService".Equals(xtr.GetAttributeValue(BpmnXMLConstants.ATTRIBUTE_TASK_IMPLEMENTATION)))
{
serviceTask.ImplementationType = ImplementationType.IMPLEMENTATION_TYPE_WEBSERVICE;
serviceTask.OperationRef = ParseOperationRef(xtr.GetAttributeValue(BpmnXMLConstants.ATTRIBUTE_TASK_OPERATION_REF), model);
}
else
{
serviceTask.Implementation = xtr.GetAttributeValue(BpmnXMLConstants.ATTRIBUTE_TASK_IMPLEMENTATION);
}
serviceTask.ResultVariableName = xtr.GetAttributeValue(BpmnXMLConstants.ACTIVITI_EXTENSIONS_NAMESPACE, BpmnXMLConstants.ATTRIBUTE_TASK_SERVICE_RESULTVARIABLE);
if (string.IsNullOrWhiteSpace(serviceTask.ResultVariableName))
{
serviceTask.ResultVariableName = xtr.GetAttributeValue(BpmnXMLConstants.ACTIVITI_EXTENSIONS_NAMESPACE, "resultVariable");
}
serviceTask.Type = xtr.GetAttributeValue(BpmnXMLConstants.ACTIVITI_EXTENSIONS_NAMESPACE, BpmnXMLConstants.ATTRIBUTE_TYPE);
serviceTask.ExtensionId = xtr.GetAttributeValue(BpmnXMLConstants.ACTIVITI_EXTENSIONS_NAMESPACE, BpmnXMLConstants.ATTRIBUTE_TASK_SERVICE_EXTENSIONID);
if (!string.IsNullOrWhiteSpace(xtr.GetAttributeValue(BpmnXMLConstants.ACTIVITI_EXTENSIONS_NAMESPACE, BpmnXMLConstants.ATTRIBUTE_TASK_SERVICE_SKIP_EXPRESSION)))
{
serviceTask.SkipExpression = xtr.GetAttributeValue(BpmnXMLConstants.ACTIVITI_EXTENSIONS_NAMESPACE, BpmnXMLConstants.ATTRIBUTE_TASK_SERVICE_SKIP_EXPRESSION);
}
ParseChildElements(XMLElementName, serviceTask, model, xtr);
return(serviceTask);
}
public override RemoteWebDriver Driver(bool useExistingBrowser = true)
{
// when useExistingBrowser is set open chrome
if (useExistingBrowser)
{
ServiceBrowser.OpenBrowser();
}
if (string.IsNullOrEmpty(BaseURL))
{
throw new Exception($"{nameof(BaseURL)} is not set.");
}
// NOTE: This will cause problem when we run this code
// in multi threaded program. Remove this code, to avoid
// running into problems when experimenting with parallel runs.
ServiceTask.CloseTask(nameof(ChromeDriver));
var options = new ChromeOptions
{
DebuggerAddress = $"{AppSettings.DebuggerBrowserUrl}:{ AppSettings.DebuggerBrowserPort}"
};
options.AddArgument("no-sandbox");
//options.AddArguments(@"user-data-dir=C:\Users\amhus\AppData\Local\Google\Chrome\User Data\Default" /*Profile Path*/);
//options.BinaryLocation = @"C:\Program Files (x86)\Google\Chrome\Application\chrome.exe";
ChromeDriver driver = null;
RetryPolicy().Execute(() =>
{
driver = new ChromeDriver(options);
});
// Temp disabling this
// SelectTab(driver);
// If using existing window then you may not need to maximize it here.
//driver.Manage().Window.Maximize();
// set default culture
ServiceCulture.SetDefaultCulture(AppSettings.DefaultCulture);
return(driver);
}
public virtual ProcessDefinitionMetaResource GetProcessDefinitionMetadata(string id)
{
IProcessDefinition processDefinition = repositoryService.CreateProcessDefinitionQuery().SetProcessDefinitionId(id).SingleResult();
if (processDefinition == null)
{
throw new ActivitiObjectNotFoundException("Unable to find process definition for the given id:'" + id + "'");
}
IList <Process> processes = repositoryService.GetBpmnModel(id).Processes;
ISet <ProcessDefinitionVariable> variables = new HashSet <ProcessDefinitionVariable>();
ISet <string> users = new HashSet <string>();
ISet <string> groups = new HashSet <string>();
ISet <ProcessDefinitionUserTask> userTasks = new HashSet <ProcessDefinitionUserTask>();
ISet <ProcessDefinitionServiceTask> serviceTasks = new HashSet <ProcessDefinitionServiceTask>();
foreach (Process process in processes)
{
var vs = GetVariables(process).ToList();
vs.ForEach(v => variables.Add(v));
IList <FlowElement> flowElementList = (IList <FlowElement>)process.FlowElements;
foreach (FlowElement flowElement in flowElementList)
{
if (flowElement.GetType().Equals(typeof(UserTask)))
{
UserTask userTask = (UserTask)flowElement;
ProcessDefinitionUserTask task = new ProcessDefinitionUserTask(userTask.Name, userTask.Documentation);
userTasks.Add(task);
userTask.CandidateUsers.ToList().ForEach(u => users.Add(u));
userTask.CandidateGroups.ToList().ForEach(ug => groups.Add(ug));
}
if (flowElement.GetType().Equals(typeof(ServiceTask)))
{
ServiceTask serviceTask = (ServiceTask)flowElement;
ProcessDefinitionServiceTask task = new ProcessDefinitionServiceTask(serviceTask.Name, serviceTask.Implementation);
serviceTasks.Add(task);
}
}
}
return(resourceAssembler.ToResource(new ProcessDefinitionMeta(processDefinition.Id, processDefinition.Name, processDefinition.Description, processDefinition.Version, users, groups, variables, userTasks, serviceTasks)));
}
private void addServiceTaskCompensationHandler(BpmnModelInstance modelInstance, string boundaryEventId, string compensationHandlerId)
{
BoundaryEvent boundaryEvent = modelInstance.getModelElementById(boundaryEventId);
BaseElement scope = (BaseElement)boundaryEvent.ParentElement;
ServiceTask compensationHandler = modelInstance.newInstance(typeof(ServiceTask));
compensationHandler.Id = compensationHandlerId;
compensationHandler.ForCompensation = true;
//JAVA TO C# CONVERTER WARNING: The .NET Type.FullName property will not always yield results identical to the Java Class.getName method:
compensationHandler.CamundaClass = typeof(IncreaseCurrentTimeServiceTask).FullName;
scope.addChildElement(compensationHandler);
Association association = modelInstance.newInstance(typeof(Association));
association.AssociationDirection = AssociationDirection.One;
association.Source = boundaryEvent;
association.Target = compensationHandler;
scope.addChildElement(association);
}
public iResponse ProcessResponse(ServiceTask task)
{
var resp = new ServiceTask();
resp.command = "processed resp";
if (client == null)
{
client = new RequestSocket();
client.Connect(service_addres);
}
CNNTask cnn_task = new CNNTask();
cnn_task.image = Capture.getImage();
string cnn_task_str = json_converter.JsonConverter.serialaze(cnn_task);
string response_cnn_message;
if (client.TrySendFrame(System.TimeSpan.FromSeconds(5), cnn_task_str) &&
client.TryReceiveFrameString(System.TimeSpan.FromSeconds(5), out response_cnn_message))
{
var response_cnn_obj = json_converter.JsonConverter.deserialaze(response_cnn_message);
if (Object.ReferenceEquals(response_cnn_obj.GetType(), typeof(CNNAnswer)))
{
CNNAnswer cnn_rec_answ = response_cnn_obj as CNNAnswer;
System.Console.WriteLine("service resp.res: {0}", cnn_rec_answ.res);
return(cnn_rec_answ);
}
else
{
System.Console.WriteLine("server illegal answer");
resp.command = "service illegal answer";
}
}
else
{
client = null;
System.Console.WriteLine("service is down");
resp.command = "service is down";
}
return(resp);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void createProcessWithParallelGateway()
public virtual void createProcessWithParallelGateway()
{
// create process
Process process = createElement(definitions, "process-with-parallel-gateway", typeof(Process));
// create elements
StartEvent startEvent = createElement(process, "start", typeof(StartEvent));
ParallelGateway fork = createElement(process, "fork", typeof(ParallelGateway));
UserTask task1 = createElement(process, "task1", typeof(UserTask));
ServiceTask task2 = createElement(process, "task2", typeof(ServiceTask));
ParallelGateway join = createElement(process, "join", typeof(ParallelGateway));
EndEvent endEvent = createElement(process, "end", typeof(EndEvent));
// create flows
createSequenceFlow(process, startEvent, fork);
createSequenceFlow(process, fork, task1);
createSequenceFlow(process, fork, task2);
createSequenceFlow(process, task1, join);
createSequenceFlow(process, task2, join);
createSequenceFlow(process, join, endEvent);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testUpdateIncomingOutgoingChildElements()
public virtual void testUpdateIncomingOutgoingChildElements()
{
BpmnModelInstance modelInstance = Bpmn.createProcess().startEvent().userTask("test").endEvent().done();
// save current incoming and outgoing sequence flows
UserTask userTask = modelInstance.getModelElementById("test");
ICollection <SequenceFlow> incoming = userTask.Incoming;
ICollection <SequenceFlow> outgoing = userTask.Outgoing;
// create a new service task
ServiceTask serviceTask = modelInstance.newInstance(typeof(ServiceTask));
serviceTask.Id = "new";
// replace the user task with the new service task
userTask.replaceWithElement(serviceTask);
// assert that the new service task has the same incoming and outgoing sequence flows
assertThat(serviceTask.Incoming).containsExactlyElementsOf(incoming);
assertThat(serviceTask.Outgoing).containsExactlyElementsOf(outgoing);
}
public IActionResult Post([FromBody] TaskDetail task)
{
try
{
var dbTask = new ServiceTask();
dbTask.Name = task.Name;
dbTask.Description = task.Description;
dbTask.StartDate = task.StartDate;
dbTask.FinishDate = task.FinishDate;
dbTask.State = task.State;
_taskcontext.Add(dbTask);
_taskcontext.SaveChanges();
return(Ok("Created Successfully"));
}
catch (Exception ex)
{
return(StatusCode(500, "Internal server error"));
}
}
public void KillService()
{
var kill_command = new ServiceTask();
kill_command.command = "kill";
string kill_message = json_converter.JsonConverter.serialaze(kill_command);
bool service_up = client?.TrySendFrame(System.TimeSpan.FromSeconds(2), kill_message) ?? false;
string response_cnn_message = "";
if (service_up &&
client.TryReceiveFrameString(System.TimeSpan.FromSeconds(5), out response_cnn_message))
{
Console.WriteLine("kill command was sent to cnn service");
}
else
{
Console.WriteLine("cnn service hard kill");
this.Kill();
}
}
// Legger til en room service ServiceTask, henter roomid fra room number input -t
private void OrderRoomServiceButton_Click(object sender, RoutedEventArgs e)
{
int roomInput = 0;
Int32.TryParse(ServiceTaskEntryRoomNumber.Text, out roomInput);
try
{
var roomId = (
from r in room
where r.RoomNumber == roomInput
select r
).First <Room>().RoomId;
ServiceTask t = new ServiceTask
{
RoomId = roomId,
TimeIssued = DateTime.Now,
TypeOfService = "Room Service",
Status = "Pending",
Description = ServiceTaskEntryDescription.Text.Trim(),// sjekker at strengen ikke er for lang
TimeCompleted = null
};
dac.ServiceTask.Add(t);
try
{
dac.SaveChanges();
}
catch (Exception er)
{
new ErrorWindow(er).ShowDialog();
throw;
}
ICollectionView view = CollectionViewSource.GetDefaultView(ServiceTaskListView.ItemsSource);
view.Refresh();
}
catch (InvalidOperationException ex)
{
MessageBox.Show("Room number does not exist!", "Room entry error", MessageBoxButton.OK);
}
}
static void Main(string[] args)
{
Console.WriteLine("Main thread start");
var cnn_service = new ServiceStarter();
cnn_service.StartService();
var listener = new Listener();
listener.service_received += (m) => { Console.WriteLine("rec1: {0}", m); };
listener.service_received += (m) => { Console.WriteLine("rec2: command == {0}", m.command); };
listener.ServiseCommandResponder = (m) =>
{
var rec = new ServiceTask();
rec.command = "default info";
if (m.command == "kill")
{
cnn_service.KillService();
working = false;
listener.working = false;
rec.command = "ok, kill";
}
else if (m.command == "capture")
{
var proc_resp = cnn_service.ProcessResponse(m);
return(proc_resp);
}
return((iResponse)rec);
};
listener.Start();
while (working)
{
Thread.Sleep(5000);
Console.WriteLine("Hello main thread");
}
cnn_service.WaitForExit();
}
protected internal override bool WriteExtensionChildElements(BaseElement element, bool didWriteExtensionStartElement, XMLStreamWriter xtw)
{
ServiceTask serviceTask = (ServiceTask)element;
if (serviceTask.CustomProperties.Count > 0)
{
foreach (CustomProperty customProperty in serviceTask.CustomProperties)
{
if (string.IsNullOrWhiteSpace(customProperty.SimpleValue))
{
continue;
}
if (!didWriteExtensionStartElement)
{
xtw.WriteStartElement(BpmnXMLConstants.BPMN_PREFIX, BpmnXMLConstants.ELEMENT_EXTENSIONS, BpmnXMLConstants.BPMN2_NAMESPACE);
didWriteExtensionStartElement = true;
}
xtw.WriteStartElement(BpmnXMLConstants.ACTIVITI_EXTENSIONS_PREFIX, BpmnXMLConstants.ELEMENT_FIELD, BpmnXMLConstants.ACTIVITI_EXTENSIONS_NAMESPACE);
xtw.WriteAttribute(BpmnXMLConstants.ATTRIBUTE_FIELD_NAME, customProperty.Name);
if ((customProperty.SimpleValue.Contains("${") || customProperty.SimpleValue.Contains("#{")) && customProperty.SimpleValue.Contains("}"))
{
xtw.WriteStartElement(BpmnXMLConstants.ACTIVITI_EXTENSIONS_PREFIX, BpmnXMLConstants.ATTRIBUTE_FIELD_EXPRESSION, BpmnXMLConstants.ACTIVITI_EXTENSIONS_NAMESPACE);
}
else
{
xtw.WriteStartElement(BpmnXMLConstants.ACTIVITI_EXTENSIONS_PREFIX, BpmnXMLConstants.ELEMENT_FIELD_STRING, BpmnXMLConstants.ACTIVITI_EXTENSIONS_NAMESPACE);
}
xtw.WriteCharacters(customProperty.SimpleValue);
xtw.WriteEndElement();
xtw.WriteEndElement();
}
}
else
{
didWriteExtensionStartElement = FieldExtensionExport.WriteFieldExtensions(serviceTask.FieldExtensions, didWriteExtensionStartElement, xtw);
}
return(didWriteExtensionStartElement);
}
public void should_get_task_from_repository()
{
var spec = new ListAllServiceSpecification();
var serviceTask = new ServiceTask {
Id = 3
};
var serviceTasks = new List <ServiceTask> {
serviceTask
};
var expectedTask = new ClientTask {
Id = 3
};
var clientTasks = new List <ClientTask> {
expectedTask
};
repo.GetTasks(spec).Returns(serviceTasks);
mapper.ConvertToClient(serviceTask).Returns(expectedTask);
var resultList = todoList.GetTasks(spec);
resultList.Should().BeEquivalentTo(clientTasks);
}
protected internal virtual void VerifyType(Process process, ServiceTask serviceTask, IList <ValidationError> errors)
{
if (!string.IsNullOrWhiteSpace(serviceTask.Type))
{
if (!serviceTask.Type.Equals("mail", StringComparison.CurrentCultureIgnoreCase) && !serviceTask.Type.Equals("mule", StringComparison.CurrentCultureIgnoreCase) && !serviceTask.Type.Equals("camel", StringComparison.CurrentCultureIgnoreCase) && !serviceTask.Type.Equals("shell", StringComparison.CurrentCultureIgnoreCase) && !serviceTask.Type.Equals("dmn", StringComparison.CurrentCultureIgnoreCase))
{
AddError(errors, ProblemsConstants.SERVICE_TASK_INVALID_TYPE, process, serviceTask, ProcessValidatorResource.SERVICE_TASK_INVALID_TYPE);
}
if (serviceTask.Type.Equals("mail", StringComparison.CurrentCultureIgnoreCase))
{
ValidateFieldDeclarationsForEmail(process, serviceTask, serviceTask.FieldExtensions, errors);
}
else if (serviceTask.Type.Equals("shell", StringComparison.CurrentCultureIgnoreCase))
{
ValidateFieldDeclarationsForShell(process, serviceTask, serviceTask.FieldExtensions, errors);
}
else if (serviceTask.Type.Equals("dmn", StringComparison.CurrentCultureIgnoreCase))
{
ValidateFieldDeclarationsForDmn(process, serviceTask, serviceTask.FieldExtensions, errors);
}
}
}
/// <summary>
/// Méthode delegate de try/catch
/// </summary>
/// <param name="method">Methode qui sera executée</param>
/// <param name="errorMessage">Message d'erreur utilisateur</param>
/// <param name="writelog">Doit écrire dans le log</param>
/// <param name="values">Valeurs de log</param>
protected void RunServiceTask(ServiceTask method, ServiceMemoryError memoryMethod, string errorMessage, bool writelog, params string[] values)
{
if (writelog)
{
EnteringMethodLogMessage(method.Method, values);
}
try
{
method();
}
catch (InsufficientMemoryException ie)
{
LogTools.WriteInfo(Logs.MANAGER_MEMORY_ERROR);
LogTools.WriteDebug(ie.Message);
if (memoryMethod != null)
{
memoryMethod();
}
}
catch (Exception ex)
{
if (LogTools.IsDebugModeActive())
{
MessageBox.Show(errorMessage + "\r\n" + Errors.ERROR_METHOD + method.Method.Name + ": " + ex.Message, Errors.ERROR_BOX_TITLE);
if (writelog)
{
LogTools.WriteDebug(errorMessage + "\r\n" + Errors.ERROR_METHOD + method.Method.Name + ": " + ex.Message);
}
}
else
{
MessageBox.Show(errorMessage, Errors.ERROR_BOX_TITLE);
}
}
}
public void InsertSocketPort(ServiceTask communicationTask, object commandDispatcher)
{
if (communicationTask == null || commandDispatcher == null)
{
return;
}
SocketPort socketPort = new SocketPort(commandDispatcher);
socketPort.PlannedWorkPattern = BehaviorExecutePattern.Asynchronization;
communicationTask.Add(socketPort);
}
public ServiceTask GetTask()
{
mNICTask = new ServiceTask();
mNICTask.Tag = Resource1.NICTaskName;
return mNICTask;
}
public ServiceTask GetTask()
{
mCommunicationTask = new ServiceTask();
mCommunicationTask.Tag = Resource1.CommunicationTaskName;
return mCommunicationTask;
}
public ServiceTaskEventArgs(ServiceTask serviceTask)
{
ServiceTask = serviceTask;
}
public ServiceTaskExceptionEventArgs(ServiceTask serviceTask, Exception e)
{
ServiceTask = serviceTask;
Exception = e;
}
protected virtual void OnTaskStopped(ServiceTask serviceTask)
{
}
protected virtual void OnTaskStarting(ServiceTask serviceTask)
{
}
protected virtual void OnTaskException(ServiceTask serviceTask, Exception e)
{
}
