/// <summary>
/// 发送订单邮件
/// </summary>
/// <param name="CustomerId"></param>
/// <param name="OrederId"></param>
/// <param name="MessageType"></param>
public static void SendOrderEmail(int CustomerId, string OrederId, MessageTypeEnum MessageType)
{
string message = "";
switch (MessageType)
{
case MessageTypeEnum.Cancel:
message = string.Format("您好，ID为：【{0}】的客户申请【取消订单】，订单号为：【{0}】，请及时处理！", CustomerId, OrederId);
break;
case MessageTypeEnum.ApplyRefund:
message = string.Format("您好，ID为：【{0}】的客户申请【申请退款】，订单号为：【{0}】，请及时处理！", CustomerId, OrederId);
break;
case MessageTypeEnum.ApplyReturns:
message = string.Format("您好，ID为：【{0}】的客户申请【申请退货】，订单号为：【{0}】，请及时处理！", CustomerId, OrederId);
break;
case MessageTypeEnum.ApplyExchange:
message = string.Format("您好，ID为：【{0}】的客户申请【申请换货】，订单号为：【{0}】，请及时处理！", CustomerId, OrederId);
break;
}
//发送信息给系统管理员
MailHelper.Send(_EmailConfig, AdminEmail, MessageType.ToString(), message);
//发送信息给Youngo管理员
MailHelper.Send(_EmailConfig, YoungoEmail, MessageType.ToString(), 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();
}
/// <summary>
/// Adding the log registers the given message.
/// </summary>
/// <param name="message"> The message text </param>
/// <param name="type"> The message type - information, warning etc. </param>
public void Log(string message, MessageTypeEnum type)
{
string msg = type.ToString() + "|" + message;
fullLog.Add(msg);
MessageRecieved?.Invoke(this, new MessageRecievedEventArgs(type, message));
}
/*
* The function loggs recieved massage
*/
public void Log(string message, MessageTypeEnum type)
{
LogObject newLog = new LogObject(type.ToString(), message);
Logs.Add(newLog);
MessageRecieved?.Invoke(this, new MessageRecievedEventArgs(type, message));
}
/// <summary>
/// Function happens when event MessageRecieved invokes.
/// </summary>
/// <param name="sender">the object that invoked the event </param>
/// <param name="args">argumnets </param>
public void onMessage(object sender, MessageRecievedEventArgs args)
{
MessageTypeEnum status = args.Status;
string message = args.Message;
switch (status)
{
case (MessageTypeEnum.INFO):
eventLog1.WriteEntry(message, EventLogEntryType.Information);
break;
case (MessageTypeEnum.FAIL):
eventLog1.WriteEntry(message, EventLogEntryType.FailureAudit);
break;
case (MessageTypeEnum.WARNING):
eventLog1.WriteEntry(message, EventLogEntryType.Warning);
break;
}
string[] argv = { status.ToString(), message };
bool result;
string messagee = this.controller.ExecuteCommand((int)CommandEnum.CommandEnum.LogCommand, argv, out result);
//write log to all clients.
// this.server.writeAll(messagee);
}
public override void HandleIncomingMessageModel(MessageTypeEnum msgType, dynamic messageModel)
{
Callback.AppendLog("Incoming message: " + msgType.ToString());
switch (msgType)
{
case MessageTypeEnum.StatusRequest:
SendStatus();
break;
case MessageTypeEnum.MonitorStart:
MonitorStart();
break;
case MessageTypeEnum.MonitorStop:
MonitorStop();
break;
case MessageTypeEnum.VarListRequest:
SendVarTypes();
break;
case MessageTypeEnum.BTInput:
Callback.AppendLog("Button" + messageModel.Key + ": " + messageModel.Value);
break;
}
}
/// <summary>
/// Logs the specified message.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="type">The type.</param>
public void Log(string message, MessageTypeEnum type)
{
MessageReceivedEventArgs msg = new MessageReceivedEventArgs(message, type);
MessageReceived.Invoke(this, msg);
this.logs.Add(msg);
string[] args = { message, type.ToString() };
//NewLogEntry?.Invoke(this, new CommandReceivedEventArgs((int) CommandEnum.LogCommand, args, null));
}
public static string GetDescription(MessageTypeEnum e)
{
FieldInfo type = e.GetType().GetField(e.ToString());
var attrs = type.GetCustomAttributes(typeof(DescriptionAttribute), true);
string message = ((DescriptionAttribute)attrs[0]).Description;
return(message);
}
/// <summary>
/// Invoke the eventHandler with all it's delegates (in this case- mostly write into logger)
/// </summary>
/// <param name="message"> specific message for the logger </param>
/// <param name="type"> type of the message </param>
///
public void Log(string message, MessageTypeEnum type)
{
String[] args = new string[2];
args[0] = message;
args[1] = type.ToString();
MessageRecieved?.Invoke(this, new MessageRecievedEventArgs(type, message));
LogNotificator?.Invoke(new CommandRecievedEventArgs((int)CommandEnum.NewLogMessage, args, ""));
_logs.Insert(0, (new LogTuple {
EnumType = Enum.GetName(typeof(MessageTypeEnum), type), Data = message
}));
}
public void Log(string message, MessageTypeEnum type)
{
MessageRecievedEventArgs args = new MessageRecievedEventArgs();
this.listOfLogs.Add(message + ";" + type.ToString());
args.Message = message;
args.Status = type;
string[] arr = { args.ToJSON() };
MessageRecieved?.Invoke(this, args);
LogAdded?.Invoke(this, new MsgCommand((int)CommandEnum.AddLogCommand, arr));
}
/// <summary>
/// Logs the specified message.
/// </summary>
/// <param name="msg">The message.</param>
/// <param name="msg_type">The type.</param>
public void Log(string msg, MessageTypeEnum msg_type)
{
//creating the new message
MessageReceivedEventArgs new_msg = new MessageReceivedEventArgs(msg, msg_type);
MessageReceived.Invoke(this, new_msg);
//adding a new message
this.logs.Add(new_msg);
string[] args = { msg, msg_type.ToString() };
//invoking log
NewLogEntry?.Invoke(this, new CommandReceivedEventArgs((int)CommandEnum.LogCommand, args, null));
}
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>
/// Returns a <see cref="System.String"/> that represents this instance.
/// </summary>
/// <returns>
/// A <see cref="System.String"/> that represents this instance.
/// </returns>
public override string ToString()
{
StringBuilder sb = new StringBuilder(base.ToString());
sb.Append(", TargetId: [");
sb.Append(mTargetId);
sb.Append("], Priority: [");
sb.Append(mPriority.ToString());
sb.Append("], MessageType: [");
sb.Append(mMessageType.ToString());
sb.Append("]");
return(sb.ToString());
}
public void Log(string message, MessageTypeEnum type)
{
MessageRecievedEventArgs msg = new MessageRecievedEventArgs();
msg.Message = message;
msg.Status = type;
MessageRecieved?.Invoke(this, msg);
string[] args = new string[2];
args[0] = type.ToString();
args[1] = message;
InfoEventArgs info = new InfoEventArgs((int)InfoEnums.LogInfo, args);
NotifyClients?.Invoke(this, info);
}
/// <summary>
/// Logs the specified message, and invokes the events of it's writing.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="type">The type.</param>
public void Log(string message, MessageTypeEnum type)
{
// The server will create a new LogEntry object when it sends info to the client
// No, sorry, you get it form the EventLog... not from here. I got confused.
MessageReceivedEventArgs mrea = new MessageReceivedEventArgs();
mrea.Message = message;
mrea.Status = type;
this._entries.Add(new LogEntry()
{
Message = message,
Type = type.ToString(),
Time = DateTime.Now
});
MessageReceived?.Invoke(this, mrea);
}
/// <summary>
/// Logging the Message
/// </summary>
/// <param name="message">The message to write in the log</param>
/// <param name="type"> type of message </param>
public void Log(string message, MessageTypeEnum type)
{
this.logs.Add(type.ToString());
this.logs.Add(message);
MessageRecieved.Invoke(this, new MessageRecievedEventArgs(message, type));
}
int ILogPlugin.Logger(string pMessage, MessageTypeEnum pTypeMessage)
{
try
{
string[] lines = new string[1];
lines[0] = $"\n[Hora: {DateTime.Now.ToString()}] - Mensage: {pMessage} | Tipo: {pTypeMessage.ToString()}\n";
File.AppendAllLines(_FullFilePath, lines);
return(1);
}
catch (Exception)
{
return(0);
}
}
public override void HandleIncomingMessageModel(MessageTypeEnum msgType, dynamic messageModel)
{
switch (msgType)
{
case MessageTypeEnum.StatusOk:
Callback.AppendLog("Controller status: " + msgType.ToString());
Callback.SetStatus(msgType.ToString());
break;
case MessageTypeEnum.StatusError:
Callback.AppendLog("Controller ERROR status: " + ((ErrorStatusModel)messageModel).Text);
Callback.SetStatus(msgType.ToString());
break;
case MessageTypeEnum.VarList:
VarTypeListModel M = (VarTypeListModel)messageModel;
System.Windows.Application.Current.Dispatcher.Invoke(new Action(() => {
// clear lists and tables
VarTypeList.VarTypes.Clear();
Callback.ClearColumns();
VarData.Rows.Clear();
foreach (VarTypeModel Model in messageModel.VarTypes)
{
// update var type list
VarTypeList.VarTypes.Add(Model);
// update vars table
Callback.AddColumn(Model.Name);
}
}));
Callback.AppendLog("Variable list received.");
// log colnames
string s = "";
foreach (VarTypeModel Model in messageModel.VarTypes)
{
s += Model.Name + " (" + Model.VarType + ");";
}
log.Info(s);
break;
case MessageTypeEnum.VarValues:
try
{
// decode bytes here:
Callback.AddRow(ModelDecoder.GetVarValuesFromBytes(VarTypeList, messageModel));
}
catch (Exception ex)
{
Callback.AppendLog(ex.Message);
}
break;
case MessageTypeEnum.StatusRequest:
SendStatus();
break;
default:
Callback.AppendLog("Incoming unknown message: " + msgType.ToString());
break;
}
}
int ILogPlugin.Logger(string pMessage, MessageTypeEnum pTypeMessage)
{
try
{
string texto = $"\n[Hora: {DateTime.Now.ToString()}] - Mensage: {pMessage} | Tipo: {pTypeMessage.ToString()}";
Console.WriteLine(texto);
return(1);
}
catch (Exception)
{
return(0);
}
}
public MessageType(MessageTypeEnum type)
{
Id = (int)type;
Name = type.ToString();
}
