/// <summary>
/// See interface docs.
/// </summary>
/// <param name="mergedFeed"></param>
/// <param name="mergeFeeds"></param>
public void Initialise(MergedFeed mergedFeed, IEnumerable <IFeed> mergeFeeds)
{
if (_Initialised)
{
throw new InvalidOperationException("A feed can only be initialised once");
}
if (mergedFeed == null)
{
throw new ArgumentNullException("receiver");
}
if (mergeFeeds == null)
{
throw new ArgumentNullException("mergePathways");
}
if (!mergedFeed.Enabled)
{
throw new InvalidOperationException($"The {mergedFeed.Name} merged feed has not been enabled");
}
var mergedListeners = GetListenersFromMergeFeeds(mergedFeed, mergeFeeds);
var mergedFeedListener = Factory.Resolve <IMergedFeedListener>();
Listener = mergedFeedListener;
Listener.ExceptionCaught += Listener_ExceptionCaught;
Listener.IgnoreBadMessages = true;
Listener.AssumeDF18CF1IsIcao = false;
mergedFeedListener.IcaoTimeout = mergedFeed.IcaoTimeout;
mergedFeedListener.IgnoreAircraftWithNoPosition = mergedFeed.IgnoreAircraftWithNoPosition;
mergedFeedListener.SetListeners(mergedListeners);
DoCommonInitialise(mergedFeed.UniqueId, mergedFeed.Name, false, mergedFeed.ReceiverUsage, startAircraftList: true);
}
/// <summary>
/// See interface docs.
/// </summary>
/// <param name="mergedFeed"></param>
/// <param name="mergeFeeds"></param>
public void ApplyConfiguration(MergedFeed mergedFeed, IEnumerable <IFeed> mergeFeeds)
{
if (!_Initialised)
{
throw new InvalidOperationException("ApplyConfiguration cannot be called on an uninitialised feed");
}
if (mergedFeed == null)
{
throw new ArgumentNullException("mergedFeed");
}
if (mergeFeeds == null)
{
throw new ArgumentNullException("mergePathways");
}
if (mergedFeed.UniqueId != UniqueId)
{
throw new InvalidOperationException($"Cannot apply configuration for merged feed #{mergedFeed.UniqueId} to feed for merged feed for #{UniqueId}");
}
var mergedFeedListener = Listener as IMergedFeedListener;
if (mergedFeedListener == null)
{
throw new InvalidOperationException($"ReceiverPathway {UniqueId} was initialised with a receiver but updated with a merged feed");
}
Name = mergedFeed.Name;
SetIsVisible(mergedFeed.ReceiverUsage);
var listeners = GetListenersFromMergeFeeds(mergedFeed, mergeFeeds);
mergedFeedListener.IcaoTimeout = mergedFeed.IcaoTimeout;
mergedFeedListener.IgnoreAircraftWithNoPosition = mergedFeed.IgnoreAircraftWithNoPosition;
mergedFeedListener.SetListeners(listeners);
}
private void CreateFeedForMergedFeed(MergedFeed mergedFeed, IEnumerable <IFeed> allReceiverPathways, List <IFeed> feeds)
{
var mergeFeeds = allReceiverPathways.Where(r => mergedFeed.ReceiverIds.Contains(r.UniqueId)).ToArray();
var feed = Factory.Resolve <IFeed>();
feed.Initialise(mergedFeed, mergeFeeds);
AttachFeed(feed, feeds);
}
void OnlyUseTwoReceiversAndNoMergedFeed()
{
_Configuration.Receivers.Remove(_Receiver3);
_Configuration.Receivers.Remove(_Receiver4);
_Configuration.MergedFeeds.Clear();
_Receiver3 = _Receiver4 = null;
_MergedFeed1 = _MergedFeed2 = null;
}
public void ServerMergedFeedJson_ToModel_MergedFeed_Returns_Null_If_MergedFeed_Is_MergeOnly()
{
var mergedFeed = new MergedFeed()
{
UniqueId = 7, Name = "Hello", ReceiverUsage = ReceiverUsage.MergeOnly
};
Assert.IsNull(ServerReceiverJson.ToModel(mergedFeed));
}
public void ConfigurationListener_Does_Not_Raise_Events_After_MergedFeed_Is_Detached()
{
var record = new MergedFeed();
_Configuration.MergedFeeds.Add(record);
_Configuration.MergedFeeds.Remove(record);
record.UniqueId += 1;
Assert.IsFalse(RaisedEvent <MergedFeed>(ConfigurationListenerGroup.MergedFeed, r => r.UniqueId, record, isListChild: true));
Assert.AreEqual(2, _PropertyChanged.CallCount);
}
public void ServerReceiverJson_ToModel_MergedFeed_Returns_Model_Based_On_MergedFeed()
{
var mergedFeed = new MergedFeed()
{
UniqueId = 7, Name = "Hello"
};
var model = ServerReceiverJson.ToModel(mergedFeed);
Assert.AreEqual(7, model.UniqueId);
Assert.AreEqual("Hello", model.Name);
}
public static void CheckProperties(MergedFeed settings)
{
Assert.AreEqual(0, settings.ReceiverIds.Count);
Assert.AreEqual(0, settings.ReceiverFlags.Count);
TestUtilities.TestProperty(settings, r => r.Enabled, true);
TestUtilities.TestProperty(settings, r => r.UniqueId, 0, 1);
TestUtilities.TestProperty(settings, r => r.Name, null, "ABC");
TestUtilities.TestProperty(settings, r => r.IcaoTimeout, 3000, 10000);
TestUtilities.TestProperty(settings, r => r.IgnoreAircraftWithNoPosition, false);
TestUtilities.TestProperty(settings, r => r.ReceiverUsage, ReceiverUsage.Normal, ReceiverUsage.HideFromWebSite);
}
/// <summary>
/// Returns a new object from a merged feed.
/// </summary>
/// <param name="mergedFeed"></param>
/// <returns></returns>
public static ServerReceiverJson ToModel(MergedFeed mergedFeed)
{
ServerReceiverJson result = null;
if (mergedFeed != null && mergedFeed.ReceiverUsage == ReceiverUsage.Normal)
{
result = new ServerReceiverJson()
{
UniqueId = mergedFeed.UniqueId,
Name = mergedFeed.Name,
};
}
return(result);
}
public void ConfigurationListener_Does_Not_Raise_Events_After_MergedFeedReceiver_Is_Detached()
{
var mergedFeed = new MergedFeed();
var settings = new MergedFeedReceiver();
_Configuration.MergedFeeds.Add(new MergedFeed()
{
ReceiverFlags = { settings }
});
_Configuration.MergedFeeds[0].ReceiverFlags.Remove(settings);
settings.UniqueId += 1;
Assert.IsFalse(RaisedEvent <MergedFeed>(ConfigurationListenerGroup.MergedFeedReceiver, r => r.UniqueId, settings, isListChild: true));
Assert.AreEqual(2, _PropertyChanged.CallCount);
}
public void ConfigurationListener_Raises_Events_When_MergedFeedRecevier_Changes()
{
foreach (var propertyName in typeof(MergedFeedReceiver).GetProperties().Select(r => r.Name))
{
TestCleanup();
TestInitialise();
var mergedFeed = new MergedFeed();
var settings = new MergedFeedReceiver();
_Configuration.MergedFeeds.Add(new MergedFeed()
{
ReceiverFlags = { settings }
});
SetValue(settings, propertyName, new Dictionary <Expression <Func <MergedFeedReceiver, object> >, Action <MergedFeedReceiver> >()
{
{ r => r.UniqueId, r => r.UniqueId += 1 },
{ r => r.IsMlatFeed, r => r.IsMlatFeed = !r.IsMlatFeed },
});
Assert.IsTrue(RaisedEvent(ConfigurationListenerGroup.MergedFeedReceiver, propertyName, settings, isListChild: true), "MergedFeedReceiver.{0}", propertyName);
}
}
public void TestInitialise()
{
_SnapshotFactory = Factory.TakeSnapshot();
_Manager = Factory.Singleton.Resolve <IFeedManager>();
_Receiver1 = new Receiver()
{
UniqueId = 1, Name = "First", DataSource = DataSource.Port30003, ConnectionType = ConnectionType.TCP, Address = "127.0.0.1", Port = 30003
};
_Receiver2 = new Receiver()
{
UniqueId = 2, Name = "Second", DataSource = DataSource.Beast, ConnectionType = ConnectionType.COM, ComPort = "COM1", BaudRate = 19200, DataBits = 8, StopBits = StopBits.One
};
_Receiver3 = new Receiver()
{
UniqueId = 3, Name = "Third", ReceiverUsage = ReceiverUsage.HideFromWebSite,
};
_Receiver4 = new Receiver()
{
UniqueId = 4, Name = "Fourth", ReceiverUsage = ReceiverUsage.MergeOnly,
};
_MergedFeed1 = new MergedFeed()
{
UniqueId = 5, Name = "M1", ReceiverIds = { 1, 2 }, ReceiverUsage = ReceiverUsage.Normal,
};
_MergedFeed2 = new MergedFeed()
{
UniqueId = 6, Name = "M2", ReceiverIds = { 3, 4 }, ReceiverUsage = ReceiverUsage.HideFromWebSite,
};
_Configuration = new Configuration()
{
Receivers = { _Receiver1, _Receiver2, _Receiver3, _Receiver4 },
MergedFeeds = { _MergedFeed1, _MergedFeed2 },
};
_ConfigurationStorage = TestUtilities.CreateMockSingleton <IConfigurationStorage>();
_ConfigurationStorage.Setup(r => r.Load()).Returns(_Configuration);
_CreatedListeners = new List <Mock <IListener> >();
_CreatedFeeds = new List <Mock <IFeed> >();
_MergedFeedFeeds = new Dictionary <MergedFeed, List <IFeed> >();
Factory.Singleton.Register <IFeed>(() => {
var feed = TestUtilities.CreateMockInstance <IFeed>();
var listener = TestUtilities.CreateMockInstance <IListener>();
_CreatedListeners.Add(listener);
feed.Setup(r => r.Initialise(It.IsAny <Receiver>(), It.IsAny <Configuration>())).Callback((Receiver rcvr, Configuration conf) => {
feed.Setup(i => i.UniqueId).Returns(rcvr.UniqueId);
feed.Setup(i => i.Name).Returns(rcvr.Name);
feed.Setup(i => i.Listener).Returns(listener.Object);
feed.Setup(i => i.IsVisible).Returns(rcvr.ReceiverUsage == ReceiverUsage.Normal);
});
feed.Setup(r => r.Initialise(It.IsAny <MergedFeed>(), It.IsAny <IEnumerable <IFeed> >())).Callback((MergedFeed mfeed, IEnumerable <IFeed> feeds) => {
feed.Setup(i => i.UniqueId).Returns(mfeed.UniqueId);
feed.Setup(i => i.Name).Returns(mfeed.Name);
feed.Setup(i => i.Listener).Returns(listener.Object);
feed.Setup(i => i.IsVisible).Returns(mfeed.ReceiverUsage == ReceiverUsage.Normal);
if (_MergedFeedFeeds.ContainsKey(mfeed))
{
_MergedFeedFeeds[mfeed] = feeds.ToList();
}
else
{
_MergedFeedFeeds.Add(mfeed, feeds.ToList());
}
});
feed.Setup(r => r.ApplyConfiguration(It.IsAny <MergedFeed>(), It.IsAny <IEnumerable <IFeed> >())).Callback((MergedFeed mfeed, IEnumerable <IFeed> feeds) => {
if (_MergedFeedFeeds.ContainsKey(mfeed))
{
_MergedFeedFeeds[mfeed] = feeds.ToList();
}
else
{
_MergedFeedFeeds.Add(mfeed, feeds.ToList());
}
});
_CreatedFeeds.Add(feed);
return(feed.Object);
});
_ExceptionCaughtRecorder = new EventRecorder <EventArgs <Exception> >();
_FeedsChangedRecorder = new EventRecorder <EventArgs>();
_ConnectionStateChangedRecorder = new EventRecorder <EventArgs <IFeed> >();
}
private static List <IMergedFeedComponentListener> GetListenersFromMergeFeeds(MergedFeed mergedFeed, IEnumerable <IFeed> mergeFeeds)
{
var result = new List <IMergedFeedComponentListener>();
foreach (var receiverId in mergedFeed.ReceiverIds)
{
var feed = mergeFeeds.FirstOrDefault(r => r.UniqueId == receiverId);
var listener = feed == null ? null : feed.Listener;
if (listener != null)
{
var mergedFeedReceiver = mergedFeed.ReceiverFlags.FirstOrDefault(r => r.UniqueId == receiverId);
var isMlatFeed = mergedFeedReceiver == null ? false : mergedFeedReceiver.IsMlatFeed;
var mergedFeedComponent = Factory.Resolve <IMergedFeedComponentListener>();
mergedFeedComponent.SetListener(listener, isMlatFeed);
result.Add(mergedFeedComponent);
}
}
return(result);
}
/// <summary>
/// Creates a new object.
/// </summary>
/// <param name="mergedFeed"></param>
public CombinedFeed(MergedFeed mergedFeed)
{
MergedFeed = mergedFeed;
MergedFeed.PropertyChanged += Wrapped_PropertyChanged;
}
/// <summary>
/// Unhooks the child records on a merged feed.
/// </summary>
/// <param name="record"></param>
private void MergedFeed_UnhookChild(MergedFeed record)
{
UnhookList <MergedFeedReceiver>(record.ReceiverFlags, _HookedMergedFeedReceivers, MergedFeedReceiver_PropertyChanged, MergedFeedReceviers_ListChanged);
}
