private void ExecuteProcess(IRobotServiceClass processClass, RobotServiceItemClass process)
{
try
{
OnStep(String.Format(Resources.Process_ManagingExecutionStatus, process.Identificator));
// Armazena o status inicial de execução
var initialStatus = process.Status;
// Caso o status seja aguardando início ou retorno
if (initialStatus != RobotServiceItemStatus.WaitingStart &&
initialStatus != RobotServiceItemStatus.WaitingReturn)
{
return;
}
// Trata atualização de status
if (initialStatus == RobotServiceItemStatus.WaitingStart)
{
process.Status = RobotServiceItemStatus.Executing;
processClass.UpdateProcessStatus(process);
}
else if (initialStatus == RobotServiceItemStatus.WaitingReturn)
{
process.Status = RobotServiceItemStatus.RequestingReturn;
processClass.UpdateProcessStatus(process);
}
try
{
// Processa
OnStep(String.Format(Resources.Process_Processing, process.Identificator));
var executed = processClass.Process(process);
// Trata atualização de status após processamento
OnStep(String.Format(Resources.Process_ManagingPostExecutionStatus, process.Identificator));
if (initialStatus == RobotServiceItemStatus.WaitingStart)
{
process.Status = process.HasReturn
? RobotServiceItemStatus.WaitingReturn
: RobotServiceItemStatus.Processed;
}
else if (initialStatus == RobotServiceItemStatus.WaitingReturn)
{
process.Status = executed
? RobotServiceItemStatus.Processed
: RobotServiceItemStatus.WaitingReturn;
}
OnStep(String.Format(Resources.Process_ExecutionFinalized, process.Identificator));
}
catch (Exception exp)
{
process.Status = RobotServiceItemStatus.ProcessedWithErrors;
process.ErrorMessage = exp.Message;
OnError(exp);
}
finally
{
processClass.UpdateProcessStatus(process);
}
}
catch (Exception exp)
{
OnError(exp);
}
}
public void Execute()
{
try
{
if (_executionType == ServiceClassExecutionType.ByDefinition)
{
_processClass = this.GetServiceClassInstance(_classDefinition, _appPath);
}
if (_processClass == null)
{
throw new NullReferenceException(Resources.ProcessClassNotFoundErrorMessage);
}
// Caso a propriedade de forçar a execução tenha sido setada no Manager ele sobrepõe a mesma propriedade configurada na classe de serviço.
if (_enforceDefined)
{
_processClass.EnforceExecution = _enforceExecution;
}
var classType = _processClass.GetType();
OnStep(String.Format(Resources.Class_Executing, classType.FullName));
// Solicita os processos a serem executados
OnStep(String.Format(Resources.Class_RequestingProcesses, classType.FullName));
var processes = _processClass.GetCurrentProcesses();
if (processes != null && processes.Any())
{
// Varre os processos e executa um a um
OnStep(String.Format(Resources.Class_EnumeratingProcesses, classType.FullName));
foreach (RobotServiceItemClass process in processes)
{
if (String.IsNullOrEmpty(process.Identificator))
{
process.Identificator = classType.FullName;
}
OnStep(String.Format(Resources.Process_ValidatingExecution, process.Identificator));
var executeProcess = false;
// Verifica se esta esperando retorno caso esteja executa de qualquer forma
OnStep(String.Format(Resources.Process_ValidatingStatus, process.Identificator));
if (process.Status == RobotServiceItemStatus.WaitingReturn)
{
executeProcess = true;
}
else
{
if (_processClass.EnforceExecution)
{
executeProcess = true;
}
else
{
OnStep(String.Format(Resources.Process_ValidatingExecutionTimeInterval, process.Identificator));
// Valida se foi informado uma hora ou um intervalo de execução
if (process.ExecuteTime == null && process.ExecuteInterval == null)
{
process.Status = RobotServiceItemStatus.NotProcessedWithErrors;
process.ErrorMessage = String.Format(Resources.ExecutionTimeNotFoundErrorMessage, process.Identificator);
_processClass.UpdateProcessStatus(process);
}
else
{
// Pega a hora base para validação
var baseTime = process.LastExecutionTime == null ? process.CreateTime : process.LastExecutionTime.Value;
// Valida se é a hora de executar o processo
if (process.ExecuteTime != null)
{
// Verifica se á exatamente a mesma hora da execução
var nowTime = DateTime.Now.ToShortTimeString();
var executeTime = process.ExecuteTime.Value.ToShortTimeString();
if (nowTime == executeTime)
{
executeProcess = true;
}
// Verifica se a hora da execução já passou e nada foi executado ainda
if (!executeProcess)
{
var nowDateTime = DateTime.Now;
var executeDateTime = new DateTime(nowDateTime.Year, nowDateTime.Month, nowDateTime.Day, process.ExecuteTime.Value.Hour, process.ExecuteTime.Value.Minute, process.ExecuteTime.Value.Second);
// Verifica se a hora de execução é menor que a hora atual (já passou a hora de ser executado)
if (executeDateTime < nowDateTime)
{
// Verifica se a hora da ultima execução é menor que a hora de executar (ainda não foi executado)
if (baseTime < executeDateTime)
{
executeProcess = true;
}
}
}
}
else if (process.ExecuteInterval != null)
{
// Pega o intervalo entre a ultima execução e a hora atual
var lastExecuteInterval = DateTime.Now - baseTime;
// Verifica se o intervalo de execução já passou
if (lastExecuteInterval >= process.ExecuteInterval)
{
executeProcess = true;
}
}
}
}
}
OnStep(String.Format(Resources.Process_VerifyingExecution, process.Identificator));
// Executa o processo caso necessário
if (executeProcess)
{
// Verificar se o processo é síncrono
if (process.Type != RobotServiceItemType.Asynchronous)
{
// Executa o processo de forma síncrona
OnStep(String.Format(Resources.Process_ExecutingSyncProcess, process.Identificator));
ExecuteProcess(_processClass, process);
}
else
{
// Executa o processo de forma assíncrona
OnStep(String.Format(Resources.Process_ExecutingAsyncProcess, process.Identificator));
var asyncProcess = new AsyncThreadCaller();
asyncProcess.MethodCall += asyncProcess_MethodCall;
var parameters = new Dictionary <string, object>();
parameters["processClass"] = _processClass;
parameters["process"] = process;
asyncProcess.Start(parameters);
}
}
}
}
OnStep(String.Format(Resources.Class_ExecutionFinalized, classType.FullName));
OnComplete(this._classDefinition);
}
catch (Exception exp)
{
OnError(exp);
OnComplete(this._classDefinition);
}
}