/// <summary>
/// Register event handler
/// </summary>
/// <typeparam name="Event">Target event</typeparam>
/// <param name="eventType">Dispatcher</param>
/// <param name="handler">handler</param>
/// <returns></returns>
public bool RegisterEventHandler <Event>(Type eventType, EventHandlerFunc <Event> handler) where Event : IBaseEvent
{
Type typo = typeof(Event);
Dispatcher dispatcher = null;
if (ExistDispatcher(eventType))
{
dispatcher = GetDispatcher(eventType);
}
else
{
throw new Exception("Dispatcher not register!");
}
if (!dispatcher.ContainsKey(typo))
{
dispatcher.Add(typo, new HandlerList());
}
if (dispatcher[typo].Contains(handler))
{
return(false);
}
dispatcher[typo].AddLast(handler);
return(true);
}
/// <summary>
/// Remove event handle
/// </summary>
/// <typeparam name="EventType">Event dispathcer</typeparam>
/// <typeparam name="Event">Target Event</typeparam>
/// <param name="handler">Handler</param>
public void RemoveEventHandler <EventType, Event>(EventHandlerFunc <Event> handler) where Event : IBaseEvent
{
if (dispatchers.TryGetValue(typeof(EventType), out Dispatcher dispatcher))
{
var list = dispatcher[typeof(Event)];
list.Remove(handler);
}
}
/// <summary>
/// 从类型监听列表中移除
/// </summary>
public void UnRegisterEvent(Type eventType, EventHandlerFunc callback)
{
mTypeEventHandlers[eventType] -= callback;
if (mTypeEventHandlers[eventType] == null)
{
mTypeEventHandlers.Remove(eventType);
}
}
/// <summary>
/// 从事件监听列表中移除
/// </summary>
public void UnRegisterEvent(Type eventType, int eventID, EventHandlerFunc callback)
{
Event e = new Event(eventType, eventID);
mIDEventHandlers[e] -= callback;
if (mIDEventHandlers[e] == null)
{
mIDEventHandlers.Remove(e);
}
}
/// <summary>
/// 监听一类事件
/// </summary>
public void RegisterEvent(Type eventType, EventHandlerFunc callback)
{
if (mTypeEventHandlers.ContainsKey(eventType))
{
mTypeEventHandlers[eventType] += callback;
}
else
{
mTypeEventHandlers.Add(eventType, callback);
}
}
/// <summary>
/// 监听一类事件中的某个 id
/// </summary>
public void RegisterEvent(Type eventType, int eventID, EventHandlerFunc callback, bool checkStickEvent = false)
{
Event e = new Event(eventType, eventID);
if (mIDEventHandlers.ContainsKey(e))
{
mIDEventHandlers[e] += callback;
}
else
{
mIDEventHandlers.Add(e, callback);
}
}
private static async Task OnResizeImage(MessageContext <ResizeImageEvent> messageContext, EventHandlerFunc <ResizeImageEvent> next)
{
var userInfo = GetUserLogInfo(messageContext);
Log.Info($"{userInfo} - Image resize: {messageContext.Message.File}");
await next(messageContext);
}
private static async Task OnRenameFolder(MessageContext <RenameFolderEvent> messageContext, EventHandlerFunc <RenameFolderEvent> next)
{
var userInfo = GetUserLogInfo(messageContext);
Log.Info($"{userInfo} - Folder rename: {messageContext.Message.SourceFolder} -> {messageContext.Message.DestinationFolder}");
await next(messageContext);
}
private static async Task OnFileUpload(MessageContext <FileUploadEvent> messageContext, EventHandlerFunc <FileUploadEvent> next)
{
var userInfo = GetUserLogInfo(messageContext);
Log.Info($"{userInfo} - File upload: {messageContext.Message.File}");
await next(messageContext);
}
private static async Task OnDownloadFile(MessageContext <DownloadFileEvent> messageContext, EventHandlerFunc <DownloadFileEvent> next)
{
var userInfo = GetUserLogInfo(messageContext);
Log.Info($"{userInfo} - File download: {messageContext.Message.File}");
await next(messageContext);
}
private async Task OnFileUpload(MessageContext <FileUploadEvent> messageContext, EventHandlerFunc <FileUploadEvent> next)
{
var stream = messageContext.Message.Stream;
var imageSettings = messageContext.ComponentResolver.Resolve <IImageSettings>();
var originalPosition = stream.Position;
using (var imageFactory = new ImageFactory())
{
try
{
imageFactory.Load(stream);
stream.Position = originalPosition;
}
catch (ImageFormatException)
{
// This is not an image or the format is not supported.
await next(messageContext);
return;
}
imageFactory.Overlay(new ImageLayer
{
Image = _watermarkImage, Opacity = 50, Size = imageFactory.Image.Size
});
var format = ImageFormats.GetFormatForFile(messageContext.Message.File);
format.Quality = imageSettings.Quality;
imageFactory.Format(format);
imageFactory.Save(stream);
}
await next(messageContext);
}
/// <summary>
/// 从多个事件监听列表中移除
/// </summary>
public void UnRegisterEvent(Type eventType, int[] eventIDs, EventHandlerFunc callback)
{
eventIDs.ValueForeach(eventID => UnRegisterEvent(eventType, eventID, callback));
}
/// <summary>
/// regist class for event bind
/// </summary>
/// <typeparam name="Event"></typeparam>
/// <param name="handler"></param>
public void BindEvent <Event>(EventHandlerFunc <Event> handler) where Event : T
{
EventDispatcher.Instance.RegisterEventHandler(GetType(), handler);
}
/// <summary>
/// Register event handle
/// </summary>
/// <typeparam name="EventType">Event dispathcer</typeparam>
/// <typeparam name="Event">Target Event</typeparam>
/// <param name="handler">Handler</param>
/// <returns></returns>
public bool RegisterEventHandler <EventType, Event>(EventHandlerFunc <Event> handler) where Event : IBaseEvent
{
return(RegisterEventHandler(typeof(EventType), handler));
}
private static async Task OnCopyFile(MessageContext <CopyFileEvent> messageContext, EventHandlerFunc <CopyFileEvent> next)
{
var userInfo = GetUserLogInfo(messageContext);
Log.Info($"{userInfo} - File copy: {messageContext.Message.SourceFile} -> {messageContext.Message.DestinationFile}");
await next(messageContext);
}
private static async Task OnDeleteFolder(MessageContext <DeleteFolderEvent> messageContext, EventHandlerFunc <DeleteFolderEvent> next)
{
var userInfo = GetUserLogInfo(messageContext);
Log.Info($"{userInfo} - Folder delete: {messageContext.Message.Folder}");
await next(messageContext);
}
/// <summary>
/// 监听一类事件中的一些 id
/// </summary>
public void RegisterEvent(Type eventType, int[] eventIDs, EventHandlerFunc callback, bool checkStickEvent = false)
{
eventIDs.ValueForeach(eventID => RegisterEvent(eventType, eventID, callback, checkStickEvent));
}
private async Task OnFileUpload(MessageContext <FileUploadEvent> messageContext, EventHandlerFunc <FileUploadEvent> next)
{
var stream = messageContext.Message.Stream;
var imageSettings = messageContext.ComponentResolver.Resolve <IImageSettings>();
using (var imageFactory = new ImageFactory())
{
try
{
imageFactory.Load(stream);
stream.Dispose();
stream = new MemoryStream();
messageContext.Message.Stream = stream;
}
catch (ImageFormatException)
{
// This is not an image or the format is not supported.
await next(messageContext);
return;
}
var rectangle = CalculateRectangle(imageFactory.Image, _watermarkImage, _position);
new PngFormat().ApplyProcessor(new Blit
{
DynamicParameter = new ImageLayer
{
Image = _watermarkImage,
Opacity = _opacity,
Size = rectangle.Size,
Position = rectangle.Location
}
}.ProcessImage, imageFactory);
var format = ImageFormats.GetFormatForFile(messageContext.Message.File);
format.Quality = imageSettings.Quality;
imageFactory.Format(format);
imageFactory.Save(stream);
stream.Position = 0;
}
await next(messageContext);
}
private async Task OnBeforeCommand(MessageContext <BeforeCommandEvent> messageContext, EventHandlerFunc <BeforeCommandEvent> next)
{
if (messageContext.Message.CommandInstance is FileUploadCommand ||
messageContext.Message.CommandInstance is CopyFilesCommand ||
messageContext.Message.CommandInstance is ImageResizeCommand ||
messageContext.Message.CommandInstance is CreateFolderCommand)
{
var commandRequest = messageContext.ComponentResolver.Resolve <ICommandRequest>();
if (!IsQuotaAvailable(commandRequest))
{
throw new CustomErrorException("Storage quota exceeded");
}
}
await next(messageContext);
}
