static async Task DoWork(string iothubCS)
{
DeviceClient deviceClient = DeviceClient.CreateFromConnectionString(iothubCS);
try
{
string deviceId = iothubCS.Split(";")[1].Split("=")[1];
deviceClient.SetConnectionStatusChangesHandler(ConnectionStatusChangeHandler);
await deviceClient.SetDesiredPropertyUpdateCallbackAsync(DesiredPropertyUpdateHandler, deviceClient);
await deviceClient.SetMethodDefaultHandlerAsync(MethodHandler, deviceClient);
await deviceClient.SetReceiveMessageHandlerAsync(ReceiveMessageHandler, deviceClient);
await deviceClient.OpenAsync();
#if TEST
int count = 10;
for (int i = 0; i < count; i++)
{
var msgContent = new
{
deviceId = deviceId,
timestamp = DateTime.UtcNow,
count = i
};
var msgJson = Newtonsoft.Json.JsonConvert.SerializeObject(msgContent);
var msg = new Message(System.Text.Encoding.UTF8.GetBytes(msgJson));
await deviceClient.SendEventAsync(msg);
Console.WriteLine($"Send - {msgJson}");
await Task.Delay(5000);
}
#endif
while (true)
{
var input = AppStreamReader.ReadLine().Trim();
if (input.ToLower().StartsWith("quit"))
{
AppStreamWriter.WriteLine("Quit");
break;
}
else
{
var msg = new Message(System.Text.Encoding.UTF8.GetBytes(input));
AppStreamWriter.WriteLine($"Input - {input}");
await deviceClient.SendEventAsync(msg);
}
}
await deviceClient.CloseAsync();
}
catch (Exception ex)
{
AppStreamWriter.WriteLine($"Exception {ex.Message}");
}
}
public static String ImportFromFile(Stream importStream, out List <Lesson> lessons)
{
lessons = new List <Lesson>();
StringBuilder sb = new StringBuilder();
using (AppStreamReader sr = new AppStreamReader(importStream))
{
try
{
int importedLessons = 0;
int importedWords = 0;
int importedKanjis = 0;
int importedGrammars = 0;
while (!sr.EndOfStream)
{
Lesson lesson = new Lesson(sr.ReadLine());
for (int i = 0; i < lesson.Size; ++i)
{
switch ((Lesson.EType)lesson.Type)
{
case Lesson.EType.vocab: lesson.Words.Add(new Word(sr.ReadLine(), lesson)); break;
case Lesson.EType.kanji: lesson.Kanjis.Add(new Kanji(sr.ReadLine(), lesson)); break;
case Lesson.EType.grammar: lesson.Grammars.Add(new Grammar(sr.ReadLine(), lesson)); break;
}
}
lessons.Add(lesson);
importedWords += lesson.Words.Count;
importedGrammars += lesson.Grammars.Count;
importedKanjis += lesson.Kanjis.Count;
}
importedLessons = lessons.Count;
sb.AppendLine(importedLessons + " Lektionen,");
sb.AppendLine(importedWords + " Vokabeln,");
sb.AppendLine(importedKanjis + " Kanjis und");
sb.AppendLine(importedGrammars + " Grammatiken gefunden");
sb.AppendLine("Datenbank wirklich wiederherstellen?");
sb.AppendLine("Achtung! Dabei wird die derzeitige Datenbank überschrieben!");
}
catch (Exception e)
{
sb.Clear();
sb.AppendLine("Import Fehlgeschlagen in Zeile: " + sr.CurrentLine);
sb.AppendLine("System: " + e.Message);
}
}
return(sb.ToString());
}
static async Task DoWork(string iothubCS)
{
DeviceClient deviceClient = DeviceClient.CreateFromConnectionString(iothubCS);
try
{
string deviceId = iothubCS.Split(";")[1].Split("=")[1];
deviceClient.SetConnectionStatusChangesHandler(ConnectionStatusChangeHandler);
await deviceClient.SetDesiredPropertyUpdateCallbackAsync(DesiredPropertyUpdateHandler, deviceClient);
await deviceClient.SetMethodDefaultHandlerAsync(MethodHandler, deviceClient);
await deviceClient.SetReceiveMessageHandlerAsync(ReceiveMessageHandler, deviceClient);
await deviceClient.OpenAsync();
var reported = new TwinCollection();
var targetProps = new
{
target = TargetDeviceId
};
reported["configuration"] = new TwinCollection(Newtonsoft.Json.JsonConvert.SerializeObject(targetProps));
await deviceClient.UpdateReportedPropertiesAsync(reported);
#if TEST
int count = 10;
for (int i = 0; i < count; i++)
{
var msgContent = new
{
deviceId = deviceId,
timestamp = DateTime.UtcNow,
count = i
};
var msgJson = Newtonsoft.Json.JsonConvert.SerializeObject(msgContent);
var msg = new Message(System.Text.Encoding.UTF8.GetBytes(msgJson));
await deviceClient.SendEventAsync(msg);
Console.WriteLine($"Send - {msgJson}");
await Task.Delay(5000);
}
#endif
while (true)
{
var input = AppStreamReader.ReadLine().Trim();
if (input.ToLower().StartsWith("quit"))
{
AppStreamWriter.WriteLine("log:Quit");
break;
}
else
{
try
{
string d2cMessageKey = "d2c:";
string urpMessageKey = "urp:";
if (input.StartsWith(d2cMessageKey))
{
var msg = new Message(System.Text.Encoding.UTF8.GetBytes(input.Substring(d2cMessageKey.Length)));
AppStreamWriter.WriteLine($"log:Send D2C - {input}");
await deviceClient.SendEventAsync(msg);
}
else if (input.StartsWith(urpMessageKey))
{
AppStreamWriter.WriteLine($"log:Update RP - {input}");
reported["External"] = new TwinCollection(input.Substring(urpMessageKey.Length));
await deviceClient.UpdateReportedPropertiesAsync(reported);
}
}
catch (Exception ex)
{
AppStreamWriter.WriteLine($"error:Exeption - {ex.Message}");
}
}
}
await deviceClient.CloseAsync();
}
catch (Exception ex)
{
AppStreamWriter.WriteLine($"log:Exception {ex.Message}");
}
}
public static String AddContentFromFile(Stream contentStream)
{
using (AppStreamReader sr = new AppStreamReader(contentStream))
{
StringBuilder sb = new StringBuilder();
try
{
List <Lesson> lessons = new List <Lesson>();
int importedLessons = 0;
int importedWords = 0;
int importedKanjis = 0;
int importedClozes = 0;
//read content from stream till end
while (!sr.EndOfStream)
{
Lesson lesson = new Lesson(sr.ReadLine());
for (int i = 0; i < lesson.size; ++i)
{
switch ((Lesson.EType)lesson.Type)
{
case Lesson.EType.vocab: lesson.Words.Add(new Word(sr.ReadLine(), lesson)); break;
case Lesson.EType.kanji: lesson.Kanjis.Add(new Kanji(sr.ReadLine(), lesson)); break;
case Lesson.EType.insert: lesson.Clozes.Add(new Cloze(sr.ReadLine(), lesson)); break;
}
}
importedWords += lesson.Words.Count;
importedClozes += lesson.Clozes.Count;
importedKanjis += lesson.Kanjis.Count;
lessons.Add(lesson);
}
importedLessons = lessons.Count;
foreach (Lesson lesson in lessons)
{
switch (lesson.Type)
{
case Lesson.EType.vocab: ImportWords(lesson); break;
case Lesson.EType.insert: ImportClozes(lesson); break;
case Lesson.EType.kanji: ImportKanjis(lesson); break;
}
}
sb.AppendLine("Import erfolreich (^ω^)/");
sb.AppendLine("Importierte Lektionen:\t" + importedLessons);
sb.AppendLine("Importierte Wörter:\t" + importedWords);
sb.AppendLine("Importierte Kanjis:\t" + importedKanjis);
sb.AppendLine("Importierte Lückentexte:\t" + importedClozes);
database.SubmitChanges();
}
catch (Exception e)
{
sb.Clear();
sb.AppendLine("Inhalt hinzufügen Fehlgeschlagen in Zeile: " + sr.CurrentLine);
sb.AppendLine("System: " + e.Message);
}
return(sb.ToString());
}
}
private static String UpdateWords(AppStreamReader sr, int itemCount)
{
for (int i = 0; i < itemCount; ++i)
{
String line = sr.ReadLine();
String idStr = line.Substring(0, line.IndexOf('|'));
Word w = context.GetWord(Convert.ToInt32(idStr));
w.Update(line);
}
StringBuilder sb = new StringBuilder();
sb.AppendLine("Aktualisierte Wörter\t: " + itemCount);
return sb.ToString();
}
private static String UpdateLessons(AppStreamReader sr, int itemCount)
{
for (int i = 0; i < itemCount; ++i)
{
String line = sr.ReadLine();
Lesson newLesson = new Lesson(line);
Lesson oldLesson = context.GetLesson(newLesson.id);
oldLesson.Update(newLesson);
}
StringBuilder sb = new StringBuilder();
sb.AppendLine("Aktualisierte Lektionen\t: " + itemCount);
return sb.ToString();
}
private static int ReadVocabLesson(AppStreamReader sr, Lesson lesson)
{
Word[] words = new Word[lesson.size];
for (int i = 0; i < words.Length; ++i)
{
String line = sr.ReadLine();
words[i] = new Word(line, lesson.id);
AppSettings.TimeStamp = Math.Max(AppSettings.TimeStamp, words[i].TimeStampTransl);
AppSettings.TimeStamp = Math.Max(AppSettings.TimeStamp, words[i].TimeStampJapanese);
}
context.words.InsertAllOnSubmit(words);
return words.Length;
}
private static int ReadKanjiLesson(AppStreamReader sr, Lesson lesson)
{
Kanji[] kanjis = new Kanji[lesson.size];
for (int i = 0; i < kanjis.Length; ++i)
{
String line = sr.ReadLine();
kanjis[i] = new Kanji(line, lesson.id);
}
context.kanjis.InsertAllOnSubmit(kanjis);
return kanjis.Length;
}
private static int ReadInsertLesson(AppStreamReader sr, Lesson lesson)
{
Sentence[] sentences = new Sentence[lesson.size];
for (int i = 0; i < sentences.Length; ++i)
{
String line = sr.ReadLine();
sentences[i] = new Sentence(line, lesson.id);
}
context.sentences.InsertAllOnSubmit(sentences);
return sentences.Length;
}
private static String AddWords(AppStreamReader sr, int itemCount)
{
Dictionary<int, int> lessonsDict = new Dictionary<int, int>();
for (int i = 0; i < itemCount; ++i)
{
String line = sr.ReadLine();
String[] parts = line.Split('|');
int lessonID = Convert.ToInt32(parts[0]);
if (lessonsDict.ContainsKey(lessonID))
{
lessonsDict[lessonID] += 1;
}
else
{
lessonsDict.Add(lessonID, 1);
}
Word w = new Word(line, lessonID);
context.words.InsertOnSubmit(w);
}
foreach (KeyValuePair<int, int> pair in lessonsDict)
{
Lesson l = context.GetLesson(pair.Key);
l.size += pair.Value;
}
StringBuilder sb = new StringBuilder();
sb.AppendLine("Wörter zu bestehenden Lektionen hinzugefügt: " + itemCount);
return sb.ToString();
}
private static String AddLessons(AppStreamReader sr, int itemCount)
{
int lessonID = context.GetLastLessonID();
int importedLessons = 0;
int importedWords = 0;
int importedSentences = 0;
int importedKanjis = 0;
for (int i = 0; i < itemCount; ++i)
{
String line = sr.ReadLine();
Lesson lesson = new Lesson(line);
lesson.id = ++lessonID;
switch (lesson.type)
{
case 0: importedWords += ReadVocabLesson(sr, lesson); break;
case 1: importedSentences += ReadInsertLesson(sr, lesson); break;
case 2: break;
case 3: importedKanjis += ReadKanjiLesson(sr, lesson); break;
case 4: break;
}
context.lessons.InsertOnSubmit(lesson);
++importedLessons;
}
StringBuilder sb = new StringBuilder();
sb.AppendLine("Hinzugefügte Lektionen\t: " + importedLessons);
sb.AppendLine("Hinzugefügte Wörter\t: " + importedWords);
sb.AppendLine("Hinzugefügte Lückentexte\t: " + importedSentences);
sb.AppendLine("Hinzugefügte Kanjis\t: " + importedKanjis);
return sb.ToString();
}
public static String ImportFromFile(IRandomAccessStream importStream)
{
StringBuilder importResults = new StringBuilder();
using (AppStreamReader sr = new AppStreamReader(importStream.AsStream()))
{
try
{
String line = sr.ReadLine();
do
{
String[] parts = line.Split('|');
int operation = Convert.ToInt32(parts[0]);
int itemCount = Convert.ToInt32(parts[1]);
String results = "";
switch (operation)
{
case 0: results = AddLessons(sr, itemCount); break;
case 1: results = UpdateLessons(sr, itemCount); break;
case 2: results = UpdateWords(sr, itemCount); break;
case 3: results = UpdateKanjis(sr, itemCount); break;
case 4: results = AddWords(sr, itemCount); break;
case 5: results = AddKanjis(sr, itemCount); break;
}
importResults.Append(results);
line = sr.ReadLine();
}
while (line != null);
context.SubmitChanges();
}
catch (Exception e)
{
importResults.Clear();
importResults.AppendLine("Import Fehlgeschlagen in Zeile: " + sr.CurrentLine);
importResults.AppendLine("System: " + e.Message);
}
}
return importResults.ToString();
}
