public void RecordTack(Tack tack)
{
//TODO: consider adding true wind angle or dir?
_connection.Execute("insert into Tack (start,endcourseoverground) values (@At,@CourseOverGround)", tack);
//TODO: there has to be a better way to do this
tack.Id = (long)_connection.ExecuteScalar("select max(id) from Tack");
}
public string Get(IChatMessageEnvelope request)
{
try
{
if (Tack == null)
{
throw new InvalidOperationException(ExceptionMessage_ITackCannotBeNull);
}
else
{
//NOTE: Define the query
request.Query =
(chatMessageQueryRepo, chatMessageEnvelopeParam) =>
{
IChatMessageEnvelope nextChatMessage = chatMessageQueryRepo.GetLatestChatMessage(chatMessageEnvelopeParam);
return(nextChatMessage);
};
IChatMessageEnvelope responseEnvelope = (IChatMessageEnvelope)Tack.GET(request);
string responseString = _marshaller.MarshallPayloadJSON(responseEnvelope);
return(responseString);
}
}
catch (InvalidOperationException ex)
{
throw new InvalidOperationException(ex.Message, ex);
}
catch (Exception ex)
{
throw new ApplicationException(ex.Message, ex);
}
}
public IChatMessageEnvelope GetByID(IChatMessageEnvelope request)
{
try
{
if (Tack == null)
{
throw new InvalidOperationException(ExceptionMessage_ITackCannotBeNull);
}
else
{
//NOTE: Define the query
request.Query =
(chatMessageQueryRepo, chatMessageEnvelopeParam) =>
{
IChatMessageEnvelope nextChatMessage = chatMessageQueryRepo.GetChatMessageByID(chatMessageEnvelopeParam);
return(nextChatMessage);
};
return((IChatMessageEnvelope)Tack.GET(request));
}
}
catch (InvalidOperationException ex)
{
throw new InvalidOperationException(ex.Message, ex);
}
catch (Exception ex)
{
throw new ApplicationException(ex.Message, ex);
}
}
public void RemoveTackFromList(Tack p_tack)
{
if (p_tack != null)
{
TacksInObject.RemoveChecking(p_tack);
_needCheckKinematic = true;
}
}
public void AddTackInList(Tack p_tack)
{
if (p_tack != null)
{
TacksInObject.AddChecking(p_tack);
_needCheckKinematic = true;
}
}
public void RemoveTackFromList(Tack p_tack)
{
if(p_tack != null)
{
TacksInObject.RemoveChecking(p_tack);
_needCheckKinematic = true;
}
}
public void AddTackInList(Tack p_tack)
{
if(p_tack != null)
{
TacksInObject.AddChecking(p_tack);
_needCheckKinematic = true;
}
}
public GameObject GetTackObjectWithIndex(int p_index, bool p_returnDefaultWhenOutOfBounds = true)
{
Tack v_tack = GetTackWithIndex(p_index, p_returnDefaultWhenOutOfBounds);
GameObject v_tackObject = v_tack != null? v_tack.gameObject : null;
if (v_tackObject == null)
{
v_tackObject = this.gameObject;
}
return(v_tackObject);
}
public void Dispose()
{
try
{
if (_isDisposed == false)
{
MessageBusWiter.Dispose();
MessageBusReaderBank.Dispose();
Tack.Dispose();
_isDisposed = true;
}
}
catch (Exception ex)
{
new ApplicationException(ex.Message, ex);
}
}
public void Dispose()
{
try
{
if (_isDisposed == false)
{
MessageBusWiter.Dispose();
MessageBusReaderBank.Dispose();
Tack.SkyWatch.UnWatch(typeof(IChatMessageEnvelope).ToString(), ServiceGUID); //NOTE: Must stop watching since SkyWatch is a global instance.
Tack.Dispose();
_isDisposed = true;
}
}
catch (Exception ex)
{
new ApplicationException(ex.Message, ex);
}
}
/// <summary>
/// compare the new state to the last values and determine if a tack has occured
/// if so, update the state with the new tack
/// </summary>
/// <param name="state"></param>
private void CheckForTack(State state)
{
var latest = _history.Last();
var deltas = _history.Where(x => x.Time > latest.Time - _tackThresholdTime).Select(x => Math.Abs(AngleUtilities.AngleDifference(latest.CourseOverGroundRadians, x.CourseOverGroundRadians))).Max();
if (deltas > _tackThreshold)
{
//tack detected
_lastTackAt = latest.Time;
var priorToTack = _history.Where(x => x.Time < latest.Time - _dataExclusionTime).OrderByDescending(x => x.Time).FirstOrDefault();
if (priorToTack != null)
{
_previousTackCourseOverGroundRadians = priorToTack.CourseOverGroundRadians;
}
else
{
_previousTackCourseOverGroundRadians = null;
}
_history.Clear();
_currentTackStartCourseOverGroundRadians = null;
var difference = AngleUtilities.AngleDifference(_previousTackCourseOverGroundRadians.Value, latest.CourseOverGroundRadians);
var differenceDegrees = AngleUtilities.RadiansToDegrees(difference);
string message = string.Format("Tack: {0:0.0}°", differenceDegrees);
_logger.Info(message);
state.AddMessage(MessageCategory.Tactical, MessagePriority.Normal, 5, message);
//record the tack in the state
if (state.RaceStarted && _currentTack != null)
{
_currentTack.CourseOverGround = AngleUtilities.RadiansToDegrees(_previousTackCourseOverGroundRadians.Value);
state.Tacks.Add(_currentTack);
}
_currentTack = new Tack();
_currentTack.At = latest.Time;
}
}
public Tack GetTackWithIndex(int p_index, bool p_returnDefaultWhenOutOfBounds = true)
{
Tack v_tack = null;
if (p_index >= 0 && p_index < TacksInObject.Count)
{
v_tack = TacksInObject[p_index];
}
if (v_tack == null && p_returnDefaultWhenOutOfBounds)
{
foreach (Tack v_tackInList in TacksInObject)
{
v_tack = v_tackInList;
if (v_tack != null)
{
break;
}
}
}
return(v_tack);
}
private void SkyWatchEventHandler(ISkyWatchEventTypes skyWatchEventType, string eventKey)
{
lock (_thisLock)
{
try
{
if (skyWatchEventType == ISkyWatchEventTypes.WriteOccured)
{
Type envelopeType = Tack.GetIEnvelopeType(eventKey);
long ID = Tack.GetStorageID(eventKey);
IChatMessageEnvelope eventSubject_ChatMessageEnvelope = _chatMessageEnvelopeFactory.InstantiateIEnvelope();
eventSubject_ChatMessageEnvelope.ChatMessageID = ID;
IChatMessageEnvelope chatMessageEnvelopeFromSkyWatch = GetByID(eventSubject_ChatMessageEnvelope);
_skyWatchQueue.Enqueue(chatMessageEnvelopeFromSkyWatch);
}
}
catch (Exception ex)
{
throw new ApplicationException(ex.Message, ex);
}
}
}
public int GetIndexOfTack(Tack p_tack, bool p_addThisTackIfNotAdded = true)
{
int v_returnIndex = -1;
if (p_tack != null)
{
for (int i = 0; i < TacksInObject.Count; i++)
{
Tack v_tackInObject = TacksInObject[i];
if (p_tack == v_tackInObject)
{
v_returnIndex = i;
break;
}
}
if (v_returnIndex == -1 && p_addThisTackIfNotAdded)
{
TacksInObject.Add(p_tack);
v_returnIndex = TacksInObject.Count - 1;
}
}
return(v_returnIndex);
}
public void TestITackCRUD()
{
IBoards boards = GetMockedIBoards();
IEnvelope envelope = _erector.Container.Resolve <IEnvelope>();
envelope.ServiceRoute = "ChatMessage";
IChatMessageEnvelope chatMessageEnvelope = _erector.Container.Resolve <IChatMessageEnvelope>();
chatMessageEnvelope.ServiceRoute = "ChatMessage";
//Boards cannot be null.
ITack nullBoardsTack = new Tack(null);
try
{
IEnvelope envelopeNullBoard = nullBoardsTack.GET(envelope);
Assert.Fail();
}
catch (InvalidOperationException ex)
{
string message = ex.Message;
Assert.AreEqual(message, nullBoardsTack.ExceptionMessage_BoardsCannotBeNull);
}
ITack tack = new Tack(boards);
//Create
IEnvelope createEnvelope = tack.POST(envelope);
Assert.IsNotNull(createEnvelope);
Assert.AreEqual(createEnvelope.ServiceRoute, envelope.ServiceRoute);
IEnvelope createChatMessageEnvelope = tack.POST(chatMessageEnvelope);
Assert.IsNotNull(createChatMessageEnvelope);
Assert.AreEqual(createChatMessageEnvelope.ServiceRoute, envelope.ServiceRoute);
Assert.IsTrue(createChatMessageEnvelope.GetType() == typeof(ChatMessageEnvelope));
//Read
IEnvelope readEnvelope = tack.GET(envelope);
Assert.IsNotNull(readEnvelope);
Assert.AreEqual(readEnvelope.ServiceRoute, envelope.ServiceRoute);
IEnvelope readChatMessageEnvelope = tack.GET(chatMessageEnvelope);
Assert.IsNotNull(readChatMessageEnvelope);
Assert.AreEqual(readChatMessageEnvelope.ServiceRoute, envelope.ServiceRoute);
Assert.IsTrue(readChatMessageEnvelope.GetType() == typeof(ChatMessageEnvelope));
//Update
IEnvelope updateEnvelope = tack.PUT(envelope);
Assert.IsNotNull(updateEnvelope);
Assert.AreEqual(updateEnvelope.ServiceRoute, envelope.ServiceRoute);
IEnvelope updateChatMessageEnvelope = tack.PUT(chatMessageEnvelope);
Assert.IsNotNull(updateChatMessageEnvelope);
Assert.AreEqual(updateChatMessageEnvelope.ServiceRoute, envelope.ServiceRoute);
Assert.IsTrue(updateChatMessageEnvelope.GetType() == typeof(ChatMessageEnvelope));
//Delete
IEnvelope deleteEnvelope = tack.DELETE(envelope);
Assert.IsNotNull(deleteEnvelope);
Assert.AreEqual(deleteEnvelope.ServiceRoute, envelope.ServiceRoute);
IEnvelope deleteChatMessageEnvelope = tack.DELETE(chatMessageEnvelope);
Assert.IsNotNull(deleteChatMessageEnvelope);
Assert.AreEqual(deleteChatMessageEnvelope.ServiceRoute, envelope.ServiceRoute);
Assert.IsTrue(deleteChatMessageEnvelope.GetType() == typeof(ChatMessageEnvelope));
}
public int GetIndexOfTack(Tack p_tack, bool p_addThisTackIfNotAdded = true)
{
int v_returnIndex = -1;
if(p_tack != null)
{
for(int i=0; i<TacksInObject.Count; i++)
{
Tack v_tackInObject = TacksInObject[i];
if(p_tack == v_tackInObject)
{
v_returnIndex = i;
break;
}
}
if(v_returnIndex == -1 && p_addThisTackIfNotAdded)
{
TacksInObject.Add(p_tack);
v_returnIndex = TacksInObject.Count -1;
}
}
return v_returnIndex;
}
