private static void WaitForInput(CSocket socket)
{
Tuple <String, Object> received = socket.ReceiveObject();
String parameter = received.Item1;
messageParameters = (MessageParameters)received.Item2;
if (parameter.Equals(CALL_INDICATION))
{
CPCC.PrintLogs(CALL_INDICATION);
CPCC.SendMessage(CALL_CONFIRMED_CPCC, messageParameters.getFirstParameter(), messageParameters.getSecondParameter(), messageParameters.getCapacity());
}
else if (parameter.Equals(CALL_TEARDOWN_CPCC))
{
CPCC.PrintLogs(CALL_TEARDOWN_CPCC);
CPCC.SendMessage(CALL_TEARDOWN_CPCC, messageParameters.getFirstParameter(), messageParameters.getSecondParameter(), messageParameters.getCapacity());
}
else if (parameter.Equals(CALL_CONFIRMED_CPCC))
{
CPCC.PrintLogs(CALL_CONFIRMED_CPCC);
}
else if (parameter.Equals(CALL_REJECTED_CPCC))
{
CPCC.PrintLogs(CALL_REJECTED_CPCC);
}
}
public override void Append(IError error)
{
string formattedMessage = MessageParameters.GetFormattedMessage(this.Layout, error);
Console.WriteLine(formattedMessage);
this.messagesAppended++;
}
public async Task <MessageParameters> CreateMessageParametersAsync(long jobId)
{
FileUploadJob job = await _fileUploadJobManager.GetJobById(jobId);
List <ITopicItem> topics = (await _jobTopicTaskService.GetTopicItems(job.JobType, job.IsFirstStage)).ToList();
JobContextMessage contextMessage = new JobContextMessage(
job.JobId,
topics,
job.Ukprn.ToString(),
job.StorageReference,
job.FileName,
job.SubmittedBy,
0,
job.DateTimeSubmittedUtc);
contextMessage.KeyValuePairs.Add("CollectionName", job.CollectionName);
contextMessage.KeyValuePairs.Add("ReturnPeriod", job.PeriodNumber);
AddExtraKeys(contextMessage, job);
MessageParameters message = new MessageParameters(job.JobType)
{
JobContextMessage = contextMessage,
SubscriptionLabel = topics[0].SubscriptionName,
TopicParameters = new Dictionary <string, object>
{
{
"To", topics[0].SubscriptionName
}
}
};
return(message);
}
public void SendMessagesAsync_Test()
{
var topicPublishMock = new Mock <ITopicPublishService <JobContextDto> >();
topicPublishMock.Setup(x => x.PublishAsync(new JobContextDto(), new Dictionary <string, object>(), "Test")).Returns(Task.CompletedTask);
var message = new MessageParameters(JobType.IlrSubmission)
{
JobContextMessage = new JobContextMessage()
{
KeyValuePairs = new Dictionary <string, object>(),
Topics = new List <ITopicItem>()
},
SubscriptionLabel = "Test",
TopicParameters = new Dictionary <string, object>(),
};
var indexedTopicsMock = new Mock <IIndex <JobType, ITopicPublishService <JobContextDto> > >();
indexedTopicsMock.SetupGet(x => x[JobType.IlrSubmission]).Returns(topicPublishMock.Object);
var messagingService = new MessagingService(indexedTopicsMock.Object, new JobContextMapper(), new Mock <ILogger>().Object);
messagingService.SendMessageAsync(message).ConfigureAwait(true);
topicPublishMock.Verify(x => x.PublishAsync(It.IsAny <JobContextDto>(), It.IsAny <Dictionary <string, object> >(), "Test"), Times.Once);
}
public async Task <IActionResult> GetAll(Guid userID, [FromQuery] MessageParameters parameters)
{
var user = new User
{
ID = userID
};
#region [Authorization]
var result = await this.AuthorizationService.AuthorizeAsync
(
this.User, user, nameof(KindlyPolicies.AllowIfOwner)
);
if (result.Succeeded == false)
{
return(this.Unauthorized());
}
#endregion
var messages = await this.Repository.GetByUser(userID, parameters);
var messageDtos = messages.Select(l => this.Mapper.Map <MessageDto>(l)).ToList();
this.Response.AddPaginationHeader(new PaginationHeader
(
messages.PageNumber,
messages.PageSize,
messages.TotalPages,
messages.TotalCount
));
return(this.Ok(messageDtos));
}
/// <summary>
/// Called when an operation request has been received.
/// </summary>
/// <remarks>An operation request is sent when a client sends an operation request to the master. So all operation requests are from game clients</remarks>
protected override void OnOperationRequest(OperationRequest operationRequest, SendParameters sendParameters)
{
var gameOperationRequest = new GameOperationRequest(operationRequest.Parameters);
if (!gameOperationRequest.IsValid)
{
#if MMO_DEBUG
Logger.DebugFormat("[OnOperationRequest]: GameOperationRequest (OpCode={0}) is not valid", operationRequest.OperationCode);
#endif
return;
}
ISession session;
if (sessions.TryGetValue(gameOperationRequest.ClientId, out session))
{
var messageParameters = new MessageParameters {
ChannelId = sendParameters.ChannelId, Encrypted = sendParameters.Encrypted
};
session.ReceiveOperationRequest(gameOperationRequest, messageParameters);
}
else
{
Logger.ErrorFormat("[OnOperationRequest]: Session (Id={0}) cannot be found", gameOperationRequest.ClientId);
}
}
public void OnOperationRequest(GameOperationRequest operationRequest, MessageParameters parameters)
{
switch ((GameOperationCode)operationRequest.OperationCode)
{
case GameOperationCode.LoginUser:
{
this.ExecUserOperation(() => this.HandleOperationLogin(operationRequest, parameters), operationRequest.ClientId, parameters);
}
break;
case GameOperationCode.CreateUser:
{
this.ExecUserOperation(() => this.HandleOperationCreateNewUser(operationRequest, parameters), operationRequest.ClientId, parameters);
}
break;
default:
{
this.peer.SendOperationResponse(operationRequest.ClientId,
new GameErrorResponse(operationRequest.OperationCode)
{
ReturnCode = (short)ResultCode.OperationNotAvailable,
},
new MessageParameters());
}
break;
}
}
public Task <PagedList <Message> > GetMessagesForUser(MessageParameters messageParameters)
{
// asQueryable pour faire des requetes après
var messages = _context.Messages
.AsQueryable();
switch (messageParameters.Contener)
{
case "Inbox":
messages = messages.Where(m => m.ReceptId == messageParameters.UserId && m.ReceptDeleted == false);
break;
case "Outbox":
messages = messages.Where(m => m.SenderId == messageParameters.UserId && m.SenderDeleted == false);
break;
default:
messages = messages.Where(m => m.ReceptId == messageParameters.UserId && m.IsRead == false &&
m.ReceptDeleted == false);
break;
}
;
messages = messages.OrderByDescending(m => m.MessageSent);
return(PagedList <Message> .CreateAsync(messages, messageParameters.PageNumber, messageParameters.PageSize));
}
protected override void OnOperationRequest(OperationRequest operationRequest, SendParameters sendParameters)
{
var gameOperationRequest = new GameOperationRequest(operationRequest.Parameters);
var parameters = new MessageParameters {
ChannelId = sendParameters.ChannelId, Encrypted = sendParameters.Encrypted
};
switch (operationRequest.OperationCode)
{
case (byte)ClientOperationCode.Login:
{
this.RequestFiber.Enqueue(() => this.loginOperationHandler.OnOperationRequest(gameOperationRequest, parameters));
}
break;
case (byte)ClientOperationCode.Character:
{
this.RequestFiber.Enqueue(() => this.characterOperationHandler.OnOperationRequest(gameOperationRequest, parameters));
}
break;
default:
{
this.SendOperationResponse(gameOperationRequest.ClientId,
new GameErrorResponse(operationRequest.OperationCode)
{
ReturnCode = (short)ResultCode.OperationNotAvailable,
},
new MessageParameters());
}
break;
}
}
public async Task SendMessageAsync(MessageParameters messageParameters)
{
JobContextMessage jobContextMessage = (JobContextMessage)messageParameters.JobContextMessage;
await _topicPublishServices[messageParameters.JobType].PublishAsync(
_jobContextMapper.MapFrom(jobContextMessage),
messageParameters.TopicParameters,
messageParameters.SubscriptionLabel);
}
public RestCall(string baseURL, string apiMethod, string httpVerbose, MessageHeader header, MessageBody body, MessageParameters parameters)
{
BaseURL = baseURL;
APIMethod = apiMethod;
HttpVerbose = httpVerbose;
Header = header;
Body = body;
Parameters = parameters;
}
public void PublishEvent()
{
for (var i = 0; i < 10000; i++)
{
var parameters = new MessageParameters("CqrsEvent");
var @event = new SendCqrsEvent(parameters, Guid.NewGuid().ToString());
_messageSender.Publish(@event);
}
}
public void SendCommand()
{
for (var i = 0; i < 5000; i++)
{
var parameters = new MessageParameters("CqrsCommand");
var command = new SendCqrsCommand(parameters, Guid.NewGuid().ToString());
_messageSender.Send(command);
}
}
public static void CreateBatBullet(Vector3 senderPosition, int damage, int direction)
{
GameObject bullet = Instantiate(batBulletPrefab);
bullet.transform.position = senderPosition + (GameController.Character.position - senderPosition) / 2;
bullet.transform.up = GameController.Character.position - senderPosition;
MessageParameters parameters = new MessageParameters(direction, damage);
GameController.Character.SendMessage("OnHit", parameters, SendMessageOptions.DontRequireReceiver);
}
public void SendQuery()
{
for (var i = 0; i < 5000; i++)
{
var parameters = new MessageParameters("CqrsQuery");
var query = new SendCqrsQuery(parameters, Guid.NewGuid().ToString());
_ = _messageSender.Send(query);
}
}
public MessageExecutor PrepareMessage(string MessageText)
{
MessageParameters MsgParam = new MessageParameters();
string LocalMachine = Environment.MachineName;
MsgParam.Message = LocalMachine + " : " + MessageText;
MessageExecutor MessageExecutor = new MessageExecutor();
MessageExecutor.MessageParameters = MsgParam;
return(MessageExecutor);
}
public async Task <ActionResult <IEnumerable <MessageDto> > > GetMessagesForUser(
[FromQuery] MessageParameters messageParameters)
{
messageParameters.UserName = User.GetUserName();
var messages = await this.unitOfWork.MessageRepository.GetMessagesForUser(messageParameters);
Response.AddPaginationHeader(messages.CurrentPage, messages.PageSize, messages.TotalCount, messages.TotalCount);
return(messages);
}
public IAppender GetAppender(string appenderType, string layoutType, string levelStr)
{
Level level = MessageParameters.ParseLevel(levelStr);
ILayout layout = this.layoutFactory.GetLayout(layoutType);
Assembly assembly = Assembly.GetExecutingAssembly();
Type typeToCreate = assembly
.GetTypes()
.FirstOrDefault(t => t.Name == appenderType);
if (typeToCreate == null)
{
throw new InvalidLayoutTypeException();
}
List <object> args = new List <object>()
{
layout,
level
};
if (appenderType == "FileAppender")
{
IFile file = new LogFile();
args.Add(file);
}
IAppender appender = (IAppender)Activator.CreateInstance(typeToCreate, args.ToArray());
//WITHOUT REFLECTION:
//Level level = MessageParameters.ParseLevel(levelStr);
//ILayout layout = this.layoutFactory.GetLayout(layoutType);
//IAppender appender;
//if (appenderType == "ConsoleAppender")
//{
// appender = new ConsoleAppender(layout, level);
//}
//else if (appenderType == "FileAppender")
//{
// IFile file = new LogFile();
// appender = new FileAppender(layout, level, file);
//}
//else
//{
// throw new InvalidAppenderTypeException();
//}
return(appender);
}
/// <summary>
/// Sends a(n) <see cref="GameEvent"/> to a session
/// </summary>
public void SendEvent(int sessionId, GameEvent gameEvent, MessageParameters messageParameters)
{
var parameters = ObjectDataMemberMapper.GetValues <DataMemberAttribute>(gameEvent);
parameters.Add(0, sessionId);
var eventData = new EventData(gameEvent.EventCode, parameters);
this.SendEvent(eventData, new SendParameters
{
ChannelId = messageParameters.ChannelId,
Encrypted = messageParameters.Encrypted,
});
}
void OnCollisionEnter2D(Collision2D collision)
{
if (collision.gameObject.tag == "shield")
{
anim.SetTrigger("GetBack");
}
if (collision.gameObject.tag == "character" && hitRequire)
{
hitRequire = false;
MessageParameters parameters = new MessageParameters(Methods.GetDirection(gameObject), damage);
GameController.Character.SendMessage("OnHit", parameters, SendMessageOptions.DontRequireReceiver);
StartCoroutine(Delay());
}
}
public async Task <PagedList <MessageDto> > GetMessagesForUser(MessageParameters messageParameters)
{
var query = this.dataContext.Messages
.OrderByDescending(message => message.MessageSent)
.ProjectTo <MessageDto>(this.mapper.ConfigurationProvider)
.AsQueryable();
query = messageParameters.Container switch
{
"Inbox" => query.Where(message => message.RecipientUserName == messageParameters.UserName && message.RecipientDeleted == false),
"Outbox" => query.Where(message => message.SenderUserName == messageParameters.UserName && message.SenderDeleted == false),
_ => query.Where(message => message.RecipientUserName == messageParameters.UserName && message.DateRead == null && message.RecipientDeleted == false),
};
return(await PagedList <MessageDto> .CreateAsync(query, messageParameters.PageNumber, messageParameters.PageSize));
}
public async Task GenerateKeysAsync()
{
var job = new FileUploadJob()
{
JobType = JobType.IlrSubmission,
JobId = 10,
Ukprn = 123456
};
IlrMessageFactory factory = GetFactory(false, job);
MessageParameters result = await factory.CreateMessageParametersAsync(It.IsAny <long>());
result.JobContextMessage.KeyValuePairs[JobContextMessageKey.InvalidLearnRefNumbers].Should()
.Be($"{job.Ukprn}/{job.JobId}/ValidationInvalidLearners.json");
}
public async Task <IActionResult> GetMessagesForUser(int userId, [FromQuery] MessageParameters messageParameters)
{
// verification user autorisé
if (userId != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value))
{
return(Unauthorized());
}
messageParameters.UserId = userId;
var messagesFromRepo = await _repo.GetMessagesForUser(messageParameters);
var messages = _mapper.Map <IEnumerable <MessageToReturnDto> >(messagesFromRepo);
Response.AddPagination(messagesFromRepo.CurrentPage, messagesFromRepo.PageSize,
messagesFromRepo.TotalCount, messagesFromRepo.TotalPages);
return(Ok(messages));
}
public IError GetError(string dateString, string levelStr, string message)
{
Level level = MessageParameters.ParseLevel(levelStr);
DateTime dateTime;
try
{
dateTime = DateTime.ParseExact(dateString, MessageParameters.dateFormat, CultureInfo.InvariantCulture);
}
catch
{
throw new InvalidDateFormatException();
}
return(new Error(dateTime, message, level));
}
public void OnHit(MessageParameters parameters)
{
health--;
if (health < 1)
{
Destroy(gameObject);
}
Vector3 getDamageForce = new Vector3(0.1f, 1, 0);
getDamageForce.x *= parameters.direction;
if (rb != null)
{
rb.velocity = Vector3.zero;
rb.AddForce(getDamagePower * getDamageForce, ForceMode2D.Impulse);
}
if (state == MonsterState.Calm || state == MonsterState.Find)
{
SetTriggered();
}
}
private void OnTriggerEnter2D(Collider2D collider)
{
if (collider.tag == parentTag)
{
return;
}
if (!hit && collider.gameObject.layer != LayerMask.NameToLayer("dont hit"))
{
hit = true;
Destroy(rb);
transform.parent = collider.transform;
int direction = force.x < 0 ? -1 : 1;
MessageParameters parameters = new MessageParameters(direction, damage);
if (collider.gameObject.tag != "shield")
{
collider.gameObject.SendMessageUpwards("OnHit", parameters, SendMessageOptions.DontRequireReceiver);
}
StartCoroutine(Hitting());
}
}
public SendCqrsQuery(MessageParameters parameters, string correlationId, string?causationId = null)
: base(parameters, correlationId, causationId)
{
}
private async Task <byte[]> SendMessageInternal(string routingKeyOrTopicName, byte[] message, IDictionary <string, object> headers, MessageType messageType, MessageParameters p = null)
{
if (EndpointType != EndpointTypeEnum.Publisher)
{
var e = new InvalidOperationException("Attempt to send a message on a consumer prohibited.");
VerboseLoggingHandler.Log(e);
throw e;
}
p ??= DefaultMessageParameters;
if (string.IsNullOrEmpty(routingKeyOrTopicName))
{
routingKeyOrTopicName = RoutingKeyOrTopicName;
}
VerboseLoggingHandler.Log($"SendMessageInternal sending message, type='{messageType}', routingKeyOrTopicName='{routingKeyOrTopicName}', durable='{p.Durable}', mandatory='{p.Mandatory}', persistent='{p.Persistent}', priority='{p.Priority}', autoAck='{p.AutoAck}', resilient='{p.Resilient}', timeout='{p.TimeOut}' (ms)");
headers ??= new Dictionary <string, object>();
byte[] ret = null;
var messageTypeText = new StringBuilder();
var messageProperties = Channel.CreateBasicProperties();
messageProperties.Type = MessageTypeFragmentsChat;
messageProperties.Timestamp = AmqpTimestampNow;
messageProperties.Priority = p.Priority;
messageProperties.Persistent = p.Persistent;
messageProperties.Expiration = p.TimeOut.ToString();
if (p.Durable)
{
messageProperties.DeliveryMode = 2;
}
messageProperties.CorrelationId = ConversationId.ToString();
if (!p.AutoAck)
{
messageTypeText.Append((MessageTypeFragmentsRequestAmqAck));
}
if ((messageType & MessageType.RequireAck) == MessageType.RequireAck)
{
messageTypeText.Append(MessageTypeFragmentsRequestAck);
}
if ((messageType & MessageType.RequireResponse) == MessageType.RequireResponse)
{
messageTypeText.Append(MessageTypeFragmentsRequestReply);
}
headers.Add(DictionaryKey_PassedQueueTtl, ReturnChannelQueueTtl);
messageProperties.Type = messageTypeText.ToString();
messageProperties.Headers = headers;
try
{
ReturnData = null;
messageProperties.ReplyTo = ReturnChannelQueueName;
VerboseLoggingHandler.Log($"Publishing now");
Channel.BasicPublish(ExchangeName, routingKeyOrTopicName, p.Mandatory, messageProperties, message);
//_channel.WaitForConfirmsOrDie(new TimeSpan(0, 0, 0, 0, timeout.Value));
if (((PublisherParameters)(ChannelParameters)).EnableConfirmSelect)
{
try
{
Channel.WaitForConfirms();
}
catch (InvalidOperationException e1)
{
if (e1.Message == "Confirms not selected")
{
var e = new InvalidOperationException("Invalid configuration. WaitForConfirms behavior requested, but Exchange not configured for them.", e1);
VerboseLoggingHandler.Log(e);
throw e;
}
else
{
VerboseLoggingHandler.Log(e1);
throw e1;
}
}
}
if (messageType == MessageType.Normal)
{
return(null);
}
VerboseLoggingHandler.Log($"Published. LatchCount='{ReturnChannelLatch.CurrentCount}', timeout='{p.TimeOut}' (ms)");
await ReturnChannelLatch.WaitAsync(p.TimeOut, LocalCancellationToken);
VerboseLoggingHandler.Log($"Released. LatchCount='{ReturnChannelLatch.CurrentCount}'");
}
finally
{
if (messageType != MessageType.Normal)
{
VerboseLoggingHandler.Log($"Completed. LatchCount='{ReturnChannelLatch.CurrentCount}'");
ret = ReturnData;
}
}
return(ret);
}
public string Write(ILayout layout, IError error)
{
string formattedMessage = MessageParameters.GetFormattedMessage(layout, error);
return(formattedMessage);
}
public static bool PrepareForMessageSend(
string callMethod,
RunTarget runTarget,
GameObject subject,
GameObject target,
GameObject referenceTarget,
MessageParameters parameters,
out GameObject obj,
out object[] suppliedParameters
)
{
suppliedParameters = new object[0];
obj = subject;
if (string.IsNullOrEmpty(callMethod) || string.IsNullOrWhiteSpace(callMethod))
{
Debug.LogWarning("Call Method is blank...");
return(false);
}
if (runTarget == RunTarget.Player && !GameManager.playerExists)
{
Debug.LogWarning("Cant Call Method: " + callMethod + " on player, player doesnt exist yet!");
return(false);
}
switch (runTarget)
{
case RunTarget.Subject:
obj = subject;
break;
case RunTarget.Target:
obj = target;
break;
case RunTarget.Reference:
obj = referenceTarget;
break;
case RunTarget.Static:
obj = null;
break;
case RunTarget.Player:
obj = GameManager.playerActor.gameObject;
break;
}
if (obj == null && runTarget != RunTarget.Static)
{
Debug.LogWarning("RunTarget: " + runTarget.ToString() + " is null, can't call method: " + callMethod);
return(false);
}
if (parameters.Length > 0)
{
List <object> parametersList = new List <object>();
for (int i = 0; i < parameters.Length; i++)
{
if (parameters[i] != null)
{
parametersList.Add(parameters[i].GetParamObject());
}
}
suppliedParameters = parametersList.ToArray();
}
return(true);
}
