public bool DeleteReceive(Receive entity)
{
if (entity == null) return false;
_unitOfWork.ReceiveRepository.Delete(entity);
_unitOfWork.Save();
return true;
}
static void Main()
{
// mimics Arduino calling structure
var receive = new Receive {RunLoop = true};
receive.Setup();
while (receive.RunLoop) receive.Loop();
receive.Exit();
}
protected override bool AroundReceive(Receive receive, object message)
{
if (message is TestRequest)
{
Sender.Tell(_testValue);
return true;
}
else return base.AroundReceive(receive, message);
}
public SynChatThinclient()
{
InitializeComponent();
_socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); // Create the Socket
// Try to connect and send the port request command
_socket.Connect(IPAddress.Parse(RemoteAddress), port);
Thread lis = new Thread(new ThreadStart(Listener));
lis.IsBackground = true;
lis.Start();
OnReceive += new Receive(Received_msg);
}
private string RemoteAddress = Properties.Settings.Default.server_ip; // Define Network Propertys (ServerIP and commandport)
#endregion Fields
#region Constructors
public SynChat()
{
InitializeComponent();
// Clear all indices in chat marker array
for(int i=0; i < 10; i++)
{
freechats[i] = true;
chatbuddies[i] = "";
}
// Marrie the delegates with their events (needed for invokes)
OnReceiveBuddy += new Buddy(ReceiveBuddy);
EnableItems += new Enable(Enable_Items);
OnReceive += new Receive(OpenChat);
OnStatusChange += new BuddyStatus(StatusChange);
OnStatusReceived += new RequestedStatusReceived(RequestedStatusReceive);
OnStatusSend += new StatusSend(SendStatus);
Client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); // Create the Socket
try
{
// Try to connect and send the port request command
Client.Connect(IPAddress.Parse(RemoteAddress), port);
}
catch (SocketException)
{
// If that fails -> Show a error and close the Application
MessageBox.Show("Konnte keine Verbindung zum Server herstellen!");
debugFile.Write("Server unavaliable\r\n");
this.Close();
}
// Create the Thread for the Listener and put it in the background
Thread lis = new Thread(new ThreadStart(Listener));
lis.IsBackground = true;
lis.Start();
// Remove menu entry for clearing chatlogs if chatlogs are disabled
if (Properties.Settings.Default.client_log_conversations)
{
alleMitschnitteLöschenToolStripMenuItem.Visible = true;
}
}
/// <summary>
/// Causes the Actor to become a different kind of actor.
/// This has little if any use with the current design
/// because messages are delivered to individual OnReceive()
/// methods.
/// </summary>
/// <param name="receive">the Receive to which messages are dispatched</param>
/// <param name="discardOld">the bool that if set causes an Unbecome() before the Become()</param>
public void Become(Receive receive, bool discardOld = true)
{
if (discardOld)
{
Unbecome();
}
Receive = receive;
Receivers.Push(receive);
Channel.ClearSubscribers();
Channel.Subscribe(Fiber, GetOnReceiveDelegate());
}
/// <summary>
/// Generates the receive model.
/// </summary>
/// <param name="receive">The receive.</param>
/// <param name="user">The user.</param>
/// <returns></returns>
public static ReceiveViewModel GenerateReceiveModel(Receive receive, List<Commodity> commodities, List<CommodityGrade> commodityGrades, List<Transporter> transporters, List<CommodityType> commodityTypes,
List<CommoditySource> commoditySources, List<Program> programs, List<Donor> donors, List<Hub> hubs, UserProfile user,List<Unit> units )
{
ReceiveViewModel model = new ReceiveViewModel();
model._UserProfile = user;
model.InitalizeViewModel(commodities, commodityGrades, transporters, commodityTypes,
commoditySources, programs, donors, hubs, user,units);
model.IsEditMode = true;
model.ReceiveID = receive.ReceiveID;
model.DriverName = receive.DriverName;
model.GRN = receive.GRN;
model.PlateNo_Prime = receive.PlateNo_Prime;
model.PlateNo_Trailer = receive.PlateNo_Trailer;
model.TransporterID = receive.TransporterID;
model.HubID = receive.HubID;
ReceiveDetail receiveDetail = receive.ReceiveDetails.FirstOrDefault();//p=>p.QuantityInMT>0);
Transaction receiveDetailtransaction = null;
if (receiveDetail != null)
foreach (Transaction transaction in receiveDetail.TransactionGroup.Transactions)
{
var negTransaction = receiveDetail.TransactionGroup.Transactions.FirstOrDefault(p => p.QuantityInMT < 0);
if (negTransaction != null)
model.SourceHubID = negTransaction.Account.EntityID;
receiveDetailtransaction = transaction;
break;
}
if (receiveDetailtransaction != null)
{
model.SINumber = receiveDetailtransaction.ShippingInstruction != null ? receiveDetailtransaction.ShippingInstruction.Value : "";
model.ProjectNumber = receiveDetailtransaction.ProjectCode != null ? receiveDetailtransaction.ProjectCode.Value : "";
model.ProgramID = receiveDetailtransaction.Program != null ? receiveDetailtransaction.Program.ProgramID : default(int);
model.StoreID = receiveDetailtransaction.Store != null ? receiveDetailtransaction.Store.StoreID : default(int);
model.StackNumber = receiveDetailtransaction.Stack.HasValue ? receiveDetailtransaction.Stack.Value : default(int);
}
else
{
model.SINumber = "";
model.ProjectNumber = "";
model.ProgramID = default(int);
model.StoreID = default(int);
model.StackNumber = default(int);
}
model.ReceiptDate = receive.ReceiptDate;
model.WayBillNo = receive.WayBillNo;
model.CommodityTypeID = receive.CommodityTypeID;
model.ResponsibleDonorID = receive.ResponsibleDonorID;
model.SourceDonorID = receive.SourceDonorID;
model.CommoditySourceID = receive.CommoditySourceID;
model.TicketNumber = receive.WeightBridgeTicketNumber;
model.WeightBeforeUnloading = receive.WeightBeforeUnloading;
model.WeightAfterUnloading = receive.WeightAfterUnloading;
model.VesselName = receive.VesselName;
model.PortName = receive.PortName;
model.ReceiptAllocationID = receive.ReceiptAllocationID;
model.PurchaseOrder = receive.PurchaseOrder;
model.SupplierName = receive.SupplierName;
model.Remark = receive.Remark;
model.ReceivedByStoreMan = receive.ReceivedByStoreMan;
model.ReceiveDetails =Cats.Models.Hubs.ReceiveDetailViewModel.GenerateReceiveDetailModels(receive.ReceiveDetails);
return model;
}
/// <summary>
/// Changes the actor's command behavior and replaces the current receive handler with the specified handler.
/// </summary>
/// <param name="receive">The new message handler.</param>
protected void Become(Receive receive)
{
Context.Become(receive);
}
public void Become(Receive receive)
{
_state = _state.Become(receive);
}
public IActorState ClearBehaviorStack()
{
_receive = null;
return this;
}
public void SetBehavior(Receive receive)
{
_behavior.Clear();
_behavior.Push(receive);
_receive = receive;
}
/// <summary>
/// TBD
/// </summary>
/// <param name="receive">TBD</param>
public void BecomeStacked(Receive receive)
{
_state = _state.BecomeStacked(receive);
}
/// <summary>
/// TBD
/// </summary>
/// <param name="receive">TBD</param>
public void Become(Receive receive)
{
_state = _state.Become(receive);
}
public static ReceiveBehavior <T> Receive <T>(Receive <T> onMessage) => new ReceiveBehavior <T>(onMessage);
public FunctionActor(Receive receive) => _receive = receive;
static WorkflowService GetService()
{
Variable <Customer> customer = new Variable <Customer>();
Variable <Order> order = new Variable <Order>();
Variable <string> drug = new Variable <string>();
Variable <double> adjustedCost = new Variable <double>();
Variable <int> percentagePaidByInsurance = new Variable <int>();
Variable <CorrelationHandle> customerHandle = new Variable <CorrelationHandle>();
Variable <CorrelationHandle> orderHandle = new Variable <CorrelationHandle>();
XPathMessageContext pathContext = new XPathMessageContext();
pathContext.AddNamespace("psns", Constants.PharmacyServiceNamespace);
// <Snippet2>
MessageQuerySet GetOrderQuerySet = new MessageQuerySet
{
{
"OrderID",
new XPathMessageQuery("//psns:Order/psns:OrderID", pathContext)
}
};
// </Snippet2>
MessageQuerySet GetOrderIDQuerySet = new MessageQuerySet
{
{
"OrderID",
new XPathMessageQuery("//ser:guid", pathContext)
}
};
MessageQuerySet customerQuerySet = new MessageQuerySet
{
{
"CustomerID",
new XPathMessageQuery("//psns:GetBaseCost/psns:Customer/psns:CustomerID", pathContext)
}
};
MessageQuerySet customerIDQuerySet = new MessageQuerySet
{
{
"CustomerID",
new XPathMessageQuery("//ser:guid", pathContext)
}
};
// This will use implicit correlation within the workflow using the WorkflowServiceHost's default CorrelationHandle
// <Snippet3>
Receive prescriptionRequest = new Receive
{
DisplayName = "Request Perscription",
OperationName = "GetBaseCost",
ServiceContractName = Constants.PharmacyServiceContractName,
CanCreateInstance = true,
//CorrelatesWith = customerHandle, -- add this line for explicit correlation
CorrelatesOn = customerQuerySet,
Content = new ReceiveParametersContent
{
Parameters =
{
{ "Customer", new OutArgument <Customer>(customer) },
{ "Drug", new OutArgument <string>(drug) },
}
}
};
// </Snippet3>
// This will use implicit correlation within the workflow using the WorkflowServiceHost's default CorrelationHandle
Receive GetInsurancePaymentPercentageRequest = new Receive
{
DisplayName = "Get Insurance Coverage",
ServiceContractName = Constants.PharmacyServiceContractName,
OperationName = "GetInsurancePaymentPercentage",
CanCreateInstance = true,
//CorrelatesWith = customerHandle, -- add this line for explicit correlation
CorrelatesOn = customerIDQuerySet,
Content = ReceiveContent.Create(new OutArgument <Guid>())
};
// This will explicitly correlate with the SendReply action after the prescriptionRequest using the OrderID (stored in the orderHandle)
Receive GetAdjustedCostRequest = new Receive
{
DisplayName = "Get Adjusted Cost",
OperationName = "GetAdjustedCost",
ServiceContractName = Constants.PharmacyServiceContractName,
CanCreateInstance = true,
CorrelatesOn = GetOrderIDQuerySet,
CorrelatesWith = orderHandle,
Content = ReceiveContent.Create(new OutArgument <Guid>())
};
Activity PrescriptonWorkflow = new Sequence()
{
Variables = { customer, order, drug, percentagePaidByInsurance, adjustedCost, customerHandle, orderHandle },
Activities =
{
new WriteLine
{
Text = "Beginning Workflow"
},
new Parallel
{
Branches =
{
new Sequence
{
Activities =
{
GetInsurancePaymentPercentageRequest,
new Assign <int>
{
To = new OutArgument <int>((e) => percentagePaidByInsurance.Get(e)),
Value = new InArgument <int>((e) => new Random().Next(0, 100))
},
new SendReply
{
DisplayName = "Return Percentage",
Request = GetInsurancePaymentPercentageRequest,
Content = SendContent.Create(new InArgument <int>((e) => percentagePaidByInsurance.Get(e)))
}
}
},
new Sequence
{
Activities =
{
prescriptionRequest,
new WriteLine
{
Text = new InArgument <string>(env => (string.Format("{0}, {1}\t{2}",customer.Get(env).LastName, customer.Get(env).FirstName, customer.Get(env).CustomerID.ToString())))
},
new Assign <Order>
{
To = new OutArgument <Order>(order),
Value = new InArgument <Order>((e) => new Order()
{
CustomerID = customer.Get(e).CustomerID,Drug = drug.Get(e), OrderID = Guid.NewGuid()
})
},
new WriteLine
{
Text = new InArgument <string>(env => (string.Format("OrderID: {0}",order.Get(env).OrderID.ToString())))
},
new Assign <int>
{
To = new OutArgument <int>((e) => order.Get(e).Cost),
Value = new InArgument <int>((e) => new Random().Next(20, 50))
},
// <Snippet0>
new SendReply
{
DisplayName = "Send Adjusted Cost",
Request = prescriptionRequest,
// Initialize the orderHandle using the MessageQuerySet to correlate with the final GetAdjustedCost request
CorrelationInitializers =
{
// <Snippet1>
new QueryCorrelationInitializer
{
CorrelationHandle = orderHandle,
MessageQuerySet = GetOrderQuerySet
}
// </Snippet1>
},
Content = SendContent.Create(new InArgument <Order>((e) => order.Get(e)))
}
// </Snippet0>
}
}
}
},
new Assign <double>
{
To = new OutArgument <double>((e) => adjustedCost.Get(e)),
Value = new InArgument <double>((e) => order.Get(e).Cost *(100 - percentagePaidByInsurance.Get(e)) * .01)
},
new WriteLine
{
Text = new InArgument <string>(env => (string.Format("Base Cost: ${0}", order.Get(env).Cost.ToString())))
},
new WriteLine
{
Text = new InArgument <string>(env => (string.Format("Insurance Coverage: {0}%", percentagePaidByInsurance.Get(env).ToString())))
},
new WriteLine
{
Text = new InArgument <string>(env => (string.Format("Adjusted Cost: ${0}", decimal.Round(Convert.ToDecimal(adjustedCost.Get(env)), 2))))
},
GetAdjustedCostRequest,
new SendReply
{
Request = GetAdjustedCostRequest,
Content = SendContent.Create(new InArgument <double>((e) => adjustedCost.Get(e)))
},
new WriteLine
{
Text = "Workflow Completed"
}
}
};
WorkflowService service = new WorkflowService
{
Name = "PharmacyService",
Body = PrescriptonWorkflow,
ConfigurationName = "PharmacyService"
};
return(service);
}
protected override bool AroundReceive(Receive receive, object message)
{
if (message is RedeliveryTick)
{
RedeliverOverdue();
return true;
}
return base.AroundReceive(receive, message);
}
public void PushBehavior(Receive receive)
{
_behavior.Push(receive);
_receive = receive;
}
public IActorState BecomeStacked(Receive receive)
{
_behaviorStack.Push(receive);
return this;
}
public Context(Func <IActor> producer, ISupervisorStrategy supervisorStrategy, Receive receiveMiddleware, Sender senderMiddleware, PID parent)
{
_producer = producer;
_supervisorStrategy = supervisorStrategy;
_receiveMiddleware = receiveMiddleware;
_senderMiddleware = senderMiddleware;
Parent = parent;
_behavior = new Stack <Receive>();
_behavior.Push(ActorReceive);
IncarnateActor();
//fast path
if (parent != null)
{
_watchers = new HashSet <PID>
{
parent
};
}
}
public void Become(Receive receive, bool discardOld = true)
{
if(discardOld && behaviorStack.Count > 1) //We should never pop off the initial receiver
behaviorStack.Pop();
behaviorStack.Push(receive);
}
public BehaviorTester State(Receive receive, Func <Receive, Receive> extend = null, params Receive[] trait) => State(receive, null, extend, trait);
void IActorContext.Become(Receive receive, bool discardOld = true)
{
if(discardOld)
Become(receive);
else
BecomeStacked(receive);
}
public BehaviorTester State(Receive receive, Receive super, Func <Receive, Receive> extend = null, params Receive[] trait) => State(receive.Method.Name, receive, super?.Method.Name, extend, trait);
public SubReceive(Receive initial)
{
_currentReceive = initial;
}
public BehaviorTester State(string name, Receive receive) => State(name, receive, null);
/// <summary>
/// Sets the way you receive the quest.
/// </summary>
/// <param name="method"></param>
protected void SetReceive(Receive method)
{
this.ReceiveMethod = method;
}
public BehaviorTester Initial(Receive behavior)
{
initial = behavior.Method.Name;
return(this);
}
internal protected virtual bool AroundReceive(Receive receive, object message)
{
var wasHandled = receive(message);
if(!wasHandled)
{
Unhandled(message);
}
return wasHandled;
}
public EmptyActor(Receive receive)
{
_receive = receive;
}
private void _toggleButtonVisibility()
{
Receive.setHidden( value : false == _canReceive(), SaveToDb : false );
Request.setHidden( value : false == _CswNbtResources.Permit.can( CswEnumNbtActionName.Submit_Request ), SaveToDb : false );
}
public static Props FromFunc(Receive receive)
{
return(FromProducer(() => new EmptyActor(receive)));
}
public static PID SpawnActorFromFunc(Receive receive) => Context.Spawn(Props.FromFunc(receive));
public void Update(List <ReceiveDetail> inserted, List <ReceiveDetail> updated, List <ReceiveDetail> deleted, Receive receive)
{
if (receive != null)
{
_unitOfWork.ReceiveRepository.Edit(receive);
_unitOfWork.Save();
foreach (ReceiveDetail insert in inserted)
{
//TODO THIS should be in transaction
insert.ReceiveDetailID = Guid.NewGuid();
receive.ReceiveDetails.Add(insert);
}
foreach (ReceiveDetail delete in deleted)
{
ReceiveDetail deletedCommodity = _unitOfWork.ReceiveDetailRepository.FindBy(p => p.ReceiveDetailID == delete.ReceiveDetailID).FirstOrDefault();
if (deletedCommodity != null)
{
_unitOfWork.ReceiveDetailRepository.Delete(deletedCommodity);
}
}
foreach (ReceiveDetail update in updated)
{
ReceiveDetail updatedCommodity = _unitOfWork.ReceiveDetailRepository.FindBy(p => p.ReceiveDetailID == update.ReceiveDetailID).FirstOrDefault();
if (updatedCommodity != null)
{
updatedCommodity.CommodityID = update.CommodityID;
updatedCommodity.Description = update.Description;
updatedCommodity.ReceiveID = update.ReceiveID;
updatedCommodity.SentQuantityInMT = update.SentQuantityInMT;
// updatedCommodity.QuantityInMT = updatedCommodity.QuantityInMT;
updatedCommodity.SentQuantityInUnit = update.SentQuantityInUnit;
updatedCommodity.UnitID = update.UnitID;
}
}
_unitOfWork.Save();
}
}
public IActorState BecomeStacked(Receive receive)
{
if (_receive == null)
{
_receive = receive;
return this;
}
return GetFullState().BecomeStacked(receive);
}
public bool AddReceive(Receive entity)
{
_unitOfWork.ReceiveRepository.Add(entity);
_unitOfWork.Save();
return(true);
}
public IActorState Become(Receive receive)
{
if (_behaviorStack.Count > 1) //We should never pop off the initial receiver
_behaviorStack.Pop();
_behaviorStack.Push(receive);
return this;
}
public bool EditReceive(Receive entity)
{
_unitOfWork.ReceiveRepository.Edit(entity);
_unitOfWork.Save();
return(true);
}
public bool AddReceive(Receive entity)
{
_unitOfWork.ReceiveRepository.Add(entity);
_unitOfWork.Save();
return true;
}
protected override bool AroundReceive(Receive receive, object message)
{
Log.Info($"{Self.Path.Name} received {message.GetType().Name}");
return(base.AroundReceive(receive, message));
}
public bool EditReceive(Receive entity)
{
_unitOfWork.ReceiveRepository.Edit(entity);
_unitOfWork.Save();
return true;
}
/// <summary>
/// TBD
/// </summary>
/// <param name="receive">TBD</param>
/// <param name="message">TBD</param>
/// <returns>TBD</returns>
protected internal override bool AroundReceive(Receive receive, object message)
{
return(_atLeastOnceDeliverySemantic.AroundReceive(receive, message) || base.AroundReceive(receive, message));
}
protected override bool AroundReceive(Receive receive, object message)
{
Log.Msg(this, l => l.Debug("{0} received {1}", GetType().Name, message.GetType().Name));
return base.AroundReceive(receive, message);
}
private Activity InternalImplementation()
{
Variable <string> requestMessage = new Variable <string> {
Name = "requestString"
};
Variable <string> replyMessage = new Variable <string> {
Name = "replyString"
};
Receive receive = new Receive
{
OperationName = "StartSample",
CanCreateInstance = true,
Content = ReceiveContent.Create(new OutArgument <string>(requestMessage)),
ServiceContractName = "ITransactedReceiveService",
};
// <Snippet0>
return(new Sequence
{
Activities =
{
new WriteLine {
Text = "Service workflow begins."
},
new System.ServiceModel.Activities.TransactedReceiveScope
{
Variables = { requestMessage, replyMessage },
Request = receive,
Body = new Sequence
{
Activities =
{
new WriteLine {
Text = new InArgument <string>("Server side: Receive complete.")
},
new WriteLine {
Text = new InArgument <string>(new VisualBasicValue <string>()
{
ExpressionText = "\"Server side: Received = '\" + requestString.toString() + \"'\""
})
},
new PrintTransactionInfo(),
new Assign <string>
{
Value = new InArgument <string>("Server side: Sending reply."),
To = new OutArgument <string>(replyMessage)
},
new WriteLine {
Text = new InArgument <string>("Server side: Begin reply.")
},
new SendReply
{
Request = receive,
Content = SendContent.Create(new InArgument <string>(replyMessage)),
},
new WriteLine {
Text = new InArgument <string>("Server side: Reply sent.")
},
},
},
},
new WriteLine {
Text = "Server workflow ends."
},
},
});
// </Snippet0>
}
public void BecomeStacked(Receive receive)
{
_state = _state.BecomeStacked(receive);
}
public Receive On(Receive next) => async message =>
protected void Become(Receive receive, bool discardOld = true)
{
if(discardOld)
Context.Become(receive);
else
Context.BecomeStacked(receive);
}
/// <summary>
/// TBD
/// </summary>
/// <param name="receive">TBD</param>
/// <param name="message">TBD</param>
/// <returns>TBD</returns>
protected override bool AroundReceive(Receive receive, object message)
{
if (message is Request)
{
var req = (Request)message;
if (req.IsProcessed)
{
// it's an unstashed Request, demand is already handled
base.AroundReceive(receive, req);
}
else
{
if (req.Count < 1)
{
if (_lifecycleState == LifecycleState.Active)
{
OnError(new ArgumentException("Number of requested elements must be positive. Rule 3.9"));
}
}
else
{
_demand += req.Count;
if (_demand < 0)
{
_demand = long.MaxValue; // long overflow: effectively unbounded
}
req.MarkProcessed();
base.AroundReceive(receive, message);
}
}
}
else if (message is Subscribe <T> )
{
var sub = (Subscribe <T>)message;
var subscriber = sub.Subscriber;
switch (_lifecycleState)
{
case LifecycleState.PreSubscriber:
_scheduledSubscriptionTimeout.Cancel();
_subscriber = subscriber;
_lifecycleState = LifecycleState.Active;
ReactiveStreamsCompliance.TryOnSubscribe(subscriber, new ActorPublisherSubscription(Self));
break;
case LifecycleState.ErrorEmitted:
if (_onError.Stop)
{
Context.Stop(Self);
}
ReactiveStreamsCompliance.TryOnSubscribe(subscriber, CancelledSubscription.Instance);
ReactiveStreamsCompliance.TryOnError(subscriber, _onError.Cause);
break;
case LifecycleState.Completed:
ReactiveStreamsCompliance.TryOnSubscribe(subscriber, CancelledSubscription.Instance);
ReactiveStreamsCompliance.TryOnComplete(subscriber);
break;
case LifecycleState.CompleteThenStop:
Context.Stop(Self);
ReactiveStreamsCompliance.TryOnSubscribe(subscriber, CancelledSubscription.Instance);
ReactiveStreamsCompliance.TryOnComplete(subscriber);
break;
case LifecycleState.Active:
case LifecycleState.Canceled:
if (_subscriber == subscriber)
{
ReactiveStreamsCompliance.RejectDuplicateSubscriber(subscriber);
}
else
{
ReactiveStreamsCompliance.RejectAdditionalSubscriber(subscriber, "ActorPublisher");
}
break;
}
}
else if (message is Cancel)
{
if (_lifecycleState != LifecycleState.Canceled)
{
// possible to receive again in case of stash
CancelSelf();
base.AroundReceive(receive, message);
}
}
else if (message is SubscriptionTimeoutExceeded)
{
if (!_scheduledSubscriptionTimeout.IsCancellationRequested)
{
CancelSelf();
base.AroundReceive(receive, message);
}
}
else
{
return(base.AroundReceive(receive, message));
}
return(true);
}
/// <summary>
/// Changes the actor's behavior and replaces the current receive handler with the specified handler.
/// The current handler is stored on a stack, and you can revert to it by calling <see cref="IActorContext.UnbecomeStacked"/>
/// <remarks>Please note, that in order to not leak memory, make sure every call to <see cref="BecomeStacked"/>
/// is matched with a call to <see cref="IActorContext.UnbecomeStacked"/>.</remarks>
/// </summary>
/// <param name="receive">The new message handler.</param>
protected void BecomeStacked(Receive receive)
{
Context.BecomeStacked(receive);
}
public Activity Create(DependencyObject target)
{
// Sequence container.
var sequence = new Sequence();
sequence.DisplayName = "Delay";
// Correlation Handle.
var handle = new Variable <CorrelationHandle>("_handle");
var trainingRequest = new Variable <TrainingRequest>("_trainingRequest");
// Get variable collection.
var variables = GetVariableCollection(target);
if (variables == null)
{
sequence.Variables.Add(handle);
sequence.Variables.Add(trainingRequest);
}
else
{
handle = AddVariable <CorrelationHandle>(variables, handle);
trainingRequest = AddVariable <TrainingRequest>(variables, trainingRequest);
}
// Create Receive Activity.
var receive = new Receive();
receive.DisplayName = "Delay Receive";
receive.Action = "http://tempuri.org/ITrainingWorkflowService/Delay";
receive.OperationName = "Delay";
receive.ProtectionLevel = ProtectionLevel.None;
receive.ServiceContractName = "ITrainingWorkflowService";
// Add parameters to Receive
var parameters = new ReceiveParametersContent();
parameters.Parameters.Add("trainingRequest", new OutArgument <TrainingRequest>(trainingRequest));
receive.Content = parameters;
// Add CorrelationInitializer to Receive
var initializer = new RequestReplyCorrelationInitializer();
initializer.CorrelationHandle = new InArgument <CorrelationHandle>(handle);
receive.CorrelationInitializers.Add(initializer);
// Create SendReply Activity
var send = new SendReply();
send.DisplayName = "Delay Reply";
send.Action = "http://tempuri.org/ITrainingWorkflowService/DelayResponse";
send.Request = receive;
send.PersistBeforeSend = true;
// Create Delay activity.
Delay delay = new Delay();
delay.DisplayName = "Delay";
delay.TrainingRequest = trainingRequest;
// Add activities to sequence.
sequence.Activities.Add(receive);
sequence.Activities.Add(delay);
sequence.Activities.Add(send);
return(sequence);
}
public void Become(Receive receive) => _currentReceive = receive;
public MessageEnumerator(Receive receive)
{
_receive = receive;
}
/// <summary>
/// Generates the receive.
/// </summary>
/// <returns></returns>
public Receive GenerateReceive()
{
Receive receive = new Receive()
{
CreatedDate = DateTime.Now,
ReceiptDate = this.ReceiptDate,
DriverName = this.DriverName,
GRN = this.GRN,
PlateNo_Prime = this.PlateNo_Prime,
PlateNo_Trailer = this.PlateNo_Trailer,
TransporterID = this.TransporterID,
HubID = this.HubID,
CommodityTypeID = this.CommodityTypeID,
WayBillNo = this.WayBillNo,
ResponsibleDonorID = this.ResponsibleDonorID,
SourceDonorID = this.SourceDonorID,
CommoditySourceID = this.CommoditySourceID,
WeightBridgeTicketNumber = this.TicketNumber,
WeightBeforeUnloading = this.WeightBeforeUnloading,
WeightAfterUnloading = this.WeightAfterUnloading,
ReceivedByStoreMan = this.ReceivedByStoreMan,
VesselName = this.VesselName,
PortName = this.PortName,
PurchaseOrder = this.PurchaseOrder,
SupplierName = this.SupplierName,
ReceiptAllocationID = this.ReceiptAllocationID,
Remark = this.Remark,
};
if (this.ReceiveID.HasValue)
{
receive.ReceiveID = this.ReceiveID.Value;
}
else
{
receive.ReceiveID = Guid.NewGuid();
}
return receive;
}
private static Activity GetCCWorkflow()
{
//<snippet1>
Variable <string> OrderId = new Variable <string>();
Variable <string> Item = new Variable <string>();
Variable <CorrelationHandle> OrderIdHandle = new Variable <CorrelationHandle>();
Receive StartOrder = new Receive
{
CanCreateInstance = true,
ServiceContractName = "IOrderService",
OperationName = "StartOrder"
};
//<snippet2>
SendReply ReplyToStartOrder = new SendReply
{
Request = StartOrder,
Content = SendParametersContent.Create(new Dictionary <string, InArgument>
{
{ "OrderId", new InArgument <string>((env) => OrderId.Get(env)) }
}),
CorrelationInitializers =
{
new QueryCorrelationInitializer
{
CorrelationHandle = OrderIdHandle,
MessageQuerySet = new MessageQuerySet
{
{
"OrderId",
new XPathMessageQuery("sm:body()/tempuri:StartOrderResponse/tempuri:OrderId")
}
}
}
}
};
//</snippet2>
//<snippet3>
Receive AddItem = new Receive
{
ServiceContractName = "IOrderService",
OperationName = "AddItem",
CorrelatesWith = OrderIdHandle,
CorrelatesOn = new MessageQuerySet
{
{
"OrderId",
new XPathMessageQuery("sm:body()/tempuri:AddItem/tempuri:OrderId")
}
},
Content = ReceiveParametersContent.Create(new Dictionary <string, OutArgument>
{
{ "OrderId", new OutArgument <string>(OrderId) },
{ "Item", new OutArgument <string>(Item) }
})
};
//</snippet3>
SendReply ReplyToAddItem = new SendReply
{
Request = AddItem,
Content = SendParametersContent.Create(new Dictionary <string, InArgument>
{
{ "Reply", new InArgument <string>((env) => "Item added: " + Item.Get(env)) }
}),
};
// Construct a workflow using StartOrder, ReplyToStartOrder, and AddItem.
//</snippet1>
Activity wf = new Sequence
{
Variables =
{
OrderId,
Item,
OrderIdHandle
},
Activities =
{
StartOrder,
new Assign <string>
{
To = new OutArgument <string>((env) => OrderId.Get(env)),
Value = new InArgument <string>((env) => Guid.NewGuid().ToString())
},
ReplyToStartOrder,
AddItem,
ReplyToAddItem
}
};
return(wf);
}
protected override bool AroundReceive(Receive receive, object message)
{
_currentState.StateReceive(receive, message);
return true;
}
private static Activity GetCCWorkflowWithInitializeCorrelationActivity()
{
//<snippet4>
Variable <string> OrderId = new Variable <string>();
Variable <string> Item = new Variable <string>();
Variable <CorrelationHandle> OrderIdHandle = new Variable <CorrelationHandle>();
InitializeCorrelation OrderIdCorrelation = new InitializeCorrelation
{
Correlation = OrderIdHandle,
CorrelationData = { { "OrderId", new InArgument <string>(OrderId) } }
};
Receive StartOrder = new Receive
{
CanCreateInstance = true,
ServiceContractName = "IOrderService",
OperationName = "StartOrder"
};
SendReply ReplyToStartOrder = new SendReply
{
Request = StartOrder,
Content = SendParametersContent.Create(new Dictionary <string, InArgument> {
{ "OrderId", new InArgument <string>((env) => OrderId.Get(env)) }
}),
};
// Other messaging activities omitted...
//</snippet4>
Receive AddItem = new Receive
{
ServiceContractName = "IOrderService",
OperationName = "AddItem",
CorrelatesWith = OrderIdHandle,
CorrelatesOn = new MessageQuerySet
{
{
"OrderId",
new XPathMessageQuery("sm:body()/tempuri:AddItem/tempuri:OrderId")
}
},
Content = ReceiveParametersContent.Create(new Dictionary <string, OutArgument>
{
{ "OrderId", new OutArgument <string>(OrderId) },
{ "Item", new OutArgument <string>(Item) }
})
};
SendReply ReplyToAddItem = new SendReply
{
Request = AddItem,
Content = SendParametersContent.Create(new Dictionary <string, InArgument> {
{ "Reply", new InArgument <string>((env) => "Item added: " + Item.Get(env)) }
}),
};
//<snippet5>
// Construct a workflow using OrderIdCorrelation, StartOrder, ReplyToStartOrder,
// and other messaging activities.
Activity wf = new Sequence
{
Variables =
{
OrderId,
Item,
OrderIdHandle
},
Activities =
{
// Wait for a new order.
StartOrder,
// Assign a unique identifier to the order.
new Assign <string>
{
To = new OutArgument <string>((env) => OrderId.Get(env)),
Value = new InArgument <string>((env) => Guid.NewGuid().ToString())
},
ReplyToStartOrder,
// Initialize the correlation.
OrderIdCorrelation,
// Wait for an item to be added to the order.
AddItem,
ReplyToAddItem
}
};
//</snippet5>
return(wf);
}
protected override bool AroundReceive(Receive receive, object message)
{
return _atLeastOnceDeliverySemantic.AroundReceive(receive, message) || base.AroundReceive(receive, message);
}
public IActorState ClearBehaviorStack()
{
_receive = null;
return(this);
}
/// <summary>
/// Changes the Actor's behavior to become the new <see cref="Actor.Receive"/> handler.
/// This method acts upon the behavior stack as follows:
/// <para>if <paramref name="discardOld"/>==<c>true</c> it will replace the current behavior (i.e. the top element)</para>
/// <para>if <paramref name="discardOld"/>==<c>false</c> it will keep the current behavior and push the given one atop</para>
/// The default of replacing the current behavior on the stack has been chosen to avoid memory
/// leaks in case client code is written without consulting this documentation first (i.e.
/// always pushing new behaviors and never issuing an <see cref="Unbecome"/>)
/// </summary>
/// <param name="receive">The receive delegate.</param>
/// <param name="discardOld">If <c>true</c> it will replace the current behavior;
/// otherwise it will keep the current behavior and it can be reverted using <see cref="Unbecome"/></param>
protected void Become(Receive receive, bool discardOld = true)
{
Context.Become(receive, discardOld);
}
public IActorState BecomeStacked(Receive receive)
{
_behaviorStack.Push(receive);
return(this);
}
