public ActionResult ProcessAnnouncement(SendAnnouncementViewModel model)
{
if (ModelState.IsValid)
{
List <string> MessageFormErrorList = new List <string>();
ViewData["To"] = model.To;
ViewData["MessageSubject"] = model.MessageSubject;
ViewData["MessageBody"] = model.MessageBody;
MessageQuery messageQuery = new MessageQuery();
bool safe = true; // Initialize to true and set to false if error is found
if (string.IsNullOrEmpty(model.MessageBody) || string.IsNullOrWhiteSpace(model.MessageBody)) // Check if message body is empty
{
MessageFormErrorList.Add("Message doesn't contain a message");
safe = false;
}
if (safe == true) // If there are no errors, proceed with sending the message
{
messageQuery.SendMessage(model.To, User.Identity.Name, model.MessageSubject, model.MessageBody);
return(RedirectToAction("Inbox", "Message"));
}
else
{
TempData["MessageFormError"] = MessageFormErrorList;
return(RedirectToAction("New", "Message"));
}
}
else
{
return(RedirectToAction("New", "Message"));
}
}
public void Show(uint id, [SmartBinder(Expect = "filter.Types")] MessageQuery filter)
{
var supplier = DbSession.Load <Supplier>(id);
PropertyBag["supplier"] = supplier;
PropertyBag["users"] = supplier.Users;
PropertyBag["contactGroups"] = supplier.ContactGroupOwner.ContactGroups.OrderBy(s => s.Type == ContactGroupType.General ? 0 : 1);
PropertyBag["usersInfo"] = ADHelper.GetPartialUsersInformation(supplier.Users);
PropertyBag["CallLogs"] = UnresolvedCall.LastCalls;
PropertyBag["CiUrl"] = Properties.Settings.Default.ClientInterfaceUrl + "auth/logon.aspx";
PropertyBag["filter"] = filter;
PropertyBag["messages"] = filter.Execute(supplier, DbSession);
Sort.Make(this);
if (IsPost)
{
BindObjectInstance(supplier, "supplier");
if (IsValid(supplier))
{
DbSession.Save(supplier);
Notify("Сохранено");
RedirectToReferrer();
}
}
}
public void RecieveMessage(MessageQuery messageData)
{
if (!m_Moods.ContainsKey(messageData.Sender))
{
m_Moods.Add(messageData.Sender, new Dictionary <string, float>());
}
var senderMoods = m_Moods[messageData.Sender];
// Standard modification from the message.
foreach (var mood in messageData.Data.MoodSet)
{
if (!senderMoods.ContainsKey(mood.Name))
{
senderMoods.Add(mood.Name, 0.0f);
}
senderMoods[mood.Name] += mood.Modification;
}
foreach (var option in messageData.MessageOptions)
{
var optionMoodSet = messageData.Data.OptionSet[option.OptionsSetIndex].Options[option.CurrentOption].MoodSet;
foreach (var mood in optionMoodSet)
{
if (!senderMoods.ContainsKey(mood.Name))
{
senderMoods.Add(mood.Name, 0.0f);
}
senderMoods[mood.Name] += mood.Modification;
}
}
EventUpdate();
}
/// <summary>
/// Please see <seealso cref="IEncodeMessageService{T}.Encode" /> for documentation.
/// </summary>
/// <param name="queryMessagesParameters">-</param>
/// <returns>-</returns>
public EncodedMessage Encode(QueryMessagesParameters queryMessagesParameters)
{
var messageHeaderParameters = new MessageHeaderParameters
{
ApplicationMessageId = queryMessagesParameters.ApplicationMessageId,
TeamSetContextId = queryMessagesParameters.TeamsetContextId ?? "",
TechnicalMessageType = TechnicalMessageType,
Mode = RequestEnvelope.Types.Mode.Direct
};
var messagePayloadParameters = new MessagePayloadParameters
{
TypeUrl = MessageQuery.Descriptor.FullName
};
var messageQuery = new MessageQuery();
queryMessagesParameters.Senders?.ForEach(sender => messageQuery.Senders.Add(sender));
queryMessagesParameters.MessageIds?.ForEach(messageId => messageQuery.MessageIds.Add(messageId));
messageQuery.ValidityPeriod = queryMessagesParameters.ValidityPeriod;
messagePayloadParameters.Value = messageQuery.ToByteString();
var encodedMessage = new EncodedMessage
{
Id = Guid.NewGuid().ToString(),
Content = EncodeMessageService.Encode(messageHeaderParameters, messagePayloadParameters)
};
return(encodedMessage);
}
/// <inheritdoc />
public Task<IEnumerable<MessageRecord>> GetAsync(MessageQuery messageQuery, CancellationToken cancellationToken)
{
lock (objLock)
{
return Task.FromResult(Messages.Where(messageQuery.Match));
}
}
public async Task <IEnumerable <MessageRecord> > GetAsync(MessageQuery messageQuery,
CancellationToken cancellationToken)
{
if (disposed)
{
throw new ObjectDisposedException(nameof(AdoNetMessageRepository));
}
// Execute.
var messages = new List <MessageRecord>();
var connection = GetConnection();
using (var command = connection.CreateCommand())
{
command.CommandText = queryProvider.GetFilterScript(messageQuery);
command.CommandTimeout = 120; // Set timeout to 2 mins since query may take long time.
using (var reader = await command.ExecuteReaderAsync(cancellationToken))
{
while (await reader.ReadAsync(cancellationToken))
{
var messageRecord = new MessageRecord
{
Type = reader.GetByte(1),
Id = reader.GetGuid(2),
ContentType = reader.GetString(3)
};
var content = serializer.IsText ? Encoding.UTF8.GetBytes(reader.GetString(4)) : (byte[])reader[4];
var contentType = Type.GetType(messageRecord.ContentType);
messageRecord.Content = serializer.Deserialize(content, contentType);
if (!reader.IsDBNull(5))
{
messageRecord.Data = serializer.Deserialize(
Encoding.UTF8.GetBytes(reader.GetString(5)), typeof(IDictionary <string, string>))
as IDictionary <string, string>;
}
if (!reader.IsDBNull(7) && !reader.IsDBNull(8))
{
messageRecord.ErrorMessage = reader.GetString(7);
messageRecord.ErrorType = reader.GetString(8);
var errorType = Type.GetType(messageRecord.ErrorType);
if (!reader.IsDBNull(6) && !string.IsNullOrEmpty(messageRecord.ErrorType))
{
var error = serializer.IsText ? Encoding.UTF8.GetBytes(reader.GetString(6)) : (byte[])reader[6];
if (error.Length > 0)
{
messageRecord.Error = serializer.Deserialize(error, errorType) as Exception;
}
}
}
messageRecord.CreatedAt = reader.GetDateTime(9);
messageRecord.ExecutionDuration = reader.GetInt32(10);
messageRecord.Status = (ProcessingStatus)reader.GetByte(11);
messages.Add(messageRecord);
}
}
}
return(messages);
}
public async Task <IActionResult> Get(MessageQuery data)
{
var result = await _mediator.Send(new GetMessagesQuery(data.ReceiverId, data.Content, data.PageNumber, data.PageSize,
data.SortColumn, data.SortDescending, data.SenderId, data.IsRead));
return(ApiContent(result));
}
public void SendMessage()
{
if (m_BackLog.Count == 0)
{
return;
}
MessageQuery sendQuery = m_BackLog[0];
m_BackLog.RemoveAt(0);
m_History.Add(sendQuery);
Cleanup();
var signalObject = Instantiate(m_SignalTemplate);
signalObject.transform.position = gameObject.transform.position;
var signal = signalObject.GetComponent <MessageSignal>();
signal.m_Goal = sendQuery.Reciever;
signal.m_Query = sendQuery;
if (m_BackLog.Count > 0)
{
BuildMessage(m_BackLog[0]);
FMODUnity.RuntimeManager.PlayOneShot(m_BackLog[0].Sender.GetComponent <Faction>().FactionAudioEvent);
}
}
public void CheckMessageForSpy()
{
var answer = true;
var query = new MessageQuery {
Spy = "James Bond",
Message = new int[] { 1, 0, 2, 0, 7, 9 }
};
var spyList = new List <Spy>();
var s1 = new Spy
{
name = "James Bond",
code = new int[] { 0, 0, 7 }
};
var s2 = new Spy
{
name = "Ethan Hunt",
code = new int[] { 3, 1, 4 }
};
spyList.Add(s1);
spyList.Add(s2);
var context = Substitute.For <ISpyDBContext>();
context.GetSpiesList().Returns(spyList);
var c = new SpyFinder.Controllers.SpiesController(context);
var result = c.Post(query).Value;
Assert.Equal(answer, result);
}
/// <summary>
/// 获取通知消息列表
/// </summary>
/// <param name="query"></param>
/// <param name="count"></param>
/// <returns></returns>
public List <MessageEntity> GetListPaged(MessageQuery query, out int count)
{
var param = new DynamicParameters();
param.Add("@recieverID", query.RecieverID);
param.Add("@msgType", query.MsgType);
param.Add("@status", query.Status);
param.Add("@pageIndex", query.PageIndex);
param.Add("@pageSize", query.PageSize);
param.Add("@field", query.Field);
param.Add("@order", query.Order);
param.Add("@rowsCount", null, DbType.Int32, ParameterDirection.Output);
List <MessageEntity> msgList = null;
try
{
msgList = QuickRepository.ExecProcQuery <MessageEntity>(
"pr_sys_MessageListPagedQuery",
param).ToList <MessageEntity>();
count = param.Get <int>("@rowsCount");
return(msgList);
}
catch (System.Exception)
{
throw;
}
}
public void FindAllFecTransmitMessagesTest()
{
MessageQuery query = new MessageQuery(sessions[7]);
IEnumerable <Message> events = query.FindAllFecMessages();
int count = events.Count();
Assert.IsTrue(events.Count() == 17406);
}
public async Task <ActionResult> Index([FromQuery] UserQuery userQuery, MessageQuery messageQuery)
{
_userModel.Users = await _getUsers.Execute(userQuery);
_userModel.Messages = await _getMessages.Execute(messageQuery);
return(View(_userModel));
}
/// <inheritdoc />
public string GetFilterScript(MessageQuery messageQuery)
{
if (messageQuery == null)
{
throw new ArgumentNullException(nameof(messageQuery));
}
return(BuildSelectString(messageQuery, new MySqlSelectStringBuilder()));
}
/// <summary>
/// Get all messages liked by the user.
/// </summary>
/// <remarks>
/// UNDOCUMENTED. Use at your own risk.
/// </remarks>
/// <param name="client">The message client.</param>
/// <param name="thread">The message thread option.</param>
/// <returns>The <see cref="MessageEnvelope"/>.</returns>
public static async Task <MessageEnvelope> GetAllLiked(
this MessageClient client,
MessageQueryThread thread = MessageQueryThread.NoThread)
{
var query = new MessageQuery(0, null, thread);
var url = client.GetFinalUrl(string.Format("{0}/liked_by.json", Endpoints.Messages), query.SerializeQueryString());
var result = await client.Client.GetAsync <MessageEnvelope>(url);
return(result.Content);
}
public void FindAllGeneralFeMessagesTest()
{
MessageQuery query = new MessageQuery(sessions[7]);
IEnumerable <SpeedEvent> events =
(IEnumerable <SpeedEvent>)query.FindAllGeneralFeMessages();
float sum = events.Sum(s => s.Speed);
Assert.IsTrue(sum == 59067.4961F);
Assert.IsTrue(events.Count() == 6463);
}
/// <summary>
/// Get all messages liked by the user.
/// </summary>
/// <remarks>
/// UNDOCUMENTED. Use at your own risk.
/// </remarks>
/// <param name="client">The message client.</param>
/// <param name="thread">The message thread option.</param>
/// <returns>The <see cref="MessageEnvelope"/>.</returns>
public static async Task<MessageEnvelope> GetAllLiked(
this MessageClient client,
MessageQueryThread thread = MessageQueryThread.NoThread)
{
var query = new MessageQuery(0, null, thread);
var url = client.GetFinalUrl(string.Format("{0}/liked_by.json", Endpoints.Messages), query.SerializeQueryString());
var result = await client.Client.GetAsync<MessageEnvelope>(url);
return result.Content;
}
public PoCSchema(IMessageService messageService)
{
//Query = resolver.Resolve<PoCQuery>();
//Mutation = resolver.Resolve<PoCMutation>();
//Subscription = resolver.Resolve<MessageSubscription>();
Query = new MessageQuery(messageService);
Mutation = new MessageMutation(messageService);
Subscription = new MessageSubscription(messageService);
}
public async Task <IActionResult> GetMessages(int userId, MessageQuery query)
{
if (userId != this.GetCurrentUserId())
{
return(Unauthorized());
}
var messages = await _datingRepository.GetMessagesForUserAsync(query);
return(Ok(_mapper.Map <QueryResultResponse <MessageResponse> >(messages)));
}
public async Task <IActionResult> GetLatest()
{
await Db.Connection.OpenAsync();
var query = new MessageQuery(Db);
var result = await query.LatestPostsAsync();
var json = await Task.Run(() => JsonConvert.SerializeObject(result));
return(new OkObjectResult(json));
}
private IEnumerable <IFieldNameQuery> CreateFieldQueries(MessageQuery messageQuery)
{
var filterQueries = new List <IFieldNameQuery>();
if (messageQuery.Id.HasValue)
{
filterQueries.Add(new TermQuery {
Field = "_id", Value = messageQuery.Id.Value
});
}
if (!string.IsNullOrEmpty(messageQuery.ContentType))
{
filterQueries.Add(new TermQuery {
Field = "ContentType", Value = messageQuery.ContentType.ToLowerInvariant()
});
}
if (!string.IsNullOrEmpty(messageQuery.ErrorType))
{
filterQueries.Add(new TermQuery {
Field = "ErrorType", Value = messageQuery.ErrorType.ToLowerInvariant()
});
}
if (messageQuery.Status.HasValue)
{
filterQueries.Add(new TermQuery {
Field = "Status", Value = messageQuery.Status.Value
});
}
if (messageQuery.Type.HasValue)
{
filterQueries.Add(new TermQuery {
Field = "Type", Value = messageQuery.Type.Value
});
}
if (messageQuery.CreatedStartDate.HasValue || messageQuery.CreatedEndDate.HasValue)
{
filterQueries.Add(new RangeQuery
{
Field = "CreatedAt",
GreaterThanOrEqualTo = messageQuery.CreatedStartDate,
LessThanOrEqualTo = messageQuery.CreatedEndDate
});
}
if (messageQuery.ExecutionDurationAbove.HasValue || messageQuery.ExecutionDurationBelow.HasValue)
{
filterQueries.Add(new RangeQuery
{
Field = "ExecutionDuration",
GreaterThanOrEqualTo = messageQuery.ExecutionDurationAbove,
LessThanOrEqualTo = messageQuery.ExecutionDurationBelow
});
}
return(filterQueries);
}
public void PushMessage(MessageQuery query)
{
m_BackLog.Add(query);
if (m_BackLog.Count == 1)
{
BuildMessage(m_BackLog[0]);
FMODUnity.RuntimeManager.PlayOneShot(m_BackLog[0].Sender.GetComponent <Faction>().FactionAudioEvent);
}
}
public void LogUserNoBilling()
{
var record = new AuditRecord("testUserAuditRecord", _client.Users.First());
session.Save(record);
Flush();
var messageQuery = new MessageQuery();
var logs = messageQuery.Execute(_client.Users.First(), session);
var log = logs.FirstOrDefault(m => m.Message.Contains("testUserAuditRecord"));
Assert.That(log, Is.Not.Null, logs.Implode());
}
public void Log_payer_with_payer_and_user()
{
Create_payer_message();
var messageQuery = new MessageQuery();
messageQuery.Types.Add(LogMessageType.Payer);
var logs = messageQuery.Execute(_client.Users.First(), session);
var log = logs.FirstOrDefault(m => m.Message.Contains("test_Payer_Audit_Record"));
Assert.That(log, Is.Not.Null, logs.Implode());
}
public async Task <IActionResult> GeAll()
{
using (var db = new AppDb())
{
await db.Connection.OpenAsync();
var query = new MessageQuery(db);
var result = await query.AllAsync();
return(new OkObjectResult(result));
}
}
public async Task <IActionResult> DeleteAll()
{
using (var db = new AppDb())
{
await db.Connection.OpenAsync();
var query = new MessageQuery(db);
await query.DeleteAllAsync();
return(new OkResult());
}
}
public async Task <List <Message> > GetMessagesForUser(MessageQuery queryObj)
{
try
{
return(await repository.GetMessagesForUser(queryObj));
}
catch (Exception e)
{
logger.LogError(e.Message);
return(null);
}
}
protected void Page_Load(object sender, EventArgs e)
{
var id = Convert.ToInt32(Request.Params["messageId"]);
var msg = new MessageQuery().Get(id);
if (msg != null)
{
Date.Text = msg.SendTime.ToString();
Title.Text = msg.Title;
Message.Text = msg.Body;
From.Text = msg.Sender.FullName;
}
}
void BuildMessage(MessageQuery query)
{
m_SenderText.text = query.Sender.GetComponent <Faction>().FactionName;
m_RecieverText.text = query.Reciever.GetComponent <Faction>().FactionName;
m_MessageImage.sprite = query.Sender.GetComponent <Faction>().FactionImage;
var builder = new StringBuilder();
var messages = query.MessageText;
foreach (var msg in m_History)
{
m_BacklogText.text += "\n";
m_BacklogText.text += msg.Sender.GetComponent <Faction>().FactionName + " to " + msg.Reciever.GetComponent <Faction>().FactionName + ": ";
foreach (var part in msg.MessageText)
{
m_BacklogText.text += part.Text;
}
}
var optionsBuilderList = new List <OptionButtonBuilder>();
bool isDone = true;
foreach (var part in messages)
{
int partStart = builder.Length;
builder.Append(part.Text);
if (part.IsOption)
{
optionsBuilderList.Add(new OptionButtonBuilder()
{
m_CharIndices = new Vector2Int(partStart, builder.Length),
m_OptionSetIndex = part.OptionsSetIndex
});
if (!part.HasBeenSet)
{
isDone = false;
}
}
}
if (isDone)
{
m_SendButton.gameObject.SetActive(true);
}
m_MessageText.text = builder.ToString();
StartCoroutine(BuildButtons(optionsBuilderList, query.Data.OptionSet));
}
private static string BuildSelectString(MessageQuery messageQuery, ISelectStringBuilder ssb)
{
ssb.SelectAll().From(TableName);
if (messageQuery.Id != null)
{
ssb.Where("content_id").EqualsTo(messageQuery.Id);
}
if (messageQuery.CreatedStartDate != null)
{
ssb.Where("created_at").GreaterOrEqualsTo(messageQuery.CreatedStartDate);
}
if (messageQuery.CreatedEndDate != null)
{
ssb.Where("created_at").LessOrEqualsTo(messageQuery.CreatedEndDate);
}
if (messageQuery.ContentType != null)
{
ssb.Where("content_type").EqualsTo(messageQuery.ContentType);
}
if (messageQuery.ErrorType != null)
{
ssb.Where("error_type").EqualsTo(messageQuery.ErrorType);
}
if (messageQuery.Status != null)
{
ssb.Where("status").EqualsTo(messageQuery.Status);
}
if (messageQuery.Type != null)
{
ssb.Where("type").EqualsTo(messageQuery.Type);
}
if (messageQuery.ExecutionDurationAbove != null)
{
ssb.Where("execution_duration").GreaterOrEqualsTo(messageQuery.ExecutionDurationAbove);
}
if (messageQuery.ExecutionDurationBelow != null)
{
ssb.Where("execution_duration").LessOrEqualsTo(messageQuery.ExecutionDurationBelow);
}
if (messageQuery.Skip > 0)
{
ssb.Skip(messageQuery.Skip);
}
if (messageQuery.Take > 0)
{
ssb.Take(messageQuery.Take);
}
return(ssb.Build());
}
public async Task <IEnumerable <MessageDto> > Execute(MessageQuery request)
{
var messageSkipVal = Context.Messages.Count() - 200;
var messagesSkip = (messageSkipVal >= 0) ? messageSkipVal : 0;
return(await Context.Messages.Skip(messagesSkip)
.Select(m => new MessageDto
{
Text = m.Text,
CreatedAt = m.CreatedAt,
Username = m.User.UserName,
ImagePath = m.User.ImagePath
}).ToListAsync());
}
protected void Page_Load(object sender, EventArgs e)
{
var id = Convert.ToInt32(Request.Params["messageId"]);
var msg = new MessageQuery().Get(id);
if (msg != null)
{
Date.Text = msg.SendTime.ToString();
Title.Text = msg.Title;
Message.Text = msg.Body;
From.Text = msg.Sender.FullName;
}
}
public async Task <IActionResult> Post(string userId, string text)
{
MessageBase body = new MessageBase(userId, text);
await Db.Connection.OpenAsync();
body.Db = Db;
await body.InsertAsync();
var query = new MessageQuery(Db);
var result = await query.LatestPostsAsync();
var json = await Task.Run(() => JsonConvert.SerializeObject(result));
return(new OkObjectResult(json));
}
