using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Net;
using System.Reflection;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using System.Xml;
namespace AnimeListenUpdater
{
#region Exceptions
class BusinessException : Exception
{
public BusinessException(string message)
: base(message)
{ }
}
class MediawikiException : BusinessException
{
public string Code { get; }
public MediawikiException(string message)
: base(message)
{ }
public MediawikiException(string code, string info)
: base("Mediawiki error \"" + code + ": " + info + "\"")
{
Code = code;
}
}
class MediawikiLagException : MediawikiException
{
public int LagTime { get; private set; }
public MediawikiLagException(string code, string info)
: base("Mediawiki error \"" + code + ": " + info + "\"")
{
LagTime = GetLagTime(info);
}
public static int GetLagTime(string info)
{
int lagtime = -1;
Match match = Regex.Match(info, "Waiting for [^ ]*: ([0-9.-]+) seconds lagged");
if (match.Success) int.TryParse(match.Groups[1].Value, out lagtime);
return lagtime;
}
}
#endregion
public class Mediawiki
{
#region Netzwerk- und Mediawiki-Funktionen
static CookieContainer cookieContainer = new CookieContainer();
static readonly string userAgentString = GetUserAgentString();
static string GetUserAgentString()
{
AssemblyName assemblyName = Assembly.GetExecutingAssembly().GetName();
// Programmname und -version
string userAgent = assemblyName.Name + "/" + assemblyName.Version.Major + "." + assemblyName.Version.Minor;
// Umgebungsinformationen (OS, Laufzeitumgebung)
userAgent += " (" + Environment.OSVersion.VersionString + "; .NET CLR " + Environment.Version + ")";
return userAgent;
}
private static string EncodeQuery(string[,] query)
{
string result = "";
for (int i = 0; i < query.GetLength(0); i++)
{
result += "&" + query[i, 0];
string value = query[i, 1];
if (value != null) result += "=" + Uri.EscapeDataString(value);
}
return result;
}
private static string MultipartQuery(string[,] postData, string boundaryIdentifier)
{
StringBuilder sb = new StringBuilder();
for (int i = 0; i < postData.GetLength(0); i++)
{
sb.Append("--");
sb.Append(boundaryIdentifier);
sb.Append("\r\nContent-Disposition: form-data; name=\"");
sb.Append(postData[i, 0]);
sb.Append("\"\r\nContent-Type: text/plain; charset=UTF-8\r\nContent-Transfer-Encoding: 8bit\r\n\r\n");
sb.Append(postData[i, 1]);
sb.Append("\r\n");
}
return sb.ToString();
}
static HttpWebRequest GenerateHttpWebRequest(string language, string[,] query)
{
string url = "https://";
if (language == "wikidata") url += "www.wikidata.org"; else url += language + ".wikipedia.org";
url += "/w/api.php?format=xml";
url += EncodeQuery(query);
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url);
request.UserAgent = userAgentString;
request.CookieContainer = cookieContainer;
request.AutomaticDecompression = DecompressionMethods.GZip;
request.KeepAlive = true;
return request;
}
public static HttpWebResponse HttpGet(string language, string[,] query)
{
HttpWebRequest request = GenerateHttpWebRequest(language, query);
return (HttpWebResponse)request.GetResponse();
}
public static HttpWebResponse HttpPost(string language, string[,] query, string[,] postData)
{
HttpWebRequest request = GenerateHttpWebRequest(language, query);
request.Method = "POST";
if (postData != null)
{
string boundary = Guid.NewGuid().ToString();
byte[] postContent = new UTF8Encoding(false).GetBytes(MultipartQuery(postData, boundary));
request.ContentType = "multipart/form-data; boundary=" + boundary;
using (Stream stream = request.GetRequestStream())
{
stream.Write(postContent, 0, postContent.Length);
}
}
return (HttpWebResponse)request.GetResponse();
}
public static void TraverseHttpWebResponse(HttpWebResponse response, Action<XmlReader> onXmlNode)
{
using (response)
using (Stream stream = response.GetResponseStream())
using (XmlReader reader = XmlReader.Create(stream))
{
if (!reader.ReadToFollowing("api")) throw new MediawikiException("Malformed response");
while (reader.Read())
{
CheckForError(reader);
onXmlNode(reader);
}
}
}
public static string CalcMd5Hash(byte[] data)
{
System.Security.Cryptography.MD5 md5 = new System.Security.Cryptography.MD5CryptoServiceProvider();
byte[] md5Hash = md5.ComputeHash(data);
return BitConverter.ToString(md5Hash).Replace("-", "").ToLowerInvariant();
}
public static void CheckForError(XmlReader reader)
{
if (reader.NodeType == XmlNodeType.Element)
{
if (reader.LocalName == "warnings") Debug.WriteLine(" warning: " + reader.ReadInnerXml());
else if (reader.LocalName == "error")
{
string code = reader.GetAttribute("code");
string info = reader.GetAttribute("info");
Debug.WriteLine(" error \"" + code + "\": " + info);
if (code == "maxlag")
throw new MediawikiLagException(code, info);
else
throw new MediawikiException(code, info);
}
}
}
public enum TokenType { Csrf, Watch, Patrol, Rollback, UserRights, Login, CreateAccount }
public static string GetToken(string lang, TokenType tokenType)
{
string tokenName = tokenType.ToString().ToLowerInvariant();
string[,] paramList = new[,] {
{ "action", "query" },
{ "meta", "tokens" },
{ "type", tokenName }
};
string token = null;
TraverseHttpWebResponse(HttpPost(lang, paramList, null), reader =>
{
if ((reader.NodeType == XmlNodeType.Element) && (reader.LocalName == "tokens"))
{
token = reader.GetAttribute(tokenName + "token");
}
});
return token;
}
public static void Login(string lang, NetworkCredential credentials)
{
string[,] paramList = new[,]
{
{ "action", "login" },
{ "lgname", credentials.UserName },
{ "lgpassword", credentials.Password },
{ "lgtoken", GetToken(lang, TokenType.Login) }
};
TraverseHttpWebResponse(HttpPost(lang, paramList, null), reader =>
{
if ((reader.NodeType == XmlNodeType.Element) && (reader.LocalName == "login"))
{
string result = reader.GetAttribute("result");
if (result != "Success")
{
if (result == "Throttled") result += $" (Please wait {reader.GetAttribute("wait")}s)";
throw new MediawikiException(result);
}
}
});
}
public static void Logout(string lang)
{
using (HttpWebResponse response = HttpGet(lang, new[,] { { "action", "logout" } })) { }
}
#endregion
}
public class Program
{
static Mediawiki wiki;
static string editToken = null;
public class AnimeItem
{
public string List;
public int Level;
public int Year;
public string Type;
public string EpisodeCount;
public string Title;
public string Link;
public string JapaneseTitle;
public string JapaneseTranscription;
public List<string> AlternativeTitles;
public List<string> Studios;
public static AnimeItem Parse(Dictionary<string, string> parsedTemplate, string list)
{
AnimeItem result = new AnimeItem();
try
{
result.List = list;
result.Level = int.Parse(parsedTemplate["1"]);
result.Year = int.Parse(parsedTemplate["2"]);
result.Type = parsedTemplate["3"].Trim();
result.EpisodeCount = parsedTemplate["4"].Trim();
result.Title = parsedTemplate["5"].Trim();
if (parsedTemplate.TryGetValue("link", out result.Link)) result.Link = result.Link.Trim();
if (parsedTemplate.ContainsKey("j")) result.JapaneseTitle = parsedTemplate["j"].Trim(); else result.JapaneseTitle = "";
if (parsedTemplate.ContainsKey("jt")) result.JapaneseTranscription = parsedTemplate["jt"].Trim(); else result.JapaneseTranscription = "";
result.AlternativeTitles = new List<string>();
result.Studios = new List<string>();
for (int i = 1; i <= 10; i++)
{
string paramName = "a" + i;
if (parsedTemplate.ContainsKey(paramName)) result.AlternativeTitles.Add(parsedTemplate[paramName].Trim());
paramName = "s" + i;
if (parsedTemplate.ContainsKey(paramName)) result.Studios.Add(parsedTemplate[paramName].Trim());
}
return result;
}
catch (KeyNotFoundException) { return null; }
catch (FormatException) { return null; }
}
public string GetWikilink()
{
string result = "[[";
if (!string.IsNullOrEmpty(Link)) result += Link + "|";
result += Title + "]]";
return result;
}
public static string GetWikiArticle(string wikilink)
{
if (string.IsNullOrEmpty(wikilink)) return "";
else
{
// entferne Wikilinkklammern und splitte an der ersten Pipe
string link = wikilink.TrimStart('[').TrimEnd(']').Split(new char[] { '|' }, 2)[0];
// erstes Element (Zielartikel) mit Großbuchstaben beginnen lassen und zurückgeben
link = Char.ToUpperInvariant(link[0]) + link.Substring(1);
return link;
}
}
public string GetYearListEntry()
{
StringBuilder sb = new StringBuilder();
sb.Append("{{Anime-Listeneintrag|");
sb.Append(0);
sb.Append("|");
sb.Append(Year);
sb.Append("|");
sb.Append(Type);
sb.Append("|");
sb.Append(EpisodeCount);
sb.Append("|");
sb.Append(Title);
if (!string.IsNullOrEmpty(Link))
{
sb.Append("|link=");
sb.Append(Link);
}
if (!string.IsNullOrEmpty(JapaneseTitle))
{
sb.Append("|j=");
sb.Append(JapaneseTitle);
}
if (!string.IsNullOrEmpty(JapaneseTranscription))
{
sb.Append("|jt=");
sb.Append(JapaneseTranscription);
}
for (int aIdx = 0; aIdx < AlternativeTitles.Count; aIdx++)
{
sb.Append("|a");
sb.Append(aIdx + 1);
sb.Append("=");
sb.Append(AlternativeTitles[aIdx]);
}
for (int sIdx = 0; sIdx < Studios.Count; sIdx++)
{
sb.Append("|s");
sb.Append(sIdx + 1);
sb.Append("=");
sb.Append(Studios[sIdx]);
}
sb.Append("|mark=year}}");
return sb.ToString();
}
public override string ToString()
{
return Title;
}
}
#region Konfiguration
static UnicodeCategory[] validCharTypes = new UnicodeCategory[] {
UnicodeCategory.UppercaseLetter, UnicodeCategory.LowercaseLetter, UnicodeCategory.TitlecaseLetter, UnicodeCategory.ModifierLetter, UnicodeCategory.OtherLetter,
UnicodeCategory.DecimalDigitNumber, UnicodeCategory.LetterNumber, UnicodeCategory.OtherNumber, UnicodeCategory.SpaceSeparator };
static string[] alphaList = new string[] { "0–9", "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z" };
static List<int> yearList = new List<int> { 1900, 1945, 1946, 1962, 1963, 1969, 1970, 1979, 1980, 1984, 1985, 1989, 1990, 1994, 1995, 1997, 1998, 1999 }; // ab 2000 wird automatisch generiert
static Dictionary<string, string> animeTypes = new Dictionary<string, string> {
{ "F", "Film" },
{ "S", "Fernsehserie" },
{ "W", "Web-Anime" },
{ "O", "OVA" },
{ "SP", "Special" },
{ "K", "Kurzfilm" }
};
#endregion
static Dictionary<string, string> ParseTemplate(string template)
{
Dictionary<string, string> result = new Dictionary<string, string>();
int startPos = template.IndexOf("{{");
int lastPos = template.LastIndexOf("}}");
if (startPos >= 0 && lastPos >= 0)
{
string[] split = template.Substring(startPos + 2, lastPos - startPos - 2).Split('|');
List<string> parameters = new List<string>();
// Wikilinks wieder zusammenführen, d.h. "[[A", "B]]" zu "[[A|B]]".
int doubleBracketCount = 0;
for (int i = 0; i < split.Length; i++)
{
if (doubleBracketCount == 0) parameters.Add(split[i]); else parameters[parameters.Count - 1] += "|" + split[i];
int curIdx = 0;
while (curIdx >= 0)
{
curIdx = split[i].IndexOf("[[", curIdx);
if (curIdx >= 0)
{
doubleBracketCount++;
curIdx += 2;
}
}
curIdx = 0;
while (curIdx >= 0)
{
curIdx = split[i].IndexOf("]]", curIdx);
if (curIdx >= 0)
{
doubleBracketCount--;
curIdx += 2;
}
}
}
for (int paramIdx = 0; paramIdx < parameters.Count; paramIdx++)
{
string[] keyValue = parameters[paramIdx].Split(new char[] { '=' }, 2);
try
{
if (keyValue.Length == 2) result.Add(keyValue[0], keyValue[1]); else result.Add(paramIdx.ToString(), parameters[paramIdx]);
}
catch (ArgumentException)
{
Console.Error.WriteLine("Doppelte Parameter: " + template);
}
}
}
return result;
}
// zur Sortierung alle Zeichen außer Buchstaben, Zahlen und Leerzeichen entfernen und Buchstaben in Kleinschreibung umwandeln
static string RemoveDiacriticsAndSpecialChars(string text)
{
if (text.StartsWith("The ") || text.StartsWith("Der ") || text.StartsWith("Die ") || text.StartsWith("Das ")) text = text.Substring(4);
return string.Concat(text.Normalize(NormalizationForm.FormKD).Where(ch => validCharTypes.Contains(CharUnicodeInfo.GetUnicodeCategory(ch)))).Normalize(NormalizationForm.FormKC).ToLowerInvariant();
}
static void WriteContent(string pagetitle, string content, string basetimestamp = null)
{
if (editToken == null) editToken = Mediawiki.GetToken("de", Mediawiki.TokenType.Csrf);
bool badToken;
do
{
badToken = false;
try
{
Console.Write("Schreibe " + pagetitle);
string md5Hash = Mediawiki.CalcMd5Hash(new UTF8Encoding(false).GetBytes(content));
var post = new string[3 + (basetimestamp != null ? 1 : 0), 2];
post[0, 0] = "token";
post[0, 1] = editToken;
post[1, 0] = "text";
post[1, 1] = content;
post[2, 0] = "md5";
post[2, 1] = md5Hash;
if (basetimestamp != null)
{
post[3, 0] = "basetimestamp";
post[3, 1] = basetimestamp;
}
using (HttpWebResponse response = Mediawiki.HttpPost("de", new[,] {
{ "assert", "user" },
{ "action", "edit" },
{ "title", pagetitle },
{ "notminor", null },
{ "summary", "Listen-Aktualisierung per [[Benutzer:Mps/AnimeListenUpdater.cs]]" } },
post))
using (Stream stream = response.GetResponseStream())
using (XmlReader reader = XmlReader.Create(stream))
{
while (reader.Read()) Mediawiki.CheckForError(reader);
}
Console.WriteLine(".");
}
catch (MediawikiException mwe)
{
Console.Error.WriteLine("\n" + pagetitle + ": " + mwe.Message);
if (mwe.Code == "badtoken")
{
// Die API wirft manchmal "badtoken", daher einfach Edit nochmal probieren.
Console.Error.WriteLine(" Neuer Versuch.");
badToken = true;
}
}
} while (badToken);
}
static bool BuildAnimeYearList(List<AnimeItem> animeList, int startYear, int endYear, TextWriter writer)
{
writer.WriteLine("__ABSCHNITTE_NICHT_BEARBEITEN__ __KEIN_INHALTSVERZEICHNIS__");
writer.WriteLine("Dies ist eine '''chronologisch sortierte Liste der Anime-Titel''' von " + startYear + " bis " + endYear + ".");
writer.WriteLine("<!--");
writer.WriteLine("##########");
writer.WriteLine("Bitte editiere diese Liste _nicht_, da sie von einem Bot automatisch generiert wird, der durchgeführte Änderungen überschreibt. Stattdessen können und sollten die alphabetisch sortierten Listen der Liste der Anime-Titel http://de.wikipedia.org/wiki/Liste_der_Anime-Titel bearbeitet werden, aus denen diese Liste generiert wird.");
writer.WriteLine("##########");
writer.WriteLine("-->");
writer.WriteLine("{{Navigationsleiste Liste der Anime-Titel}}");
writer.WriteLine();
bool hasAtLeastOneYear = false;
for (int year = startYear; year <= endYear; year++)
{
IEnumerable<AnimeItem> animesInYear = from anime in animeList
where anime.Year == year
orderby RemoveDiacriticsAndSpecialChars(anime.Title)
select anime;
if (animesInYear.Any())
{
hasAtLeastOneYear = true;
writer.WriteLine("== " + year + " ==");
writer.WriteLine("{{Anime-Listenkopf|");
foreach (AnimeItem anime in animesInYear)
{
writer.WriteLine(anime.GetYearListEntry());
}
writer.WriteLine("|mark=year}}");
writer.WriteLine();
}
}
writer.WriteLine("[[Kategorie:Liste (Anime)|#" + startYear + "]]");
return hasAtLeastOneYear;
}
static bool BuildAnimeStudioList(List<AnimeItem> animeList, TextWriter writer)
{
IEnumerable<string> linkedStudios = animeList.SelectMany(anime => anime.Studios) // Studiolisten zusammenführen
.Where(studio => studio.StartsWith("[[")) // nach verlinkten Studios filtern
.Select(studio => AnimeItem.GetWikiArticle(studio)) // Linkklammern entfernen, nach Pipe separieren und nur erstes Element (Linkziel) zurückgeben
.Distinct() // doppelte Einträge entfernen
.OrderBy(name => RemoveDiacriticsAndSpecialChars(name)); // sortieren
foreach (string curStudio in linkedStudios)
{
writer.WriteLine("{{#ifeq: {{{1}}}|" + curStudio + "|");
Dictionary<string, List<AnimeItem>> animesOfStudio = animeList
.Where(anime => anime.Studios.Any(studio => AnimeItem.GetWikiArticle(studio) == curStudio)) // nach Anime die vom aktuellen Studio gefertigt wurden filtern
.OrderBy(anime => anime.Year + RemoveDiacriticsAndSpecialChars(anime.Title)) // nach Jahr und Titel sortieren
.GroupBy(anime => anime.Type) // nach Typ gruppieren
.ToDictionary(group => group.Key, group => group.ToList()); // in assoziative Liste überführen
// Generierungsregeln:
// ab 10 Einträge pro Typ: eigene Gruppe (Reihenfolge: Fernsehserien, Filme, Original Video Animations, Specials, Kurzfilme, Weitere Anime-Produktionen)
// ab 10 Einträge pro Gruppe: zwei Spalten, wobei bei ungerader Anzahl die erste Spalte länger ist
bool hasCaptions = false;
foreach (string animeType in animeTypes.Keys)
{
#region wenn ein Studio mehr als 10 Animes eines Typs produziert hat, diese separat aufführen
if (animesOfStudio.ContainsKey(animeType) && animesOfStudio[animeType].Count >= 10)
{
hasCaptions = true;
switch (animeType)
{
case "S":
writer.WriteLine("=== Fernsehserien ===");
break;
case "F":
writer.WriteLine("=== Filme ===");
break;
case "W":
writer.WriteLine("=== Web-Animes ===");
break;
case "O":
writer.WriteLine("=== Original Video Animations ===");
break;
case "SP":
writer.WriteLine("=== Specials ===");
break;
case "K":
writer.WriteLine("=== Kurzfilme ===");
break;
}
writer.WriteLine("<div style=\"{{Spaltenbreite}}\">");
foreach (AnimeItem anime in animesOfStudio[animeType])
{
writer.WriteLine("* " + anime.Year + ": ''" + anime.GetWikilink() + "''");
}
writer.WriteLine("</div>");
animesOfStudio.Remove(animeType);
}
#endregion
}
IEnumerable<AnimeItem> otherAnimes = animesOfStudio
.SelectMany(kvp => kvp.Value)
.OrderBy(anime => anime.Year + RemoveDiacriticsAndSpecialChars(anime.Title));
if (otherAnimes.Any())
{
if (hasCaptions) writer.WriteLine("=== Weitere Anime-Produktionen ===");
int newColIdx = (int)Math.Ceiling(otherAnimes.Count() / 2.0);
if (hasCaptions || newColIdx >= 5)
{
writer.WriteLine("{{(!}} class=\"toptextcells\"");
writer.WriteLine("{{!}}");
}
writer.WriteLine("<div style=\"{{Spaltenbreite}}\">");
foreach (AnimeItem anime in otherAnimes)
{
string desc;
if (animeTypes.ContainsKey(anime.Type)) desc = " (" + animeTypes[anime.Type] + ")"; else desc = "";
writer.WriteLine("* " + anime.Year + ": ''" + anime.GetWikilink() + "''" + desc);
}
writer.Write("</div>");
}
writer.Write("}}");
}
writer.Write("<div class=\"noprint\" style=\"padding-left:1em;\"><small>''Diese Liste wird aus den Einträgen der [[Liste der Anime-Titel]] generiert. Einträge können und sollten dort ergänzt werden.</small></div>");
writer.Write("<noinclude>[[Kategorie:Vorlage:Film und Fernsehen]]</noinclude>");
return true;
}
static bool BuildMaintainenceInfo(List<AnimeItem> animeList, TextWriter writer)
{
var allStudios = animeList.SelectMany(anime => anime.Studios, (anime, studio) => new { Name = studio, List = anime.List });
var linkedStudios = allStudios
.Where(studio => studio.Name.StartsWith("[["))
.Select(studio => new { Name = AnimeItem.GetWikiArticle(studio.Name), List = studio.List })
.GroupBy(studio => studio.Name)
.Select(studio => new { Name = studio.Key, Count = studio.Count(), Lists = studio.Select(list => list.List).Distinct().OrderBy(list => list) })
.OrderBy(studio => studio.Name);
var unlinkedStudios = allStudios
.Where(studio => !studio.Name.StartsWith("[["))
.Select(studio => new { Name = studio.Name, List = studio.List })
.GroupBy(studio => studio.Name)
.Select(studio => new { Name = studio.Key, Count = studio.Count(), Lists = studio.Select(list => list.List).Distinct().OrderBy(list => list) });
writer.WriteLine("== Nur teilweise verlinkte Studios ==");
writer.WriteLine("{| class=\"wikitable sortable\"");
writer.WriteLine("! Studio || Auftreten || Listen");
foreach (var linkedStudio in linkedStudios)
{
var match = unlinkedStudios.FirstOrDefault(unlinkedStudio => unlinkedStudio.Name == linkedStudio.Name);
if (match != null)
{
writer.WriteLine("|-\n| {0} || {1} || {2}", linkedStudio.Name, match.Count, string.Join(", ", match.Lists.Select(list => "[[Liste der Anime-Titel/" + list + "|" + list + "]]")));
}
}
writer.WriteLine("|}\n");
writer.WriteLine("== Potentiell verlinkbare Studios ==");
writer.WriteLine("{| class=\"wikitable sortable\"");
writer.WriteLine("! Studio || Anzahl || Listen");
foreach (var unlinkedStudio in unlinkedStudios)
{
if (!string.IsNullOrEmpty(unlinkedStudio.Name) && unlinkedStudio.Count > 5 && linkedStudios.All(linkedStudio => linkedStudio.Name != unlinkedStudio.Name))
{
writer.WriteLine("|-\n| {0} || {1} || {2}", unlinkedStudio.Name, unlinkedStudio.Count, string.Join(", ", unlinkedStudio.Lists.Select(list => "[[Liste der Anime-Titel/" + list + "|" + list + "]]")));
}
}
writer.WriteLine("|}\n");
Dictionary<string, List<string>> combinedStudioList = allStudios
.Where(studio => !string.IsNullOrEmpty(studio.Name))
.Select(studio => new { Name = AnimeItem.GetWikiArticle(studio.Name), List = studio.List })
.GroupBy(studio => studio.Name)
.OrderBy(studio => studio.Key)
.ToDictionary(group => group.Key, group => group.Select(studio => studio.List).Distinct().ToList());
writer.WriteLine("== Ähnliche Studionamen ==");
writer.WriteLine("{| class=\"wikitable sortable\"");
writer.WriteLine("! Studio || Ähnliche Namen || Listen");
string[] allStudiosArray = combinedStudioList.Keys.ToArray();
for (int i = 0; i < allStudiosArray.Length; i++)
{
string targetStudio = allStudiosArray[i];
Dictionary<string, int> similarStudios = new Dictionary<string, int>();
for (int j = 0/*i + 1*/; j < allStudiosArray.Length; j++)
{
if (i == j) continue;
string otherStudio = allStudiosArray[j];
int dist = LevenshteinDistance(RemoveDiacriticsAndSpecialChars(targetStudio), RemoveDiacriticsAndSpecialChars(otherStudio));
if (dist <= 2)
{
similarStudios.Add(otherStudio, dist);
}
}
if (similarStudios.Count > 0)
{
writer.Write("|-\n| rowspan=\"{0}\" | {1} |", similarStudios.Count, targetStudio);
foreach (string similarName in similarStudios.OrderBy(item => item.Value).Select(item => item.Key))
{
writer.WriteLine("| {0} || {1}\r\n|-", similarName,
string.Join(", ", combinedStudioList[similarName].Select(list => "[[Liste der Anime-Titel/" + list + "|" + list + "]]")));
}
}
}
writer.WriteLine("|}");
return true;
}
static int LevenshteinDistance(string source, string target)
{
if (string.IsNullOrEmpty(source) && string.IsNullOrEmpty(target)) return 0;
if (string.IsNullOrEmpty(source)) return target.Length;
if (string.IsNullOrEmpty(target)) return source.Length;
int[,] d = new int[source.Length + 1, target.Length + 1];
for (int i = 1; i <= source.Length; i++) d[i, 0] = i;
for (int j = 1; j <= target.Length; j++) d[0, j] = j;
for (int j = 1; j <= target.Length; j++)
{
for (int i = 1; i <= source.Length; i++)
{
if (source[i - 1] == target[j - 1])
d[i, j] = d[i - 1, j - 1];
else
d[i, j] = new int[] {
d[i - 1, j] + 1, // Löschung
d[i, j - 1] + 1, // Einfügung
d[i - 1, j - 1] + 1 // Ersetzung
}.Min();
}
}
return d[source.Length, target.Length];
}
struct ContentAndTimestamp
{
public string Content;
public string Timestamp;
}
private static NetworkCredential GetCredentials()
{
Console.Write("Benutzer: ");
string user = Console.ReadLine();
Console.Write("Passwort: ");
string password = string.Empty;
// Sternchen zeigen, statt eingetipptem Passwort
while (true)
{
ConsoleKeyInfo keyInfo = Console.ReadKey(true);
if (keyInfo.Key == ConsoleKey.Enter)
{
Console.WriteLine();
break;
}
else if (keyInfo.Key == ConsoleKey.Backspace)
{
if (password.Length > 0)
{
password = password.Remove(password.Length - 1);
// bei Backspace: Cursor eine Position zurück, mit Leerzeichen überschreiben, wieder eine Position zurück
Console.Write(keyInfo.KeyChar + " " + keyInfo.KeyChar);
}
}
else
{
password += keyInfo.KeyChar;
Console.Write("*");
}
}
Console.WriteLine();
return new NetworkCredential(user, password);
}
static void Main(string[] args)
{
string matchStudiosFilename = null;
NetworkCredential credentials = null;
#region Kommandozeilenparameter auswerten
string user = null, password = null;
for (int i = 0; i < args.Length; i++)
{
if (args[i] == "-?")
{
Console.WriteLine(Assembly.GetExecutingAssembly().GetName() + " [Parameter]");
Console.WriteLine();
Console.WriteLine("-user Benutzername Benutzername angeben");
Console.WriteLine("-pass Passwort Passwort angeben");
Console.WriteLine("-matchstudios Datei Studionamen in den Jahreslisten angleichen.");
Console.WriteLine(" Eingabe ist eine UTF8-kodierte Datei die zeilenweise die Ersetzungen angibt im Format: Ist<TAB>Soll");
return;
}
else
if (i + 1 < args.Length)
{
switch (args[i])
{
case "-user":
user = args[i + 1];
i++;
break;
case "-pass":
password = args[i + 1];
i++;
break;
case "-matchstudios":
matchStudiosFilename = args[i + 1];
if (!File.Exists(matchStudiosFilename))
{
Console.WriteLine("Datei nicht gefunden!");
return;
}
break;
}
}
}
if (!string.IsNullOrEmpty(user) && !string.IsNullOrEmpty(password)) { credentials = new NetworkCredential(user, password); }
#endregion
wiki = new Mediawiki();
try
{
if (credentials == null) { credentials = GetCredentials(); }
Mediawiki.Login("de", credentials);
#region Eingabelisten lesen
Console.WriteLine("Alphabetische Listen lesen:");
Console.Write(" ");
Dictionary<string, ContentAndTimestamp> alphabeticLists = new Dictionary<string, ContentAndTimestamp>();
Parallel.ForEach(alphaList, letter =>
{
Mediawiki.TraverseHttpWebResponse(Mediawiki.HttpGet("de", new[,] {
{ "action", "query" },
{ "prop", "revisions" },
{ "titles", "Liste der Anime-Titel/" + letter },
{ "rvprop", "content|timestamp" } }),
delegate (XmlReader reader)
{
if ((reader.NodeType == XmlNodeType.Element) && (reader.Name == "rev"))
{
string curTimestamp = reader.GetAttribute("timestamp");
string content = reader.ReadString();
lock (alphabeticLists)
{
alphabeticLists.Add(letter, new ContentAndTimestamp() { Content = content, Timestamp = curTimestamp });
Console.Write(letter);
}
}
});
});
Console.WriteLine();
#endregion
if (matchStudiosFilename != null)
{
#region Studionamen ersetzen
Console.WriteLine("\nErsetzungen:");
Dictionary<Regex, string> replacers = new Dictionary<Regex, string>();
foreach (string line in File.ReadAllLines(matchStudiosFilename, Encoding.UTF8))
{
string[] items = line.Split('\t');
if (items.Length >= 2) replacers.Add(new Regex(@"(\|\s*s[0-9]+\s*=\s*\[*)" + Regex.Escape(items[0]) + @"(\s*[\|}\]])", RegexOptions.Singleline | RegexOptions.CultureInvariant), items[1]);
Console.WriteLine(" " + items[0] + " -> " + items[1]);
}
Console.Write("Fortfahren [j/n]: ");
if (Console.ReadLine().ToLowerInvariant() == "j")
{
foreach (string letter in alphabeticLists.Keys.OrderBy(key => key))
{
string content = alphabeticLists[letter].Content;
foreach (Regex replace in replacers.Keys) content = replace.Replace(content, "$1" + replacers[replace] + "$2");
WriteContent("Liste der Anime-Titel/" + letter, content, alphabeticLists[letter].Timestamp);
}
}
#endregion
}
else
{
#region Eingabelisten parsen
List<AnimeItem> animeList = new List<AnimeItem>();
Regex templateRegex = new Regex(@"\{\{\s*Anime\-Listeneintrag.+?}}", RegexOptions.Singleline);
Regex commentRegex = new Regex(@"<!--.+?-->", RegexOptions.Singleline);
foreach (string letter in alphabeticLists.Keys.OrderBy(key => key))
{
Console.WriteLine("Liste " + letter);
string content = commentRegex.Replace(alphabeticLists[letter].Content, "");
foreach (Match match in templateRegex.Matches(content))
{
Dictionary<string, string> entry = ParseTemplate(match.Value);
AnimeItem anime = AnimeItem.Parse(entry, letter);
if (anime != null)
{
animeList.Add(anime);
//Console.WriteLine(" " + anime);
}
else Console.Error.WriteLine("Nicht auswertbarer Eintrag: " + match.Value);
}
}
#endregion
// Jahreslisten ergänzen
int maxYear = animeList.Select(anime => anime.Year).Max();
if (maxYear > DateTime.Now.Year + 1)
{
Console.Write("Das höchste gefundene Jahr ist " + maxYear + ". Jahreslisten bis dahin erstellen [j/n]: ");
if (Console.ReadLine().ToLowerInvariant() != "j") return;
}
for (int year = 2000; year <= maxYear; year = year + 2)
{
yearList.Add(year);
yearList.Add(year + 1);
}
for (int yearIdx = 0; yearIdx < yearList.Count / 2; yearIdx++)
{
int startYear = yearList[yearIdx * 2];
int endYear = yearList[yearIdx * 2 + 1];
TextWriter yearWriter = new StringWriter();
if (BuildAnimeYearList(animeList, startYear, endYear, yearWriter))
WriteContent("Liste der Anime-Titel (" + startYear + "–" + endYear + ")", yearWriter.ToString());
}
TextWriter studioWriter = new StringWriter();
if (BuildAnimeStudioList(animeList, studioWriter)) WriteContent("Vorlage:Animestudio Werksliste", studioWriter.ToString());
TextWriter maintainenceWriter = new StringWriter();
if (BuildMaintainenceInfo(animeList, maintainenceWriter)) WriteContent("Benutzer:Mps/Test", maintainenceWriter.ToString());
}
Console.WriteLine("Fertig.");
}
catch (MediawikiException ex)
{
Console.Error.WriteLine("Mediawiki-Fehler: " + ex.Message);
}
finally
{
//wiki.Logout();
}
#if (DEBUG)
Console.ReadLine();
#endif
}
}
}
