public RobotServiceClassManager(IRobotServiceClass processClass, bool enforceExecution)
{
_executionType = ServiceClassExecutionType.ByClass;
_processClass = processClass;
_enforceExecution = enforceExecution;
_enforceDefined = true;
}
public RobotServiceClassManager(IRobotServiceClass processClass)
{
_executionType = ServiceClassExecutionType.ByClass;
_processClass = processClass;
_enforceDefined = false;
}
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 IRobotServiceClass GetServiceClassInstance(ServiceClassDefinition classDefinition, string appPath)
{
IRobotServiceClass processClass = null;
OnStep(String.Format(Resources.Class_InitializingProcessment, classDefinition.TypeFullName));
try
{
// Pega o caminho do assembly
OnStep(String.Format(Resources.Assembly_Locating, classDefinition.AssemblyName));
string assemblyPath = null;
if (File.Exists(classDefinition.AssemblyName))
{
assemblyPath = classDefinition.AssemblyName;
}
else if (File.Exists(Path.Combine(appPath, classDefinition.AssemblyName)))
{
assemblyPath = Path.Combine(appPath, classDefinition.AssemblyName);
}
// Tenta carregar o assembly do caminho encontrado ou do GAC
Assembly assembly;
try
{
if (!String.IsNullOrEmpty(assemblyPath))
{
OnStep(String.Format(Resources.Assembly_Loading, assemblyPath));
assembly = Assembly.LoadFrom(assemblyPath);
}
else
{
OnStep(String.Format(Resources.Assembly_Loading, classDefinition.AssemblyName));
assembly = Assembly.ReflectionOnlyLoadFrom(classDefinition.AssemblyName);
}
}
catch
{
assembly = null;
}
// Verifica se o assembly foi carregado
if (assembly != null)
{
OnStep(String.Format(Resources.Assembly_Loaded, classDefinition.AssemblyName));
// Tenta carregar a classe configurada
var type = assembly.GetType(classDefinition.TypeFullName);
// Verifica se a classe foi encontrada
OnStep(String.Format(Resources.Assembly_VerifyingClassExists, classDefinition.AssemblyName, classDefinition.TypeFullName));
if (type != null)
{
// Verifica se a classe implementa a interface IRobotServiceClass
OnStep(String.Format(Resources.Class_VerifyingInterfaceImplementation, classDefinition.TypeFullName));
var classInterfaceType = typeof(IRobotServiceClass);
var interfaces = type.GetInterfaces();
var implementsInfertace = interfaces.Any(interfaceType => interfaceType.FullName == classInterfaceType.FullName);
if (implementsInfertace)
{
//Instancia a classe
OnStep(String.Format(Resources.Class_Instantiation, classDefinition.TypeFullName));
processClass = (IRobotServiceClass)assembly.CreateInstance(type.FullName);
OnStep(String.Format(Resources.Class_Instantiated, classDefinition.TypeFullName));
}
else
{
throw new NotImplementedException(String.Format(Resources.Class_NotImplementErrorMessage, classDefinition.TypeFullName, classInterfaceType.FullName));
}
}
else
{
throw new Exception(String.Format(Resources.Assembly_TypeNotFoundErrorMessage, classDefinition.AssemblyName, classDefinition.TypeFullName));
}
}
else
{
throw new FileNotFoundException(String.Format(Resources.Assembly_AssemblyNotFoundErrorMessage, classDefinition.AssemblyName));
}
return(processClass);
}
catch (Exception exp)
{
OnError(exp);
}
return(processClass);
}
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);
}
}
