public void TestAddMessage()
{
MessageDetail message = new MessageDetail
{
MessageId = "1",
Subject = "First Message",
Body = "Body for First Message",
TenantId = "FirstTenant",
SentBy = "user1",
SentTo = new List <string> {
"user2", "user3"
},
CreatedOn = DateTime.Now,
LastModifiedOn = DateTime.Now,
SentOn = DateTime.Now,
Status = "DRAFT"
};
// Currently Dont know how the repository can be tested in LF framework
//var repository = new MessageMongoRepository();
//var service = new MessageService(repository);
//var result = service.Add(message);
//result.Wait();
//Assert.True(result.Result);
}
public void AdminSendMessage(string toUserId, string message)
{
string fromAdminId = Context.ConnectionId;
var toUser = ConnectedUsers.FirstOrDefault(x => x.ConnectionId == toUserId);
var fromAdminUser = ConnectedUsers.FirstOrDefault(x => x.ConnectionId == fromAdminId);
if (toUser != null && fromAdminUser != null)
{
var meeting = ListMeeting.SingleOrDefault(x => x.Id == toUserId);
if (meeting != null)
{
meeting.Messages = SetStatusAllMessageInMeeting(meeting, 1);
var message_ = new MessageDetail {
ConnectionId = toUserId, UserName = toUser.UserName, IsAdmin = 1, Status = 0, CreateDate = DateTime.Now, Message = message
};
var messages_ = meeting.Messages;
messages_.Add(message_);
meeting.Messages = messages_;
}
var last_message = meeting.Messages.Where(x => x.Status == 0).OrderByDescending(x => x.CreateDate).FirstOrDefault();
Clients.Client(toUserId).SendAsync("onGuestReceivedMessage", fromAdminId, fromAdminUser.UserName, message, "left") /*.onGuestReceivedMessage(fromAdminId, fromAdminUser.UserName, message, "left");*/;
Clients.Caller.SendAsync("onAdminReceivedMessage", toUserId, fromAdminUser.UserName, message, "right", new { lastmessage = last_message, countunread = 0 }) /*.onAdminReceivedMessage(toUserId, fromAdminUser.UserName, message, "right", new { lastmessage = last_message, countunread = 0 })*/;
}
}
public MessageResponeModel Add(MessageDetail message)
{
MessageResponeModel returnModel = new MessageResponeModel();
if (message.MessageGroupID == 0)
{
returnModel.MessageID = "002";
returnModel.Message = MessageList.GetMessage("002", new string[] { "group id" });
return(returnModel);
}
if (string.IsNullOrEmpty(message.Content))
{
returnModel.MessageID = "002";
returnModel.Message = MessageList.GetMessage("002", new string[] { "nội dung" });
return(returnModel);
}
int result = messageDetailDA.Add(message);
if (result == 1)
{
returnModel.MessageID = "003";
returnModel.Message = MessageList.GetMessage("003", new string[] { });
}
else
{
returnModel.MessageID = "002";
returnModel.Message = MessageList.GetMessage("002", new string[] { });
}
return(returnModel);
}
public IEnumerable <Conversation> GetByUserId(string id)
{
var conversations = _conversations.AsQueryable()
.Where(x => x.Receivers.Contains(id))
.ToList();
MessageDetail tempMessage = null;
conversations.ForEach(c =>
{
c.Users = GetAllUserInConversation(c.Id).ToList();
tempMessage = _messages.Find(m => m.ConversationId == c.Id)
.SortByDescending(m => m.Time)
.Limit(1)
.FirstOrDefault();
if (tempMessage == null)
{
tempMessage = new MessageDetail()
{
Time = c.CreatedDate,
Content = "",
ConversationId = c.Id
};
}
c.LastMessage = tempMessage;
});
conversations = conversations.OrderByDescending(c => c.LastMessage.Time).ToList();
return(conversations);
}
public async Task <bool> SendEmailAsync(string token, string subject, string body)
{
var model = new MessageDetail()
{
Body = body,
Subject = subject
};
var myContent = JsonConvert.SerializeObject(model);
var buffer = System.Text.Encoding.UTF8.GetBytes(myContent);
var byteContent = new ByteArrayContent(buffer);
byteContent.Headers.ContentType = new MediaTypeHeaderValue(HttpConstants.MEDIA_TYPE_APPLICATION_FORM);
byteContent.Headers.Add(App.Configuration.AppConfig.TokenHeaderName, token);
var requestUri = ClientService.GetRequestUri(ControllerName, "send");
var response = await ClientService.PostAsync(requestUri, byteContent);
if (response != null)
{
Task <string> jsonTask = response.Content.ReadAsStringAsync();
var result = JsonConvert.DeserializeObject(jsonTask.Result);
if (jsonTask.Result.Contains(HttpConstants.SUCCESS))
{
return(true);
}
}
return(false);
}
private int AddMessageinCache(MessageDetail _MessageDetail)
{
int Recent_id = 0;
#region Save Message Detail in Database
using (var conn = new MySqlConnection(ConnectionString.Get("EscademyMDB")))
{
conn.Open();
using (var cmd = conn.CreateCommand())
{
cmd.CommandText = "INSERT INTO esc_chat (Sender_Id, Receiver_id, Message, Status, Created_at) VALUES (@senderId, @receiverId, @message, @status, @createdAt)";
cmd.Parameters.AddWithValue("@senderId", _MessageDetail.FromUserID);
cmd.Parameters.AddWithValue("@receiverId", _MessageDetail.ToUserID);
cmd.Parameters.AddWithValue("@message", _MessageDetail.Message);
cmd.Parameters.AddWithValue("@status", 0);
cmd.Parameters.AddWithValue("@createdAt", _MessageDetail.ExactMessageSentDateTime);
cmd.ExecuteNonQuery();
Recent_id = Convert.ToInt32(cmd.LastInsertedId);
}
conn.Close();
}
#endregion
#region Add Message in Cache
CurrentMessage.Add(_MessageDetail);
if (CurrentMessage.Count > 100)
{
CurrentMessage.RemoveAt(0);
}
#endregion
return(Recent_id);
}
public MessageDetail AddMessage(string senderId, string receiverId, MessageDetail message)
{
var conversation = _conversationRepository.FindPrivateConversationByReceiverId(senderId, receiverId);
if (conversation == null)
{
conversation = new Conversation()
{
Id = ObjectId.GenerateNewId().ToString(),
Type = "private",
Receivers = new List <string>()
{
message.FromUserId, receiverId
},
CreatedDate = DateTime.Now,
SeenIds = new List <string>()
{
message.FromUserId
}
};
conversation = _conversationRepository.Add(conversation);
}
else
{
conversation.SeenIds = new List <string>()
{
message.FromUserId
};
_conversationRepository.Update(conversation);
}
message.ConversationId = conversation.Id;
return(_messageRepository.Add(message));
}
/// <summary>
/// 添加一条信息详情
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public int AddMessageDetail(MessageDetail model)
{
StringBuilder strSql = new StringBuilder();
strSql.Append(
"insert into MessageDetail (BatchId,AccId,Title,Content,ArriveMark,OpenMark,ChannelId,Remark,CreateTime,AccIdNumber,ContentType,ContentUrl) " +
"Values(@BatchId,@AccId,@Title,@Content,@ArriveMark,@OpenMark,@ChannelId,@Remark,@CreateTime,@AccIdNumber,@ContentType,@ContentUrl)");
try
{
int reVal = DapperHelper.Execute(strSql.ToString(), new
{
BatchId = model.BatchId,
AccId = model.AccId,
Title = model.Title,
Content = model.Content,
ArriveMark = 0,
OpenMark = 0,
ChannelId = model.ChannelId,
Remark = model.Remark,
CreateTime = DateTime.Now,
AccIdNumber = model.AccIdNumber,
ContentType = model.ContentType,
ContentUrl = model.ContentUrl
});
return(reVal);
}
catch (Exception ex)
{
Logger.Error("插入批次" + model.BatchId + "消息详情出错", ex);
return(0);
}
}
public static void Main()
{
try
{
BulkSMS_API api = new BulkSMS_API(sAPIBaseURL, sAPITokenId, sSecret);
Console.WriteLine("==[ ReadProfile() ]==========================================================");
Profile p = api.ReadProfile();
Console.WriteLine("First Name: " + p.firstName);
Console.WriteLine("==[ QueryMessages(...) ]=====================================================");
var qm = api.QueryMessages();
if (qm != null)
{
foreach (MessageDetail qm_md in qm)
{
Console.WriteLine(qm_md.id);
}
}
Console.WriteLine("==[ BlockedNumbers(...) ]====================================================");
var bns = api.BlockedNumbers();
if (bns != null)
{
foreach (BlockedNumber bn in bns)
{
Console.WriteLine("Blocked Number: " + bn.phoneNumber);
}
}
Console.WriteLine("==[ GetMessage(...) ]========================================================");
MessageDetail md = api.GetMessage("799777944003158017");
Console.WriteLine("GetMessage: " + md.id);
Console.WriteLine("==[ GetRelatedMessages(...) ]================================================");
var rm = api.GetRelatedMessages("799777944003158017");
if (rm != null)
{
foreach (MessageDetail rm_md in rm)
{
Console.WriteLine(rm_md.id);
}
}
SendMessages();
}
catch (BulkSMSException bx)
{
Console.WriteLine("BulkSms error occurred.");
Console.WriteLine(bx.Message);
Console.WriteLine(bx.BulkSmsError.title);
Console.WriteLine(bx.BulkSmsError.status);
Console.WriteLine(bx.BulkSmsError.type);
Console.WriteLine(bx.BulkSmsError.detail);
}
Console.Write("Press <ENTER>.");
Console.ReadLine();
}
public async Task <IActionResult> SendPrivateMessage(MessageDetail message)
{
if (!ConnectedUsers.Any(x => x.UserId.Equals(message.FromUserId)))
{
throw new InvalidOperationException(Resources.UserIsDisconnected);
}
var toUser = ConnectedUsers.FirstOrDefault(x => x.UserId == message.ToUserId);
if (toUser is null)
{
throw new InvalidOperationException(Resources.UserIsDisconnected);
}
await Clients.AllExcept(Context.ConnectionId)
.SendAsync(ChatHubMethods.UpdateUnreadMessages, message.FromUserId);
// send a private message to listener user
await Clients.Client(toUser.ConnectionId)
.SendAsync(ChatHubMethods.ReceiveMessage, message);
AddMessageInCache(message);
return(new OkResult());
}
/// <summary>
/// Updates geocodable information.
/// </summary>
/// <param name="needMessage">Need show message.</param>
/// <param name="candidate">Geocoded candidate (can be NULL).</param>
/// <param name="obj">Source object to geocoded candidate.</param>
private void _UpdateGeocodableInfo(bool needMessage,
AddressCandidate candidate,
AppData.DataObject obj)
{
Debug.Assert(null != obj); // Created.
IGeocodable geocodable = _GetGeocodable(obj);
geocodable.GeoLocation = null;
if ((null == candidate) || (candidate.Score <= App.Current.Geocoder.MinimumMatchScore))
{
// Not geocoded.
geocodable.Address.MatchMethod = string.Empty;
}
else
{
GeocodeHelpers.SetCandidate(geocodable, candidate);
++_geocodedCount;
// Store warning.
if (needMessage)
{
string objectName = _informer.ObjectName;
string errorTextFormat =
App.Current.GetString("ImportProcessStatusRecordOutMapExtendGeocodedFormat",
objectName.ToLower(),
"{0}",
objectName);
var description =
new MessageDetail(MessageType.Warning, errorTextFormat, obj);
_details.Add(description);
}
}
}
public Task SendMessage(MessageDetail message)
{
string methodName = Guid.Empty.Equals(message.ToUserId) ?
ChatHubMethods.CacheMessage : ChatHubMethods.SendPrivateMessage;
return(_connection.InvokeAsync(methodName, message));
}
/// <summary>
/// 点击好友列表页面的发送消息按钮
/// </summary>
/// <param name="param"></param>
private void ClickSendToFriend(object param)
{
button.clip = sendMsg;
button.Play();
var chatMsg = new mmopb.sendMessageToOnlineFriend_req();
friendView.chatPanle.SetActive(true);
GameObject friend = (GameObject)param;
FriendDetail friendDetail = friend.GetComponentInChildren <FriendDetail>();
roleId_chat = friendDetail.friendId;
friendDetail.messageNotice.SetActive(false);
//加载预制体
GameObject _message = Resources.Load("MessageFriend") as GameObject;
LinkedList <Message> friendMsg;
if (messages.TryGetValue(roleId_chat, out friendMsg))
{
foreach (Message friend_message in friendMsg)
{
// 对象初始化
GameObject message = Instantiate(_message, friendView.chatParentTransForm);
MessageDetail messageDetail = message.GetComponent <MessageDetail>();
DateTime dt = DateTime.Parse("1970-01-01 00:00:00").AddSeconds(friend_message.Time);
dt = dt.AddSeconds(8 * 60 * 60); // +8h的时差
string time = dt.ToString("HH:mm:ss");
messageDetail.time.text = "【" + time + "】";
messageDetail.name.text = friend_message.Name;
messageDetail.content.text = "：" + friend_message.Content;
}
}
}
public MessageDetail SendMessage(string message)
{
MessageDetail ret = new MessageDetail();
ret.sendHistory.Add(String.Format("ABCProvider : {0}", message));
return(ret);
}
public int Read(byte[] recieveBuffer, ref IPEndPoint ipFrom)
{
lock (messagesBuffer)
{
if (messageDetails.Count == 0)
{
return(0);
}
MessageDetail detail = messageDetails.Dequeue();
// If no more details remain all messages have been read from buffer, reset index
// so future messages can re-use the messagesBuffer.
//
// ASSUMPTION: We will never receive more messages than messageBuffer can hold
// between reads to read all messages
//
if (messageDetails.Count == 0)
{
messagesBufferIndex = 0;
}
// Try assign ipFrom to IPEndPoint message received from
if (!IPEndPoint.TryParse(detail.RemoteAddress.RawName, detail.RemotePort, out ipFrom))
{
localPeer.Log(LogLevel.Error, String.Format("Failed to parse remote end point: {0}:{1}", detail.RemoteAddress.RawName, detail.RemotePort));
return(0);
}
System.Buffer.BlockCopy(messagesBuffer, detail.Index, recieveBuffer, 0, detail.Count);
return(detail.Count);
}
}
private async void SendMessage()
{
var message = new MessageDetail
{
FromUserId = FromUser.UserId,
FromUserName = FromUser.UserName,
ToUserId = ToUser.UserId,
MessageDate = DateTime.Now,
Message = Message
};
try
{
await _chatHub.SendMessage(message);
Device.BeginInvokeOnMainThread(() =>
{
IsProcessing = true;
message.FromUserName = "******";
Messages.Add(message);
RaisePropertyChanged(nameof(MessagesCount));
Message = "";
IsProcessing = false;
});
}
catch (Exception)
{
await _dialogService.DisplayAlertAsync("Error", Resources.UnableToSendTheMessage, "Ok");
}
}
///////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Showes process results with details in message window.
/// </summary>
/// <param name="importer">Importer object.</param>
/// <param name="geocoder">Geocoder object (can be NULL).</param>
/// <param name="storage">Storage object</param>
/// <param name="status">Status text.</param>
public void Inform(Importer importer, Geocoder geocoder, Storage storage, string status)
{
Debug.Assert(!string.IsNullOrEmpty(status)); // not empty
Debug.Assert(null != importer); // created
Debug.Assert(null != storage); // created
var details = new List <MessageDetail>();
// add statistic
string statistic = _CreateStatistic(importer, geocoder, storage);
Debug.Assert(!string.IsNullOrEmpty(statistic));
var statisticDetail = new MessageDetail(MessageType.Information, statistic);
details.Add(statisticDetail);
// add geocoder exception
if ((null != geocoder) &&
(null != geocoder.Exception))
{
details.Add(_GetServiceMessage(geocoder.Exception));
}
// add steps deatils
details.AddRange(importer.Details);
if (null != geocoder)
{
details.AddRange(geocoder.Details);
}
details.AddRange(storage.Details);
// show status with details
App.Current.Messenger.AddMessage(status, details);
}
public void SendToConversation(string senderId, string conversationId, string message)
{
var messageObject = new MessageDetail()
{
Id = ObjectId.GenerateNewId().ToString(),
Content = message,
ConversationId = conversationId,
FromUserId = senderId,
Time = DateTime.Now
};
_conversationRepository.UpdateSeenIds(conversationId, new List <string>()
{
senderId
});
_messageRepository.Add(messageObject);
var users = _conversationRepository.GetAllUserInConversation(conversationId);
foreach (var user in users)
{
if (user.Connections != null)
{
Clients.Clients(user.Connections).SendAsync("clientMessageListener", conversationId, messageObject);
}
}
}
public async Task <IActionResult> PutMessageDetail(string id, MessageDetail messageDetail)
{
if (id != messageDetail.MessageSid)
{
return(BadRequest());
}
_context.Entry(messageDetail).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MessageDetailExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
///////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Showes process results with details in message window.
/// </summary>
/// <param name="importer">Importer object.</param>
/// <param name="geocoder">Geocoder object (can be NULL).</param>
/// <param name="storage">Storage object</param>
/// <param name="status">Status text.</param>
public void Inform(Importer importer, Geocoder geocoder, Storage storage, string status)
{
Debug.Assert(!string.IsNullOrEmpty(status)); // not empty
Debug.Assert(null != importer); // created
Debug.Assert(null != storage); // created
var details = new List<MessageDetail>();
// add statistic
string statistic = _CreateStatistic(importer, geocoder, storage);
Debug.Assert(!string.IsNullOrEmpty(statistic));
var statisticDetail = new MessageDetail(MessageType.Information, statistic);
details.Add(statisticDetail);
// add geocoder exception
if ((null != geocoder) &&
(null != geocoder.Exception))
{
details.Add(_GetServiceMessage(geocoder.Exception));
}
// add steps deatils
details.AddRange(importer.Details);
if (null != geocoder)
details.AddRange(geocoder.Details);
details.AddRange(storage.Details);
// show status with details
App.Current.Messenger.AddMessage(status, details);
}
public async Task <ActionResult <MessageDetail> > PostMessageDetail(MessageDetail messageDetail)
{
_context.MessageDetails.Add(messageDetail);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetMessageDetail", new { id = messageDetail.MessageSid }, messageDetail));
}
// GET: Message/Details/5
public ActionResult Details(int id)
{
MessageDetail messageDetail = null;
using (DBManager db = new DBManager())
{
string UserID = User.Identity.Name;
string procedureName = "CPK.uspMessageDetail";
List <SqlParameter> paraList = new List <SqlParameter>();
paraList.Add(Common.GetParameter("MessageID", DbType.String, id, ParameterDirection.Input));
if (User.IsInRole("Admin"))
{
UserID = "Administrator";
}
paraList.Add(Common.GetParameter("UserID", DbType.String, UserID, ParameterDirection.Input));
DataSet DbSet = db.GetSelectQuery(paraList, procedureName);
messageDetail = Common.DataToClass <MessageDetail>(DbSet.Tables[0].Rows[0]);
if (!User.IsInRole("Admin"))
{
messageDetail.Recipients = string.Empty;
}
else
{
string temp = messageDetail.Recipients;
messageDetail.Recipients = temp.Remove(temp.Length - 1);
}
}
return(View(messageDetail));
}
public async Task <IActionResult> PutMessageDetail([FromRoute] int id, [FromBody] MessageDetail messageDetail)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != messageDetail.MsgId)
{
return(BadRequest());
}
_context.Entry(messageDetail).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MessageDetailExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
/// <summary>
/// Does import object.
/// </summary>
/// <param name="references">Dictionary property name to field position in data source.</param>
/// <param name="currentNumber">Current record number.</param>
private void _ImportObject(Dictionary <string, int> references, int currentNumber)
{
Debug.Assert(null != _profile); // inited
Debug.Assert(null != _provider); // inited
Debug.Assert(null != _projectData); // inited
Debug.Assert(null != references); // created
try
{
ImportType type = _profile.Type;
ImportResult res = CreateHelpers.Create(type,
references,
_provider,
_projectData,
_defaultDate);
_IsObjectSkipped(res, currentNumber);
}
catch (Exception ex)
{
Logger.Error(ex);
// store problem description
string text =
App.Current.GetString("ImportProcessStatusRecordFailed",
_informer.ObjectName,
currentNumber);
var description = new MessageDetail(MessageType.Warning, text);
_details.Add(description);
++_failedCount;
}
}
private static void AddMessageInCache(MessageDetail _MessageDetail)
{
CurrentMessages.Add(_MessageDetail);
if (CurrentMessages.Count > 1000)
{
CurrentMessages.RemoveAt(0);
}
}
private void AddMessageinCache(MessageDetail _MessageDetail)
{
CurrentMessage.Add(_MessageDetail);
if (CurrentMessage.Count > 100)
{
CurrentMessage.RemoveAt(0);
}
}
private void UpdateDS(string message)
{
var messageDetail = new MessageDetail(user.Id, int.Parse(comboBoxUser.SelectedValue.ToString()), 1, message, DateTime.Now.ToString());
var json = new JavaScriptSerializer().Serialize(messageDetail);
server.Send("AddMessage@" + json + "\n");
string[] answer = boardcastView.Recv().Split('&');
messageDetail.Massageid = int.Parse(answer[1]);
}
protected void GetMessage(string ID)
{
DataSet dt = DbHelperSQL.Query("select * from sys_UserMessage where id ='" + ID + "'");
DbHelperSQL.ExecuteSql("update sys_UserMessage set bRead='True' where id ='" + ID + "'");
DataView dv = dt.Tables[0].DefaultView;
MessageDetail.DataSource = dv;
MessageDetail.DataBind();
}
public void TestAddMessage()
{
mockConversationRepository.Setup(x => x.FindPrivateConversationByReceiverId(It.IsAny <string>())).Returns(conversation);
mockConversationRepository.Setup(x => x.Update(It.IsAny <Conversation>())).Returns(conversation);
mockMessageRepository.Setup(x => x.Add(It.IsAny <MessageDetail>())).Returns(messageDetail);
var chatService = new ChatService.Services.ChatService(mockConversationRepository.Object, mockMessageRepository.Object);
MessageDetail messageDetailActual = chatService.AddMessage("5d4d0x2613376b00013a898z", messageDetail);
Assert.AreEqual(messageDetailActual, messageDetail);
}
public static string GetGroupMessages()
{
JavaScriptSerializer TheSerializer = new JavaScriptSerializer();
//Si groupFacade est null on l'instancie
if (groupFacade == null)
{
groupFacade = new GroupFacade();
}
//Si homeFacade est null on l'instancie
if (homeFacade == null)
{
homeFacade = new HomeFacade();
}
//On ajoute a la liste following tous les groups aux quels l'utilisateur participe
following = homeFacade.GetPersonGroups(theUser.Id);
//On instance une nouvelle liste qui contiendera les id des groups aux quels l'utilisateur participe
groupsId = new List <int>();
//On initialise une nouvelle liste, qui contiendera des objets de MessageDetail
List <MessageDetail> listMessageDetail = new List <MessageDetail>();
//Pour chaque group dans la liste following
foreach (group followingId in following)
{
//On initialise une nouvelle liste qui contiendera les messages
List <Message> listMessage = new List <Message>();
//On ajoute dans la liste groupMessages tous les messages des groups dans lesquels l'utilisateur participe
groupMessages = groupFacade.GetGroupChatHistory(followingId.Id);
//Pour chaque message de la liste groupMessages
foreach (chathistory msg in groupMessages)
{
//..On ajoute dans la liste listMessage les messages qui se trouve dans la liste prit a partir des messages de groupe
listMessage.Add(new Message
{
authorName = msg.person.Name,
message = msg.Message,
dateMessage = msg.CreationDate.ToString()
});
}
MessageDetail messageDetail = new MessageDetail
{
groupId = followingId.Id,
Message = listMessage
};
listMessageDetail.Add(messageDetail);
}
// TheSerializer.Serialize(personId);
return(TheSerializer.Serialize(listMessageDetail));
}
/// <summary>
/// 保存（新增、修改）
/// </summary>
/// <param name="keyValue">主键值</param>
/// <param name="list">实体</param>
/// <returns></returns>
public bool SaveForm(string keyValue, MessageEntity ds)
{
try
{
if (!string.IsNullOrEmpty(keyValue))
{
ds.Modify(keyValue);
this.BaseRepository().Update(ds);
}
else
{
ds.Create();
this.BaseRepository().Insert(ds);
}
var num = this.BaseRepository().ExecuteBySql(string.Format("select count(id) from base_messagedetail where messageid='{0}'", ds.Id));
if (num > 0)
{
this.BaseRepository().ExecuteBySql(string.Format("delete from base_messagedetail where messageid='{0}'", ds.Id));
}
if (!string.IsNullOrWhiteSpace(ds.UserId))
{
var arr = ds.UserId.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
for (int i = 0; i < arr.Length; i++)
{
var userEntity = new UserInfoService().GetUserInfoByAccount(arr[i]);
if (userEntity != null)
{
MessageDetail md = new MessageDetail();
md.UserAccount = userEntity.Account;
md.UserId = userEntity.UserId;
md.UserName = userEntity.RealName;
md.DeptCode = userEntity.DepartmentCode;
md.DeptId = userEntity.DepartmentId;
md.DeptName = userEntity.DeptName;
if (userEntity.Account == ds.SendUser)
{
md.Status = 1;
md.LookTime = DateTime.Now;
}
else
{
md.Status = 0;
}
md.MessageId = ds.Id;
new MessageDetailService().SaveForm(md.Id, md);
}
}
}
return(true);
}
catch
{
return(false);
}
}
internal void Setup(TextBox textBox, MessageDetail[] messages, bool showDetailsPanel)
{
this.lbxItems.Items.Clear();
this.scPanels.Panel2Collapsed = !showDetailsPanel;
if ((textBox == null) || (messages == null) || (messages.Length == 0))
{
this._textBox = null;
}
else
{
this._textBox = textBox;
this.lbxItems.Items.AddRange(messages);
}
this.UpdateSelected();
}
/// <summary>
/// Reports error occured due to failure of the specified service.
/// </summary>
/// <param name="service">The name of the failed service.</param>
/// <param name="exception">The exception occured during reports building.</param>
private void _ReportServiceError(string service, Exception exception)
{
Debug.Assert(exception != null);
Debug.Assert(service != null);
Logger.Error(exception);
var message =
App.Current.GetString(REPORT_SERVICE_FAILED_MESSAGE_KEY, service);
if (exception is CommunicationException)
{
var detailsMessage =
App.Current.GetString(REPORT_SERVICE_CONNECTION_ERROR_KEY, service);
var detail = new MessageDetail(MessageType.Error, detailsMessage);
ICollection<MessageDetail> details =
CommonHelpers.CreateCollectionWithOneObject(detail);
App.Current.Messenger.AddError(message, details);
}
else
{
CommonHelpers.AddServiceMessageWithDetail(message, service, exception);
}
}
///////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Gets service message as detail.
/// </summary>
/// <param name="ex">Service exception to conversion.</param>
/// <returns>Created message detail.</returns>
private MessageDetail _GetServiceMessage(Exception ex)
{
Debug.Assert(null != ex); // created
App currentApp = App.Current;
string service = currentApp.FindString("ServiceNameGeocoding");
MessageDetail detail = null;
var exCommunication = ex as CommunicationException;
if (null == exCommunication)
{ // other exception
var exAuthentication = ex as AuthenticationException;
if (null == exAuthentication)
{ // all other exception
Debug.Assert(false); // not supported
Logger.Error(ex);
detail = new MessageDetail(MessageType.Warning, ex.Message);
}
else
{ // authentication exception
string message = currentApp.GetString("ServiceAuthError",
service,
exAuthentication.ServiceName);
// create link to license page
var link = new Link(currentApp.FindString("LicencePanelText"),
Pages.PagePaths.LicensePagePath,
LinkType.Page);
detail = new MessageDetail(MessageType.Warning, message, link);
}
}
else
{ // communication exception
string message =
CommonHelpers.FormatServiceCommunicationError(service, exCommunication);
detail = new MessageDetail(MessageType.Warning, message);
}
return detail;
}
internal frmEntryMessages(IEntryMessageResultsConnection connector, TextBox textBox, MessageDetail[] messages, bool showDetailsPanel)
: this(connector)
{
this.Setup(textBox, messages, showDetailsPanel);
}
/// <summary>
/// Does print report.
/// </summary>
/// <param name="generator">Report generator object.</param>
/// <param name="description">Report state description.</param>
/// <param name="showPrintDialog">Need show print dialog flag.</param>
/// <param name="copiesCount">Selecetd copies count.</param>
/// <param name="isCanceled">Is operation ccancel by user.</param>
/// <returns>Operation status message.</returns>
private MessageDetail _DoPrint(ReportsGenerator generator,
ReportStateDescription description,
bool showPrintDialog,
ref int copiesCount,
ref bool isCanceled)
{
Debug.Assert(null != generator);
Debug.Assert(null != description);
isCanceled = false;
MessageDetail detail = null;
try
{
// generate report
if (null == description.Report)
generator.RunReport(description);
// init print dialog
DDActiveReports.Document.Document document = description.Report.Document;
document.PrintAborted +=
new DDActiveReports.Document.PrintAbortedEventHandler(Document_PrintAborted);
DDActiveReports.Document.Printer printer = document.Printer;
printer.PrinterSettings.PrintRange = PrintRange.SomePages;
printer.PrinterSettings.FromPage = 1;
printer.PrinterSettings.ToPage = description.Report.Document.Pages.Count;
printer.PrinterSettings.PrintRange = PrintRange.AllPages;
// select application printer
ArcLogistics.App.PrinterSettingsStore settings = App.Current.PrinterSettingsStore;
if (!string.IsNullOrEmpty(settings.PrinterName))
{
description.Report.Document.Printer.PrinterName = settings.PrinterName;
description.Report.Document.Printer.DefaultPageSettings = settings.PageSettings;
}
// do printing
if (!description.Report.Document.Print(showPrintDialog, true))
isCanceled = true;
else
{
if (showPrintDialog)
{
// store copies count
copiesCount = description.Report.Document.Printer.PrinterSettings.Copies;
// store printer settings in application
var prntSettings = description.Report.Document.Printer.PrinterSettings;
if (!string.IsNullOrEmpty(prntSettings.PrinterName))
settings.StoreSetting(prntSettings.PrinterName,
prntSettings.DefaultPageSettings);
}
string message = App.Current.GetString("ReportPreviewPrintDoneFormat",
description.ReportName);
detail = new MessageDetail(MessageType.Information, message);
}
}
catch (Exception ex)
{
string message = App.Current.GetString("ReportPreviewPrintFailFormat",
description.ReportName);
detail = _DoExceptionRoutine(message, ex, generator, description);
}
return detail;
}
/// <summary>
/// Updates geocodable information.
/// </summary>
/// <param name="needMessage">Need show message.</param>
/// <param name="candidate">Geocoded candidate (can be NULL).</param>
/// <param name="obj">Source object to geocoded candidate.</param>
private void _UpdateGeocodableInfo(bool needMessage,
AddressCandidate candidate,
AppData.DataObject obj)
{
Debug.Assert(null != obj); // Created.
IGeocodable geocodable = _GetGeocodable(obj);
geocodable.GeoLocation = null;
if ((null == candidate) || (candidate.Score <= App.Current.Geocoder.MinimumMatchScore))
{
// Not geocoded.
geocodable.Address.MatchMethod = string.Empty;
}
else
{
GeocodeHelpers.SetCandidate(geocodable, candidate);
++_geocodedCount;
// Store warning.
if (needMessage)
{
string objectName = _informer.ObjectName;
string errorTextFormat =
App.Current.GetString("ImportProcessStatusRecordOutMapExtendGeocodedFormat",
objectName.ToLower(),
"{0}",
objectName);
var description =
new MessageDetail(MessageType.Warning, errorTextFormat, obj);
_details.Add(description);
}
}
}
/// <summary>
/// Do deploying to route server.
/// </summary>
/// <param name="routes">Routes to deploy.</param>
/// <param name="deploymentDate">Date/time to deploy routes for.</param>
private void _DeployToRouteServer(
IEnumerable<Route> routes,
DateTime deploymentDate)
{
bool savedSuccessfully = false;
var hasRoutesBeenSent = false;
List<MessageDetail> details = new List<MessageDetail>();
try
{
// Try to deploy.
hasRoutesBeenSent = _app.Tracker.Deploy(routes, deploymentDate); // Exception
// Save schedule changes to db.
_app.Project.Save();
savedSuccessfully = true;
}
catch (Exception ex)
{
// if some error occurs during.
MessageDetail detail = new MessageDetail(MessageType.Error, ex.Message);
details.Add(detail);
Logger.Error(ex);
}
// Show deploy message in UI.
// If routes was deployed.
if (savedSuccessfully && hasRoutesBeenSent)
_app.Messenger.AddInfo((string)_resourceDictionary["AllRoutesSent"]);
// If there was nothing to deploy.
else if (savedSuccessfully && !hasRoutesBeenSent)
_app.Messenger.AddWarning((string)_resourceDictionary["NothingWasSent"]);
// If there was error.
else
_app.Messenger.AddError((string)_resourceDictionary["FailedToSendRoutes"], details);
}
/// <summary>
/// Check deploying type.
/// </summary>
/// <param name="routesConfigs">Config of routes to deploy.</param>
/// <returns>True if need to deploy to tracking server. False otherwise.</returns>
private bool _IsDeployToTrackingServer(IList<SentRouteConfig> routesConfigs)
{
// Get first selected route and check its type.
foreach (SentRouteConfig sendedRouteConfig in routesConfigs)
{
if (sendedRouteConfig.IsChecked)
{
MobileDevice mobileDevice = sendedRouteConfig.Route.Driver.MobileDevice;
if (mobileDevice == null)
{
mobileDevice = sendedRouteConfig.Route.Vehicle.MobileDevice;
}
if (mobileDevice.SyncType != SyncType.WMServer)
{
return false;
}
}
}
// Show error in case of not all used mobile devices has unique tracking ID.
if (!_IsTrackingIDUnique(routesConfigs))
{
string sendedMessage = (string)_resourceDictionary["FailedToSendRoutes"];
List<MessageDetail> details = new List<MessageDetail>();
string messageDetailText = (string)_resourceDictionary["MobileDevicesShouldHaveUniqueIDs"];
MessageDetail detail = new MessageDetail(MessageType.Error, messageDetailText);
details.Add(detail);
_app.Messenger.AddError(sendedMessage, details);
return false;
}
else
{
// Check that all routes has mobile device and its types is "Tracking server".
if (!_IsMobileDevicesPresentWithTrackingType(routesConfigs))
{
string messageDetailText = (string)_resourceDictionary["AllMobileDevicesShouldBePresentWithTrackingType"];
_app.Messenger.AddWarning(messageDetailText);
}
}
return true;
}
private void AddMessageinCache(string userName, string message)
{
string groupName = ConnectedUsers.FirstOrDefault(u => u.UserName == userName) == null ? "" : ConnectedUsers.FirstOrDefault(u => u.UserName == userName).Event;
var m = new MessageDetail()
{
UserName = userName,
Message = message,
Sent = System.DateTime.Now,
GroupName =groupName
};
CurrentMessage.Add(m);
m.Save();
if (CurrentMessage.Count > 100)
CurrentMessage.RemoveAt(0);
}
/// <summary>
/// Add info about failed layers in messagewindow.
/// </summary>
private void _AddFailedLayersInfo()
{
if (_failedLayers.Count > 0)
{
List<MessageDetail> details = new List<MessageDetail>();
foreach (AgsLayer agsLayer in _failedLayers)
{
string message = string.Format((string)App.Current.FindResource("LayerFailed"), agsLayer.MapLayer.Name);
MessageDetail messageDetail = new MessageDetail(MessageType.Error, message);
details.Add(messageDetail);
}
App.Current.Messenger.AddError((string)App.Current.FindResource("SomeMapLayersFailed"), details);
// Clear to prevent error copies.
_failedLayers.Clear();
}
}
/// <summary>
/// Add available service layers to map and process unavailable.
/// </summary>
private void _InitServiceLayers()
{
// Save AgsLayers to list
_agsLayers = new List<AgsLayer>();
map.Layers.Clear();
foreach (MapLayer layer in this.Map.Layers)
{
AgsMapLayer agsMapLayer = layer as AgsMapLayer;
AgsLayer wrap = AgsLayerFactory.CreateLayer(agsMapLayer.Server, layer);
_agsLayers.Add(wrap);
// subscribe to StateChanged event to react on server state changing
agsMapLayer.Server.StateChanged += new EventHandler(Server_StateChanged);
wrap.ArcGISLayer.InitializationFailed += new EventHandler<EventArgs>(ArcGISLayer_InitializationFailed);
if (agsMapLayer.Server.State == ESRI.ArcLogistics.Services.AgsServerState.Authorized)
map.Layers.Add(wrap.ArcGISLayer);
}
// Check all layers availability and save it to details list
List<MessageDetail> details = new List<MessageDetail>();
foreach (MapLayer mapLayer in Map.Layers)
{
AgsMapLayer agsMapLayer = mapLayer as AgsMapLayer;
if (agsMapLayer != null)
{
if (agsMapLayer.Server.State == AgsServerState.Unavailable)
{
string format = (string)App.Current.FindResource("LayerUnavailable");
string errorMessage = string.Format(format, mapLayer.Name);
MessageDetail detail = new MessageDetail(MessageType.Error, errorMessage);
details.Add(detail);
}
else if (agsMapLayer.Server.State == AgsServerState.Unauthorized)
{
string format = (string)App.Current.FindResource("LayerNotAuthorized");
string errorMessage = string.Format(format, mapLayer.Name, agsMapLayer.Server.Title);
Link link = new Link((string)App.Current.FindResource("LicencePanelText"),
Pages.PagePaths.LicensePagePath, LinkType.Page);
MessageDetail detail = new MessageDetail(MessageType.Error, errorMessage, link);
details.Add(detail);
}
}
}
// Add info to messenger in case of at least one unavailable layer
if (details.Count > 0)
App.Current.Messenger.AddError((string)App.Current.FindResource("SomeMapLayersCannotBeLoaded"), details);
}
/// <summary>
/// Saves report routine.
/// </summary>
/// <param name="exporter">Exporter object.</param>
/// <param name="exportDir">Export directory.</param>
/// <param name="fileName">Export report file name (can be null).</param>
/// <param name="fileExt">Export file extension.</param>
/// <param name="generator">Report generator.</param>
/// <param name="description">Report state descriiption.</param>
/// <returns>Status messages.</returns>
private MessageDetail _DoSaveReport(IDocumentExport exporter,
string exportDir,
string fileName,
string fileExt,
ReportsGenerator generator,
ReportStateDescription description)
{
Debug.Assert(null != exporter);
Debug.Assert(null != generator);
Debug.Assert(null != description);
Debug.Assert((null != exportDir) && (null != fileExt));
MessageDetail detail = null;
string fullFileName = null;
try
{
string filename = (string.IsNullOrEmpty(fileName)) ?
_ValidateFileName(description.ReportName) : fileName;
fullFileName = Path.Combine(exportDir, filename + fileExt);
if (null == description.Report)
generator.RunReport(description);
exporter.Export(description.Report.Document, fullFileName);
string message = App.Current.GetString("ReportPreviewSaveDoneFormat",
description.ReportName, fullFileName);
detail = new MessageDetail(MessageType.Information, message);
}
catch (Exception ex)
{
string message = App.Current.GetString("ReportPreviewSaveFailFormat",
description.ReportName, fullFileName);
detail = _DoExceptionRoutine(message, ex, generator, description);
}
return detail;
}
/// <summary>
/// Method gets details messages about successfully assigned orders during
/// routing operation. Details message are expanded by route names.
/// </summary>
/// <param name="schedule">Schedule.</param>
/// <param name="info">Operation info.</param>
/// <returns>Collection of message details.</returns>
private ICollection<MessageDetail> _GetSuccessfullyAssignedOrdersDetails(
Schedule schedule, AsyncOperationInfo info)
{
var routedOrdersDetails = new Collection<MessageDetail>();
ICollection<Order> ordersToAssign = _GetOrdersToAssign(info);
if (ordersToAssign == null)
return routedOrdersDetails;
// Find all pairs Route & Order.
var detailsPairs = new List<KeyValuePair<Route, Order>>();
foreach (Order order in ordersToAssign)
foreach (Route route in schedule.Routes)
foreach (Stop stop in route.Stops)
if (stop.AssociatedObject is Order &&
((Order)stop.AssociatedObject).Equals(order))
{
var pair = new KeyValuePair<Route, Order>(
route, order);
detailsPairs.Add(pair);
}
string formatString =
(string)App.Current.FindResource(ORDERS_SUCCESSFULLY_ASSIGNED);
// Add messages expanded by Routes.
foreach (Route route in schedule.Routes)
foreach (KeyValuePair<Route, Order> pair in detailsPairs)
{
if (pair.Key.Name == route.Name)
{
DataObject[] parameters = new DataObject[] { pair.Value, pair.Key };
MessageDetail detail = new MessageDetail(MessageType.Information,
formatString, parameters);
routedOrdersDetails.Add(detail);
}
}
return routedOrdersDetails;
}
