internal MessageEvent(MessageEventType type, long messageId, long uncompressedMessageSize, long compressedMessageSize)
{
this.Type = type;
this.MessageId = messageId;
this.UncompressedMessageSize = uncompressedMessageSize;
this.CompressedMessageSize = compressedMessageSize;
}
internal MessageEvent(MessageEventType type, long messageId, long uncompressedMessageSize, long compressedMessageSize)
{
Type = type;
MessageId = messageId;
UncompressedMessageSize = uncompressedMessageSize;
CompressedMessageSize = compressedMessageSize;
}
public ActionEntry(MessageEventType type, MethodInfo action, Type unit, object state)
{
Type = type;
Action = action;
Unit = unit;
State = state;
}
private void EnqueueEventAnswer(
string eventId,
long userId,
long peerId,
bool haveEventData = false,
string text = null,
MessageEventType messageEventType = null)
{
VkParameters vkParameters = new VkParameters
{
{ "event_id", eventId },
{ "user_id", userId },
{ "peer_id", peerId }
};
if (haveEventData)
{
vkParameters.Add("event_data",
JsonConvert.SerializeObject(new EventData()
{
Text = text,
Type = messageEventType
})
);
}
commandsQueue.Enqueue(new Command(CommandType.SendMessageEventAnswer, vkParameters));
}
/// <summary>
/// Creates a new instance of <see cref="MessageEventArgs"/>
/// </summary>
/// <param name="title"></param>
/// <param name="description"></param>
/// <param name="eventType"></param>
/// <param name="cancel"></param>
public MessageEventArgs(string title, string description, MessageEventType eventType, bool cancel = false)
: base(cancel)
{
Title = title;
Description = description;
EventType = eventType;
}
/// <summary>
/// Constructor with all fields except primary key fields
/// </summary>
public MessageEvent(int id, int messageId, MessageEventType messageEventType, string reference, string notes, Guid createdByUserId, DateTime createdDatetime)
{
this.MessageId = messageId;
this.MessageEventType = messageEventType;
this.Reference = reference;
this.Notes = notes;
this.CreatedByUserId = createdByUserId;
this.CreatedDateTime = createdDatetime;
}
private static void Send(MessageEventType typ, string from, string message)
{
MessageInfo info = new MessageInfo(typ, from, message);
//trace is allways used for all levels and can be de-activated in config
Trace.TraceInformation(info.ToString());
//send message
EventDispatcher.Instance.RaiseMessage(info);
}
public static MessageEventBuilder Builder(MessageEventType type, long messageId)
{
return(new MessageEventBuilder()
.SetType(type)
.SetMessageId(messageId)
// We need to set a value for the message size because the autovalue requires all
// primitives to be initialized.
.SetUncompressedMessageSize(0)
.SetCompressedMessageSize(0));
}
private void WriteLog(string _log, MessageEventType _logType)
{
//If user has not defined the event. do not write log.
if (null != this.OnLogWrite)
{
MessageEventArgs EventMessage = new MessageEventArgs(_log);
EventMessage.Type = _logType;
this.OnLogWrite("nscLibrary.Utility.SMTPCommunicator", EventMessage);
}
}
internal MessageEventBuilder(
MessageEventType type,
long messageId,
long uncompressedMessageSize,
long compressedMessageSize)
{
this.type = type;
this.messageId = messageId;
this.uncompressedMessageSize = uncompressedMessageSize;
this.compressedMessageSize = compressedMessageSize;
}
public void Execute(int messageId, MessageEventType messageStatus, Guid createdByUserId)
{
// in parameters
var parameters = new List<SqlParameter>
{
DbHelper.CreateParameter(Parameters.MessageId, messageId),
DbHelper.CreateParameter(Parameters.MessageEventTypeCode, messageStatus.GetCode()),
DbHelper.CreateParameter(Parameters.CreatedByUserId, createdByUserId),
};
DbHelper.ExecuteNonQueryCommand(this, parameters);
}
/// <summary>
/// IValueConverter.Convert
/// </summary>
/// <param name="value"></param>
/// <param name="targetType"></param>
/// <param name="parameter"></param>
/// <param name="culture"></param>
/// <returns></returns>
public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
{
MessageEventType val = (MessageEventType)value;
if (val == MessageEventType.Error)
{
return(new BitmapImage(new Uri("pack://application:,,,/Resources/Images/16x16/error.png")));
}
else
{
return(null);
}
}
private string GetHelpText(MessageEventType type)
{
var entries = _service.GetEntries();
StringBuilder builder = new();
foreach (var ent in entries)
{
var desc = ent.Action.GetCustomAttribute <DescriptionAttribute>();
var extr = ent.Action.GetCustomAttribute <ExtractAttribute>();
if (desc == null || extr == null)
{
continue;
}
var rece = ent.Action.GetCustomAttribute <ReceiveAttribute>();
if (rece?.Type != type)
{
continue;
}
var receStr = rece?.Type switch
{
MessageEventType.Friend => "🧑🤝🧑",
MessageEventType.Group => "👪",
MessageEventType.Stranger => "👤",
_ => "👣"
};
builder.Append(receStr);
builder.Append(' ');
builder.AppendLine(extr.RawString);
builder.Append(" - ");
builder.AppendLine(desc.Description);
}
return(builder.ToString().Trim());
}
private void WriteLog(string _log, MessageEventType _logType)
{
//If user has not defined the event. do not write log.
if (null != this.OnLogWrite)
{
MessageEventArgs EventMessage = new MessageEventArgs(_log);
EventMessage.Type = _logType;
this.OnLogWrite("nscLibrary.Utility.SMTPCommunicator", EventMessage);
}
}
public void AddEventListener(MessageEventType type, EventListener <MessageEvent <EventSource, EventSource> > listener, bool useCapture = false)
{
}
public MessageEvent(MessageEventType type, dynamic message)
{
MessageType = type;
Message = message;
}
public ForwardChannel()
{
Rule = new RelationMatcher("*:*");
Destination = 10000;
DestinationType = MessageEventType.Friend;
}
public void AddEventListener(MessageEventType type, EventListener <MessageEvent <Worker, Worker> > listener, bool useCapture = false)
{
}
internal MessageEventBuilder SetType(MessageEventType type)
{
this.type = type;
return(this);
}
public MessageEventArgs(MessageEventType type, string message)
{
_Info.Type = type;
_Info.Details = message;
}
public void AddEventListener(MessageEventType type, EventListener <MessageEvent <MessagePort, MessagePort> > listener, bool useCapture = false)
{
}
public ReceiveAttribute(MessageEventType type)
{
Type = type;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="typ"></param>
/// <param name="where"></param>
/// <param name="details"></param>
public MessageInfo(MessageEventType typ, string where, string details)
{
_Type = typ;
_Where = where;
_Details = details;
}
public MessageEvent(MessageEventType type, string message, params object[] args)
: this(type, string.Format(message, args))
{
}
public void RemoveEventListener(MessageEventType type, EventListener <MessageEvent <WebSocket, WebSocket> > listener, bool useCapture = false)
{
}
public void RemoveEventListener(MessageEventType type, EventListener <MessageEvent <RTCDataChannel, RTCDataChannel> > listener, bool useCapture = false)
{
}
public MessageEventArgs(MessageEventType type, string message)
{
this.Type = type;
this.Message = message;
}
public MessageEventArgs(MessageEventType type)
{
_Info.Type = type;
}
public void RemoveEventListener(MessageEventType type, EventListener <MessageEvent <DedicatedWorkerContext, DedicatedWorkerContext> > listener, bool useCapture = false)
{
}
public MessageEvent(MessageEventType type, string message)
{
Message = message;
Type = type;
}
public ForwardChannel(RelationMatcher rule, long destination, MessageEventType type)
{
Rule = rule;
Destination = destination;
DestinationType = type;
}
protected Message(MessageEventType eventType, string?context = null)
{
Event = eventType;
Context = context;
}
public void RemoveEventListener(MessageEventType type, EventListener <MessageEvent <Window> > listener, bool useCapture = false)
{
}
