public Presenter(IEventProvider provider, IExceptionThrower thrower)
{
_provider = provider;
_thrower = thrower;
_provider.Event += Presenter_Go;
_provider.Event2 += Presenter_Go2;
}
/// <summary>
/// Creates a new EliteDangerousAPI class
/// </summary>
/// <param name="services">ServiceProvider</param>
public EliteDangerousAPI(IServiceProvider services)
{
try
{
Version = Assembly.GetExecutingAssembly().GetName().Version;
_log = services.GetRequiredService <ILogger <EliteDangerousAPI> >();
_config = services.GetRequiredService <IConfiguration>();
_eventProvider = services.GetRequiredService <IEventProvider>();
_eventProcessors = services.GetRequiredService <IEnumerable <IEventProcessor> >();
_journalDirectoryProvider = services.GetRequiredService <IJournalDirectoryProvider>();
_journalProvider = services.GetRequiredService <IJournalProvider>();
_journalProcessor = services.GetRequiredService <IJournalProcessor>();
_statusProvider = services.GetRequiredService <IStatusProvider>();
_statusProcessor = services.GetRequiredService <IStatusProcessor>();
Events = services.GetRequiredService <EventHandler>();
Status = services.GetRequiredService <IShipStatus>();
}
catch (Exception ex)
{
PreInitializationException = ex;
}
}
public void Handle(IEventProvider eventProvider, params IProjectionContext[] projectionContexts)
{
Contract.Requires(eventProvider != null);
Contract.Requires(projectionContexts != null);
throw new NotImplementedException();
}
/// <summary>
/// Writes an activity event, used to correlate start and stop events properly.
/// </summary>
/// <param name="provider">The event provider to use</param>
/// <param name="startEventId">The starting event ID to write</param>
/// <param name="stopEventId">The stopping event ID to write</param>
/// <returns>The activity to be disposed when stopped</returns>
public static DisposableEventActivity WriteEventActivity(this IEventProvider provider, int startEventId, int stopEventId)
{
if (provider.IsEnabled)
{
var activity = CreateEventActivity();
provider.WriteEvent(
new EventDescriptor(
eventId: startEventId,
opcode: EventOpcode.Start,
activityId: activity?.Id ?? 0
)
);
return(new DisposableEventActivity(
activity,
() => provider.WriteEvent(
new EventDescriptor(
eventId: stopEventId,
opcode: EventOpcode.Stop,
activityId: activity?.Id ?? 0
)
)
));
}
else
{
// the using statement handles null disposable properly.
return(null);
}
}
protected EventManager(IEventProvider eventProvider)
{
m_eventProvider = eventProvider;
m_callback = MediaPlayerEventOccured;
m_hCallback = Marshal.GetFunctionPointerForDelegate(m_callback);
}
public void SetUp()
{
_queueReader = new Mock <IQueueReader>();
_queueWriter = new Mock <IQueueWriter>();
_messageQueue = new Mock <IMessageQueue>();
_eventRepository = new Mock <IEventRepository>();
_messageQueue.Setup(_ => _.BeginRead(It.IsAny <MessageQueueKeys>())).Returns(_queueReader.Object);
_messageQueue.Setup(_ => _.BeginWrite(It.IsAny <MessageQueueKeys>())).Returns(_queueWriter.Object);
_target = new EventProvider(_messageQueue.Object, _eventRepository.Object);
_event = new Event
{
Key = "event_key",
Data = new Dictionary <string, string>
{
{ "1", "2" },
{ "3", "4" }
}
};
}
public IProjection GetProjection(IEventProvider eventProvider)
{
Contract.Requires(eventProvider != null);
Contract.Ensures(Contract.Result <IProjection>() != null);
throw new NotImplementedException();
}
private void LoadEvents(IEventProvider provider, int updateIntervalHours, int updateDays, UpdateInterval interval)
{
if (!provider.Storage.LastUpdated(interval).WithInHours(updateIntervalHours))
{
var events = provider.Source.GetTopEvents(DateTime.Now, DateTime.Now.AddDays(updateDays), Locations.Vancouver);
provider.Storage.SaveToDb(events, interval);
}
}
public EventProviderTransactionCollection(IEventProvider eventProvider, IReadOnlyCollection <EventProviderTransaction> transactions)
{
Contract.Requires(eventProvider != null);
Contract.Requires(transactions != null);
EventProvider = eventProvider;
Transactions = transactions;
}
public LocomotivaEventMetadataProvider(IEventProvider provider, UrlProviderFactory urlProviderFactory, ContractScoreCalculatorModule scoreCalculator)
{
_provider = provider;
_urlProviderFactory = urlProviderFactory;
_scoreCalculator = scoreCalculator;
Errors = new List <string>();
}
public static bool TrySetTopicInfo <TModel>(this IEventProvider eventProvider, TModel model, Type eventType, string topic)
{
if (eventProvider.TryGetEventName(eventType, out string eventName))
{
return(eventProvider.TrySetTopicInfo(eventName, model, topic));
}
return(false);
}
/// <summary>
/// Write a single activity event, to be used with the stopping opcode later on.
/// </summary>
/// <param name="provider">The event provider to use</param>
/// <param name="eventId">The event ID to write</param>
/// <param name="opCode">The opcode of the event</param>
/// <param name="payload">An optional payload</param>
/// <returns>An activity identifier, to be used as a relatedActivityId, or activity id for the stopping event.</returns>
public static EventActivity WriteEventActivity(this IEventProvider provider, int eventId, EventOpcode opCode, object[] payload = null)
{
var activity = CreateEventActivity();
provider.WriteEvent(new EventDescriptor(eventId: eventId, opcode: opCode, activityId: activity?.Id ?? 0), payload);
return(activity);
}
public static bool SetTopicInfo(this IEventProvider eventProvider, object @event, string topic)
{
if (eventProvider.TryGetEventName(@event.GetType(), out string eventName))
{
return(eventProvider.TrySetTopicInfo(eventName, @event, topic));
}
return(false);
}
public void Handle(IEventProvider eventProvider, params IProjectionContext[] projectionContexts)
{
// get projection
var projection = _projectionFactory.GetProjection(eventProvider);
// project
projectionContexts.ForEach(projection.Project);
}
public static Type GetConsumerType(this IEventProvider eventProvider, Type eventType)
{
if (eventProvider.TryGetEventName(eventType, out string eventName))
{
return(eventProvider.GetConsumerType(eventName));
}
return(null);
}
public static string GetTopic(this IEventProvider eventProvider, Type eventType, object toipcInfo)
{
if (eventProvider.TryGetEventName(eventType, out string eventName))
{
return(eventProvider.GetTopic(eventName, toipcInfo));
}
return(null);
}
public static SubscriptionInfo CreateSubscriptionInfo(this IEventProvider eventProvider, string eventName, Type eventType, string topic) =>
new SubscriptionInfo
{
Topic = topic,
EventName = eventName,
EventType = eventType,
ConsumerType = eventProvider.GetConsumerType(eventType)
};
public static MqttApplicationMessage CreateMessage(this IEventProvider eventProvider, object @event, string topic)
{
if (eventProvider.TryGetEventName(@event.GetType(), out string eventName))
{
return(eventProvider.CreateMessage(eventName, @event, topic));
}
return(null);
}
public static Type GetConverterType(this IEventProvider eventProvider, string eventName)
{
if (eventProvider.TryGetEventOptions(eventName, out var options))
{
return(options.ConverterType);
}
return(null);
}
public static string GetEventName(this IEventProvider eventProvider, Type eventType)
{
if (eventProvider.TryGetEventName(eventType, out string eventName))
{
return(eventName);
}
throw new EventNotFoundException(eventName, eventType);
}
public EventController(IService <Event> service, ICustomLogger logger, IEventProvider provider, IProvider <Category> categoryProvider, IProvider <Organizer> organizerProvider)
{
_service = service;
_logger = logger;
_provider = provider;
_categoryProvider = categoryProvider;
_organizerProvider = organizerProvider;
}
public static string GetTopicEntity(this IEventProvider eventProvider, Type eventType, string topic, string name)
{
if (eventProvider.TryGetEventName(eventType, out string eventName))
{
return(eventProvider.GetTopicEntity(eventName, topic, name));
}
return(null);
}
public static bool HasTopicPattern(this IEventProvider eventProvider, Type eventType)
{
if (eventProvider.TryGetEventName(eventType, out string eventName))
{
return(eventProvider.HasTopicPattern(eventName));
}
return(false);
}
private void doNewEvent(IEventProvider evt)
{
DialogResult result = EventProviderEditorDlg.Show(this, evt, _project.Events, true);
if (result != DialogResult.Cancel)
{
_project.Events.Add(evt);
}
}
public QueueListener(IQueueProvider queueProvider, IMessageProvider messageProvider, ITableStorageProvider tableStorageProvider, IConfigurationProvider configurationProvider, IEventProvider eventProvider)
{
this.queueProvider = queueProvider;
this.messageProvider = messageProvider;
this.tableStorageProvider = tableStorageProvider;
this.configurationProvider = configurationProvider;
this.eventProvider = eventProvider;
}
protected EventManager(IEventProvider eventProvider)
{
MEventProvider = eventProvider;
VlcEventHandlerDelegate callback1 = MediaPlayerEventOccured;
_hCallback1 = Marshal.GetFunctionPointerForDelegate(callback1);
_mCallbacks.Add(callback1);
}
public void Track(IEventProvider eventProvider)
{
if (_trackedEventProviders.Exists(x => x.Id == eventProvider.Id))
{
return;
}
_trackedEventProviders.Add(eventProvider);
}
protected EventManager(IEventProvider eventProvider)
{
m_eventProvider = eventProvider;
VlcEventHandlerDelegate callback1 = MediaPlayerEventOccured;
hCallback1 = Marshal.GetFunctionPointerForDelegate(callback1);
m_callbacks.Add(callback1);
}
public ApiService(
IEventProvider eventProvider,
IRequestExecutorProvider requestExecutorProvider,
IUnitOfWork unitOfWork)
{
_eventProvider = eventProvider;
_requestExecutorProvider = requestExecutorProvider;
_unitOfWork = unitOfWork;
}
protected void profileBtn_Click(object sender, EventArgs e)
{
IEventProvider eventProvider = this.Page as IEventProvider;
if (eventProvider != null)
{
eventProvider.Trigger = true;
}
}
public static EventOptions GetEventOptions(this IEventProvider eventProvider, Type eventType)
{
if (TryGetEventOptions(eventProvider, eventType, out var options))
{
return(options);
}
throw new EventNotFoundException(eventType.Name, eventType);
}
public static bool TryGetEventOptions(this IEventProvider eventProvider, Type eventType, out EventOptions options)
{
if (eventProvider.TryGetEventName(eventType, out var eventname))
{
return(eventProvider.TryGetEventOptions(eventname, out options));
}
options = null;
return(false);
}
private EventStream(IEventProvider eventProvider, IEnumerable <EventStreamRevision> revisions)
{
Contract.Requires(eventProvider != null);
Contract.Requires(revisions != null);
EventProvider = eventProvider;
_revisions.AddRange(revisions);
LatestVersion = GetLatestVersion();
}
public void Save(IEventProvider eventProvider)
{
Within.Transaction(_dbConfig.ConnectionString, transaction =>
{
int version = GetEventProviderVersion(eventProvider.Id, transaction);
if (version == -1)
StoreEventProvider(eventProvider, transaction);
if (version > eventProvider.Version)
throw new ConcurrencyViolationException();
eventProvider.GetChanges().ForEach(e => StoreChange(e, eventProvider.Id, transaction));
UpdateEventProviderVersion(eventProvider, transaction);
});
}
public AccountController(
UserManager<ApplicationUser> userManager,
SignInManager<ApplicationUser> signInManager,
IEmailSender emailSender,
ISmsSender smsSender,
ApplicationDbContext applicationDbContext,
IEventProvider eventProvider)
{
_userManager = userManager;
_signInManager = signInManager;
_emailSender = emailSender;
_smsSender = smsSender;
_applicationDbContext = applicationDbContext;
_eventProvider = eventProvider;
_userCreatedEvent = eventProvider.GetEvent<ApplicationUserCreatedEvent>();
}
public HealthMonitor(IEventProvider eventProvider, IEventValidator eventValidator, IPoolManager poolManager)
{
if (eventProvider == null)
{
throw new ArgumentNullException("eventProvider");
}
if (eventValidator == null)
{
throw new ArgumentNullException("eventValidator");
}
if (poolManager == null)
{
throw new ArgumentNullException("poolManager");
}
this.eventProvider = eventProvider;
this.eventProvider.OnEntryWritten += this.OnEntryWritten;
this.eventValidator = eventValidator;
this.poolManager = poolManager;
}
public ProviderToken(IEventProvider prov, IEventColorProvider colorer)
{
_prov = prov;
_colorer = colorer;
_name = (_prov == null) ? "" : _prov.Name;
}
public void Visit(SoundEventElement element)
{
Provider = new SoundEvent.Provider(element.Name, _inst.Resources, element.Resource);
}
public AEventElement GetElement(IEventProvider provider)
{
if (_models.ContainsKey(provider))
{
return _models[provider];
}
this.TryVisit(provider);
_models[provider] = Element;
return Element;
}
public void Visit(DelayEventElement element)
{
Provider = new DelayEventProvider(element.Name)
{
Delay = element.Delay,
Subordinate = GetProvider(element.Subordinate.Subordinate)
};
}
public void Visit(PeriodicEventElement element)
{
Provider = new PeriodicEventProvider(element.Name)
{
Period = element.Period,
Variance = element.Variance,
Subordinate = GetProvider(element.Subordinate.Subordinate)
};
}
public void Visit(RandomEventElement element)
{
var provider = new RandomEventSelector(element.Name);
provider.Selection.AddRange(element.Selection
.Select(e => GetProvider(e.Subordinate)));
Provider = provider;
}
public void Visit(SequentialEventElement element)
{
var provider = new SequentialEventSelector(element.Name);
provider.Sequence.AddRange(element.Sequence
.Select(e => GetProvider(e.Subordinate)));
Provider = provider;
}
public VlmEventManager(IEventProvider eventProvider)
: base(eventProvider)
{
}
public ConcurrencyViolationException(IEventProvider<IDomainEvent> eventProvider)
: base(CreateMessage(eventProvider))
{
}
public Color this[IEventProvider prov]
{
get { return !_colors.ContainsKey(prov) ? Color.Gray : _colors[prov]; }
}
public EventBroker(IEventProvider eventProvider)
: base(eventProvider)
{
}
private static void CreateEventProvider(IEventProvider provider, SqlTransaction transaction)
{
using (var command = new SqlCommand(InsertNewProviderQuery, transaction.Connection))
{
command.Transaction = transaction;
command.Parameters.AddWithValue("Id", provider.Id);
command.Parameters.AddWithValue("Type", provider.GetType().ToString());
command.Parameters.AddWithValue("Version", provider.Version);
command.ExecuteNonQuery();
}
}
private static string CreateMessage(IEventProvider<IDomainEvent> eventProvider)
{
return string.Format("The AggregateRoot {0} of Type {1} was changed",eventProvider.Id,eventProvider.GetType().FullName);
}
public void Finish()
{
_prov = null;
}
public static AEventControl Create(IEventProvider provider, IEventColorProvider colorer)
{
ProviderVisitor visitor = new ProviderVisitor(colorer);
visitor.TryVisit(provider);
return visitor.Control;
}
public void Visit(SimultaneousEventElement element)
{
var provider = new SimultaneousEventProvider(element.Name);
provider.Group.AddRange(element.Group
.Select(e => GetProvider(e.Subordinate)));
Provider = provider;
}
public TabManager(IEventProvider eventProvider, IStorageService storageService)
{
_storageService = storageService;
eventProvider.SolutionOpened += EventProvider_SolutionOpened;
eventProvider.SolutionClosed += EventProvider_SolutionClosed;
}
public MediaEventManager(IEventProvider eventProvider)
: base(eventProvider)
{
}
public MediaListPlayerEventManager(IEventProvider eventProvider)
: base(eventProvider)
{
}
public MediaDiscoveryEventManager(IEventProvider eventProvider)
: base(eventProvider)
{
}
public void Load(ISceneProvider draw, IEventProvider events, INetworkProvider network, ISoundProvider sound, IModuleProvider modules, IMovementProvider movement, ICollisionProvider collision, IVoiceChatProvider voicechat, IWorldManager world, ITextureManager texture, ISoundManager soundmanager)
{
this.drawprovider = draw;
this.eventprovider = events;
this.networkprovider = network;
this.soundprovider = sound;
this.moduleprovider = modules;
this.movementprovider = movement;
this.collisionprovider = collision;
this.voicechatprovider = voicechat;
this.texturemanager = texture;
this.worldmanager = world;
this.soundmanager = soundmanager;
this.LoadContexts (drawprovider, eventprovider, networkprovider, soundprovider, moduleprovider, movementprovider,
collisionprovider, voicechatprovider, texturemanager, worldmanager, soundmanager);
}
public Map GetMap(string filepath, IEventProvider eventprovider)
{
Uri location = new Uri(filepath);
FileInfo MapPath = new FileInfo(location.LocalPath);
if (!MapPath.Exists)
throw new ArgumentException("Invalid file path. Map does not exist.", "location");
Map Map = new Map();
XmlDocument doc = new XmlDocument();
doc.Load(MapPath.FullName);
XmlNodeList nodes = doc.GetElementsByTagName("Map");
XmlNodeList innerNodes = nodes[0].ChildNodes;
for (int i = 0; i < innerNodes.Count; i++)
{
if (innerNodes[i].Name == "Name")
Map.Name = innerNodes[i].InnerText;
else if (innerNodes[i].Name == "TileSet")
Map.TextureName = innerNodes[i].InnerText;
else if (innerNodes[i].Name == "MapSize")
{
int x = 0, y = 0;
foreach (XmlNode node in innerNodes[i].ChildNodes)
{
if (node.Name == "X")
x = Convert.ToInt32(node.InnerText);
else if (node.Name == "Y")
y = Convert.ToInt32(node.InnerText);
}
Map.MapSize = new MapPoint(x, y);
}
else if (innerNodes[i].Name == "TilePixelSize")
{
Map.TileSize = Convert.ToInt32(innerNodes[i].InnerText);
}
else if (innerNodes[i].Name == "UnderLayer")
{
string[] baseText = innerNodes[i].InnerText.Replace("\r\n", string.Empty).Replace(" ", string.Empty).Trim().Split(' ');
Map.UnderLayer = Array.ConvertAll<string, int>(baseText, new Converter<string, int>(this.ConvertStringToInt));
}
else if (innerNodes[i].Name == "BaseLayer")
{
string[] baseText = innerNodes[i].InnerText.Replace("\r\n", string.Empty).Replace(" ", string.Empty).Trim().Split(' ');
Map.BaseLayer = Array.ConvertAll<string, int>(baseText, new Converter<string, int>(this.ConvertStringToInt));
}
else if (innerNodes[i].Name == "MiddleLayer")
{
string[] baseText = innerNodes[i].InnerText.Replace("\r\n", string.Empty).Replace(" ", string.Empty).Trim().Split(' ');
Map.MiddleLayer = Array.ConvertAll<string, int>(baseText, new Converter<string, int>(this.ConvertStringToInt));
}
else if (innerNodes[i].Name == "TopLayer")
{
string[] baseText = innerNodes[i].InnerText.Replace("\r\n", string.Empty).Replace(" ", string.Empty).Trim().Split(' ');
Map.TopLayer = Array.ConvertAll<string, int>(baseText, new Converter<string, int>(this.ConvertStringToInt));
}
else if (innerNodes[i].Name == "CollisionLayer")
{
string[] baseText = innerNodes[i].InnerText.Replace("\r\n", string.Empty).Replace(" ", string.Empty).Trim().Split(' ');
Map.CollisionLayer = Array.ConvertAll<string, int>(baseText, new Converter<string, int>(this.ConvertStringToInt));
}
else if (innerNodes[i].Name == "OpaqueLayer")
{
string[] baseText = innerNodes[i].InnerText.Replace("\r\n", string.Empty).Replace(" ", string.Empty).Trim().Split(' ');
Map.OpaqueLayer = Array.ConvertAll<string, int>(baseText, new Converter<string, int>(this.ConvertStringToInt));
}
else if (innerNodes[i].Name == "AnimatedTiles")
{
XmlNodeList tiles = innerNodes[i].ChildNodes;
foreach (XmlNode node in tiles)
{
int tileID = 0;
int frameCount = 0;
Rectangle tileRect = Rectangle.Empty;
foreach (XmlNode subnode in node.ChildNodes)
{
if (subnode.Name == "TileID")
tileID = Convert.ToInt32(subnode.InnerText);
else if (subnode.Name == "FrameCount")
frameCount = Convert.ToInt32(subnode.InnerText);
else if (subnode.Name == "TileRect")
{
var data = Array.ConvertAll<string, int>(subnode.InnerText.Split(' '), new Converter<string, int>(this.ConvertStringToInt));
tileRect = new Rectangle(data[0], data[1], data[2], data[3]);
}
}
Map.AnimatedTiles.Add(tileID, new FrameAnimation(tileRect, frameCount));
}
}
else if (innerNodes[i].Name == "Events")
{
var root = innerNodes[i];
XmlNodeList events = root.ChildNodes;
foreach (XmlNode node in events)
{
#region Event Loading
string type = string.Empty;
Directions dir = Directions.Any;
Dictionary<String, String> parameters = new Dictionary<string, string>();
MapPoint eventlocation = MapPoint.Zero;
MapPoint size = MapPoint.Zero;
ActivationTypes activation = ActivationTypes.Static;
foreach (XmlNode cnode in node.ChildNodes)
{
switch (cnode.Name)
{
case "Type": type = cnode.InnerText; break;
case "Dir": dir = (Directions)Enum.Parse(typeof(Directions), cnode.InnerText); break;
case "Parameters": parameters = this.LoadParametersFromXml(cnode); break;
case "Location": eventlocation = new MapPoint(cnode); break;
case "Size": size = new MapPoint(cnode); break;
case "Activation": activation = (ActivationTypes)Enum.Parse(typeof(ActivationTypes), cnode.InnerText); break;
}
}
IMapEvent newEvent = this.CreateEventFromString(type);
if (newEvent == null)
{
MapEditorManager.NoEvents = true;
break;
}
newEvent.Direction = dir;
newEvent.Parameters = parameters;
newEvent.Rectangle = new Rectangle(eventlocation.IntX, eventlocation.IntY, size.IntX, size.IntY);
newEvent.Activation = activation;
eventprovider.AddEvent(Map, newEvent);
#endregion
}
}
}
return Map;
}
public static DialogResult Show(IWin32Window owner, IEventProvider prov, IEnumerable<IEventProvider> items, bool cancellable)
{
var dlg = new EventProviderEditorDlg();
dlg.Load += (o, e) =>
{
dlg.Cancellable = cancellable;
dlg.ShowItems = (items != null);
if (items != null)
dlg.ItemList.AddRange(items);
dlg.Provider = prov;
};
return dlg.ShowDialog(owner);
}
private static void UpdateEventProviderVersion(IEventProvider provider, SqlTransaction transaction)
{
using (var command = new SqlCommand(UpdateEventProviderVersionQuery, transaction.Connection))
{
command.Transaction = transaction;
command.Parameters.AddWithValue("Id", provider.Id);
command.ExecuteNonQuery();
}
}