QuizManager.cs
27cc59e440e7master

QuizManager.cs
View Options

			using Firebase;
			using Firebase.Database;
			using Firebase.Storage;
			using System.Collections;
			using System.Collections.Generic;
			using System.Text;
			using UnityEngine;
			using UnityEngine.UI;

			public class QuizManager : MonoBehaviour
			{

			string quizzesKey = "quizzes";
			string quizTitleKey = "title";
			string questionsKey = "questions";

			IDictionary<string, string> quizzesDict = new Dictionary<string, string>();
			IDictionary<int, string> quizzesIDsDict = new Dictionary<int, string>();

			Dropdown quizzesDropdown;

			private void Start()
			{

			Firebase.Auth.FirebaseAuth auth = Firebase.Auth.FirebaseAuth.DefaultInstance;
			auth.SignInWithEmailAndPasswordAsync("the1shadow@gmail.com", "firebasepw").ContinueWith(task =>
			{
			// Set this before calling into the realtime database.
			FirebaseApp.DefaultInstance.Options.DatabaseUrl = new System.Uri("https://aal-sfl.firebaseio.com/");

			// Get dropdown reference
			quizzesDropdown = GameObject.Find("QuizzesDropdown").GetComponent<Dropdown>();

			// Set up event listeners from the DB
			DatabaseReference quizzesRef = FirebaseDatabase.DefaultInstance.GetReference(quizzesKey);
			quizzesRef.ChildAdded += HandleChildAdded;
			quizzesRef.ChildChanged += HandleChildChanged;
			quizzesRef.ChildRemoved += HandleChildRemoved;
			//quizzesRef.ChildMoved += HandleChildMoved;
			});

			}

			public void CreateQuestionClick()
			{

			// Get input fields from user
			InputField quizNameField = GameObject.Find("QuizName").GetComponent<InputField>();
			InputField questionField = GameObject.Find("Question").GetComponent<InputField>();
			InputField answerField = GameObject.Find("Answer").GetComponent<InputField>();

			// Get input text
			string quizName = quizNameField.text;
			string questionText = questionField.text;
			string answerText = answerField.text;

			Question question = new Question(questionText, answerText);

			// Create question in Firebase
			CreateQuestionFirebase(quizName, question);
			}

			/***************************************************/
			/* Test retrieval of record from the Firebase DB */
			/***************************************************/
			public void QuizDropdownChange(Dropdown dropdown)
			{
			string quizId = quizzesIDsDict[dropdown.value];

			Text scrollText = GameObject.Find("QuizScrollText").GetComponent<Text>();

			Debug.Log("Selected quiz : " + dropdown.value + " (" + dropdown.captionText.text + ")" + "[" + quizId + "]");

			// Retrieve given quiz by ID
			DatabaseReference quizzesRef = FirebaseDatabase.DefaultInstance.GetReference(quizzesKey);
			quizzesRef.Child(quizId).GetValueAsync().ContinueWith(task =>
			{
			StringBuilder sb = new StringBuilder();

			IList<object> questions = (IList<object>) task.Result.Child(questionsKey).Value;
			int idx = 0;
			foreach(object question in questions)
			{
			IDictionary<string, object> questionDict = (IDictionary<string, object>)question;
			Debug.Log(question);

			// Build question-answer text to put into the ScrollView
			sb.AppendLine("Question " + idx++ + " : " + questionDict["question"] + "\n"
			+ "Answer : " + questionDict["answer"] + "\n");
			}

			// Put text into the ScrollView
			scrollText.text = sb.ToString();
			});

			}

			/***************************************************/
			/* Test creation and update of Firebase DB records */
			/***************************************************/
			void CreateQuestionFirebase(string quizName, Question question)
			{
			// Get the root reference location of the database.
			DatabaseReference reference = FirebaseDatabase.DefaultInstance.RootReference;

			// Look for quiz with a given title in the DB
			reference.Child(quizzesKey).OrderByChild(quizTitleKey).EqualTo(quizName).GetValueAsync().ContinueWith(task =>
			{
			if (task.IsCanceled)
			{
			Debug.LogError("GetValueAsync was canceled.");
			}
			if (task.IsFaulted)
			{
			Debug.LogError("GetValueAsync encountered an error : " + task.Exception);
			GameObject.Find("CreateQuestionMessage").GetComponent<Text>().text = task.Exception.InnerExceptions[0].Message;
			return;
			}

			// Quiz already exists, don't overwrite!
			if (task.Result.HasChildren)
			{
			IDictionary<string, object> result = (IDictionary<string, object>)task.Result.Value;

			// Get the key of the first (and only) retrieved result
			string quizKey = GetCollectionFirstElement(result.Keys);

			Debug.Log("Quiz found : " + quizKey);

			// Get the current list of questions
			DataSnapshot questionsNode = GetEnumerableFirstElement(task.Result.Children).Child(questionsKey);
			IList<object> questionsList = (IList<object>)questionsNode.Value;

			// Add new question to the list
			questionsList.Add(question.ToDictionary());

			// Save new list back to the DB
			reference.Child(quizzesKey).Child(quizKey).Child(questionsKey).SetValueAsync(questionsList).ContinueWith(updateQuestionTask =>
			{
			if (updateQuestionTask.IsCanceled)
			{
			Debug.LogError("SetValueAsync was canceled.");
			return;
			}
			if (updateQuestionTask.IsFaulted)
			{
			Debug.LogError("SetValueAsync encountered an error: " + updateQuestionTask.Exception);
			GameObject.Find("CreateQuestionMessage").GetComponent<Text>().text = updateQuestionTask.Exception.InnerExceptions[0].Message;
			return;
			}

			Debug.Log("Question created in quiz " + quizName + " : " + question.question);
			GameObject.Find("CreateQuestionMessage").GetComponent<Text>().text = "Question added!";
			});
			}
			// Quiz doesn't exist, go ahead normally
			else
			{
			Debug.Log("Quiz NOT found : " + task.Result);

			// Create or retrieve quiz
			List<Question> questions = new List<Question> { question };

			Quiz quiz = new Quiz(quizName, questions);

			// Convert object to JSON for storage
			string json = JsonUtility.ToJson(quiz);

			// Generate quiz key and store it
			string quizKey = reference.Child(quizzesKey).Push().Key;

			reference.Child(quizzesKey).Child(quizKey).SetRawJsonValueAsync(json).ContinueWith(questionTask =>
			{
			if (questionTask.IsCanceled)
			{
			Debug.LogError("SetRawJsonValueAsync was canceled.");
			return;
			}
			if (questionTask.IsFaulted)
			{
			Debug.LogError("SetRawJsonValueAsync encountered an error: " + questionTask.Exception);
			GameObject.Find("CreateQuestionMessage").GetComponent<Text>().text = questionTask.Exception.InnerExceptions[0].Message;
			return;
			}

			Debug.Log("Question created in quiz " + quizName + " : " + question.question);
			GameObject.Find("CreateQuestionMessage").GetComponent<Text>().text = "Question added!";
			});
			}

			}
			);

			}

			/***************************************************/
			/* Test handling incoming changes from Firebase DB */
			/***************************************************/
			void HandleChildAdded(object sender, ChildChangedEventArgs args)
			{
			if (args.DatabaseError != null)
			{
			Debug.LogError(args.DatabaseError.Message);
			return;
			}

			string quizTitle = ((IDictionary)args.Snapshot.Value)[quizTitleKey].ToString();
			string quizId = args.Snapshot.Key;

			// Add or update dictionary
			quizzesDict[quizId] = quizTitle;

			RenderQuizzesDropdown(quizzesDict);

			Debug.Log("Quiz added : " + quizTitle);
			// Do something with the data in args.Snapshot
			}

			void HandleChildChanged(object sender, ChildChangedEventArgs args)
			{
			if (args.DatabaseError != null)
			{
			Debug.LogError(args.DatabaseError.Message);
			return;
			}

			string quizTitle = ((IDictionary)args.Snapshot.Value)[quizTitleKey].ToString();
			string quizId = args.Snapshot.Key;

			// Add or update dictionary
			quizzesDict[quizId] = quizTitle;

			RenderQuizzesDropdown(quizzesDict);

			Debug.Log("Quiz modified : " + quizTitle);
			// Do something with the data in args.Snapshot
			}

			void HandleChildRemoved(object sender, ChildChangedEventArgs args)
			{
			if (args.DatabaseError != null)
			{
			Debug.LogError(args.DatabaseError.Message);
			return;
			}

			string quizTitle = ((IDictionary)args.Snapshot.Value)[quizTitleKey].ToString();
			string quizId = args.Snapshot.Key;

			// Remove from dictionary
			quizzesDict.Remove(quizId);

			RenderQuizzesDropdown(quizzesDict);

			Debug.Log("Quiz removed : " + quizTitle);
			// Do something with the data in args.Snapshot
			}

			// Render the dropdown list of quizzes
			void RenderQuizzesDropdown(IDictionary<string, string> quizzesDict)
			{

			quizzesDropdown.ClearOptions();
			quizzesIDsDict.Clear();

			List<string> options = new List<string>(quizzesDict.Count);

			int idx = 0;
			foreach (KeyValuePair<string,string> quizDictEntry in quizzesDict)
			{
			options.Add(quizDictEntry.Value);
			quizzesIDsDict[idx++] = quizDictEntry.Key;
			};

			quizzesDropdown.AddOptions(options);
			quizzesDropdown.RefreshShownValue();
			QuizDropdownChange(quizzesDropdown);
			}

			// Utility methods
			T GetCollectionFirstElement<T>(ICollection<T> collection)
			{
			IEnumerator<T> en = collection.GetEnumerator();
			en.MoveNext();
			return en.Current;
			}

			T GetEnumerableFirstElement<T>(IEnumerable<T> enumerable)
			{
			IEnumerator<T> en = enumerable.GetEnumerator();
			en.MoveNext();
			return en.Current;
			}
			}

rSFLFB/Assets/Code/QuizManager.cs27cc59e440e7master

QuizManager.csView Options

rSFLFB/Assets/Code/QuizManager.cs
27cc59e440e7master

QuizManager.cs
View Options