/// <summary>
/// Send requests to the configured service endpoint, and setup the state machine to accept the responses.
/// </summary>
/// <typeparam name="TInstance">The state instance type</typeparam>
/// <typeparam name="TData">The event data type</typeparam>
/// <typeparam name="TRequest">The request message type</typeparam>
/// <typeparam name="TResponse">The response message type</typeparam>
/// <param name="binder">The event binder</param>
/// <param name="request">The configured request to use</param>
/// <param name="messageFactory">The request message factory</param>
/// <returns></returns>
public static EventActivityBinder <TInstance, TData> MultiRequest <TInstance, TData, TState, TRequest, TResponse>(
this EventActivityBinder <TInstance, TData> binder,
MultiRequest <TInstance, TState, TRequest, TResponse> request,
AsyncEventMultiMessageFactory <TInstance, TData, TRequest> messageFactory)
where TInstance : class, SagaStateMachineInstance
where TData : class
where TRequest : class
where TResponse : class
{
ScheduleTokenId.UseTokenId <RequestTimeoutExpired <TRequest> >(x => x.RequestId);
var activity = new MultiRequestActivity <TInstance, TData, TState, TRequest, TResponse>(request, messageFactory);
return(binder.Add(activity));
}
/// <summary>
/// Sets the <see cref="MultiRequest{TInstance, TKey, TRequest, TResponse}"/> property.
/// </summary>
/// <typeparam name="TKey"></typeparam>
/// <typeparam name="TRequest"></typeparam>
/// <typeparam name="TResponse"></typeparam>
/// <param name="stateMachine"></param>
/// <param name="property"></param>
/// <param name="request"></param>
static void InitializeMultiRequest <TKey, TRequest, TResponse>(
AutomatonymousStateMachine <TInstance> stateMachine,
PropertyInfo property,
MultiRequest <TInstance, TKey, TRequest, TResponse> request)
where TRequest : class
where TResponse : class
{
if (property.CanWrite)
{
property.SetValue(stateMachine, request);
}
else if (ConfigurationHelpers.TryGetBackingField(stateMachine.GetType().GetTypeInfo(), property, out var backingField))
{
backingField.SetValue(stateMachine, request);
}
else
{
throw new ArgumentException($"The multi-request property is not writable: {property.Name}");
}
}
public Response ReturnToRoom([FromBody] MultiRequest req)
{
try
{
var personIds = req.PersonIds
.Split(new char[] { '|' }, StringSplitOptions.RemoveEmptyEntries)
.Select(s => s.AsInteger()).ToList();
RockContext rockContext = new RockContext();
PersonService personService = new PersonService(rockContext);
var people = personService.GetByIds(personIds);
foreach (var person in people)
{
DataHelper.AddReturnToRoomHistory(rockContext, person);
}
rockContext.SaveChanges();
return(new Response(true, "Success", false));
}
catch (Exception e)
{
ExceptionLogService.LogException(e, System.Web.HttpContext.Current);
return(new Response(false, "An error occured", false));
}
}
public IEnumerable<Response> Exec(MultiRequest request) {
var requestInfo = request as IMultiRequestInfo;
if(!requestInfo.IsValid) {
throw new InvalidRequestException();
}
ThrowIfDisposed();
var isReconnect = !_attemptReconnect;
while(true) {
InitSocket();
try {
_socket.SendRequest(request);
_receiver.Reset(request);
var responses = new List<Response>();
while(true) {
var response = _receiver.GetResponse();
if(!requestInfo.IsExpected(response.Status)) {
return new[] { response };
}
responses.Add(response);
if(response.Status == requestInfo.TerminationStatus) {
return responses;
}
}
} catch(SocketException) {
DisposeSocket();
if(isReconnect) {
throw;
}
} catch(ObjectDisposedException) {
DisposeSocket();
if(isReconnect) {
throw;
}
}
isReconnect = true;
_socket = null;
}
}
/// <summary>
/// Initializes a new instance.
/// </summary>
/// <param name="request"></param>
protected MultiRequestActivityImpl(MultiRequest <TInstance, TState, TRequest, TResponse> request)
{
this.request = request ?? throw new ArgumentNullException(nameof(request));
}
/// <summary>
/// Initializes a new instance.
/// </summary>
/// <param name="request"></param>
/// <param name="serviceAddressProvider"></param>
/// <param name="asyncMessageFactory"></param>
public MultiRequestActivity(MultiRequest <TInstance, TState, TRequest, TResponse> request, ServiceAddressProvider <TInstance> serviceAddressProvider, AsyncEventMultiMessageFactory <TInstance, TRequest> asyncMessageFactory) :
base(request)
{
this.asyncMessageFactory = asyncMessageFactory;
serviceAddressProvider = context => serviceAddressProvider(context) ?? request.Settings.ServiceAddress;
}
/// <summary>
/// Initializes a new instance.
/// </summary>
/// <param name="request"></param>
/// <param name="messageFactory"></param>
public MultiRequestActivity(MultiRequest <TInstance, TState, TRequest, TResponse> request, EventMultiMessageFactory <TInstance, TRequest> messageFactory) :
base(request)
{
this.messageFactory = messageFactory;
serviceAddressProvider = context => request.Settings.ServiceAddress;
}
public IEnumerable <Tuple <int, string> > Repeat(int n, string wat)
{
var responses = _client.Exec(MultiRequest.Create("REPEAT").WithArgument(n.ToString()).WithArgument(wat).ExpectMultiple("OK", false).TerminatedBy("DONE"));
return(responses.Select(x => new Tuple <int, string>(int.Parse(x.Arguments[0]), x.Arguments[1])));
}
/// <summary>
/// Initializes a new instance.
/// </summary>
/// <param name="request"></param>
public MultiRequestItemFinishedActivity(MultiRequest <TInstance, TState, TRequest, TResponse> request)
{
this.request = request ?? throw new ArgumentNullException(nameof(request));
}
/// <summary>
/// Initializes a new <see cref="MultiRequestFinishedEvent{TInstance, TState, TRequest, TResponse}"/> from the given context and request.
/// </summary>
/// <param name="context"></param>
/// <param name="request"></param>
/// <returns></returns>
public static MultiRequestFinishedEvent <TInstance, TState, TRequest, TResponse> Init(InstanceContext <TInstance> context, MultiRequest <TInstance, TState, TRequest, TResponse> request)
{
return(new MultiRequestFinishedEvent <TInstance, TState, TRequest, TResponse>(
request.GetItems(context)
.Select(i => new { RequestId = request.GetRequestId(context, i), State = i })
.Where(i => i.RequestId != null)
.ToDictionary(i => i.RequestId.Value, i => (MultiRequestFinishedItem <TRequest, TResponse>) new MultiRequestFinishedItem <TInstance, TState, TRequest, TResponse>(context, request.Accessor, i.State))));
}
public MultiResult Post([FromBody] MultiRequest mr, string profile = null)
{
MultiResult result = new MultiResult(Request);
try {
if (mr == null)
{
throw new Exception("The body is missing or not formatted correctly. Maybe just a comma is missing between two attributes.");
}
//Apply profile from URI
if (!string.IsNullOrEmpty(profile))
{
if (mr.connection == null)
{
mr.connection = new ConnectionParams {
Profile = profile
}
}
;
else if (string.IsNullOrEmpty(mr.connection.Profile))
{
mr.connection.Profile = profile;
}
}
System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
sw.Start();
var cp = SAPB1.getEffectiveConnectionParams(mr?.connection, ref result.connection);
//START Transaction with using and pass the same transaction object to each request processor
using (var t = DIConnection.startTransaction(cp)) { //Must be used with using !!!
MReqResult reqResult = null;
try {
result.totalJobsRequested = mr.requests.Count;
for (int i = 0; i < mr.requests.Count; i++)
{
result.index = i;
MReqJob mrJob = mr.requests[i];
reqResult = new MReqResult();
if (!string.IsNullOrEmpty(mrJob.boName) || mrJob.boReq != null)
{
//result.reqJob = mrJob;
bool post = false;
bool delete = false;
bool put = false;
bool getReq = false;
if (string.IsNullOrEmpty(mrJob.reqType))
{
throw new SQLBrokerError($"Multi-Request BO job {mrJob.boName} has no reqType property (GET, PUT, DELETE, POST)");
}
else
{
switch (mrJob.reqType)
{
case "GET": getReq = true; break;
case "POST": post = true; break;
case "PUT": put = true; break;
case "DELETE": delete = true; break;
default: {
throw new SQLBrokerError($"Multi-Request BO job {mrJob.boName} reqType {mrJob.reqType} is invalid. Use GET, PUT, DELETE, POST");
}
}
}
if (mrJob.boReq == null)
{
if (getReq || delete)
{
mrJob.boReq = new BORequest {
connection = new ConnectionParams {
Profile = profile
}
};
}
else
{
throw new SQLBrokerError($"Multi-Request BO job {mrJob.boName} no boReq object defined for PUT, POST");
}
}
if (string.IsNullOrEmpty(mrJob.boName))
{
throw new SQLBrokerError("Multi-request BO job has no boName property");
}
if (string.IsNullOrEmpty(mrJob.boId))
{
if (getReq || put || delete)
{
throw new SQLBrokerError($"Multi-Request BO job {mrJob.boName} reqType {mrJob.reqType} requires non-empty boId property.");
}
}
else
{
if (post)
{
throw new SQLBrokerError($"Multi-Request BO job {mrJob.boName} reqType {mrJob.reqType} doesn't allow boId property. Delete boId from your request.");
}
}
reqResult.boResult = new BOResult(Request);
reqResult.boResult.connection = new NoPwdConnectionParams(cp);
reqResult.boResult.jobNumber = i;
SAPB1.BOJob(t, q: mrJob.boReq, name: mrJob.boName, id: mrJob.boId, post: post, delete: delete, put: put, result: reqResult.boResult);
}
if (mrJob.sqlReq != null)
{
throw new SQLBrokerError($"Multi-Request SQL is not supported currently. Stay tuned, however.");
//var sqlResult = SAPB1.SQLQuery(value, false, new SQLResult(Request));
}
result.results.Add(reqResult);
}
t.Commit();
sw.Stop();
result.execMillis = (int)sw.Elapsed.TotalMilliseconds;
return(result);
} catch (Exception) {
result.errorResult = reqResult;
//ROLLBACK Transaction, if not rolled back alreadt
t.Rollback();
throw;
}
}
//COMMIT the transacyion if no errors occured
} catch (Exception e) {
if (e is SQLBrokerError)
{
SQLBrokerError brokerError = e as SQLBrokerError;
if (result.errorResult == null)
{
result.errorResult = new MReqResult();
}
result.errorResult.boResult = brokerError.boResult;
result.errorResult.sqlResult = brokerError.sqlResult;
}
return(result.setResponseStatus(HttpStatusCode.BadRequest, e));
}
}
