public CardViewModel(MagicCardDefinition card)
{
Name = card.NameEN;
CardId = card.CardId;
SetCode = card.SetCode;
// Set = card.Set;
IsFoil = false;
Price = null;
NumberInSet = card.NumberInSet;
}
private CollectionCardViewModel(
ICardDatabase cardDatabase,
MagicCollectionItem collectionItem)
{
_cardDatabase = cardDatabase;
_collectionItem = collectionItem;
// TODO: Das später async on request laden
_card = _cardDatabase.FindCardById(_collectionItem.CardId);
}
public string CreateCardIdPart(
MagicCardDefinition card,
char delimiter,
bool useMkmName,
bool useForLocalFileSystem)
{
var numberInSet = card.NumberInSet;
if (string.IsNullOrWhiteSpace(numberInSet))
{
numberInSet = card.CardId;
}
if (string.IsNullOrWhiteSpace(card.SetCode))
{
return("");
}
var cardName = card.NameEN;
if (useMkmName && !string.IsNullOrWhiteSpace(card.NameMkm))
{
cardName = card.NameMkm
.Replace("\\", "-")
.Replace(",", "-")
.Replace("(", "")
.Replace(")", "")
.Replace("/", "-")
.Replace("*", "X");
}
var setCode = StaticMagicData.SetDefinitionsBySetCode[card.SetCode].CodeMagicCardsInfo;
if (card.MagicCardType == MagicCardType.Token)
{
var setName = StaticMagicData.SetDefinitionsBySetCode[card.SetCode].Name
.ToLowerInvariant()
.Replace(" core set", "")
.Replace(" ", "-");
return(string.Format(
CultureInfo.InvariantCulture,
"{2}{0}{2}{1}.jpg",
setCode.ToLowerInvariant(),
cardName.ToLowerInvariant().Replace("Æ", "Ae"),
delimiter));
}
return(string.Format(
CultureInfo.InvariantCulture,
"{2}{0}{2}{1}.jpg",
setCode.ToLowerInvariant(),
numberInSet,
delimiter));
}
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);
}
static TokenDefinitions()
{
var config = new CsvConfiguration()
{
Encoding = Encoding.UTF8,
HasHeaderRecord = false,
CultureInfo = CultureInfo.InvariantCulture,
};
TockenDefinition = new List <MagicCardDefinition>();
var assembly = typeof(PatchCardDefinitions).Assembly;
var tokenDefinitions = assembly.FindAllEmbeddedResource("TokenDefinitions");
foreach (var patchFile in tokenDefinitions)
{
using (var stream = assembly.GetManifestResourceStream(patchFile))
{
using (var inputCsv = new CsvReader(new StreamReader(stream), config))
{
while (inputCsv.Read())
{
var setCode = inputCsv.GetField <string>(0).Trim();
if (setCode == "COMMENT")
{
continue;
}
var cardDefinition = new MagicCardDefinition()
{
SetCode = setCode,
NumberInSet = inputCsv.GetField <string>(1),
NameEN = inputCsv.GetField <string>(2).Trim(),
NameDE = inputCsv.GetField <string>(3).Trim(),
NameMkm = inputCsv.GetField <string>(4).Trim(),
MagicCardType = MagicCardType.Token,
};
cardDefinition.CardId = string.Format(
CultureInfo.InvariantCulture,
"{0}_TOKEN_{1}",
cardDefinition.SetCode,
cardDefinition.NumberInSet);
TockenDefinition.Add(cardDefinition);
}
}
}
}
}
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();
}
public string DownloadImage(MagicCardDefinition card, MagicCardPrice cardPrice)
{
if (card == null)
{
return(null);
}
if (cardPrice == null)
{
cardPrice = StaticPriceDatabase.FindPrice(card, false, false, "CardImage download", false);
}
// Add default image path if needed
cardPrice.BuildDefaultMkmImagePath(card);
FileInfo localStorage = null;
string fullUrl = null;
try
{
var cache = PathHelper.CardImageCacheFolder;
localStorage = new FileInfo(Path.Combine(cache, CreateCardIdPart(card, '\\', true, true).TrimStart('\\')));
if (localStorage.Exists)
{
return(localStorage.FullName);
}
var url = CreateCardIdPart(card, '/', false, false);
if (url == null)
{
return(null);
}
var stopwatch = Stopwatch.StartNew();
if (!localStorage.Directory.Exists)
{
localStorage.Directory.Create();
}
using (var client = new WebClient())
{
var rootUrl = card.MagicCardType != MagicCardType.Token
? "http://magiccards.info/scans/en"
: "http://magiccards.info/extras/token";
fullUrl = !string.IsNullOrWhiteSpace(cardPrice.ImagePath)
? "http://www.magickartenmarkt.de/" + cardPrice.ImagePath
: rootUrl + url;
client.DownloadFile(new Uri(fullUrl), localStorage.FullName);
}
stopwatch.Stop();
_notificationCenter.FireNotification(
LogLevel.Debug,
string.Format("Downloaded image for '{0}[{1}]' in {2}", card.NameEN, card.SetCode, stopwatch.Elapsed));
}
catch (Exception error)
{
_notificationCenter.FireNotification(
LogLevel.Debug,
string.Format("Error downloading image for '{0}[{1}]': {2} ({3})", card.NameEN, card.SetCode, error.Message, fullUrl));
return(null);
}
return(localStorage.FullName);
}
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);
}
