public MessageReceiveRow AddMessageChat(MessageRow request)
{
if (request.Context == null)
{
base.AddError("Authenticate failed !");
return(null);
}
var m_msgRepository = UnitOfWork.Repository <DB_TB_INVITE_MESSAGE>();
var row = new DB_TB_INVITE_MESSAGE()
{
AccountId = request.Context.Id,
CreatedDate = DateTime.Now,
InviteId = request.InviteId,
Message = request.Message
};
m_msgRepository.Add(row);
UnitOfWork.Commit();
return(m_msgRepository.GetQueryable().Where(a => a.Id == row.Id).Select(a => new MessageReceiveRow()
{
AccountId = a.AccountId,
name = a.DB_TB_ACCOUNTS.ACC_FIRSTNAME,
Id = a.Id,
InviteId = a.InviteId,
text = a.Message,
CreatedDate = a.CreatedDate
}).FirstOrDefault());
}
public static void AddMessageFromVmg(Vcard vmg)
{
if (!vmg.MessageFound || string.IsNullOrEmpty(vmg.MessageBody))
{
return;
}
string number, name;
if (vmg.PhoneNumbers.Count > 0)
{
number = vmg.PhoneNumbers[0];
name = NumToName(number);
}
else
{
number = "";
name = "";
}
string hash;
if (FindExistingMessage(number, vmg.MessageBody, out hash))
{
return;
}
MessageRow row = _defaultInstance.Message.AddMessageRow(vmg.MessageBox, vmg.MessageTime, number, name, vmg.MessageBody, hash);
if (row.time == DateTime.MinValue)
{
row.SettimeNull();
}
}
public FormResponse DeletePartyWallItem([FromUri] int messageId)
{
FormResponse formResponse = new FormResponse();
PartyHost partyHost = (PartyHost)this.Members.GetCurrentMember();
// is party host the host of the party associated with message being deleted ?
MessageRow messageRow = this.DatabaseContext.Database.SingleOrDefault <MessageRow>(@"
SELECT A.MessageId,
A.MemberId,
A.Text,
A.Image,
A.Timestamp
FROM wonderlandMessage A
LEFT OUTER JOIN wonderlandMemberParty B ON A.MemberID = B.MemberId
WHERE A.MessageId=@0
AND B.PartyGuid=@1",
messageId,
partyHost.PartyGuid);
if (messageRow != null)
{
if (messageRow.Image.HasValue)
{
IMedia media = this.Services.MediaService.GetById(messageRow.Image.Value);
this.Services.MediaService.Delete(media);
}
this.DatabaseContext.Database.Delete(messageRow);
formResponse.Success = true;
}
return(formResponse);
}
private void RenderMessageRepositoryDiv(ComponentController paComponentController)
{
DataTable lcMessageList;
MessageRow lcMessageRow;
if ((lcMessageList = RetrieveMessageList()) != null)
{
lcMessageRow = new MessageRow(null);
paComponentController.AddElementType(ComponentController.ElementType.MessageRepository);
paComponentController.AddAttribute(HtmlAttribute.Class, ctCLSMessageRepositoryDiv);
paComponentController.RenderBeginTag(HtmlTag.Div);
for (int lcCount = 0; lcCount < lcMessageList.Rows.Count; lcCount++)
{
lcMessageRow.Row = lcMessageList.Rows[lcCount];
paComponentController.AddElementAttribute(ComponentController.ElementAttribute.ea_Code, lcMessageRow.MessageCode.ToLower());
paComponentController.AddElementAttribute(ComponentController.ElementAttribute.ea_Button1, lcMessageRow.Button1);
paComponentController.AddElementAttribute(ComponentController.ElementAttribute.ea_Button2, lcMessageRow.Button2);
paComponentController.AddElementAttribute(ComponentController.ElementAttribute.ea_Title, lcMessageRow.Title);
paComponentController.AddElementAttribute(ComponentController.ElementAttribute.ea_Type, lcMessageRow.MessageType.ToLower());
paComponentController.RenderBeginTag(HtmlTag.Span);
paComponentController.Write(lcMessageRow.Message);
paComponentController.RenderEndTag();
}
paComponentController.RenderEndTag();
}
}
public void SendMessage(MessageRow request)
{
var result = _sevice.AddMessageChat(request);
var context = GlobalHost.ConnectionManager.GetHubContext <FgoHub>();
context.Clients.Group(request.InviteId.ToString()).SendComplete(result);
}
public Response <MessageReceiveRow> AddMessageChat(MessageRow request)
{
MessageReceiveRow result = null;
BusinessProcess.Current.Process(p =>
{
result = IoC.Get <IOrderBusiness>().AddMessageChat(request);
});
return(BusinessProcess.Current.ToResponse(result));
}
public IHttpActionResult GetMessageChat(MessageRow request)
{
try
{
return(Ok(_Service.GetMessageChat(request)));
}
catch (Exception ex)
{
logger.Error("Exception is {0}", ex);
return(null);
}
}
private void table_SelectionChanged(object sender, SelectionEventArgs e)
{
if (1 != e.NewSelectedIndicies.Length)
{
return;
}
MessageRow row = e.TableModel.Rows[e.NewSelectedIndicies[0]] as MessageRow;
if (null == row)
{
return;
}
m_viewPart.Select(row.Instance);
}
private async Task ProcessMessage(RegistrationInfo ri, IDbConnection db, MessageRow dbMessage)
{
var mh = new MessageHandlerRow
{
HandlerId = ri.HandlerTypeName,
HandleDate = DateTime.Now,
MessageId = dbMessage.Id
};
try
{
var handler = this.cfg.DependencyAdapter.GetService(ri.HandlerType);
var message = (IMessage)JsonConvert.DeserializeObject(dbMessage.Content, ri.MessageType);
message.InternalId = dbMessage.Id;
try
{
await(Task) ri.HandlerType.GetMethod("Handle").Invoke(handler, new object[] { message });
mh.Handled = true;
}
catch (Exception e)
{
dbMessage.RetryNo++;
mh.Error = e.Message;
var result = await this.errorHandler.OnError(handler, e, message, dbMessage.RetryNo);
if (result == false) // do not retry
{
dbMessage.RetryNo = -1;
}
db.Update(dbMessage);
}
}
catch (Exception e)
{
var ie = DbBusUtils.GetMostInnerException(e);
mh.Error = ie.Message;
this.log.LogError(ie, $"Error handling message #{dbMessage.Id} of type [{ri.MessageTypeName}], handler: [{ri.HandlerTypeName}]");
}
await db.SaveAsync(mh);
}
public void LoadAllMessages()
{
IList messages = null;
using (IDbSession session = m_sessionFactory.NewSession())
{
messages = session.QueryForList("GetAllMessages", null);
}
List <Row> rows = new List <Row>();
foreach (Message message in messages)
{
MessageRow row = new MessageRow(message);
row.Tag = message;
MailCell mailCell = new MailCell(m_sessionFactory, message, new Image[] { m_image_close_mail, m_image_open_mail });
row.Cells.Add(mailCell);
row.Cells.Add(new LevelCell(m_sessionFactory, message, new Image[] { m_image_right, m_image_gray_flag, m_image_red_flag }));
row.Cells.Add(new Cell(message.HeaderFrom));
row.Cells.Add(new ReadStateCell(m_sessionFactory, message, new Image[] { m_image_litter_point, m_image_big_point }, mailCell));
row.Cells.Add(new Cell(message.HeaderSubject));
row.Cells.Add(new SpamCell(m_sessionFactory, message, new Image[] { m_image_litter_point, m_image_spam }));
row.Cells.Add(new Cell(message.ReceivedDate.ToShortTimeString()));
row.Cells.Add(new Cell(message.HeaderSize));
rows.Add(row);
}
tableModel.Rows.Clear();
tableModel.Rows.AddRange(rows.ToArray());
foreach (Row row in tableModel.Rows)
{
foreach (Cell cell in row.Cells)
{
MessageCell messageCell = cell as MessageCell;
if (null != messageCell)
{
messageCell.Refresh();
}
}
}
}
internal PartyWallItem(MessageRow message)
{
IPartier partier = (IPartier) new MembershipHelper(UmbracoContext.Current).GetById(message.MemberId);
this.Id = message.MessageId;
this.PartyWallItemType = PartyWallItemType.Message;
this.ThumbnailUrl = partier.ProfileImageUrl;
this.IsPartyHost = partier is PartyHost;
this.Name = partier.FirstName + " " + partier.LastName;
this.Text = message.Text;
if (message.Image.HasValue)
{
UmbracoHelper umbracoHelper = new UmbracoHelper(UmbracoContext.Current);
this.ImageUrl = umbracoHelper.TypedMedia(message.Image.Value).Url; // TODO:S3URL
}
this.Timestamp = message.Timestamp.ToUniversalTime();
}
private static void AddMessageInternal(Message m)
{
string hash;
if (FindExistingMessage(m.PhoneNumber, m.MessageText, out hash))
{
return;
}
MessageRow row = _defaultInstance.Message.AddMessageRow(m.DirectionBox,
m.MessageTime,
m.PhoneNumber,
string.IsNullOrEmpty(m.Name) ? NumToName(m.PhoneNumber) : m.Name,
m.MessageText,
hash);
if (row.time == DateTime.MinValue)
{
row.SettimeNull();
}
}
public List <MessageReceiveRow> GetMessageChat(MessageRow request)
{
if (request.Context == null)
{
base.AddError("Authenticate failed !");
return(null);
}
var m_msgRepository = UnitOfWork.Repository <DB_TB_INVITE_MESSAGE>();
var fromDate = DateTime.Now.AddDays(-7);
return(m_msgRepository.GetQueryable().Where(a => a.InviteId == request.InviteId && a.CreatedDate >= fromDate)
.Select(a => new MessageReceiveRow()
{
AccountId = a.AccountId,
name = a.DB_TB_ACCOUNTS.ACC_FIRSTNAME,
Id = a.Id,
InviteId = a.InviteId,
text = a.Message,
type = a.AccountId == request.Context.Id?"sent": "received",
CreatedDate = a.CreatedDate
}).OrderBy(a => a.CreatedDate).ToList());
}
public async Task <IMessage> Publish(IMessage message)
{
var watch = System.Diagnostics.Stopwatch.StartNew();
var msg = new MessageRow
{
Created = DateTime.Now,
ValidUntil = DateTime.Now + this.cfg.MessageLifetime,
MessageType = message.GetType().FullName,
Content = JsonConvert.SerializeObject(message)
};
using (var db = this.cfg.DbConnectionFactory.Open())
{
await db.SaveAsync(msg);
message.InternalId = msg.Id;
}
watch.Stop();
this.log.LogDebug($"Message #{message.InternalId} of type [{message.GetType().FullName}] published in {watch.ElapsedMilliseconds} ms");
return(message);
}
public MessageBccContactsRow AddMessageBccContactsRow(MessageRow parentMessageRowByFK_Message_MessageBccContacts, ContactRow parentContactRowByFK_Contact_MessageBccContacts) {
MessageBccContactsRow rowMessageBccContactsRow = ((MessageBccContactsRow)(this.NewRow()));
object[] columnValuesArray = new object[] {
null,
null};
if ((parentMessageRowByFK_Message_MessageBccContacts != null)) {
columnValuesArray[0] = parentMessageRowByFK_Message_MessageBccContacts[0];
}
if ((parentContactRowByFK_Contact_MessageBccContacts != null)) {
columnValuesArray[1] = parentContactRowByFK_Contact_MessageBccContacts[3];
}
rowMessageBccContactsRow.ItemArray = columnValuesArray;
this.Rows.Add(rowMessageBccContactsRow);
return rowMessageBccContactsRow;
}
public void RemoveMessageRow(MessageRow row) {
this.Rows.Remove(row);
}
public void AddMessageRow(MessageRow row) {
this.Rows.Add(row);
}
public MessageRowChangeEvent(MessageRow row, global::System.Data.DataRowAction action) {
this.eventRow = row;
this.eventAction = action;
}
public ContentRow AddContentRow(
string ContentDescription,
string MIMEVersion,
string ContentFilename,
string ContentDisposition,
string ContentId,
string PartID,
string TextData,
byte[] BinaryData,
string ContentType,
string ContentTransferEncoding,
MessageRow parentMessageRowByFK_Message_Content,
string MD5,
string Language,
string Charset,
long ContentSize,
long Lines,
string HTMLData) {
ContentRow rowContentRow = ((ContentRow)(this.NewRow()));
object[] columnValuesArray = new object[] {
null,
ContentDescription,
MIMEVersion,
ContentFilename,
ContentDisposition,
ContentId,
PartID,
TextData,
BinaryData,
ContentType,
ContentTransferEncoding,
null,
MD5,
Language,
Charset,
ContentSize,
Lines,
HTMLData};
if ((parentMessageRowByFK_Message_Content != null)) {
columnValuesArray[11] = parentMessageRowByFK_Message_Content[0];
}
rowContentRow.ItemArray = columnValuesArray;
this.Rows.Add(rowContentRow);
return rowContentRow;
}
public GroupForwardFlagsRow AddGroupForwardFlagsRow(GroupRow parentGroupRowByGroupGroupForwardFlags, MessageRow parentMessageRowByMessageGroupForwardFlags, bool ResponseRequired, bool IgnoreResponse, bool ForwardToAll) {
GroupForwardFlagsRow rowGroupForwardFlagsRow = ((GroupForwardFlagsRow)(this.NewRow()));
object[] columnValuesArray = new object[] {
null,
null,
null,
ResponseRequired,
IgnoreResponse,
ForwardToAll};
if ((parentGroupRowByGroupGroupForwardFlags != null)) {
columnValuesArray[1] = parentGroupRowByGroupGroupForwardFlags[0];
}
if ((parentMessageRowByMessageGroupForwardFlags != null)) {
columnValuesArray[2] = parentMessageRowByMessageGroupForwardFlags[0];
}
rowGroupForwardFlagsRow.ItemArray = columnValuesArray;
this.Rows.Add(rowGroupForwardFlagsRow);
return rowGroupForwardFlagsRow;
}
public static MessageReadResult Poison(MessageRow messageRow)
{
return(new MessageReadResult(null, messageRow));
}
MessageReadResult(Message message, MessageRow poisonMessage)
{
Message = message;
PoisonMessage = poisonMessage;
}
public MessageRowChangeEvent(MessageRow row, DataRowAction action)
{
this.eventRow = row;
this.eventAction = action;
}
