/// <summary>
/// Method called when a process token executes the step.
/// </summary>
public ExitType Execute(IStepExecutionContext context)
{
IState _timenow = _propTimenow.GetState(context);
double timenow = Convert.ToDouble(_timenow.StateValue);
IState _salida = _propSalida.GetState(context);
double salida = Convert.ToDouble(_salida.StateValue);
IState _aux = _propAux.GetState(context);
double aux = Convert.ToDouble(_aux.StateValue);
IState _idcamion = _propIdcamion.GetState(context);
double idcamion = Convert.ToDouble(_idcamion.StateValue);
SerializarElement sr = new SerializarElement();
if (File.Exists(sr.SerializationFile))
{
Vect v = sr.deserializa();
vectores = sr.deserializa();
vectores.MipYc = v.MipYc;
vectores.MipYv = v.MipYv;
vectores.MipTc = v.MipTc;
vectores.MipTv = v.MipTv;
//Dinamico
vectores.Din1 = v.Din1;
vectores.DesCam = v.DesCam;
vectores.Fila = v.Fila;
//LP
vectores.TCV = v.TCV;
vectores.TCC = v.TCC;
vectores.TCj = v.TCj;
vectores.TDi = v.TDi;
vectores.Destij = v.Destij;
vectores.Dj = v.Dj;
vectores.Uj = v.Uj;
vectores.Ui = v.Ui;
vectores.RLi = v.RLi;
vectores.RUi = v.RUi;
vectores.PlYc = v.PlYc;
vectores.PlYv = v.PlYv;
vectores.PlTc = v.PlTc;
vectores.PlTv = v.PlTv;
vectores.PlTcmalo = v.PlTcmalo;
vectores.Mine = v.Mine;
vectores.Mineralocado = v.Mineralocado;
vectores.Lastrealocado = v.Lastrealocado;
}
/*
* vectores.PlTc[30, 0]; #flujo pala 1
* vectores.PlTc[30, 1]; #flujo pala 2
* etc etc
*
* vectores.Din1[x, 4] = pala1; #Ultimo tiempo que pala 1 tuvo una asignacion
* vectores.Din1[x + 30, 4] = pala2; #Ultimo tiempo que pala 2 tuvo una asignacion
* vectores.Din1[x + 60, 4] = pala3; etc
* vectores.Din1[x + 90, 4] = pala4;
* vectores.Din1[x + 120, 4] = pala5;
* vectores.Din1[x + 150, 4] = pala6;
* vectores.Din1[x + 180, 4] = pala7;
* vectores.Din1[x + 210, 4] = pala8;
* vectores.Din1[x + 240, 4] = pala9;
* vectores.Din1[x + 270, 4] = pala10;
* vectores.Din1[x + 300, 4] = pala11;
* vectores.Din1[x + 330, 4] = pala12;
* vectores.Din1[x + 360, 4] = pala13;
* vectores.Din1[x + 390, 4] = pala14;
* vectores.Din1[x + 420, 4] = pala15;
* vectores.Din1[x + 450, 4] = pala16;
* vectores.Din1[x + 480, 4] = pala17;
* vectores.Din1[x + 510, 4] = pala18;
* vectores.Din1[x + 540, 4] = pala19;
* vectores.Din1[x + 570, 4] = pala20;
*
* timenow; #tiempo actual
*
*
*
*/
int Npalas = 20;
int NSitios = 30;
double[] tij_op = new double[Npalas];
double[] desv_tij = new double[Npalas];
double[] Puntaje = new double[Npalas];
double Pmax = -10000000000;
double Destino = 0;
int[] Candidata = new int[Npalas];
double botadero;
for (int j = 0; j < Npalas; j++)
{
Candidata[j] = 0;
if (vectores.PlYv[Convert.ToInt32(vectores.DesCam[Convert.ToInt32(idcamion) - 1, 2] - 1), j] > 0 && vectores.Uj[j] > 0)
{
Candidata[j] = 1;
}
}
for (int j = 0; j < Npalas; j++)
{
if (Candidata[j] > 0)
{
double FlujoCamionesCargadoTotal = 0;
for (int i = 0; i < NSitios; i++)
{
FlujoCamionesCargadoTotal = FlujoCamionesCargadoTotal + vectores.PlYv[i, j];
}
tij_op[j] = 1 / FlujoCamionesCargadoTotal;
desv_tij[j] = (timenow - vectores.Din1[30 * j, 4]) - tij_op[j];
Puntaje[j] = desv_tij[j] / tij_op[j];
if (Puntaje[j] > Pmax)
{
Pmax = Puntaje[j];
Destino = j + 1;
}
}
}
if (Destino == 4 || Destino == 5 || Destino == 6 || Destino == 10 || Destino == 17 || Destino == 18)
{
botadero = 1;
}
else if (Destino == 7 || Destino == 8 || Destino == 12)
{
botadero = 4;
}
else if (Destino == 1 || Destino == 2 || Destino == 3 || Destino == 11)
{
botadero = 8;
}
else
{
Destino = 0;
botadero = 3;
}
_salida.StateValue = Destino;
_aux.StateValue = botadero;
sr.serializa(vectores);
sr.closeStream();
return(ExitType.FirstExit);
}
public override ExecutionResult Run(IStepExecutionContext context)
{
Console.WriteLine(Message);
return(ExecutionResult.Next());
}
public override ExecutionResult Run(IStepExecutionContext context)
{
Console.WriteLine("Doing Task 2");
throw new Exception();
}
public Task <ExecutionResult> RunAsync(IStepExecutionContext context)
{
return(Task.FromResult(Run(context)));
}
public override ExecutionResult Run(IStepExecutionContext context)
{
Console.WriteLine("Hello world");
return(ExecutionResult.Next());
}
public override ExecutionResult Run(IStepExecutionContext context) => context.PersistenceData == null
? ExecutionResult.Sleep(Period,
new object())
: ExecutionResult.Next();
public override ExecutionResult Run(IStepExecutionContext context)
{
Console.WriteLine($"Doing {nameof(TaskA)}");
return(ExecutionResult.Next());
}
public override async Task <ExecutionResult> RunAsync(IStepExecutionContext context)
{
Output = (Input1 + Input2);
return(ExecutionResult.Next());
}
public override async Task Invoke(IStepExecutionContext context = null)
{
var messageRepository = ResolverFactory.Resolve <MessageRepository>();
var reporterRepository = ResolverFactory.Resolve <ReporterRepository>();
var messageDeliveryChannelRepository = ResolverFactory.Resolve <MessageDeliveryChannelRepository>();
var logger = ResolverFactory.Resolve <ILogger>("SyncService");
var errorLogger = ResolverFactory.Resolve <ILogger>("Error");
try
{
var undeliverMessages = messageRepository.GetUndeliveredMessages(100, 0);
var linkedReportModels = messageRepository.GetLinkedReports(undeliverMessages.Select(m => m.Id));
var reportModels = reporterRepository.GetByIds(linkedReportModels.Select(r => r.ReporterId.ToString()).Distinct());
var linkedDeliveryChannels = reporterRepository.GetLinkedDeliveryChannels(reportModels.Select(r => r.Id.ToString()));
var deliveryChannelModels = messageDeliveryChannelRepository.GetByIds(linkedDeliveryChannels.Select(c => c.DeliveryChannelId.ToString()).Distinct());
// Order same same channels, these one should be run in sequence, e.g: slack cannot be send in parallel
var channelDict = new Dictionary <string, List <MessageDeliveryChannelModel> >();
foreach (var channel in deliveryChannelModels)
{
if (!channelDict.ContainsKey(channel.ChannelId))
{
channelDict.Add(channel.ChannelId, new List <MessageDeliveryChannelModel> {
});
}
channelDict[channel.ChannelId].Add(channel);
}
await Task.Run(() => Parallel.ForEach(channelDict, async(c, i) =>
{
foreach (var channel in c.Value)
{
var relatedReports = reportModels.Where(rp => linkedDeliveryChannels.Any(dc => dc.DeliveryChannelId == channel.Id));
var relatedMessages = undeliverMessages.Where(m => linkedReportModels.Any(rm => rm.MessageId == m.Id && relatedReports.Any(r => r.Id == rm.ReporterId)));
var messageDic = new Dictionary <MessageType, List <MessageModel> >();
foreach (var relatedMessage in relatedMessages)
{
if (!messageDic.ContainsKey(relatedMessage.MessageType))
{
messageDic.Add(relatedMessage.MessageType, new List <MessageModel>());
}
messageDic[relatedMessage.MessageType].Add(relatedMessage);
}
var options = messageDeliveryChannelRepository.LoadOptions(channel.Id.ToString(), channel.EntityType);
var delieveryChannel = channels.FirstOrDefault(cc => cc.Id == channel.ChannelId);
delieveryChannel.SetOptions(options.Select(o => new OptionItem {
Name = o.Key, Value = o.Value
}));
delieveryChannel.OnReport(s => logger.Information(s));
foreach (var dict in messageDic)
{
if (dict.Value == null || dict.Value.Count == 0)
{
continue;
}
try
{
// send bulk messages in sequence because of MessageType is different
await delieveryChannel.DeliverMessage(string.Join("\n", dict.Value.Select(v => v.Message)), dict.Key);
}
finally
{
// Update the message as repotered no matter what
messageRepository.SetMessagesAsReported(dict.Value.Select(v => v.Id));
}
}
}
}));
}
catch (Exception ex)
{
errorLogger.Error(ex, ex.Message);
throw;
}
finally
{
ResolverFactory.Release(logger);
ResolverFactory.Release(errorLogger);
logger = null;
errorLogger = null;
}
}
public override ExecutionPipelineDirective BeforeExecute(WorkflowExecutorResult executorResult, IStepExecutionContext context, ExecutionPointer executionPointer, IStepBody body)
{
if (executionPointer.EventPublished)
{
if (body is ISubscriptionBody)
{
(body as ISubscriptionBody).EventData = executionPointer.EventData;
}
}
return(ExecutionPipelineDirective.Next);
}
public override ExecutionResult Run(IStepExecutionContext context)
{
Console.WriteLine("Goodbye World!");
return(ExecutionResult.Next());
}
public override ExecutionResult Run(IStepExecutionContext context)
{
Console.WriteLine("Doing Task 3");
//throw new Exception();
return(ExecutionResult.Next());
}
public override async Task Invoke(IStepExecutionContext context = null)
{
var executeAt = DateTime.Now.ToUnixTimestamp();
var firstQueuedItem = entityRepository.GetCurrentQueuedItems();
if (firstQueuedItem == null)
{
return;
}
IIndexModel indexModel = null;
IndexItemModel itemModel = null;
IIndexer indexer = null;
IPusher pusher = null;
IEnumerable <OptionItem> options = null;
if (firstQueuedItem.TargetEntityType == EntityType.Entity)
{
indexModel = entityRepository.GetById(firstQueuedItem.TargetEntityId.ToString());
options = entityRepository.LoadOptions(indexModel.Id.ToString()).Select(o => new OptionItem {
Name = o.Key, Value = o.Value
});
var sourceConnection = connectionRepository.GetById(indexModel.SourceConnectionId.ToString());
var destinationConnection = connectionRepository.GetById(indexModel.DestinationConnectionId.ToString());
indexer = entityIndexers.FirstOrDefault(i => i.IsImplemented(indexModel.SourceProcessorId, sourceConnection.ProviderId));
pusher = entityPushers.FirstOrDefault(p => p.IsImplemented(indexModel.DestinationProcessorId, destinationConnection.ProviderId));
}
else
{
var attributeModel = attributeRepository.GetById(firstQueuedItem.TargetEntityId.ToString());
indexModel = attributeModel;
var entityModel = entityRepository.GetById(attributeModel.EntityId.ToString());
options = attributeRepository.LoadOptions(attributeModel.Id.ToString()).Select(o => new OptionItem {
Name = o.Key, Value = o.Value
});
var sourceConnection = connectionRepository.GetById(attributeModel.SourceConnectionId.ToString());
var destinationConnection = connectionRepository.GetById(attributeModel.DestinationConnectionId.ToString());
indexer = attributeIndexers.FirstOrDefault(i => i.IsImplemented(attributeModel.SourceProcessorId, entityModel.SourceProcessorId, sourceConnection.ProviderId));
pusher = attributePushers.FirstOrDefault(p => p.IsImplemented(attributeModel.DestinationProcessorId, entityModel.DestinationProcessorId, destinationConnection.ProviderId));
}
indexer.SetIndex(indexModel);
indexer.SetOptions(options);
pusher.SetIndex(indexModel);
pusher.SetOptions(options);
pusherManager.SetIndex(indexModel);
pusherManager.OnReport(s => Logger.Information(s));
pusherManager.SetIndexer(indexer);
pusherManager.SetPusher(pusher);
try
{
itemModel = entityRepository.GetIndexedItemById(indexModel, firstQueuedItem.TargetItemId.ToString());
var pushState = await pusherManager.PushItem(itemModel);
var queueItemStatus = firstQueuedItem.Status == PushState.None ? PushState.Success : firstQueuedItem.Status;
var messageId = messageRepository.Create(new
{
Message = string.Join("\n", pusherManager.GetReportMessages()),
CreatedAt = DateTime.Now.ToUnixTimestamp(),
MessageType = MessageType.Information,
Status = MessageStatus.None
});
queueItemStatus = queueItemStatus & pushState;
if ((pushState & PushState.Success) <= 0)
{
queueItemStatus = (queueItemStatus | PushState.Success) ^ (PushState.Success);
}
queueItemRepository.Update(firstQueuedItem.Id.ToString(), new
{
UpdatedAt = DateTime.Now.ToUnixTimestamp(),
ExecuteAt = executeAt,
ExecutedAt = DateTime.Now.ToUnixTimestamp(),
MessageId = messageId,
Status = queueItemStatus
});
}
catch (Exception ex)
{
var messages = $@"Queue item (Id: {firstQueuedItem.Id}) failed to run.
Addtional information:
```{JsonConvert.SerializeObject(indexModel, Formatting.Indented)}```
Progress:
```{string.Join("\n - ", pusherManager.GetReportMessages())}```
Exception:
```{ex}```";
var messageId = messageRepository.Create(new
{
Message = messages,
CreatedAt = DateTime.Now.ToUnixTimestamp(),
MessageType = MessageType.Error,
Status = MessageStatus.None
});
queueItemRepository.Update(firstQueuedItem.Id.ToString(), new
{
UpdatedAt = DateTime.Now.ToUnixTimestamp(),
ExecuteAt = executeAt,
ExecutedAt = DateTime.Now.ToUnixTimestamp(),
MessageId = messageId,
Status = (firstQueuedItem.Status | PushState.UnexpectedError | PushState.Failed | PushState.Success) ^ PushState.Success, // remove success
});
throw;
}
}
public override ExecutionResult Run(IStepExecutionContext context)
{
_myService.DoTheThings();
return(ExecutionResult.Next());
}
public override ExecutionPipelineDirective BeforeExecute(WorkflowExecutorResult executorResult, IStepExecutionContext context, ExecutionPointer executionPointer, IStepBody body)
{
if (executionPointer.EventPublished)
{
if ((body is UserStep) && (executionPointer.EventData is UserAction))
{
(body as UserStep).UserAction = (executionPointer.EventData as UserAction);
executionPointer.ExtensionAttributes["ActionUser"] = (executionPointer.EventData as UserAction).User;
}
}
return(ExecutionPipelineDirective.Next);
}
protected virtual void RunImpl(IStepExecutionContext context)
{
}
public override ExecutionResult Run(IStepExecutionContext context)
{
Output = (Input1 + Input2);
return(ExecutionResult.Next());
}
public override ExecutionResult Run(IStepExecutionContext context)
{
throw new NotImplementedException();
}
public override ExecutionResult Run(IStepExecutionContext context)
{
Value2 = Value1 + 1;
return(ExecutionResult.Next());
}
private object GetSwitchOutcome(IStepExecutionContext context)
{
var switchPointer = context.Workflow.ExecutionPointers.First(x => x.Children.Contains(context.ExecutionPointer.Id));
return(switchPointer.Outcome);
}
public sealed override async Task <ExecutionResult> RunAsync(IStepExecutionContext context)
{
ResponseObject <TResPayload> resObj;
try
{
switch (MethodType)
{
case ERestMethodType.GET:
resObj = await GetAsync <TResPayload>(Method);
break;
case ERestMethodType.POST:
var reqBody = RequestBodyObj.Serialize();
resObj = await PostAsync <TResPayload>(Method, reqBody);
break;
case ERestMethodType.PUT:
// TODO: implement
// ..
throw new NotImplementedException("TODO");
case ERestMethodType.DELETE:
// TODO: implement
// ..
throw new NotImplementedException("TODO");
default:
throw new IndexOutOfRangeException($"Unknown {nameof(MethodType)}={MethodType}.");
}
}
catch (Exception e)
{
string method;
switch (MethodType)
{
case ERestMethodType.GET:
method = nameof(GetAsync);
break;
case ERestMethodType.POST:
method = nameof(GetAsync);
break;
case ERestMethodType.PUT:
// TODO: implement
// ..
throw new NotImplementedException("TODO");
case ERestMethodType.DELETE:
// TODO: implement
// ..
throw new NotImplementedException("TODO");
default:
throw new IndexOutOfRangeException($"Unknown {nameof(MethodType)}={MethodType}.");
}
throw new WorkflowAbortException($"Exception in {method} method.", e);
}
Debug.Assert(resObj != null);
if (resObj.IsOk == false)
{
throw new WorkflowAbortException(resObj.ToString());
}
ResponsePayload = resObj.Payload;
return(ExecutionResult.Next());
}
public virtual ExecutionPipelineDirective BeforeExecute(WorkflowExecutorResult executorResult, IStepExecutionContext context, ExecutionPointer executionPointer, IStepBody body)
{
return(ExecutionPipelineDirective.Next);
}
public abstract ExecutionResult Run(IStepExecutionContext context);
public virtual void AfterExecute(WorkflowExecutorResult executorResult, IStepExecutionContext context, ExecutionResult stepResult, ExecutionPointer executionPointer)
{
}
private void ProcessInputs(WorkflowInstance workflow, WorkflowStep step, IStepBody body, IStepExecutionContext context)
{
//TODO: Move to own class
foreach (var input in step.Inputs)
{
var member = (input.Target.Body as MemberExpression);
object resolvedValue = null;
switch (input.Source.Parameters.Count)
{
case 1:
resolvedValue = input.Source.Compile().DynamicInvoke(workflow.Data);
break;
case 2:
resolvedValue = input.Source.Compile().DynamicInvoke(workflow.Data, context);
break;
default:
throw new ArgumentException();
}
step.BodyType.GetProperty(member.Member.Name).SetValue(body, resolvedValue);
}
}
public override ExecutionResult Run(IStepExecutionContext context)
{
return(_body.Invoke(context));
}
public override ExecutionResult Run(IStepExecutionContext context)
{
Console.WriteLine("Doing Task C");
return(ExecutionResult.Next());
}
public override ExecutionResult Run(IStepExecutionContext context)
{
return(ExecutionResult.Next());
}
private void Assign(object data, IStepBody step, IStepExecutionContext context)
{
_action.Invoke((TStepBody)step, (TData)data);
}
public override ExecutionResult Run(IStepExecutionContext context)
{
Step2Ticker++;
CheckSum += Convert.ToInt32(context.Item);
return(ExecutionResult.Next());
}