Beispiel #1
0
        /// <summary>
        /// Coroutine for sending an xAPI Statement.
        ///
        /// This version requires a constructed Statement object.
        /// </summary>
        /// <param name="statement"></param>
        /// <param name="callback"></param>
        /// <returns></returns>
        public static IEnumerator SendMultiStatementRoutine(Statement[] statements, Action <MultiStatementStoredResponse> callback = null)
        {
            // Serialize this thing then convert into a utf-8 byte array
            var payload = JsonConvert.SerializeObject(statements);
            var request = XAPIMessenger.BuildPostRequest(XAPIMessenger.Config.StatementEndpoint, payload);

            // Yield during the request
            yield return(request.SendWebRequest());

            // Use the callback if supplied
            if (callback != null)
            {
                // Check for the statement IDs
                string[] statementKeys = null;

                try
                {
                    statementKeys = JsonConvert.DeserializeObject <string[]>(request.downloadHandler.text);
                }
                catch (Exception ex)
                {
                    Debug.LogErrorFormat("ERROR: Response Code: {0}", request.responseCode);
                    Debug.LogErrorFormat("ERROR: Could not deserialize LRS response.  Expected JSON string array, received: {0}", request.downloadHandler.text);
                    Debug.LogErrorFormat("ERROR: Exception: {0}", ex.Message);
                }

                callback(new MultiStatementStoredResponse {
                    Request      = request,
                    Statements   = statements,
                    StatementIDs = statementKeys
                });
            }
        }
        public override void OnInspectorGUI()
        {
            // Get our component
            this.messenger = (target as XAPIMessenger);

            // Tell people what it does
            EditorGUILayout.HelpBox(
                "Primary component when using this Unity xAPI Wrapper." +
                "\n\nThis component will send web requests using Unity's coroutine system and its cross-platform Web Request library." +
                "\n\nIf this component does not exist when needed, the Wrapper will create one."
                , MessageType.Info
                );

            // Expose the private ConfigObject field
            base.OnInspectorGUI();

            GUI.enabled           = false;
            EditorGUI.indentLevel = 2;

            // Make sure we have a configuration
            if (this.messenger.LocalConfigObject != null)
            {
                // Sanity
                var config = this.messenger.LocalConfigObject.config;

                EditorGUILayout.TextField("-LRS Endpoint", config.Endpoint);
                EditorGUILayout.IntField("-Timeout (s)", config.Timeout);

                // The main area of interest is changing how we authenticate with the LRS
                switch (config.AuthMethod)
                {
                default:
                case LRSAuthMethod.Basic:
                    EditorGUILayout.TextField("-Username", config.Username);
                    EditorGUILayout.TextField("-Password", config.Password);
                    break;

                case LRSAuthMethod.BasicEncoded:
                    EditorGUILayout.TextField("-Basic Auth", config.BasicAuth);
                    break;
                }

                // Just show the values based on their auth method
            }
            // Warn them if we haven't gotten a configuration yet...
            else
            {
                EditorGUILayout.HelpBox(
                    "An LRS configuration has not been supplied!" +
                    "\n\nYou must supply an LRS configuration to use this library." +
                    "\n\nRight-click within the inspector and select:" +
                    "\n\n     Create > XAPI > New LRS Configuration"
                    , MessageType.Error
                    );
            }

            GUI.enabled           = true;
            EditorGUI.indentLevel = 0;
        }
 /// <summary>
 /// Send the given statement to the configured LRS.
 /// </summary>
 /// <param name="statements">Statement to send.</param>
 /// <param name="callback">Optional callback for once this operation ends.</param>
 public static void SendStatement(Statement statement, Action <StatementStoredResponse> callback = null)
 {
     // Make sure we have a messenger.  Each overload of this function eventually
     // uses this version, so we only need to check for a messenger here.
     //
     XAPIWrapper.CheckMessenger();
     XAPIMessenger.SendStatement(statement, callback);
 }
        /// <summary>
        /// Assign an LRS configuration to this wrapper.  This configuration will be used for
        /// all statements sent after assignment.
        /// </summary>
        /// <param name="config"></param>
        public static void AssignConfig(Config config)
        {
            // Make sure our messenger exists
            XAPIWrapper.CheckMessenger();

            // Relay this to it
            XAPIMessenger.AssignConfig(config);
        }
        /// <summary>
        /// Retrieves a single statement from the configured LRS.
        ///
        /// As you can't overload a function with identical argument types, this is private with
        /// a slightly different name.
        /// </summary>
        /// <param name="url"></param>
        /// <param name="callback"></param>
        private static void GetStatement(StatementQuery query, Action <Statement, UnityWebRequest> callback)
        {
            // Make sure we have a messenger
            XAPIWrapper.CheckMessenger();

            // Build the fully qualified URL
            string url = XAPIMessenger.Config.StatementEndpoint + query.BuildQueryString();;

            XAPIMessenger.GetStatement(url, callback);
        }
        /// <summary>
        /// Coroutine for sending an xAPI Statement.
        ///
        /// This version requires a constructed Statement object.
        /// </summary>
        /// <param name="statement"></param>
        /// <param name="callback"></param>
        /// <returns></returns>
        public static IEnumerator SendStatementRoutine(Statement statement, Action <StatementStoredResponse> callback = null)
        {
            var outboundArray = new Statement[] { statement };

            yield return(XAPIMessenger.SendMultiStatementRoutine(outboundArray, res =>
            {
                if (callback != null)
                {
                    callback(new StatementStoredResponse {
                        Request = res.Request,
                        Statement = res.Statements == null ? null : res.Statements[0],
                        StatementID = res.StatementIDs == null ? null : res.StatementIDs[0]
                    });
                }
            }));
        }
Beispiel #7
0
        public static IEnumerator GetStatementRoutine(string url, Action <Statement, UnityWebRequest> callback)
        {
            // Serialize this thing then convert into a utf-8 byte array
            var request = XAPIMessenger.BuildGetRequest(url);

            // Yield during the request
            yield return(request.SendWebRequest());

            // Return whatever we found.
            Statement statement = JsonConvert.DeserializeObject <Statement>(request.downloadHandler.text);

            // Fix IFI
            statement.Actor.ifi = statement.Actor.GuessIFI();

            // Make the callback
            callback(statement, request);
        }
Beispiel #8
0
        /// <summary>
        /// Coroutine for retrieving xAPI statements from the configured LRS.
        /// </summary>
        /// <param name="url"></param>
        /// <param name="callback"></param>
        /// <returns></returns>
        public static IEnumerator GetStatementsRoutine(string url, Action <StatementResult, UnityWebRequest> callback)
        {
            // Serialize this thing then convert into a utf-8 byte array
            var request = XAPIMessenger.BuildGetRequest(url);

            yield return(request.SendWebRequest());

            // Return whatever we found.
            StatementResult result = JsonConvert.DeserializeObject <StatementResult>(request.downloadHandler.text);

            // Correct Actor IFI Types
            for (int k = 0; k < result.StatementCount; k++)
            {
                result.Statements[k].Actor.ifi = result.Statements[k].Actor.GuessIFI();
            }

            // Make the callback
            callback(result, request);
        }
        /// <summary>
        /// Retrieves statements using the "more" property attached to a previous statement response.
        ///
        /// This function will remove the first parts of that "more" property to fit your LRS endpoint.
        /// </summary>
        /// <param name="moreIrl"></param>
        /// <param name="callback"></param>
        public static void GetMoreStatements(string moreIrl, Action <StatementResult, UnityWebRequest> callback)
        {
            // Make sure it's formatted correctly
            if (moreIrl.Contains("/more/"))
            {
                // Find out where it is
                int    index = moreIrl.IndexOf("/more/");
                string more  = moreIrl.Substring(index, moreIrl.Length - index);

                // Build the fully qualified URL
                string url = XAPIMessenger.Config.Endpoint + more;

                // Make the request
                XAPIMessenger.GetStatements(url, callback);
            }
            else
            {
                throw new ArgumentException("XAPIWrapper.GetMoreStatements: moreIrl argument must contain \"/more/\"");
            }
        }
Beispiel #10
0
        // Called when this component is first created
        void Awake()
        {
            // Check if we already have an instance live
            if (XAPIMessenger.instance != null)
            {
                GameObject.Destroy(this);
                return;
            }

            // If we didn't, then this is it
            XAPIMessenger.instance = this;
            GameObject.DontDestroyOnLoad(this.gameObject);

            // Check if we were assigned a ConfigObject
            if (this.configObject != null)
            {
                this.config = this.configObject.config;
                Debug.LogFormat("LRS Configuration loaded for: {0}", this.config.Endpoint);
            }
            else
            {
                Debug.LogErrorFormat("LRS CONFIGURATION MISSING FROM XAPI MESSENGER.  YOU MUST ASSIGN A CONFIGURATION.");
            }
        }
 /// <summary>
 /// Send an array of statements to the configured LRS.
 /// </summary>
 /// <param name="statements">Statements to send.</param>
 /// <param name="callback">Optional callback for once this operation ends.</param>
 public static void SendStatements(Statement[] statements, Action <MultiStatementStoredResponse> callback = null)
 {
     XAPIWrapper.CheckMessenger();
     XAPIMessenger.SendStatements(statements, callback);
 }
        /// <summary>
        /// Retrieves statements according to the StatementQuery values.
        ///
        /// The StatementResult object in the callback may contain a `MoreIRL` value.  If that is the case,
        /// then more statements matching your query can be returned using that endpoints with your LRS.
        /// </summary>
        /// <param name="result"></param>
        /// <param name="callback"></param>
        public static void GetStatements(StatementQuery query, Action <StatementResult, UnityWebRequest> callback)
        {
            string url = XAPIMessenger.Config.StatementEndpoint + query.BuildQueryString();

            XAPIMessenger.GetStatements(url, callback);
        }
 /// <summary>
 /// Retrieves statements from a fully-qualified URL pointing to the configured LRS.
 ///
 /// This is the most granular version of the call and should only be made by the wrapper itself.
 /// </summary>
 /// <param name="url"></param>
 /// <param name="callback"></param>
 public static void GetStatements(string url, Action <StatementResult, UnityWebRequest> callback)
 {
     // Make sure we have a messenger
     XAPIWrapper.CheckMessenger();
     XAPIMessenger.GetStatements(url, callback);
 }
Beispiel #14
0
 /// <summary>
 /// Retrieve statements from an LRS.
 /// </summary>
 /// <param name="url"></param>
 /// <param name="callback"></param>
 public static void GetStatement(string url, Action <Statement, UnityWebRequest> callback)
 {
     XAPIMessenger.instance.StartCoroutine(XAPIMessenger.GetStatementRoutine(url, callback));
 }
Beispiel #15
0
 /// <summary>
 /// Sends an xAPI statement.  This accepts a full statement as an argument.
 /// </summary>
 /// <param name="statement"></param>
 /// <param name="callback"></param>
 public static void SendStatements(Statement[] statements, Action <MultiStatementStoredResponse> callback = null)
 {
     XAPIMessenger.instance.StartCoroutine(XAPIMessenger.SendMultiStatementRoutine(statements, callback));
 }