private async Task PlaybackEvent(HookEvent evt, BaseItem item, SessionInfo session, User user)
{
if (user == null)
{
return;
}
if (item == null)
{
return;
}
await ExecuteWebhook(new EventInfo
{
Event = evt,
Item = item,
User = user,
Session = session == null ? null : new SessionInfoDto(session),
Server = new ServerInfoDto
{
Id = _appHost.SystemId,
Name = _appHost.FriendlyName,
Version = _appHost.ApplicationVersion.ToString(),
},
});
}
private async Task InitAsync()
{
try
{
Log.Debug("Init ModelConnector {Type} -- {Name}", typeof(TDrived), Name);
if (Model.IsNothing())
{
return;
}
OnLoad();
//Log.Information("Ask For {Property}", _name);
await DoAsync(from model in Model
select Func(async() =>
{
var eventActor = await Ask <IEventActor>(model.Actor, new MakeEventHook(Name), TimeSpan.FromSeconds(15));
//Log.Information("Ask Compled For {Property}", _name);
eventActor.Register(HookEvent.Create <PropertyChangedEvent>(PropertyChangedHandler));
eventActor.Register(HookEvent.Create <ValidatingEvent>(ValidateCompled));
Tell(model.Actor, new TrackPropertyEvent(Name), eventActor.OriginalRef);
Interlocked.Exchange(ref _eventActor, eventActor);
Interlocked.Exchange(ref _isInitializing, 0);
}));
}
catch (Exception e)
{
Log.Error(e, "Error Bind Property {Name}", Name);
}
}
private string GetEventName(HookEvent evt)
{
switch (evt)
{
case HookEvent.Pause:
return("media.pause");
case HookEvent.Resume:
return("media.resume");
case HookEvent.Stop:
return("media.stop");
case HookEvent.Scrobble:
return("media.scrobble");
case HookEvent.Rate:
return("media.rate");
case HookEvent.MarkPlayed:
return("media.scrobble");
default:
return("media.play");
}
}
public void Request(string name, Action <Option <object> > valueResponse, CultureInfo?info = null)
{
var hook = EventActor.Create(_system, null, true);
hook.Register(HookEvent.Create <LocCoordinator.ResponseLocValue>(res => valueResponse(res.Result)));
hook.Send(_extension.LocCoordinator,
new LocCoordinator.RequestLocValue(name, info ?? CultureInfo.CurrentUICulture));
}
private JObject ReadData(HookEvent @event)
{
using (var streamReader = new StreamReader(@event.Body))
using (var jsonReader = new JsonTextReader(streamReader))
{
return((JObject)JToken.ReadFrom(jsonReader));
}
}
public async Task HandleEventAsync(HookEvent eventData)
{
var eventTypes = CaptainHookPublisherManager.EventTypes;
var key = CalculateKey(eventData.ReceiverName, eventData.Id, eventData.EventType);
if (!eventTypes.ContainsKey(key))
{
return;
}
var handlerType = eventTypes[key];
if (ReflectionHelper.IsAssignableToGenericType(handlerType, typeof(IEventPublisher <>)))
{
var genericImplementations = ReflectionHelper.GetImplementedGenericTypes(handlerType, typeof(IEventPublisher <>));
if (genericImplementations.Count != 1)
{
return;
}
var implementedPayloadTypes = genericImplementations[0].GetGenericArguments();
if (implementedPayloadTypes.Length != 1)
{
return;
}
var payloadType = implementedPayloadTypes[0];
var payload = eventData.Payload;
if (!payloadType.IsAssignableFrom(eventData.Payload.GetType()))
{
var json = (JsonElement)eventData.Payload;
payload = ToObject(json, payloadType);
}
var parameterType = typeof(HookEventToPublish <>).MakeGenericType(payloadType);
var eventWrapper = Activator.CreateInstance(parameterType, new[] { eventData, payload });
using (var scope = ServiceScopeFactory.CreateScope())
{
var contextProvider = scope.ServiceProvider.GetRequiredService <IHookEventContextProvider>();
contextProvider.SetContext(eventData);
var receiver = scope.ServiceProvider.GetRequiredService(handlerType);
var method = typeof(IEventPublisher <>)
.MakeGenericType(payloadType)
.GetMethod(
nameof(IEventPublisher <object> .HandleEventAsync),
new[] { parameterType }
);
await(Task) method.Invoke(receiver, new[] { eventWrapper });
}
}
else
{
throw new AbpException("The object instance is not an event handler. Object type: " + handlerType.AssemblyQualifiedName);
}
}
public void Request(string name, Action <object?> valueResponse, Maybe <CultureInfo> info = default)
{
var hook = EventActor.Create(_system, Maybe <string> .Nothing, true);
hook.Do(h =>
{
h.Register(HookEvent.Create <LocCoordinator.ResponseLocValue>(res => valueResponse(res.Result)));
h.Send(_extension.LocCoordinator, new LocCoordinator.RequestLocValue(name, info.Or(CultureInfo.CurrentUICulture)));
});
}
public void RunHooks(HookMode hookMode, HookType hookType, HookEvent hookEvent)
{
if (Program.Options.CommonTestSpacerBuildPackCompile.NoHooks == false)
{
Hooks.Where(hook => hook.Mode == hookMode)
.Where(hook => hook.Event == hookEvent)
.Where(hook => hook.Type == hookType).ToList()
.ForEach(hook => hook.Run());
}
}
protected override void runHooks(HookType hookType, HookEvent hookEvent)
{
Program.HooksManager.RunHooks(HookMode.Common, hookType, hookEvent);
Program.HooksManager.RunHooks(HookMode.Test, hookType, hookEvent);
if (Mode == TestMode.Full)
{
Program.HooksManager.RunHooks(HookMode.FullTest, hookType, hookEvent);
}
else if (Mode == TestMode.Quick)
{
Program.HooksManager.RunHooks(HookMode.QuickTest, hookType, hookEvent);
}
}
public async Task Handle(HookEvent @event, ITriggerAction action)
{
var gitlabEvent = @event.Headers["X-Gitlab-Event"].FirstOrDefault();
if (string.IsNullOrWhiteSpace(gitlabEvent))
{
Console.WriteLine($"[GitLab] Unhandled hook {gitlabEvent}");
return;
}
if (gitlabEvent == "Merge Request Hook")
{
await HandleMergeRequest(ReadData(@event), action);
}
}
private async Task PlaybackEvent(HookEvent evt, BaseItem item, SessionInfo session, List <User> users)
{
if (users.Count <= 0)
{
return;
}
if (item == null)
{
return;
}
foreach (var user in users)
{
await PlaybackEvent(evt, item, session, user);
}
}
public HooksReceiverModule(IIndex <string, IHookHandler> hookHandler, Func <ITriggerAction> action)
{
Post("/hooks/{type}", async _ =>
{
if (!hookHandler.TryGetValue((string)_.type, out var handler))
{
return(Response
.AsJson(new { ok = false, msg = $"Unknown hook type {(string) _.type}" })
.WithStatusCode(HttpStatusCode.BadRequest));
}
var headers = Request.Headers.ToDictionary(x => x.Key, x => x.Value);
var @event = new HookEvent(headers, Request.Body);
await handler.Handle(@event, action());
return(Response.AsJson(new { ok = true }));
});
}
public Task <HookInfo> GenerateHook(string address, HookEvent hook, string url)
{
try
{
string evt = "";
switch (hook)
{
case HookEvent.ConfirmedTransaction:
evt = "confirmed-tx";
break;
case HookEvent.DoubleSpendTransaction:
evt = "double-spend-tx";
break;
case HookEvent.NewBlock:
evt = "new-block";
break;
case HookEvent.TransactionConfirmation:
evt = "tx-confirmation";
break;
case HookEvent.UnconfirmedTransaction:
evt = "unconfirmed-tx";
break;
}
return(PostAsync <HookInfo>("hooks", new
{
@event = evt,
url,
address
}));
}
catch (Exception ex)
{
throw new Exception();
}
}
public Task <HookInfo> GenerateHook(string address, HookEvent hook, string url)
{
try {
string evt = "";
switch (hook)
{
case HookEvent.ConfirmedTransaction:
evt = "confirmed-tx";
break;
case HookEvent.DoubleSpendTransaction:
evt = "double-spend-tx";
break;
case HookEvent.NewBlock:
evt = "new-block";
break;
case HookEvent.TransactionConfirmation:
evt = "tx-confirmation";
break;
case HookEvent.UnconfirmedTransaction:
evt = "unconfirmed-tx";
break;
}
return(PostAsync <HookInfo>("hooks", new {
@event = evt,
url,
address
}));
} catch {
return(Task.Factory.StartNew(() => new HookInfo {
Error = "Hook already exists"
}));
}
}
public GlobalHook(HookEvent subcriptions) : this()
{
SubscribedEvents.Add(subcriptions);
}
protected override void runHooks(HookType hookType, HookEvent hookEvent)
{
Program.HooksManager.RunHooks(HookMode.Common, hookType, hookEvent);
Program.HooksManager.RunHooks(HookMode.Build, hookType, hookEvent);
}
public void UnSubscribe(HookEvent eventType)
{
SubscribedEvents.RemoveAll(e => e == eventType);
}
public void Subscribe(HookEvent eventType)
{
SubscribedEvents.Add(eventType);
}
static void HookCallback(ref MouseState state)
{
HookEvent?.Invoke(ref state);
}
private static void OnNewHook(object sender, HookEvent e)
{
Console.WriteLine("Hook received {0}", e.Hook.Rating);
}
protected abstract void runHooks(HookType hookType, HookEvent hookEvent);
