public void set_up_roll(TravelCard tc, int num_sides)
{
this.tc = tc;
this.num_sides = num_sides;
MapUI.I.set_active_travelcard_continueB(false);
MapUI.I.set_active_travelcard_rollB(true);
}
public void TravelCardToStringIsCorrect()
{
TravelCard card = new TravelCard("Oslo", "Paris");
string toStringResult = card.ToString();
toStringResult.Should().Be("Oslo → Paris");
}
private void PostToastNotification(TravelCard card)
{
DateTimeOffset youngestValueExpiration = card.PeriodEndDate1 > card.PeriodEndDate2 ? card.PeriodEndDate1 : card.PeriodEndDate2;
ToastVisual visual = new ToastVisual()
{
BindingGeneric = new ToastBindingGeneric()
{
Children =
{
new AdaptiveText()
{
Text = $"Remaining value: {(card.ValueTotalCents / 100m).ToString("#.##")} €\n" +
$"Season pass expires: {youngestValueExpiration.ToLocalTime().ToString(DateTimeFormatInfo.CurrentInfo.ShortDatePattern)}",
HintMaxLines = 2
},
new AdaptiveText()
{
Text = $"Card {card.CardNumber}\n"
}
}
},
};
ToastContent content = new ToastContent
{
Visual = visual,
Scenario = ToastScenario.Default
};
var toast = new ToastNotification(content.GetXml());
ToastNotificationManager.CreateToastNotifier().Show(toast);
}
/// <summary>
/// Creates no-branches way over allowed points from given start
/// </summary>
private TravelFragment tryBuildFragmentFrom(TravelCard startPoint)
{
if (startPoint == null)
{
return(null);
}
TravelFragment result = new TravelFragment(startPoint);
TravelCard lastFoundPoint = startPoint;
// while next step is only one possible - keep moving
while (_travelPointsDic.ContainsKey(lastFoundPoint.To)
// only one possible move
&& _travelPointsDic[lastFoundPoint.To].Count == 1
// no fragments as next possible move (could became unresolvable)
&& _travelFragments.All(item => item.StartPoint != lastFoundPoint.To))
{
// single point - add and continue
TravelCard tempPoint = _travelPointsDic[lastFoundPoint.To].First();
// remove item from possible points
_travelPointsDic.Remove(lastFoundPoint.To);
// add to fragment
result.Add(tempPoint);
lastFoundPoint = tempPoint;
}
return(result);
}
public void finish_roll(int result)
{
MapUI.I.set_active_travelcard_continueB(true);
MapUI.I.travelcard_rollB.interactable = false;
tc.use_roll_result(result);
tc = null;
}
public void TravelCardIsCreatedAndFilledOnValidData()
{
const string departureFrom = "Oslo";
const string arriveTo = "Paris";
TravelCard card = new TravelCard(departureFrom, arriveTo);
card.DepartureFrom.Should().Be(departureFrom);
card.ArriveTo.Should().Be(arriveTo);
}
public void Has_DepartueOrDestinationIsNull_InvalidDataException()
{
//arrange
string departue = "Moscow";
string destination = null;
//act
var card = new TravelCard(departue, destination);
//assert
}
public void PrintResult_IsCorrect()
{
//arrange
var card = new TravelCard("Test1", "Test2");
//act
var result = card.Print();
//assert
Assert.AreEqual("Test1 > Test2", result);
}
public void TestSorting()
{
var init = _repo.CreateCards(20);
var copy = new TravelCard[init.Length];
Array.Copy(init, copy, init.Length);
CardHelpers.ShuffleCards(copy);
CardHelpers.OrderCards(copy);
CollectionAssert.AreEqual(init, copy);
}
public void Verify_Display()
{
var log = new TravelCard
{
MyDistanceFromSource = 10,
RouteCovered = "ABC",
StopsTravelled = 2
};
var actual = log.ToString();
var expected = "Path: ABC | My Distance: 10 | Others Distance: 0 | Stops: 2";
Assert.AreEqual(expected, actual);
}
public TravelCardViewModel(TravelCard backingCard)
{
_backingCard = backingCard;
SeasonPasses[0] = new SeasonPassViewModel(_backingCard.PeriodPass.ProductCode1,
_backingCard.PeriodPass.PeriodStartDate1,
_backingCard.PeriodPass.PeriodEndDate1,
_backingCard.PeriodPass.ValidityArea1);
SeasonPasses[1] = new SeasonPassViewModel(_backingCard.PeriodPass.ProductCode2,
_backingCard.PeriodPass.PeriodStartDate2,
_backingCard.PeriodPass.PeriodEndDate2,
_backingCard.PeriodPass.ValidityArea2);
SeasonPasses = SeasonPasses.OrderByDescending(x => x.EndDate).ToArray();
}
/// <summary>
/// Shuffles cards list
/// </summary>
/// <param name="cards">Cards collection</param>
public static void ShuffleCards(TravelCard[] cards)
{
Random rnd = new Random();
int n = cards.Length;
for (int i = 0; i < n; i++)
{
int r = i + (int)(rnd.NextDouble() * (n - i));
TravelCard t = cards[r];
cards[r] = cards[i];
cards[i] = t;
}
}
public void GetOrderedCards_ThreeCardsAllDisordered_Ok()
{
var card1 = new TravelCard("C", "D");
var card2 = new TravelCard("B", "C");
var card3 = new TravelCard("A", "B");
var disorderedCards = new List <TravelCard> {
card1, card2, card3
};
List <TravelCard> orderedCards = _pathService.GetOrderedCards(disorderedCards);
Assert.Equal(card3, orderedCards[0]);
Assert.Equal(card2, orderedCards[1]);
Assert.Equal(card1, orderedCards[2]);
}
public void GetOrderedCards_ThreeCardsWithLastTwoDisordered_Ok()
{
var card1 = new TravelCard("Мельбурн", "Кельн");
var card2 = new TravelCard("Москва", "Париж");
var card3 = new TravelCard("Кельн", "Москва");
var disorderedCards = new List <TravelCard> {
card1, card2, card3
};
List <TravelCard> orderedCards = _pathService.GetOrderedCards(disorderedCards);
Assert.Equal(card1, orderedCards[0]);
Assert.Equal(card3, orderedCards[1]);
Assert.Equal(card2, orderedCards[2]);
}
public ICard Process(decimal annualSalary)
{
string annualAmount = annualSalary.ToString();
ICard card;
if (annualSalary < 10000)
{
card = new SmartCard(annualAmount, _cardService);
}
else
{
card = new TravelCard(annualAmount, _cardService);
}
return(card);
}
public AllocateySortVsNonAllocateySort()
{
_sortedData = new TravelCard[N];
_sortedData[0] = new TravelCard("A-1" + Guid.NewGuid().ToString(), "A");
for (int i = 0; i < N - 1; i++)
{
string city = String.Concat("A", i.ToString(), Guid.NewGuid().ToString());
_sortedData[i] = new TravelCard(_sortedData[i].DepartureFrom, city);
_sortedData[i + 1] = new TravelCard(city, "A");
}
_sortedReversedData = _sortedData.Reverse().ToArray();
Random rnd = new Random();
_sortedShuffledData = _sortedData.OrderBy(d => d.GetHashCode()).ToArray();
}
/// <summary>
/// Reads the travel card data from HSL Mifare DESFire card.
/// </summary>
/// <param name="card">The card to try to read.</param>
/// <returns>A deserialized Travel Card object if the card was valid, otherwise null.</returns>
public static async Task <TravelCard> ReadTravelCardAsync(SmartCard card)
{
using (SmartCardConnection connection = await card.ConnectAsync())
{
byte[] selection = (await connection.TransmitAsync(Commands.SelectHslCommand.AsBuffer())).ToArray();
if (selection != null &&
selection.Length > 0 &&
selection.SequenceEqual(Commands.OkResponse))
{
// Travel card info bytes
byte[] appInfo = null;
byte[] controlInfo = null;
byte[] periodPass = null;
byte[] storedValue = null;
byte[] eTicket = null;
byte[] history = null;
// Temporary containers for history chunks
byte[] hist1 = new byte[2];
byte[] hist2 = new byte[2];
appInfo = (await connection.TransmitAsync(Commands.ReadAppInfoCommand.AsBuffer())).ToArray();
controlInfo = (await connection.TransmitAsync(Commands.ReadControlInfoCommand.AsBuffer())).ToArray();
periodPass = (await connection.TransmitAsync(Commands.ReadPeriodPassCommand.AsBuffer())).ToArray();
storedValue = (await connection.TransmitAsync(Commands.ReadStoredValueCommand.AsBuffer())).ToArray();
eTicket = (await connection.TransmitAsync(Commands.ReadETicketCommand.AsBuffer())).ToArray();
hist1 = (await connection.TransmitAsync(Commands.ReadHistoryCommand.AsBuffer())).ToArray();
// If we have more history, the last two bytes of the history array will contain the MORE_DATA bytes.
if (hist1.Skip(Math.Max(0, hist1.Length - 2)).ToArray() == Commands.MoreDataResponse)
{
hist2 = (await connection.TransmitAsync(Commands.ReadNextCommand.AsBuffer())).ToArray();
}
// Combine the two history chunks into a single array, minus their last two MORE_DATA bytes
history = hist1.Take(hist1.Length - 2)
.Concat(hist2.Take(hist2.Length - 2)).ToArray();
return(TravelCard.CreateTravelCard(appInfo, controlInfo, periodPass, storedValue, eTicket, history));
}
else
{
return(null);
}
}
}
public void GetTripPathFast_EmptyList_Success()
{
//arrange
var cards = new TravelCard <string>[]
{
};
var expectedResult = new TravelCard <string>[]
{
};
//act
var result = cards.GetTripPathFast();
//assert
CollectionAssert.AreEqual(expectedResult, result);
}
/// <summary>
/// Setting rest of the cards in collection.
/// </summary>
/// <param name="cards">Cards collection</param>
public static void SetRestCards(TravelCard[] cards)
{
int last = 1;
for (int i = last; i < cards.Length; i++)
{
if (cards[i].CityFrom == cards[last - 1].CityTo)
{
TravelCard tmp = cards[last];
cards[last] = cards[i];
cards[i] = tmp;
i = last++;
}
}
if (last < cards.Length)
{
throw new InvalidOperationException("There is a gap in a cards list.");
}
}
private async Task ReadCard(SmartCard card)
{
try
{
TravelCard travelCard = await CardOperations.ReadTravelCardAsync(card);
StringBuilder builder = new StringBuilder();
BuildPropertyString(travelCard, 0, builder);
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
PropertiesTextBlock.Text = builder.ToString();
});
}
catch (Exception e)
{
Debug.WriteLine($"Oh noes: {e}");
}
}
static void Main(string[] args)
{
var someData = new List <TravelCard>()
{
new TravelCard("Питер", "Владивосток"),
new TravelCard("Казань", "Можайск"),
new TravelCard("Владивосток", "Тверь"),
new TravelCard("Сочи", "Анапа"),
new TravelCard("Тверь", "Сочи"),
new TravelCard("Москва", "Питер"),
new TravelCard("Калуга", "Казань"),
new TravelCard("Можайск", "Москва")
};
Console.WriteLine("Входные данные:");
Console.WriteLine(TravelCard.CollectionToString(someData));
var result = TravelCard.Sort(someData);
Console.WriteLine("Результат:");
Console.WriteLine(TravelCard.CollectionToString(result));
Console.ReadKey();
}
private async void Reader_CardAdded(SmartCardReader sender, CardAddedEventArgs args)
{
await SharedState.LogAsync($"BackgroundScanner ({_taskInstance.InstanceId}): CardAdded event fired.");
try
{
TravelCard card = await CardOperations.ReadTravelCardAsync(args.SmartCard);
if (card != null)
{
await SharedState.LogAsync($"BackgroundScanner ({_taskInstance.InstanceId}): Successful read card.");
Task updateCardTask = SharedState.SetAsync(SharedState.LastSeenCard, card.RawValues);
await SharedState.LogAsync($"BackgroundScanner ({_taskInstance.InstanceId}): LastSeenCard updated.");
Task updateTimestampTask = SharedState.SetAsync(SharedState.LastSeenTimestamp, DateTimeOffset.UtcNow);
await SharedState.LogAsync($"BackgroundScanner ({_taskInstance.InstanceId}): LastSeenTimestamp updated.");
if (await SharedState.GetAsync <bool>(SharedState.IsApplicationInForeground))
{
await SharedState.LogAsync($"BackgroundScanner ({_taskInstance.InstanceId}): Application is in the foreground. Changed Progress value.");
_taskInstance.Progress = 2;
}
else
{
await SharedState.LogAsync($"BackgroundScanner ({_taskInstance.InstanceId}): Application is in the background. Post toast notification.");
PostToastNotification(card);
}
}
}
catch (Exception ex)
{
await SharedState.LogAsync($"BackgroundScanner ({_taskInstance.InstanceId}): Failed to read travel card! Exception: {ex}\nStack trace: {ex.StackTrace}");
}
}
public TravelCard[] CreateCards(int count)
{
string appFolder = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
string cityList = Path.Combine(appFolder, "city_list.txt");
string[] cities = File.ReadAllLines(cityList);
TravelCard[] cards = new TravelCard[count];
Random rnd = new Random();
int[] rndValues = new int[count];
Func <int, int> rndCityIndex = (cityNo) => {
int rndValue = rnd.Next(cities.Length);
while (rndValues.Contains(rndValue))
{
rndValue = rnd.Next(cities.Length);
}
rndValues[cityNo] = rndValue;
return(rndValue);
};
var firstCity = cities[rndCityIndex(0)];
for (var i = 0; i < count; i++)
{
var nextCity = cities[rndCityIndex(i)];
if (i == 0)
{
cards[i] = new TravelCard(firstCity, nextCity);
continue;
}
cards[i] = new TravelCard(cards[i - 1].CityTo, nextCity);
}
return(cards);
}
/// <summary>
/// Searches for an entry point for cards collection. Places the match in a first position.
/// </summary>
/// <param name="cards">Cards collection</param>
/// <param name="cur">Current card to compare with</param>
public static void SetStartCard(TravelCard[] cards, int cur = 0)
{
if (cur >= cards.Length)
{
throw new InvalidOperationException("There is no entry point in cards collection");
}
for (int i = 0; i < cards.Length; i++)
{
if (i == cur)
{
continue;
}
if (cards[cur].CityFrom == cards[i].CityTo)
{
SetStartCard(cards, cur + 1);
return;
}
}
TravelCard tmp = cards[0];
cards[0] = cards[cur];
cards[cur] = tmp;
}
public void setUp()
{
this.testCard = new TravelCard();
}
public void Add(TravelCard item)
{
_data.Add(item);
}
/// <summary>
/// .ctor
/// </summary>
public TravelFragment(TravelCard firstCard)
{
Add(firstCard);
}
public static async Task <TravelCard> ReadTravelCard(ISmartCard card)
{
using (ISmartCardConnection connection = await card.Connect())
{
try
{
byte[] selection = await connection.Transcieve(Commands.SelectHslCommand);
if (selection != null &&
selection.Length > 0 &&
selection.SequenceEqual(Commands.OkResponse))
{
// Travel card info bytes
byte[] appInfo = null;
byte[] controlInfo = null;
byte[] periodPass = null;
byte[] storedValue = null;
byte[] eTicket = null;
byte[] history = null;
// Temporary containers for history chunks
byte[] hist1 = new byte[2];
byte[] hist2 = new byte[2];
appInfo = await connection.Transcieve(Commands.ReadAppInfoCommand);
controlInfo = await connection.Transcieve(Commands.ReadControlInfoCommand);
periodPass = await connection.Transcieve(Commands.ReadPeriodPassCommand);
storedValue = await connection.Transcieve(Commands.ReadStoredValueCommand);
eTicket = await connection.Transcieve(Commands.ReadETicketCommand);
hist1 = await connection.Transcieve(Commands.ReadHistoryCommand);
// If we have more history, the last two bytes of the history array will contain the MORE_DATA bytes.
if (hist1.Skip(Math.Max(0, hist1.Length - 2)).ToArray() == Commands.MoreDataResponse)
{
hist2 = await connection.Transcieve(Commands.ReadNextCommand);
}
// Combine the two history chunks into a single array, minus their last two MORE_DATA bytes
history = hist1.Take(hist1.Length - 2)
.Concat(hist2.Take(hist2.Length - 2))
.ToArray();
return(TravelCard.CreateTravelCard(appInfo, controlInfo, periodPass, storedValue, eTicket, history));
}
else
{
Debug.WriteLine($"Failed to read travel card. Did not received OK_RESPONSE when trying to select the HSL application.");
return(null);
}
}
catch (Exception ex)
{
Debug.WriteLine($"Failed to read card. Exception: {ex}");
return(null);
}
}
}
public void TestLink()
{
var source = new List <TravelCard>()
{
new TravelCard()
{
From = "c0", To = "c1"
},
new TravelCard()
{
From = "c1", To = "c2"
},
new TravelCard()
{
From = "c5", To = "c6"
},
new TravelCard()
{
From = "c2", To = "c3"
},
new TravelCard()
{
From = "c6", To = "c7"
},
new TravelCard()
{
From = "c3", To = "c4"
},
new TravelCard()
{
From = "c4", To = "c5"
},
new TravelCard()
{
From = "c8", To = "c9"
},
new TravelCard()
{
From = "c7", To = "c8"
}
};
//выполняем сортировку (тест)
var result = TravelCard.Sort(source);
//проверяем коректность "ссылок"
//for (int i = 1; i < result.Count - 1; ++i)
//{
// Assert.IsTrue(result[i].To.Equals(result[i + 1].From));
// Assert.IsTrue(result[i].From.Equals(result[i - 1].To));
//}
var sorted = new List <TravelCard>()
{
new TravelCard()
{
From = "c0", To = "c1"
},
new TravelCard()
{
From = "c1", To = "c2"
},
new TravelCard()
{
From = "c2", To = "c3"
},
new TravelCard()
{
From = "c3", To = "c4"
},
new TravelCard()
{
From = "c4", To = "c5"
},
new TravelCard()
{
From = "c5", To = "c6"
},
new TravelCard()
{
From = "c6", To = "c7"
},
new TravelCard()
{
From = "c7", To = "c8"
},
new TravelCard()
{
From = "c8", To = "c9"
},
};
Assert.IsTrue(sorted.Count == result.Count);
for (int i = 0; i < sorted.Count; ++i)
{
Assert.IsTrue(sorted[i].From.Equals(result[i].From));
Assert.IsTrue(sorted[i].To.Equals(result[i].To));
}
}
public bool IsMatch(TravelCard ticket) => ticket.MyDistanceFromSource > Distance;
