/// <summary> /// Zobrazí chybovou hlášku týkající se sběrnice /// </summary> /// <param name="type">typ hlášky</param> /// <param name="message">text chyby</param> public void showDisgnosticMessage(MessageTypeEnum type, string message) { switch (type) { case MessageTypeEnum.error: //MessageBox.Show(message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); labelMessage.ForeColor = Color.Red; break; case MessageTypeEnum.success: labelMessage.ForeColor = Color.Green; break; case MessageTypeEnum.progress: labelMessage.ForeColor = Color.Blue; break; } if (labelMessage.InvokeRequired) { ShowDisagnosticMessageCallback cb = new ShowDisagnosticMessageCallback(showDisgnosticMessage); this.Invoke(cb, new object[] { type, message }); } else { labelMessage.Text = message; } }
public static void AddMessage(this FlowLayoutPanel source, MessageTypeEnum messageType, string message) { var panel = new FlowLayoutPanel(); panel.AutoSize = true; panel.WrapContents = false; panel.FlowDirection = FlowDirection.TopDown; var lbl = new Label(); lbl.AutoSize = true; lbl.Margin = new Padding(10, 10, 10, 0); lbl.Text = messageType.ToString(); lbl.ForeColor = Color.FromName("White"); lbl.BackColor = messageType.ToColor(); lbl.BorderStyle = BorderStyle.FixedSingle; lbl.Font = new Font("Microsoft Sans Serif", 10f, FontStyle.Bold); panel.Controls.Add(lbl); var lbl2 = new Label(); lbl2.AutoSize = true; lbl2.Margin = new Padding(10, 5, 10, 5); lbl2.Text = message; lbl2.Font = new Font("Microsoft Sans Serif", 10f); panel.Controls.Add(lbl2); source.Controls.Add(panel); Application.DoEvents(); source.Focus(); }
public Message(MessageTypeEnum _messageType, string _userName, string _time, string _text, byte[] _bitmap, string _room) { messageType = _messageType; userName = _userName; time = _time; text = _text; bitmap = _bitmap; room = _room; }
public MeasuringMessage(DateTime dateTime, MessageTypeEnum messageType, string measurableType, Guid plantsAreaId, double parameterValue) { Id = Guid.NewGuid(); DateTime = dateTime; MessageType = messageType; MeasurableType = measurableType; PlantsAreaId = plantsAreaId; ParameterValue = parameterValue; }
public static void ShowMessage(this System.Web.Mvc.Controller controller, MessageTypeEnum messageType, string message, bool showAfterRedirect = false) { var messageTypeKey = messageType.ToString(); if (showAfterRedirect) { controller.TempData[messageTypeKey] = message; } else { controller.ViewData[messageTypeKey] = message; } }
/// <summary> /// Set up simple message /// messageType = eviivo /// contentType = plain text /// Status = unread /// text = "Test text" /// business id = 1 /// message id = 1 /// </summary> /// <param name="businessId">business to create message for, default 1</param> /// <param name="messageId">id of message, default 1</param> /// <param name="messageTypeEnum">message type, default eviivo</param> /// <param name="contentTypeEnum">content type, default plain</param> /// <param name="messageStatusEnum">message status, default unread</param> /// <param name="content">content text, default "Test text"</param> /// <returns>a new Message</returns> public static Message BuildSimple(long businessId = 1, int messageId = 1, MessageTypeEnum messageTypeEnum = MessageTypeEnum.EviivoMessage, ContentTypeEnum contentTypeEnum = ContentTypeEnum.PlainText, MessageStatusEnum messageStatusEnum = MessageStatusEnum.Unread, string content = "Test text") { return new Message { BusinessId = businessId, Id = messageId, MessageStatusEnum = messageStatusEnum, MessageTypeEnum = messageTypeEnum, ContentTypeEnum = contentTypeEnum, Content = content, CreatedDateTime = DateTime.Now, Events = new System.Collections.Generic.List<MessageEvent>() }; }
public int QuerySendCount(string userId, MessageStatusEnum status, MessageTypeEnum type) { var query = uow.Set <Message>().Where(x => x.IsDelete == false); return(query.Where(x => x.Sender.Id == userId && (x.Status & status) != 0 && (x.Type & type) != 0).Count()); }
public ProducerMessageHeader(IBinaryHeaderEncoder writer, FieldEncodingEnum encoding, MessageLengthFieldTypeEnum lengthFieldType, MessageTypeEnum messageType, ConfigurationVersionDataType configurationVersion) { m_MessageType = messageType; m_Encoding = encoding; m_lengthFieldType = lengthFieldType; m_HeaderWriter = new HeaderWriter(writer, PackageHeaderLength()); MessageSequenceNumber = 0; ConfigurationVersion = configurationVersion; }
/// <summary> /// shows a message on the log /// </summary> /// <param name="message">message content</param> /// <param name="type">type of the message</param> public void Log(string message, MessageTypeEnum type) { m_logging.Log(IMAGES_PORT + message, type); }
public void ConsoleWrite(string msg, MessageTypeEnum type) { LogWrite(FormatMessage(msg, type)); }
protected void ShowAlertDialogFragment(int aMessage, MessageTypeEnum aType) { ShowAlertDialogFragment(Resources.GetString(aMessage), aType); }
/// <summary> /// Logs message to for asynchronous displaying. /// </summary> /// <param name="line">Message to be displayed</param> /// <param name="type">Type of a message</param> /// <param name="logToEventLog">Log to event log</param> public void LogMessage(string line, MessageTypeEnum type, bool logToEventLog) { if (!line.EndsWithCSafe("<br />", StringComparison.InvariantCultureIgnoreCase)) { line = line + "<br />"; } ProgressMessagesHelper progressMessages = new ProgressMessagesHelper(); switch (type) { case MessageTypeEnum.Info: progressMessages.LogInfo(line, SourceText, EventCodeText, logToEventLog); break; case MessageTypeEnum.Warning: progressMessages.LogWarning(line, SourceText, EventCodeText, logToEventLog); break; case MessageTypeEnum.Error: progressMessages.LogError(line, SourceText, EventCodeText, logToEventLog); break; case MessageTypeEnum.Finished: progressMessages.LogQuit(line, SourceText, EventCodeText, logToEventLog); break; } }
public LogRecord(MessageTypeEnum type, LogMessage message, Server server) : this() { MessageTypeId = (int)type; LogMessage = message; Server = server; }
private void VeraMessagesCallBack(MessageTypeEnum messageType, string message) { //var addText = string.Format("{0} - {1}\r\n", messageType, message); this.flowLayoutPanel1.AddMessage(messageType, message); }
public Message(MessageTypeEnum MessageType) { this.MessageType = MessageType; }
/// <summary> /// Constructor /// </summary> /// <param name="messageNumber">The message number</param> /// <param name="messageType">The message type</param> public MSBuildMessage(int messageNumber, MessageTypeEnum messageType) : base(messageNumber, messageType) { }
public static MessageType Create(MessageTypeEnum v) { return new MessageType { InnerValue = v }; }
/// <summary> /// Constructor /// </summary> /// <param name="messageText">The message tesxt</param> /// <param name="messageType">The message type</param> public MSBuildMessage(string messageText, MessageTypeEnum messageType) : base(0, messageText, messageType) { }
public String FormatMessage(String msg, MessageTypeEnum type) { String prefix = "[^bBattlelog Cache^n] "; if (type.Equals(MessageTypeEnum.Warning)) { prefix += "^1^bWARNING^0^n: "; } else if (type.Equals(MessageTypeEnum.Error)) { prefix += "^1^bERROR^0^n: "; } else if (type.Equals(MessageTypeEnum.Exception)) { prefix += "^1^bEXCEPTION^0^n: "; } return prefix + msg; }
public void FromByte(byte data) { MessageType = (MessageTypeEnum)((data >> 5) & 0x7); ExtendedMessage = (data & 0x10) != 0; HopsLeft = (byte)((data >> 2) & 0x3); MaxHops = (byte)((data >> 0) & 0x3); }
public static Message genRoomNotifi(string toNoti, MessageTypeEnum type) { Message msg = new Message(); msg.messageType = type; msg.text = toNoti; msg.time = System.DateTime.Now.ToString(); return msg; }
private static ContentInfo ContentParser(MessageTypeEnum type, string messageInfo, string messageId, string targetId) { var result = JsonConvert.DeserializeObject<ContentInfo>(messageInfo); result.MessageType = type; result.Id = messageId; if (type != MessageTypeEnum.TxtMsg) { if (type == MessageTypeEnum.ContactNtf) { result.content += result.message; } else if (type == MessageTypeEnum.InfoNtf) { result.content += result.message; } else if (type == MessageTypeEnum.ProfileNtf) { } else if (type == MessageTypeEnum.CmdNtf) { } else if (type == MessageTypeEnum.CmdMsg) { } else if (type == MessageTypeEnum.DizNtf) { result.content = type.GetDescription(); } else if (type == MessageTypeEnum.LBSMsg) { result.content = "[地理位置]"; } } if (type == MessageTypeEnum.VcMsg) { var localFile = String.Format(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Temp", targetId + "-" + messageId + ".wav")); if (!File.Exists(localFile)) { var tempAmrFile = String.Format(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Temp", targetId + "-" + messageId + ".amr")); Byte[] wavBytes = Convert.FromBase64String(result.content); File.WriteAllBytes(tempAmrFile, wavBytes); Rcsdk.DecodeAmrToWav(tempAmrFile, localFile); } result.extra = localFile; } if (type == MessageTypeEnum.ImgMsg) { var image = System.Drawing.Image.FromStream(new MemoryStream(System.Convert.FromBase64String(result.content))); var localFile = String.Format(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Temp", targetId + "-" + messageId + ".jpg")); if (!File.Exists(localFile)) { image.Save(localFile, System.Drawing.Imaging.ImageFormat.Jpeg); } result.thumImgPath = localFile; } if (type == MessageTypeEnum.TxtMsg) { result.content = EncryptHelper.Decrypt(result.content); // result.content = Regex.Replace(result.content, @"\p{Cs}", "[表情]"); } if (type == MessageTypeEnum.file) { //ToDO:如果为文件,则保存 } return result; }
private static async Task <LogRecord> CreateRecord(ApplicationContext context, Server server, MessageTypeEnum type, string message) { return(new LogRecord(type, await GetOrCreateMessage(context, message), server)); }
/// <summary> /// Add a notification to a booking /// </summary> /// <param name="businessId">Business for booking</param> /// <param name="booking">Booking to create the notification for</param> /// <param name="cultureCode">Culture for translating</param> /// <param name="type">Booking Type</param> /// <param name="notificationDate">The datetime at which this notification should be presented to the user</param> /// <param name="parameters">string.format() parameters to be included in the message content</param> private void AddNotificationMessage(long businessId, Model.Booking.Booking booking, string cultureCode, MessageTypeEnum type, DateTime notificationDate, params object[] parameters) { var notificationMessage = new Message { ContentTypeEnum = Model.Common.ContentTypeEnum.PlainText, BusinessId = businessId, MessageTypeEnum = type, MessageStatusEnum = MessageStatusEnum.Unread }; var notificationKey = string.Empty; switch (type) { case MessageTypeEnum.PreAuth: notificationKey = PREAUTH_NOTIFICATION_KEY; break; case MessageTypeEnum.CollectPayOnArrival: notificationKey = COLLECTPOA_NOTIFICATION_KEY; break; case MessageTypeEnum.BookingWithExtras: notificationKey = EXTRAS_NOTIFICATION_KEY; break; } // get message text var items = dictionaryManager.GetDictionaryItemByKeysAndCultures(new List<string> { notificationKey }, null); if (items != null && items.Any()) { ICollection<DictionaryInstance> instances = items.First().DictionaryInstances; notificationMessage.Content = dictionaryManager.DictionaryInstanceToContentByCulture(instances, cultureCode); // if content isn't empty if (!string.IsNullOrWhiteSpace(notificationMessage.Content)) { // format the text notificationMessage.Content = string.Format(notificationMessage.Content, parameters); } } // booking id for now notificationMessage.Reference = booking.Id.HasValue ? booking.Id.Value.ToString() : string.Empty; notificationMessage.NotifyAfter = notificationDate; messageDao.AddMessage(notificationMessage); }
/// <summary> /// Constructor /// </summary> /// <param name="messageNumber">The message number</param> /// <param name="messageType">The message type</param> public Message(int messageNumber, MessageTypeEnum messageType) { this.messageNumber = messageNumber; this.messageText = String.Empty; this.messageType = messageType; }
/// <summary> /// Constructor /// </summary> /// <param name="messageNumber">The message number</param> /// <param name="messageText">The message text</param> /// <param name="messageType">The message type</param> public WixMessage(int messageNumber, string messageText, MessageTypeEnum messageType) : base(messageNumber, messageText, messageType) { }
/// <summary> /// Closes given directory (directory path is in args). /// Sends a notification to server which holds a list of all handlers (closes only given one). /// </summary> public string CloseDirectory(string[] args, out MessageTypeEnum status) { status = MessageTypeEnum.INFO; OnClose(this, new DirectoryCloseEventArgs(args[0])); return("Got command: " + (CommandEnum.CloseCommand).ToString() + " Args: " + args[0]); }
/// <summary> /// Constructor /// </summary> /// <param name="messageNumber">The message number</param> /// <param name="messageType">The message type</param> public WixMessage(int messageNumber, MessageTypeEnum messageType) : base(messageNumber, messageType) { }
private static ContentInfo ConversationContentParser(MessageTypeEnum type, string messageInfo) { var result = JsonConvert.DeserializeObject<ContentInfo>(messageInfo); result.MessageType = type; if (type != MessageTypeEnum.TxtMsg) { result.content = type.GetDescription(); if (type == MessageTypeEnum.ContactNtf) { result.content += result.message; } else if (type == MessageTypeEnum.InfoNtf) { result.content += result.message; } else if (type == MessageTypeEnum.ProfileNtf) { } else if (type == MessageTypeEnum.CmdNtf) { } else if (type == MessageTypeEnum.CmdMsg) { } } else { result.content = EncryptHelper.Decrypt(result.content); } return result; }
/// <summary> /// Gets the producer message header. /// </summary> /// <param name="writer">The writer <see cref="IBinaryHeaderEncoder" /> to populate the payload with the header information.</param> /// <param name="encoding">The encoding.</param> /// <param name="lengthFieldType">Type of the length field in the the message header.</param> /// <param name="messageType">Type of the message.</param> /// <param name="configurationVersion">The configuration version.</param> /// <returns>MessageHeader.</returns> internal static MessageHeader GetProducerMessageHeader(IBinaryHeaderEncoder writer, FieldEncodingEnum encoding, MessageLengthFieldTypeEnum lengthFieldType, MessageTypeEnum messageType, ConfigurationVersionDataType configurationVersion) { return new ProducerMessageHeader(writer, encoding, lengthFieldType, messageType, configurationVersion); }
protected void ShowAlertDialogFragment(string aMessage, MessageTypeEnum aType) { ShowAlertDialogFragment(aMessage, Resources.GetString(Resource.String.common_warning), Resource.Drawable.ic_dialog_warning_shadow); }
internal override void Synchronize() { m_MessageType = (MessageTypeEnum)m_reader.ReadByte(); m_EncodingFlags = m_reader.ReadByte(); switch ((MessageLengthFieldTypeEnum)(m_EncodingFlags & EncodingFlagsMessageLengthMask)) { case MessageLengthFieldTypeEnum.OneByte: m_MessageLength = m_reader.ReadByte(); break; case MessageLengthFieldTypeEnum.TwoBytes: m_MessageLength = m_reader.ReadUInt16(); break; case MessageLengthFieldTypeEnum.FourBytes: m_MessageLength = m_reader.ReadUInt32(); break; } m_MessageSequenceNumber = m_reader.ReadUInt16(); m_ConfigurationVersion.MajorVersion = m_reader.ReadByte(); m_ConfigurationVersion.MinorVersion = m_reader.ReadByte(); switch (m_MessageType) { case MessageTypeEnum.DataKeyFrame: case MessageTypeEnum.DataDeltaFrame: case MessageTypeEnum.Event: m_TimeStamp = m_reader.ReadDateTime(); m_FieldCount = m_reader.ReadUInt16(); break; case MessageTypeEnum.KeepAlive: break; case MessageTypeEnum.DataSetMetadata: break; default: break; } m_IsSynchronized = true; }
/// <summary> /// Gets the producer message header. /// </summary> /// <param name="writer">The writer <see cref="IBinaryHeaderEncoder" /> to populate the payload with the header information.</param> /// <param name="encoding">The encoding.</param> /// <param name="lengthFieldType">Type of the length field in the the message header.</param> /// <param name="messageType">Type of the message.</param> /// <param name="configurationVersion">The configuration version.</param> /// <returns>MessageHeader.</returns> internal static MessageHeader GetProducerMessageHeader(IBinaryHeaderEncoder writer, FieldEncodingEnum encoding, MessageLengthFieldTypeEnum lengthFieldType, MessageTypeEnum messageType, ConfigurationVersionDataType configurationVersion) { return(new ProducerMessageHeader(writer, encoding, lengthFieldType, messageType, configurationVersion)); }
public static BaseMessage ParseMessage(string message) { BaseMessage retMessage = null; MessageTypeEnum header = (MessageTypeEnum)Enum.Parse(typeof(MessageTypeEnum), message.Substring(0, 3), true); CommandEnum cmd = (CommandEnum)Enum.Parse(typeof(CommandEnum), message.Substring(3, 2), true); if (header == MessageTypeEnum.REQ) { switch (cmd) { case CommandEnum.Download: retMessage = new DownloadRequest(); break; case CommandEnum.Upload: retMessage = new UploadRequest(); break; case CommandEnum.ListFiles: retMessage = new ListFilesRequest(); break; case CommandEnum.ClientConnection: retMessage = new ClientConnectionRequest(); break; case CommandEnum.ClientDisconnection: retMessage = new ClientDisconnectionRequest(); break; case CommandEnum.ClientDownload: retMessage = new ClientDownloadRequest(); break; case CommandEnum.ClientUpload: retMessage = new ClientUploadRequest(); break; case CommandEnum.Backup: { retMessage = new ListFilesRequest(); retMessage.Cmd = CommandEnum.Backup; break; } default: throw new Exception(string.Format("Mensaje desconocido: {0} - {1}", header, cmd)); } } else if (header == MessageTypeEnum.RES) { switch (cmd) { case CommandEnum.Download: retMessage = new DownloadResponse(); break; case CommandEnum.Upload: retMessage = new UploadResponse(); break; case CommandEnum.ListFiles: retMessage = new ListFilesResponse(); break; case CommandEnum.ClientConnection: retMessage = new ClientConnectionResponse(); break; case CommandEnum.ClientDisconnection: retMessage = new ClientDisonnectionResponse(); break; case CommandEnum.ClientDownload: retMessage = new ClientDownloadResponse(); break; case CommandEnum.ClientUpload: retMessage = new ClientUploadResponse(); break; default: throw new Exception(string.Format("Mensaje desconocido: {0} - {1}", header, cmd)); } } else { throw new Exception(string.Format("Mensaje desconocido: {0} - {1}", header, cmd)); } retMessage.Data = message.Substring(10); if (!ValidateMessage(message, retMessage)) { throw new Exception("El formato del mensaje recibido es incorrecto"); } return(retMessage); }
public Message(MessageTypeEnum messageType) { MessageType = messageType; }
public IEnumerable <MessageViewModel> QuerySend(string key, int offset, int limit, out int count, MessageStatusEnum status, MessageTypeEnum type, string ownerId = "") { var query = uow.Set <Message>().Where(x => x.IsDelete == false && (x.Status & status) != 0 && (x.Type & type) != 0); if (!string.IsNullOrEmpty(key)) { query = query.Where(x => x.Title.Contains(key) || x.Accepter.UserName.Contains(key) || x.Accepter.Name.Contains(key) || x.Content.Contains(key)); } if (!string.IsNullOrEmpty(ownerId)) { query = query.Where(x => x.Sender.Id == ownerId); } count = query.Count(); return(query.OrderByDescending(x => x.CreateAt).Skip(offset).Take(limit).ToList().Select(x => new MessageViewModel(x))); }
/// <summary> /// constructor /// </summary> /// <param name="msg">message content</param> /// <param name="type">type of message</param> public MessageRecievedEventArgs(string msg, MessageTypeEnum type) { Message = msg; Status = type; }
/// <summary> /// Executing the Command Requet /// </summary> /// <param name="commandID">CommandId - <see cref="CommandState"/></param> /// <param name="args">arguments for the command</param> /// <param name="result"> true if succeeded</param> /// <param name="type"> <seealso cref="MessageTypeEnum"/></param> /// <returns>string - msg of the execute </returns> public string ExecuteCommand(int commandID, string[] args, out bool result, out MessageTypeEnum type) { return(commands[commandID].Execute(args, out result, out type)); }
//Log function. //Invoke message recieved event to write to the event log. public void Log(string message, MessageTypeEnum type) { MessageRecievedEventArgs msg = new MessageRecievedEventArgs(message, type); MessageRecieved?.Invoke(this, msg); }
public MessageRecievedEventArgs(string message, MessageTypeEnum type)////////// { Status = type; Message = message; }
/// <summary> /// C'tor for MessageRecievedEventArgs, recevies message and type of her /// </summary> /// <param name="message">string contain the message</param> /// <param name="status">what kind of message (INFO, WARNING, FAIL)</param> public MessageRecievedEventArgs(string message, MessageTypeEnum status) { this.Message = message; this.Status = status; }
/// <summary> /// MessageRecievedEventArgs function. /// </summary> /// <param name="status">type of log writting</param> /// <param name="message">message text</param> public MessageRecievedEventArgs(MessageTypeEnum status, string message) { this.status = status; this.message = message; }
/// <summary> /// Constructor /// </summary> /// <param name="messageNumber">The message number</param> /// <param name="messageText">The message text</param> /// <param name="messageType">The message type</param> public Message(int messageNumber, string messageText, MessageTypeEnum messageType) { this.messageNumber = messageNumber; this.messageText = messageText; this.messageType = messageType; }
private void AddMessage(MessageTypeEnum messageType, string message) { MessageCallBack.Invoke(messageType, message); }
public StatusEnum GetStatus(MessageTypeEnum e) { InitMessageStatus(); return(dic.FirstOrDefault(a => a.Key == e).Value); }
public void Log(string message, MessageTypeEnum type) { MessageRecieved?.Invoke(this, new MessageRecievedEventArgs(type, message)); }
public int Logger(string pMessage, MessageTypeEnum pTypeMessage) { return(LogService.Log(pMessage, pTypeMessage)); }
public LogMessageRecord(string message, MessageTypeEnum type) { this.Message = message; this.Type = type; }
public LogRecord(MessageTypeEnum type, int messageId, int serverId) : this() { MessageTypeId = (int)type; LogMessageId = messageId; ServerId = serverId; }
public MessageReportData(string message, MessageIndentEnum messageIndent) { Message = message; MessageIndent = messageIndent; MessageType = MessageTypeEnum.InfoText; }
public static void SendAllMessage <T>(string message, MessageTypeEnum type, decimal money = 0) where T : BaseServiceSocketMiddleware { SendAllMessage <T>(Newtonsoft.Json.JsonConvert.SerializeObject(new { Message = message, Type = type, Money = money })); }
public MessageReportData(string message, MessageIndentEnum messageIndent, MessageTypeEnum messageType) { Message = message; MessageIndent = messageIndent; MessageType = messageType; }
void SetMessageStatus(MessageTypeEnum e, StatusEnum s) { switch (e) { case MessageTypeEnum.EditPayPassWord: messageStatus.EditPayPassWord = (int)s; break; case MessageTypeEnum.EditLoginPassWord: messageStatus.EditLoginPassWord = (int)s; break; case MessageTypeEnum.OrderCreated: messageStatus.OrderCreated = (int)s; break; case MessageTypeEnum.OrderPay: messageStatus.OrderPay = (int)s; break; case MessageTypeEnum.OrderShipping: messageStatus.OrderShipping = (int)s; break; case MessageTypeEnum.OrderRefundApply: messageStatus.OrderRefundApply = (int)s; break; case MessageTypeEnum.OrderRefundSuccess: messageStatus.OrderRefundSuccess = (int)s; break; case MessageTypeEnum.OrderRefundFail: messageStatus.OrderRefundFail = (int)s; break; //2.4删除 //case MessageTypeEnum.ShopSuccess: // messageStatus.ShopSuccess = (int)s; // break; case MessageTypeEnum.OrderReturnApply: messageStatus.OrderReturnApply = (int)s; break; case MessageTypeEnum.OrderReturnSuccess: messageStatus.OrderReturnSuccess = (int)s; break; case MessageTypeEnum.OrderReturnFail: messageStatus.OrderReturnFail = (int)s; break; case MessageTypeEnum.FightGroupOpenSuccess: messageStatus.FightGroupOpenSuccess = (int)s; break; case MessageTypeEnum.FightGroupJoinSuccess: messageStatus.FightGroupJoinSuccess = (int)s; break; case MessageTypeEnum.FightGroupFailed: messageStatus.FightGroupFailed = (int)s; break; case MessageTypeEnum.FightGroupSuccess: messageStatus.FightGroupSuccess = (int)s; break; case MessageTypeEnum.SelfTakeOrderPay: messageStatus.SelfTakeOrderPay = (int)s; break; case MessageTypeEnum.AlreadyVerification: messageStatus.AlreadyVerification = (int)s; break; case MessageTypeEnum.VirtualOrderPay: messageStatus.VirtualOrderPay = (int)s; break; case MessageTypeEnum.VirtualAlreadyVerification: messageStatus.VirtualAlreadyVerification = (int)s; break; case MessageTypeEnum.DistributorApply: messageStatus.DistributorApply = (int)s; break; case MessageTypeEnum.DistributorAuditSuccess: messageStatus.DistributorAuditSuccess = (int)s; break; case MessageTypeEnum.DistributorAuditFail: messageStatus.DistributorAuditFail = (int)s; break; case MessageTypeEnum.DistributorNewJoin: messageStatus.DistributorNewJoin = (int)s; break; case MessageTypeEnum.DistributorCommissionSettled: messageStatus.DistributorCommissionSettled = (int)s; break; case MessageTypeEnum.MemberWithDrawApply: messageStatus.MemberWithDrawApply = (int)s; break; case MessageTypeEnum.MemberWithDrawSuccess: messageStatus.MemberWithDrawSuccess = (int)s; break; case MessageTypeEnum.MemberWithDrawFail: messageStatus.MemberWithDrawFail = (int)s; break; case MessageTypeEnum.ShopOrderShipping: messageStatus.ShopOrderShipping = (int)s; break; case MessageTypeEnum.ShopDelivering: messageStatus.ShopDelivering = (int)s; break; } }
public MessageEventArgs(string Message, MessageTypeEnum Type) { this.Message = Message; this.Type = MessageTypeEnum.Status; }
public string FormatMessage(string msg, MessageTypeEnum type) { string prefix = "[^bAdKats^n] "; if (type.Equals(MessageTypeEnum.Warning)) { prefix += "^1^bWARNING^0^n: "; } else if (type.Equals(MessageTypeEnum.Error)) { prefix += "^1^bERROR^0^n: "; } else if (type.Equals(MessageTypeEnum.Success)) { prefix += "^b^2SUCCESS^n^0: "; } else if (type.Equals(MessageTypeEnum.Exception)) { prefix += "^1^bEXCEPTION^0^n: "; } return prefix + msg; }
/// <summary> /// Initializes a new instance of the <see cref="LogMessage"/> class. /// </summary> /// <param name="m">The m.</param> /// <param name="t">The t.</param> public LogMessage(String m, MessageTypeEnum t) { this.message = m; this.type = t; }