static SetDefinitions()
{
var config = new CsvConfiguration()
{
Encoding = Encoding.UTF8,
HasHeaderRecord = false,
CultureInfo = CultureInfo.InvariantCulture,
};
BlockDefinition = new Dictionary <string, MagicSetDefinition>();
using (var inputCsv = new CsvReader(new StringReader(definitionCsv), config))
{
while (inputCsv.Read())
{
var setDefinition = new MagicSetDefinition
{
Code = inputCsv.GetField <string>(1).Trim(),
CodeMagicCardsInfo = inputCsv.GetField <string>(2).Trim(),
Name = inputCsv.GetField <string>(3).Trim(),
Block = inputCsv.GetField <string>(4).Trim(),
ReleaseDate = inputCsv.GetField <string>(5).Trim(),
IsPromoEdition = inputCsv.GetField <bool>(6),
};
BlockDefinition.Add(inputCsv.GetField <string>(0).Trim(), setDefinition);
}
}
}
public BinderStatisticsPerSet(
MagicSetDefinition setDefinition,
IEnumerable <MagicBinderCardViewModel> cardsOfSet)
{
SetDefinition = setDefinition;
_cardsOfSet = cardsOfSet;
foreach (var card in _cardsOfSet)
{
NumberOfCards += card.Quantity;
switch (card.Definition.Rarity)
{
case MagicRarity.Mythic:
Mythic += card.Quantity;
MythicValue += card.Quantity * (card.Price.HasValue ? card.Price : 0m).Value;
break;
case MagicRarity.Rare:
Rare += card.Quantity;
RareValue += card.Quantity * (card.Price.HasValue ? card.Price : 0m).Value;
break;
case MagicRarity.Uncommon:
Uncommon += card.Quantity;
UncommonValue += card.Quantity * (card.Price.HasValue ? card.Price : 0m).Value;
break;
case MagicRarity.Common:
Common += card.Quantity;
CommonValue += card.Quantity * (card.Price.HasValue ? card.Price : 0m).Value;
break;
}
}
}
public void DisplayOwnedCardsFromSet(MagicSetDefinition setDefinition)
{
var old = CardLookup.SearchAsYouType;
CardLookup.SearchAsYouType = false;
LookupSource = LookupSource.ActiveBinder;
CardLookup.Reset();
CardLookup.SearchSet = setDefinition;
CardLookup.SearchAsYouType = old;
LookupCards();
}
public IEnumerable <MagicBinderCardViewModel> ReadFileContent(string content)
{
var result = new List <MagicBinderCardViewModel>();
var groupedCards = StaticMagicData.CardDefinitions.GroupBy(d => d.SetCode).ToList();
MagicSetDefinition set = null;
MagicCardDefinition definition = null;
string lastSetCodeName;
using (var inputCsv = new CsvReader(new StringReader(content)))
{
while (inputCsv.Read())
{
var card = new MagicBinderCard()
{
Quantity = inputCsv.GetField <int>("Count"),
QuantityTrade = inputCsv.GetField <int>("Tradelist Count"),
Grade = inputCsv.GetField <string>("Condition").ToMagicGrade(),
IsFoil = inputCsv.GetField <string>("Foil") == "foil",
Language = inputCsv.GetField <string>("Language").ToMagicLanguage()
};
var cardNumber = inputCsv.GetField <string>("Card Number");
var cardName = inputCsv.GetField <string>("Name");
var setName = inputCsv.GetField <string>("Edition");
if (set == null || !set.Name.Equals(setName, StringComparison.InvariantCultureIgnoreCase))
{
if (!StaticMagicData.SetDefinitionsBySetName.TryGetValue(setName, out set))
{
// TODO: Handle error
_notificationCenter.FireNotification(LogLevel.Error, string.Format("Cannot find set for card {0} ({1})", cardName, setName));
continue;
}
}
var setCodeName = StaticMagicData.MakeNameSetCode(set.Code, cardName, cardNumber);
lastSetCodeName = setCodeName;
if (!StaticMagicData.CardDefinitionsByNameSetCode.TryGetValue(setCodeName, out definition))
{
_notificationCenter.FireNotification(LogLevel.Error, string.Format("Cannot find card {0} ({1})", cardName, setName));
continue;
}
result.Add(new MagicBinderCardViewModel(definition, card));
}
}
return(result);
}
public void Write(
string fileName,
IEnumerable <IMagicBinderCardViewModel> cards,
MagicLanguage language,
MagicGrade grade,
Func <IMagicBinderCardViewModel, int> quantitySelector)
{
var outputCsv = new CsvWriter(File.CreateText(fileName));
outputCsv.WriteField("Count");
outputCsv.WriteField("Name");
outputCsv.WriteField("Edition");
outputCsv.WriteField("Foil");
outputCsv.WriteField("Language");
outputCsv.WriteField("Condition");
outputCsv.WriteField("Comment");
outputCsv.NextRecord();
string lastSetCode = "";
MagicSetDefinition definition = null;
foreach (var card in cards)
{
if (lastSetCode != card.Definition.SetCode)
{
lastSetCode = card.Definition.SetCode;
definition = StaticMagicData.SetDefinitionsBySetCode[lastSetCode];
}
outputCsv.WriteField(quantitySelector(card));
outputCsv.WriteField(PatchCardName(card.NameEN), true);
outputCsv.WriteField(PatchSetName(definition.Name.Replace("Magic: The Gathering�Conspiracy", "Conspiracy")), true);
outputCsv.WriteField(card.IsFoil ? "foil" : null);
outputCsv.WriteField(card.Language.HasValue ? card.Language.Value.ToString() : language.ToString());
outputCsv.WriteField(card.Grade.HasValue ? card.Grade.Value.ToCsv() : grade.ToCsv());
outputCsv.WriteField(card.Comment);
outputCsv.NextRecord();
}
outputCsv.Dispose();
}
private static void MainOld(string[] args)
{
var exeFolder = PathHelper.ExeFolder;
MagicSetDefinition lastSet = null;
var relativeToSource = @"..\..\..\MyMagicCollection.Shared";
var exportFileName = Path.Combine(exeFolder, relativeToSource, "CSV", "MagicDatabase.csv");
if (File.Exists(exportFileName))
{
File.Delete(exportFileName);
}
var exportSetFileName = Path.Combine(exeFolder, relativeToSource, "CSV", "MagicDatabaseSets.csv");
if (File.Exists(exportSetFileName))
{
File.Delete(exportSetFileName);
}
int count = 0;
var inputFiles = Directory.EnumerateFiles(exeFolder, "set_*.csv", SearchOption.AllDirectories).ToList();
var textWriter = new StreamWriter(exportFileName);
var config = new CsvConfiguration()
{
Encoding = Encoding.UTF8,
HasHeaderRecord = true,
CultureInfo = CultureInfo.InvariantCulture,
};
// config.RegisterClassMap(new MagicCardDefinitionCsvMapper());
var availableSets = new Dictionary <string, MagicSetDefinition>();
var writer = new CsvWriter(textWriter, config);
writer.WriteHeader <MagicCardDefinition>();
var setWriter = new CsvWriter(new StreamWriter(exportSetFileName), config);
setWriter.WriteField <string>("Code");
setWriter.WriteField <string>("Name");
setWriter.WriteField <string>("CodeMagicCardsInfo");
setWriter.WriteField <string>("ReleaseDate");
setWriter.WriteField <string>("Block");
setWriter.WriteField <string>("IsPromoEdition");
setWriter.NextRecord();
var uniqueList = new Dictionary <string, string>();
// Write Tokens:
writer.WriteRecords(TokenDefinitions.TockenDefinition);
foreach (var inputCsvName in inputFiles)
{
Console.WriteLine("Reading file " + new FileInfo(inputCsvName).Name);
var inputCsv = new CsvReader(new StringReader(File.ReadAllText(inputCsvName)));
inputCsv.Configuration.Delimiter = "||";
while (inputCsv.Read())
{
count += 1;
var setCode = PatchSetCode(inputCsv.GetField <string>("set_code"));
var card = new MagicCardDefinition();
card.NameDE = inputCsv.GetField <string>("name_DE");
card.NameEN = inputCsv.GetField <string>("name");
card.CardId = inputCsv.GetField <string>("id");
card.CardType = inputCsv.GetField <string>("type");
card.MagicCardType = GetCardType(card.CardType);
card.NumberInSet = SafeGetInt(inputCsv, "number_int").ToString();
card.LegalityModern = ComputeLegality(inputCsv.GetField <string>("legality_Modern"));
card.LegalityStandard = ComputeLegality(inputCsv.GetField <string>("legality_Standard"));
card.LegalityLegacy = ComputeLegality(inputCsv.GetField <string>("legality_Legacy"));
card.LegalityVintage = ComputeLegality(inputCsv.GetField <string>("legality_Vintage"));
card.LegalityPauper = ComputeLegality(inputCsv.GetField <string>("legality_Pauper"));
card.LegalityCommander = ComputeLegality(inputCsv.GetField <string>("legality_Commander"));
card.LegalityFrenchCommander = ComputeLegality(inputCsv.GetField <string>("legality_French_Commander"));
card.Rarity = CardDatabaseHelper.ComputeRarity(inputCsv.GetField <string>("rarity"));
card.ManaCost = inputCsv.GetField <string>("manacost");
card.ConvertedManaCost = CardDatabaseHelper.ComputeConvertedManaCost(inputCsv.GetField <string>("converted_manacost"));
if (!IsSetIncluded(setCode))
{
continue;
}
// TODO: Add Patch for MKM Name (multiple versions, etc.)
string mkmName = null;
if (PatchCardDefinitions.PatchMkmCardDefinition.TryGetValue(card.CardId, out mkmName))
{
card.NameMkm = mkmName;
}
//else
//{
// card.NameMkm = card.NameEN;
//}
card.RulesText = inputCsv.GetField <string>("ability");
// .Replace("£", Environment.NewLine);
card.RulesTextDE = inputCsv.GetField <string>("ability_DE");
// .Replace("£", Environment.NewLine);
var setName = CardDatabaseHelper.PatchSetName(inputCsv.GetField <string>("set"));
if (!string.IsNullOrWhiteSpace(setName) && !availableSets.ContainsKey(setCode))
{
MagicSetDefinition blockData;
if (SetDefinitions.BlockDefinition.TryGetValue(setCode, out blockData))
{
availableSets.Add(setCode, blockData);
}
else
{
var definition = new MagicSetDefinition
{
Name = setName,
Code = setCode,
CodeMagicCardsInfo = PatchSetCodeMagicCardsInfo(setCode),
};
availableSets.Add(setCode, definition);
}
}
if (availableSets.TryGetValue(setCode, out lastSet))
{
card.SetCode = lastSet.Code;
}
else
{
card.SetCode = setCode;
}
var unique = StaticMagicData.MakeNameSetCode(setCode, card.NameEN, card.NumberInSet);
if (uniqueList.ContainsKey(unique))
{
// Ignore variants of
continue;
}
uniqueList.Add(unique, unique);
writer.WriteRecord(card);
Console.WriteLine(count + " Reading " + card.NameEN + "(" + card.SetCode + ")...");
}
inputCsv.Dispose();
}
// Write Sets
foreach (var set in availableSets.OrderBy(s => s.Key))
{
// setWriter.WriteRecord(set.Value);
setWriter.WriteField <string>(set.Value.Code);
setWriter.WriteField <string>(set.Value.Name);
setWriter.WriteField <string>(set.Value.CodeMagicCardsInfo);
setWriter.WriteField <string>(set.Value.ReleaseDate);
setWriter.WriteField <string>(set.Value.Block);
setWriter.WriteField <bool>(set.Value.IsPromoEdition);
setWriter.NextRecord();
}
writer.Dispose();
setWriter.Dispose();
}
private static void Main(string[] args)
{
var exeFolder = PathHelper.ExeFolder;
MagicSetDefinition lastSet = null;
var relativeToSource = @"..\..\..\MyMagicCollection.Shared";
var exportFileName = Path.Combine(exeFolder, relativeToSource, "CSV", "MagicDatabase.csv");
if (File.Exists(exportFileName))
{
File.Delete(exportFileName);
}
var exportSetFileName = Path.Combine(exeFolder, relativeToSource, "CSV", "MagicDatabaseSets.csv");
if (File.Exists(exportSetFileName))
{
File.Delete(exportSetFileName);
}
int count = 0;
var inputFiles = Directory.EnumerateFiles(exeFolder, "AllSets-x.json", SearchOption.AllDirectories).ToList();
var textWriter = new StreamWriter(exportFileName);
var config = new CsvConfiguration()
{
Encoding = Encoding.UTF8,
HasHeaderRecord = true,
CultureInfo = CultureInfo.InvariantCulture,
};
// config.RegisterClassMap(new MagicCardDefinitionCsvMapper());
var availableSets = new Dictionary <string, MagicSetDefinition>();
var availableCards = new List <MagicCardDefinition>();
var writer = new CsvWriter(textWriter, config);
writer.WriteHeader <MagicCardDefinition>();
var setWriter = new CsvWriter(new StreamWriter(exportSetFileName), config);
setWriter.WriteField <string>("Code");
setWriter.WriteField <string>("Name");
setWriter.WriteField <string>("CodeMagicCardsInfo");
setWriter.WriteField <string>("ReleaseDate");
setWriter.WriteField <string>("Block");
setWriter.WriteField <string>("IsPromoEdition");
setWriter.NextRecord();
var uniqueList = new Dictionary <string, string>();
foreach (var inputCsvName in inputFiles)
{
Console.WriteLine("Reading file " + new FileInfo(inputCsvName).Name);
var jsonContent = File.ReadAllText(inputCsvName);
var allCardsAndSets = JObject.Parse(jsonContent);
var numberOfCards = allCardsAndSets.Count;
foreach (var setAndCards in allCardsAndSets)
{
var casted = setAndCards.Value as JObject;
if (casted != null)
{
var block = casted.GetValue("block");
var mkmCode = casted.GetValue("magicCardsInfoCode");
var code = casted.GetValue("code").ToString();
var releaseDate = casted.GetValue("releaseDate");
var onlineOnly = casted.GetValue("onlineOnly");
if (onlineOnly != null)
// && onlineOnly.Value.ToString() == "true")
{
continue;
}
var setData = new MagicSetDefinition
{
Code = code,
CodeMagicCardsInfo = mkmCode != null?mkmCode.ToString() : code,
Name = CardDatabaseHelper.PatchSetName(casted.GetValue("name").ToString()),
Block = block != null?block.ToString() : null,
ReleaseDate = releaseDate != null?releaseDate.ToString() : null,
};
availableSets.Add(setData.Code, setData);
Console.WriteLine("Working set " + setData.Name + "...");
var cards = casted.GetValue("cards");
foreach (var card in cards.Cast <JObject>())
{
var cardName = card.GetValue("name").ToString().Trim();
var nameParts = card.GetValue("names");
if (nameParts != null)
{
cardName = string.Join(" // ", nameParts.Select(c => c.ToString()));
}
var multiverseId = card.GetValue("multiverseid");
if (multiverseId == null)
{
continue;
// multiverseId = setData.Code + "_" + cardName;
}
var rulesText = card.GetValue("originalText");
var manaCost = card.GetValue("manaCost");
var convertedManaCost = card.GetValue("cmc");
var rarity = card.GetValue("rarity");
var numberInSet = card.GetValue("number");
var cardLayout = card.GetValue("layout");
MagicCardType magicCardType = MagicCardType.Unknown;
var cardLayoutValue = cardLayout != null?cardLayout.ToString() : null;
if (cardLayoutValue == "token")
{
cardName += " Token";
magicCardType = MagicCardType.Token;
}
// TODO: Card Type
var cardDefinition = new MagicCardDefinition
{
CardId = multiverseId != null?multiverseId.ToString() : "",
NameEN = cardName,
CardType = card.GetValue("type").ToString(),
RulesText = rulesText != null?rulesText.ToString() : null,
ManaCost = manaCost != null?manaCost.ToString() : null,
ConvertedManaCost = convertedManaCost != null?CardDatabaseHelper.ComputeConvertedManaCost(convertedManaCost.ToString()) : (int?)null,
SetCode = setData.Code,
NumberInSet = numberInSet != null?numberInSet.ToString() : null,
Rarity = CardDatabaseHelper.ComputeRarity(rarity != null ? rarity.ToString() : null),
CardLayout = cardLayoutValue,
MagicCardType = magicCardType,
};
// Patch special names for MKM (land versions, etc.)
string mkmName = null;
if (PatchCardDefinitions.PatchMkmCardDefinition.TryGetValue(cardDefinition.CardId, out mkmName))
{
cardDefinition.NameMkm = mkmName.Trim();
}
else
{
cardDefinition.NameMkm = cardDefinition.NameEN;
}
var legalities = card.GetValue("legalities") as JObject;
if (legalities != null)
{
foreach (var legality in legalities.Cast <JProperty>().ToList())
{
var legalityName = legality.Name.ToLowerInvariant();
if (legalityName.EndsWith(" block"))
{
continue;
}
switch (legalityName)
{
case "modern":
cardDefinition.LegalityModern = true;
break;
case "standard":
cardDefinition.LegalityStandard = true;
break;
case "pauper":
cardDefinition.LegalityPauper = true;
break;
case "legacy":
cardDefinition.LegalityLegacy = true;
break;
case "commander":
cardDefinition.LegalityCommander = true;
break;
case "vintage":
cardDefinition.LegalityVintage = true;
break;
case "singleton 100":
case "freeform":
case "prismatic":
case "time spiral block":
case "tribal wars legacy":
// known but unsupported
break;
default:
break;
}
}
}
// Foreign languages
var languages = card.GetValue("foreignNames");
if (languages != null)
{
foreach (var language in languages.Cast <JObject>().ToList())
{
var languageName = language.GetValue("language").ToString().ToLowerInvariant();
switch (languageName)
{
case "german":
cardDefinition.NameDE = language.GetValue("name").ToString();
break;
default:
break;
}
}
}
availableCards.Add(cardDefinition);
//Console.WriteLine("Working card " + cardDefinition.NameEN + "...");
}
}
}
}
// Remove split card duplicates
CardDatabaseHelper.RemoveSplitCardDuplicates(availableCards);
// Add Tokens
availableCards.AddRange(TokenDefinitions.TockenDefinition);
// Find duplicates
var duplicates = availableCards.GroupBy(c => c.CardId).Where(g => g.Count() > 1).ToList();
foreach (var duplicate in duplicates)
{
Console.WriteLine("DUPLICATE CARD! " + duplicate.Count() + " " + duplicate.First().NameEN);
foreach (var item in duplicate)
{
item.CardId = item.CardId + "_" + item.NumberInSet;
}
}
duplicates = availableCards.GroupBy(c => c.CardId).Where(g => g.Count() > 1).ToList();
foreach (var duplicate in duplicates)
{
Console.WriteLine("DUPLICATE CARD AFTER FIX! " + duplicate.Count() + " " + duplicate.First().NameEN);
//foreach (var item in duplicate)
//{
// item.CardId = item.CardId + "_" + item.NumberInSet;
//}
}
// Add Version string to cards:
CardDatabaseHelper.PatchPotentialVersionCardData(availableCards);
// Write cards
writer.WriteRecords(availableCards.OrderBy(c => c.SetCode).ThenBy(c => c.NameEN).ToList());
// Write Sets
var cardsBySet = availableCards.GroupBy(c => c.SetCode).ToList();
foreach (var set in availableSets.OrderBy(s => s.Key))
{
if (!cardsBySet.Any(c => c.Key == set.Key))
{
continue;
}
// setWriter.WriteRecord(set.Value);
setWriter.WriteField <string>(set.Value.Code);
setWriter.WriteField <string>(set.Value.Name);
setWriter.WriteField <string>(set.Value.CodeMagicCardsInfo);
setWriter.WriteField <string>(set.Value.ReleaseDate);
setWriter.WriteField <string>(set.Value.Block);
setWriter.WriteField <bool>(set.Value.IsPromoEdition);
setWriter.NextRecord();
}
writer.Dispose();
setWriter.Dispose();
// Dump potential cards to be fixed:
var dump = CardDatabaseHelper.GetPotentialVersionCardData(availableCards);
Console.WriteLine(dump);
Debug.WriteLine(dump);
}
public static string MakeSetImageName(MagicSetDefinition definition, MagicRarity rarity)
{
var rarityCode = rarity.ToCode();
return(definition.Code + "_" + rarityCode + ".jpg");
}
