trunk/TELTest/QuizContainer.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Xml;

namespace TELTest {
    public class QuizContainer : IEquatable<QuizContainer> {
        public QuizContainer() {
            Created = DateTime.MinValue;
        }
        public string Title;
        public string Author;
        public string Password;
        public DateTime Created;
        public Guid Guid;
        public QuizQuestion[] Questions;
        public Visibility Visibility;
        public string SerializeXML() {
            XmlDocument xd = new XmlDocument();
            var quiz = xd.CreateNode(XmlNodeType.Element, "Quiz", null);
            var title = xd.CreateNode(XmlNodeType.Element, "Name", null);
            title.InnerText = Title;
            quiz.AppendChild(title);

            var author = xd.CreateNode(XmlNodeType.Element, "Author", null);
            author.InnerText = Author;
            quiz.AppendChild(author);

            var guid = xd.CreateNode(XmlNodeType.Element, "Guid", null);
            guid.InnerText = Guid + "";
            quiz.AppendChild(guid);

            var created = xd.CreateNode(XmlNodeType.Element, "Created", null);
            created.InnerText = Created.ToString("O");
            quiz.AppendChild(created);

            var pwd = xd.CreateNode(XmlNodeType.Element, "Password", null);
            pwd.InnerText = Password;
            quiz.AppendChild(pwd);

            var vis = xd.CreateNode(XmlNodeType.Element, "Visibility", null);
            vis.InnerText = ((int)Visibility) + "";
            quiz.AppendChild(vis);

            var questions = xd.CreateNode(XmlNodeType.Element, "Questions", null);
            foreach (var item in Questions) {
                var q = xd.CreateNode(XmlNodeType.Element, "Question", null);

                var cap = xd.CreateNode(XmlNodeType.Element, "Caption", null);
                cap.InnerText = item.Content;
                q.AppendChild(cap);

                foreach (var it2 in item.Answers) {
                    var ans = xd.CreateNode(XmlNodeType.Element, "Answer", null);
                    ans.InnerText = it2.Content;
                    if (it2.Correct) {
                        var attr = xd.CreateAttribute("Correct");
                        attr.InnerText = "True";
                        ans.Attributes.Append(attr);
                    }
                    q.AppendChild(ans);
                }
                questions.AppendChild(q);
            }
            quiz.AppendChild(questions);
            return quiz.OuterXml;
        }
        public static QuizContainer FromXml(string content) {
            XmlDocument xd = new XmlDocument();
            xd.LoadXml(content);

            QuizContainer qc = new QuizContainer();
            qc.Title = xd.GetElementsByTagName("Name")[0].InnerText;
            qc.Author = xd.GetElementsByTagName("Author")[0].InnerText;
            var pw = xd.GetElementsByTagName("Password");
            if (pw.Count != 0) {
                qc.Password = pw[0].InnerText;
            }

            var vs = xd.GetElementsByTagName("Visibility");
            if (vs.Count != 0) {
                qc.Visibility = (Visibility)int.Parse(vs[0].InnerText);
            }
            qc.Guid = Guid.Parse(xd.GetElementsByTagName("Guid")[0].InnerText.Trim());
            List<QuizQuestion> qst = new List<QuizQuestion>();
            var q = xd.GetElementsByTagName("Questions")[0];
            foreach (XmlNode item in q.ChildNodes) {
                QuizQuestion qq = new QuizQuestion();
                qq.Content = item["Caption"].InnerText;
                List<QuizQuestionAnswer> ass = new List<QuizQuestionAnswer>();
                var an = item.ChildNodes;
                foreach (XmlNode aw in an) {

                    if (aw.Name.ToUpper() != "ANSWER") continue;
                    ass.Add(new QuizQuestionAnswer() {
                        Content = aw.InnerText,
                        Correct = aw.Attributes["Correct"] != null && aw.Attributes["Correct"].InnerText.ToUpper() != "FALSE"
                    });
                }
                qq.Answers = ass.ToArray();
                qst.Add(qq);
            }
            qc.Questions = qst.ToArray();
            return qc;
        }
        public static QuizContainer FromQuizhouse_poor(string content) {
            TextReader tr = new StringReader(content);
            QuizContainer qc = new QuizContainer();
            qc.Title = tr.ReadLine();
            qc.Author = tr.ReadLine();
            qc.Questions = new QuizQuestion[5];
            for (int i = 0; i < 5; i++) {
                qc.Questions[i] = new QuizQuestion() {
                    Content = tr.ReadLine(),
                    Answers = new[] {
                        new QuizQuestionAnswer(){ Content = tr.ReadLine() },
                        new QuizQuestionAnswer(){ Content = tr.ReadLine() },
                        new QuizQuestionAnswer(){ Content = tr.ReadLine() },
                        new QuizQuestionAnswer(){ Content = tr.ReadLine() },
                    }
                };
                string corr = tr.ReadLine();
                switch (corr.ToUpper()[0]) {
                case 'A':
                    qc.Questions[i].Answers[0].Correct = true;
                    break;
                case 'B':
                    qc.Questions[i].Answers[1].Correct = true;
                    break;
                case 'C':
                    qc.Questions[i].Answers[2].Correct = true;
                    break;
                case 'D':
                    qc.Questions[i].Answers[3].Correct = true;
                    break;
                }
            }
            return qc;
        }

        public bool IsQuizhouse_poorCompliant() {
            if (string.IsNullOrWhiteSpace(Title)) return false;
            if (string.IsNullOrWhiteSpace(Author)) return false;
            if (Questions.Length != 5) return false;
            foreach (var item in Questions) {
                if (item.Answers.Length != 4) return false;
                int correctAnswers = 0;
                foreach (var answer in item.Answers) {
                    if (answer.Correct) correctAnswers++;
                }
                if (correctAnswers != 1) return false;
            }
            return true;
        }

        public string SerializeQuizhouse_poor() {
            if (!IsQuizhouse_poorCompliant()) return null;
            StringBuilder sb = new StringBuilder();
            sb.AppendLineRN(Title);
            sb.AppendLineRN(Author);
            for (int i = 0; i < 5; i++) {
                sb.AppendLineRN(Questions[i].Content);
                char correct = ' ';
                for (int j = 0; j < 4; j++) {
                    sb.AppendLineRN(Questions[i].Answers[j].Content);
                    if (Questions[i].Answers[j].Correct) correct = char.ToLower(Utilities.NumberToLetter(j)[0]);
                }
                sb.AppendLineRN(correct + "");
            }
            return sb.ToString();
        }

        public override Boolean Equals(Object obj) => this.Equals(obj as QuizContainer);
        public Boolean Equals(QuizContainer other) => !(other is null) && this.Title == other.Title && this.Author == other.Author && this.Password == other.Password && this.Created == other.Created && this.Guid.Equals(other.Guid) && Enumerable.SequenceEqual(this.Questions, other.Questions);
        //EqualityComparer<QuizQuestion[]>.Default.Equals(this.Questions, other.Questions);

        public override Int32 GetHashCode() {
            Int32 hashCode = -614606056;
            hashCode = hashCode * -1521134295 + EqualityComparer<String>.Default.GetHashCode(this.Title);
            hashCode = hashCode * -1521134295 + EqualityComparer<String>.Default.GetHashCode(this.Author);
            hashCode = hashCode * -1521134295 + EqualityComparer<String>.Default.GetHashCode(this.Password);
            hashCode = hashCode * -1521134295 + this.Created.GetHashCode();
            hashCode = hashCode * -1521134295 + this.Guid.GetHashCode();
            hashCode = hashCode * -1521134295 + EqualityComparer<QuizQuestion[]>.Default.GetHashCode(this.Questions);
            return hashCode;
        }

        public static Boolean operator ==(QuizContainer left, QuizContainer right) {
            return EqualityComparer<QuizContainer>.Default.Equals(left, right);
        }

        public static Boolean operator !=(QuizContainer left, QuizContainer right) {
            return !(left == right);
        }
    }
    public struct QuizQuestion : IEquatable<QuizQuestion> {
        public string Content;
        public QuizQuestionAnswer[] Answers;

        public override Boolean Equals(Object obj) => obj is QuizQuestion question && this.Equals(question);
        public Boolean Equals(QuizQuestion other) => this.Content == other.Content && Enumerable.SequenceEqual(this.Answers, other.Answers);

        public override Int32 GetHashCode() {
            Int32 hashCode = 2043989270;
            hashCode = hashCode * -1521134295 + EqualityComparer<String>.Default.GetHashCode(this.Content);
            hashCode = hashCode * -1521134295 + EqualityComparer<QuizQuestionAnswer[]>.Default.GetHashCode(this.Answers);
            return hashCode;
        }

        public static Boolean operator ==(QuizQuestion left, QuizQuestion right) {
            return left.Equals(right);
        }

        public static Boolean operator !=(QuizQuestion left, QuizQuestion right) {
            return !(left == right);
        }
    }
    public struct QuizQuestionAnswer : IEquatable<QuizQuestionAnswer> {
        public string Content;
        public bool Correct;

        public override Boolean Equals(Object obj) => obj is QuizQuestionAnswer answer && this.Equals(answer);
        public Boolean Equals(QuizQuestionAnswer other) => this.Content == other.Content && this.Correct == other.Correct;

        public override Int32 GetHashCode() {
            Int32 hashCode = -1538403773;
            hashCode = hashCode * -1521134295 + EqualityComparer<String>.Default.GetHashCode(this.Content);
            hashCode = hashCode * -1521134295 + this.Correct.GetHashCode();
            return hashCode;
        }

        public static Boolean operator ==(QuizQuestionAnswer left, QuizQuestionAnswer right) {
            return left.Equals(right);
        }

        public static Boolean operator !=(QuizQuestionAnswer left, QuizQuestionAnswer right) {
            return !(left == right);
        }
    }
}
Revision:	2
Committed:	Wed Feb 11 13:07:01 2026 UTC (8 weeks, 4 days ago) by figdor32
File size:	10836 byte(s)
Log Message:	Initial check-in
#	Content
1	using System;
2	using System.Collections.Generic;
3	using System.IO;
4	using System.Linq;
5	using System.Text;
6	using System.Xml;
7
8	namespace TELTest {
9	public class QuizContainer : IEquatable<QuizContainer> {
10	public QuizContainer() {
11	Created = DateTime.MinValue;
12	}
13	public string Title;
14	public string Author;
15	public string Password;
16	public DateTime Created;
17	public Guid Guid;
18	public QuizQuestion[] Questions;
19	public Visibility Visibility;
20	public string SerializeXML() {
21	XmlDocument xd = new XmlDocument();
22	var quiz = xd.CreateNode(XmlNodeType.Element, "Quiz", null);
23	var title = xd.CreateNode(XmlNodeType.Element, "Name", null);
24	title.InnerText = Title;
25	quiz.AppendChild(title);
26
27	var author = xd.CreateNode(XmlNodeType.Element, "Author", null);
28	author.InnerText = Author;
29	quiz.AppendChild(author);
30
31	var guid = xd.CreateNode(XmlNodeType.Element, "Guid", null);
32	guid.InnerText = Guid + "";
33	quiz.AppendChild(guid);
34
35	var created = xd.CreateNode(XmlNodeType.Element, "Created", null);
36	created.InnerText = Created.ToString("O");
37	quiz.AppendChild(created);
38
39	var pwd = xd.CreateNode(XmlNodeType.Element, "Password", null);
40	pwd.InnerText = Password;
41	quiz.AppendChild(pwd);
42
43	var vis = xd.CreateNode(XmlNodeType.Element, "Visibility", null);
44	vis.InnerText = ((int)Visibility) + "";
45	quiz.AppendChild(vis);
46
47	var questions = xd.CreateNode(XmlNodeType.Element, "Questions", null);
48	foreach (var item in Questions) {
49	var q = xd.CreateNode(XmlNodeType.Element, "Question", null);
50
51	var cap = xd.CreateNode(XmlNodeType.Element, "Caption", null);
52	cap.InnerText = item.Content;
53	q.AppendChild(cap);
54
55	foreach (var it2 in item.Answers) {
56	var ans = xd.CreateNode(XmlNodeType.Element, "Answer", null);
57	ans.InnerText = it2.Content;
58	if (it2.Correct) {
59	var attr = xd.CreateAttribute("Correct");
60	attr.InnerText = "True";
61	ans.Attributes.Append(attr);
62	}
63	q.AppendChild(ans);
64	}
65	questions.AppendChild(q);
66	}
67	quiz.AppendChild(questions);
68	return quiz.OuterXml;
69	}
70	public static QuizContainer FromXml(string content) {
71	XmlDocument xd = new XmlDocument();
72	xd.LoadXml(content);
73
74	QuizContainer qc = new QuizContainer();
75	qc.Title = xd.GetElementsByTagName("Name")[0].InnerText;
76	qc.Author = xd.GetElementsByTagName("Author")[0].InnerText;
77	var pw = xd.GetElementsByTagName("Password");
78	if (pw.Count != 0) {
79	qc.Password = pw[0].InnerText;
80	}
81
82	var vs = xd.GetElementsByTagName("Visibility");
83	if (vs.Count != 0) {
84	qc.Visibility = (Visibility)int.Parse(vs[0].InnerText);
85	}
86	qc.Guid = Guid.Parse(xd.GetElementsByTagName("Guid")[0].InnerText.Trim());
87	List<QuizQuestion> qst = new List<QuizQuestion>();
88	var q = xd.GetElementsByTagName("Questions")[0];
89	foreach (XmlNode item in q.ChildNodes) {
90	QuizQuestion qq = new QuizQuestion();
91	qq.Content = item["Caption"].InnerText;
92	List<QuizQuestionAnswer> ass = new List<QuizQuestionAnswer>();
93	var an = item.ChildNodes;
94	foreach (XmlNode aw in an) {
95
96	if (aw.Name.ToUpper() != "ANSWER") continue;
97	ass.Add(new QuizQuestionAnswer() {
98	Content = aw.InnerText,
99	Correct = aw.Attributes["Correct"] != null && aw.Attributes["Correct"].InnerText.ToUpper() != "FALSE"
100	});
101	}
102	qq.Answers = ass.ToArray();
103	qst.Add(qq);
104	}
105	qc.Questions = qst.ToArray();
106	return qc;
107	}
108	public static QuizContainer FromQuizhouse_poor(string content) {
109	TextReader tr = new StringReader(content);
110	QuizContainer qc = new QuizContainer();
111	qc.Title = tr.ReadLine();
112	qc.Author = tr.ReadLine();
113	qc.Questions = new QuizQuestion[5];
114	for (int i = 0; i < 5; i++) {
115	qc.Questions[i] = new QuizQuestion() {
116	Content = tr.ReadLine(),
117	Answers = new[] {
118	new QuizQuestionAnswer(){ Content = tr.ReadLine() },
119	new QuizQuestionAnswer(){ Content = tr.ReadLine() },
120	new QuizQuestionAnswer(){ Content = tr.ReadLine() },
121	new QuizQuestionAnswer(){ Content = tr.ReadLine() },
122	}
123	};
124	string corr = tr.ReadLine();
125	switch (corr.ToUpper()[0]) {
126	case 'A':
127	qc.Questions[i].Answers[0].Correct = true;
128	break;
129	case 'B':
130	qc.Questions[i].Answers[1].Correct = true;
131	break;
132	case 'C':
133	qc.Questions[i].Answers[2].Correct = true;
134	break;
135	case 'D':
136	qc.Questions[i].Answers[3].Correct = true;
137	break;
138	}
139	}
140	return qc;
141	}
142
143	public bool IsQuizhouse_poorCompliant() {
144	if (string.IsNullOrWhiteSpace(Title)) return false;
145	if (string.IsNullOrWhiteSpace(Author)) return false;
146	if (Questions.Length != 5) return false;
147	foreach (var item in Questions) {
148	if (item.Answers.Length != 4) return false;
149	int correctAnswers = 0;
150	foreach (var answer in item.Answers) {
151	if (answer.Correct) correctAnswers++;
152	}
153	if (correctAnswers != 1) return false;
154	}
155	return true;
156	}
157
158	public string SerializeQuizhouse_poor() {
159	if (!IsQuizhouse_poorCompliant()) return null;
160	StringBuilder sb = new StringBuilder();
161	sb.AppendLineRN(Title);
162	sb.AppendLineRN(Author);
163	for (int i = 0; i < 5; i++) {
164	sb.AppendLineRN(Questions[i].Content);
165	char correct = ' ';
166	for (int j = 0; j < 4; j++) {
167	sb.AppendLineRN(Questions[i].Answers[j].Content);
168	if (Questions[i].Answers[j].Correct) correct = char.ToLower(Utilities.NumberToLetter(j)[0]);
169	}
170	sb.AppendLineRN(correct + "");
171	}
172	return sb.ToString();
173	}
174
175	public override Boolean Equals(Object obj) => this.Equals(obj as QuizContainer);
176	public Boolean Equals(QuizContainer other) => !(other is null) && this.Title == other.Title && this.Author == other.Author && this.Password == other.Password && this.Created == other.Created && this.Guid.Equals(other.Guid) && Enumerable.SequenceEqual(this.Questions, other.Questions);
177	//EqualityComparer<QuizQuestion[]>.Default.Equals(this.Questions, other.Questions);
178
179	public override Int32 GetHashCode() {
180	Int32 hashCode = -614606056;
181	hashCode = hashCode * -1521134295 + EqualityComparer<String>.Default.GetHashCode(this.Title);
182	hashCode = hashCode * -1521134295 + EqualityComparer<String>.Default.GetHashCode(this.Author);
183	hashCode = hashCode * -1521134295 + EqualityComparer<String>.Default.GetHashCode(this.Password);
184	hashCode = hashCode * -1521134295 + this.Created.GetHashCode();
185	hashCode = hashCode * -1521134295 + this.Guid.GetHashCode();
186	hashCode = hashCode * -1521134295 + EqualityComparer<QuizQuestion[]>.Default.GetHashCode(this.Questions);
187	return hashCode;
188	}
189
190	public static Boolean operator ==(QuizContainer left, QuizContainer right) {
191	return EqualityComparer<QuizContainer>.Default.Equals(left, right);
192	}
193
194	public static Boolean operator !=(QuizContainer left, QuizContainer right) {
195	return !(left == right);
196	}
197	}
198	public struct QuizQuestion : IEquatable<QuizQuestion> {
199	public string Content;
200	public QuizQuestionAnswer[] Answers;
201
202	public override Boolean Equals(Object obj) => obj is QuizQuestion question && this.Equals(question);
203	public Boolean Equals(QuizQuestion other) => this.Content == other.Content && Enumerable.SequenceEqual(this.Answers, other.Answers);
204
205	public override Int32 GetHashCode() {
206	Int32 hashCode = 2043989270;
207	hashCode = hashCode * -1521134295 + EqualityComparer<String>.Default.GetHashCode(this.Content);
208	hashCode = hashCode * -1521134295 + EqualityComparer<QuizQuestionAnswer[]>.Default.GetHashCode(this.Answers);
209	return hashCode;
210	}
211
212	public static Boolean operator ==(QuizQuestion left, QuizQuestion right) {
213	return left.Equals(right);
214	}
215
216	public static Boolean operator !=(QuizQuestion left, QuizQuestion right) {
217	return !(left == right);
218	}
219	}
220	public struct QuizQuestionAnswer : IEquatable<QuizQuestionAnswer> {
221	public string Content;
222	public bool Correct;
223
224	public override Boolean Equals(Object obj) => obj is QuizQuestionAnswer answer && this.Equals(answer);
225	public Boolean Equals(QuizQuestionAnswer other) => this.Content == other.Content && this.Correct == other.Correct;
226
227	public override Int32 GetHashCode() {
228	Int32 hashCode = -1538403773;
229	hashCode = hashCode * -1521134295 + EqualityComparer<String>.Default.GetHashCode(this.Content);
230	hashCode = hashCode * -1521134295 + this.Correct.GetHashCode();
231	return hashCode;
232	}
233
234	public static Boolean operator ==(QuizQuestionAnswer left, QuizQuestionAnswer right) {
235	return left.Equals(right);
236	}
237
238	public static Boolean operator !=(QuizQuestionAnswer left, QuizQuestionAnswer right) {
239	return !(left == right);
240	}
241	}
242	}