public Task Create(ActivityStreamCreateContext context)
{
//pass into context.EventData whatever you want for Blog ContentType
//eg
context.EventData["MyCustomBlogData"] = "eeee";
throw new System.NotImplementedException();
}
// public async Task<dynamic> BuildFilterDisplayAsync(Filters filters) {
// var filterDisplay = await (dynamic)_shapeFactory.CreateAsync( "AuditTrailFilter");
// var filterDisplayContext = new DisplayFilterContext(_shapeFactory, filters, filterDisplay);
//
// var _auditTrailEventHandlers= _serviceProvider.GetRequiredService<IAuditTrailEventHandler>();
//
// // Invoke event handlers.
// await _auditTrailEventHandlers.DisplayFilterAsync(filterDisplayContext);
//
// // Give each provider a chance to provide a filter display.
// var providersContext = DescribeProviders();
//
// foreach (var action in providersContext.FilterDisplays) {
// action(filterDisplayContext);
// }
//
// return filterDisplay;
// }
/// <summary>
/// Records an audit trail event.
/// </summary>
/// <typeparam name="T">The audit trail event provider type to determine the scope of the event name.</typeparam>
/// <param name="eventName">The shorthand name of the event</param>
/// <param name="user">The user to associate with the event. This is typically the currently loggedin user.</param>
/// <param name="properties">A property bag of custom event data that could be useful for <see cref="IAuditTrailEventHandler"/> implementations. These values aren't stored. Use the eventData parameter to persist additional data with the event.</param>
/// <param name="eventData">A property bag of custom event data that will be stored with the event record.</param>
/// <param name="eventFilterKey">The name of a custom key to use when filtering events.</param>
/// <param name="eventFilterData">The value of a custom filter key to filter on.</param>
/// <returns>The created audit trail event record if the specified event was not disabled.</returns>
public async Task <ActivityStreamEventResult> CreateRecord <T>(string eventName, string user, IDictionary <string, object> properties = null, IDictionary <string, object> eventData = null, string eventFilterKey = null, string eventFilterData = null) where T : IActivityStreamEventProvider
{
var eventDescriptor = DescribeEvent <T>(eventName);
// if (!await(IsEventEnabled(eventDescriptor)))
if (!(IsEventEnabled(eventDescriptor)))
{
return new ActivityStreamEventResult {
Record = null,
IsDisabled = true
}
}
;
if (properties == null)
{
properties = new Dictionary <string, object>();
}
if (eventData == null)
{
eventData = new Dictionary <string, object>();
}
var context = new ActivityStreamCreateContext {
Event = eventName,
User = user,
Properties = properties,
EventData = eventData
// EventFilterKey = eventFilterKey,
// EventFilterData = eventFilterData
};
// var _auditTrailEventHandlers= _serviceProvider.GetRequiredService<IActivityStreamEventHandler>();
var activityStreamProvider = _serviceProvider.GetRequiredService <IActivityStreamEventProvider>();
// await _auditTrailEventHandlers.Create(context);
await activityStreamProvider.ExecuteAsync(context);
string loggedinuser = _httpContextAccessor.HttpContext?.User.Identity.Name;
var record = new ActivityStreamItem {
Category = eventDescriptor.CategoryDescriptor.Category,
EventName = eventName,
FullEventName = eventDescriptor.Event,
CreatedUtc = _clock.UtcNow,
User = !string.IsNullOrEmpty(loggedinuser) ? loggedinuser : null,
ActivityStreamData = JsonConvert.SerializeObject(context.EventData)// _serializer.Serialize(context.EventData),
// EventFilterKey = context.EventFilterKey,
// EventFilterData = context.EventFilterData,
// Comment = context.Comment,
// ClientIpAddress = GetClientAddress().GetAwaiter().GetResult()
};
// _auditTrailRepository.Create(record);
// await _auditTrailRepository.SaveAsync(record);
await _activityStreamRepository.InsertAsync(record);
return(new ActivityStreamEventResult {
Record = record,
IsDisabled = false
});
}
public bool CanExecute(ActivityStreamCreateContext context)
{
if ((string)context.EventData["ContentType"] == "Ticket")
{
return(true);
}
return(true);
}
public async Task ExecuteAsync(ActivityStreamCreateContext context)
{
//pass control to other classes to handle stream data specific per content type
var activityStreamEventHandlers = _serviceProvider.GetRequiredService <IEnumerable <IActivityStreamEventHandler> >();
foreach (var activityStreamEventHandler in activityStreamEventHandlers)
{
if (await activityStreamEventHandler.CanExecuteAsync(context))
{
await activityStreamEventHandler.Create(context);
}
}
}
public Task <bool> CanExecuteAsync(ActivityStreamCreateContext context)
{
return(Task.FromResult(CanExecute(context)));
}
