UnityObjectRecognition/Assets/Scripts/Unity-API-connection/Server/ControllerAPI.cs

using System;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Events;


namespace ExtralityLab.API
{
    public class ControllerAPI
    {
        // Entry point of the webservice
        static string SERVER_HOST = "http://127.0.0.1:8000"; // Configured dynamically.

        // Network manager
        private HttpClient httpClient;
        private Action<string> OnErrorHandler = null;

        // Constructor
        public ControllerAPI(Action<string> onErrorHandler = null)
        {
            httpClient = new HttpClient(new JsonSerializationOption());
            if(onErrorHandler != null )
            {
                OnErrorHandler = onErrorHandler;
            }
        }

        /// <summary>
        /// Callback for all the Api requests that fail
        /// </summary>
        /// <param name="text"></param>
        private void OnErrorHttpResponse(string text)
        {
            if (OnErrorHandler != null)
            {
                OnErrorHandler(text);
            }
            else
            {
                Debug.LogWarning($"Error on HttpResponse: {text}");
                Debug.Log($"\n{HttpClient.latestServerResponse}");
            }
        }

         public async void ProcessImageYOLO(ExtralityLab.API.Image dataObject, UnityAction<YoloServerResponse> callbackOnSuccess)
        {
            // Request info about this environment to the server
            string url = SERVER_HOST + string.Format(Urls.YOLO_DETECT);

            /////// TODO: Get image bytes
            
            string dataString = dataObject.Stringify();//JsonConvert.SerializeObject(data_object);

            // Post request
            YoloServerResponse result = new YoloServerResponse();
            result = await httpClient.Post<YoloServerResponse>(url, dataString, callbackOnSuccess, OnErrorHttpResponse);
        }

        ////////////////////////////
        /// ////////////////////////////
        /// ////////////////////////////
        /// ////////////////////////////

        //// TODO: REMOVE CALLBACKS BELOW WHEN NOT NEEDED!!

        /// <summary>
        /// Checks whether the server produces any response in the root URI
        /// </summary>
        /// <param name="hostName"></param>
        /// <param name="portNumber"></param>
        public async void ConfigureServer(string hostName, int portNumber, UnityAction<BasicHttpResponse> callbackOnSuccess)
        {
            if (hostName.CompareTo("") == 0)
                Debug.LogError("HostName cannot be empty. Please define the address for the API host");

            // Configure the format of the URLs
            SERVER_HOST = hostName + ":" + portNumber.ToString();
            Debug.Log($"ViTAL server configured at {SERVER_HOST}");

            // Initialize objects
            BasicHttpResponse response = await httpClient.Get<BasicHttpResponse>(SERVER_HOST + Urls.ROOT, callbackOnSuccess, OnErrorHttpResponse);
        }

        /// <summary>
        /// Writes test data in mongoDB. For example, when the DB is empty 
        /// or the collections do not exist
        /// </summary>
        /// <param name="callbackOnSuccess"></param>
        public async void GetWriteDataInDB(UnityAction<BasicHttpResponse> callbackOnSuccess)
        {
            BasicHttpResponse response = new BasicHttpResponse();
            response = await httpClient.Get(SERVER_HOST + Urls.WRITE_TEST_DATA, callbackOnSuccess, OnErrorHttpResponse);
        }

        /// <summary>
        /// Logs in a user in the system based on email and password
        /// </summary>
        /// <param name="callbackOnSuccess"></param>
        public async void PostLogin(LoginCredentials dataObject, UnityAction<Dictionary<string, string>> callbackOnSuccess)
        {
            // Request info about this environment to the server
            string url = SERVER_HOST + string.Format(Urls.USERS_LOGIN);//, data.application_name);

            // Convert the object to json
            //string data_string = data_object.Stringify(pretty:false);

            // Prepare element
            string dataString = dataObject.Stringify();//JsonConvert.SerializeObject(data_object);
            Dictionary<string, object> dataDict = JsonSerializationOption.ParseJsonToDictionary(dataString);
            dataDict.Remove("_id");

            // Dict to json
            dataString = JsonSerializationOption.ParseDictionaryToJson(dataDict);

            // Post request
            Dictionary<string, string> response = new Dictionary<string, string>();
            response = await httpClient.Post(url, dataString, callbackOnSuccess, OnErrorHttpResponse);
        }

        /// <summary>
        /// Logs in a user in the system based on email and password
        /// </summary>
        /// <param name="callbackOnSuccess"></param>
        public async void GetUserFromToken(UnityAction<User> callbackOnSuccess, string authorizationToken)
        {
            // Request info about this environment to the server
            string url = SERVER_HOST + string.Format(Urls.USERS_GET_USER);//, data.application_name);

            User response = new User();
            response = await httpClient.Get<User>(url, callbackOnSuccess, OnErrorHttpResponse, authorizationToken);
        }

        public async void GetTraineesFromTrainer(string trainer_id, UnityAction<List<User>> callbackOnSuccess, UnityAction<string> callbackOnError, string authorizationToken)
        {
            // Request info about this environment to the server
            string url = SERVER_HOST + string.Format(Urls.USERS_GET_TRAINES_BY_TRAINER, trainer_id);

            List<User> response = new List<User>();
            response = await httpClient.Get<List<User>>(url, callbackOnSuccess, callbackOnError, authorizationToken);
        }

        public async void NotifySessionStarted(string session_id, UnityAction<BasicHttpResponse> callbackOnSuccess, string authorizationToken)
        {
            // Request info about this environment to the server
            string url = SERVER_HOST + string.Format(Urls.SESSION_STARTED, session_id);

            BasicHttpResponse response = new BasicHttpResponse();
            response = await httpClient.Get<BasicHttpResponse>(url, callbackOnSuccess, OnErrorHttpResponse, authorizationToken);
        }

        public async void NotifySessionStopped(string session_id, UnityAction<BasicHttpResponse> callbackOnSuccess)
        {
            // Request info about this environment to the server
            string url = SERVER_HOST + string.Format(Urls.SESSION_ENDED, session_id);

            BasicHttpResponse response = new BasicHttpResponse();
            response = await httpClient.Get<BasicHttpResponse>(url, callbackOnSuccess, OnErrorHttpResponse);
        }


        /// <summary>
        /// List of all environments
        /// </summary>
        public async void GetAllEnvironmentsXR(UnityAction< List<EnvironmentXR> > callbackOnSuccess)
        {
            List<EnvironmentXR> response = new List<EnvironmentXR>();
            response = await httpClient.Get(SERVER_HOST + Urls.ENVIRONMENTS_ROOT, callbackOnSuccess, OnErrorHttpResponse);
        }


        //[ContextMenu("BioPhyS-ViTAL/GetEnvironmentData")]
        /// <summary>
        /// Function to do the initial request, when the application starts.
        /// </summary>
        /// <param name="applicationName">Application name</param>
        public async void GetEnvironmentXR(string applicationName, UnityAction< List<EnvironmentXR> > callbackOnSuccess)
        {
            if (applicationName.CompareTo("") == 0)
                Debug.LogError("The application name cannot be empty. Please define a unique identifier for the current XR environment.");

            // Request info about this environment to the server
            string url = SERVER_HOST + string.Format(Urls.ENVIRONMENTS_BY_NAME, applicationName);

            List<EnvironmentXR> result = new List<EnvironmentXR>();
            result = await httpClient.Get< List<EnvironmentXR> >(url, callbackOnSuccess, OnErrorHttpResponse);
        }

        public async void GetEnvironmentXRwithID(string applicationId, UnityAction<EnvironmentXR> callbackOnSuccess, string authorizationToken)
        {
            if (applicationId.CompareTo("") == 0 && applicationId != null)
            {
                Debug.LogError("The application name cannot be empty. Please define a unique identifier for the current XR environment.");
                return;
            }

            // Request info about this environment to the server
            string url = SERVER_HOST + string.Format(Urls.ENVIRONMENTS_BY_ID, applicationId);

            EnvironmentXR result = new EnvironmentXR();
            result = await httpClient.Get<EnvironmentXR>(url, callbackOnSuccess, OnErrorHttpResponse, authorizationToken);
        }


        public async void PostEnvironmentXR(EnvironmentXR dataObject, UnityAction<BasicHttpResponse> callbackOnSuccess)
        {
            // Request info about this environment to the server
            string url = SERVER_HOST + string.Format(Urls.ENVIRONMENTS_ROOT);//, data.application_name);

            // Convert the object to json
            //string data_string = data_object.Stringify(pretty:false);

            // Prepare element
            string dataString = dataObject.Stringify();//JsonConvert.SerializeObject(data_object);
            Dictionary<string, object> dataDict = JsonSerializationOption.ParseJsonToDictionary(dataString);
            dataDict.Remove("_id");
            dataDict.Remove("created_at");
            dataDict.Remove("sessions");

            // Dict to json
            dataString = JsonSerializationOption.ParseDictionaryToJson(dataDict);

            // Post request
            BasicHttpResponse result = new BasicHttpResponse();
            result = await httpClient.Post<BasicHttpResponse>(url, dataString, callbackOnSuccess, OnErrorHttpResponse);
        }

        public async void UpdateAdaptiveComponentsEnvironmentXR(EnvironmentXR dataObject, UnityAction<EnvironmentXR> callbackOnSuccess, string authorizationToken)
        {
            // Request info about this environment to the server
            string url = SERVER_HOST + string.Format(Urls.ENVIRONMENTS_BY_ID, dataObject._id);

            // Prepare element
            string dataString = dataObject.Stringify();//JsonConvert.SerializeObject(data_object);
            Dictionary<string, object> dataDict = JsonSerializationOption.ParseJsonToDictionary(dataString);
            //dataDict.Remove("_id");
            dataDict.Remove("created_at");
            dataDict.Remove("sessions");

            List<Dictionary<string,object>> dataAcList = new List<Dictionary<string, object>>();
            foreach(AdaptiveComponent ac in dataObject.adaptive_components)
            {
                string dataAcString = ac.Stringify();
                Dictionary<string, object> dataAcDict = JsonSerializationOption.ParseJsonToDictionary(dataAcString);
                dataAcDict.Remove("_id");
                //dataAcString = JsonSerializationOption.ParseDictionaryToJson(dataAcDict);
                dataAcList.Add(dataAcDict);
            }
            dataDict.Remove("adaptive_components"); // Delete the ones containing `_id`
            dataDict.Add("adaptive_components", dataAcList); // Put the same without `_id`

            // Dict to json
            dataString = JsonSerializationOption.ParseDictionaryToJson(dataDict);

            // Post request
            EnvironmentXR result = new EnvironmentXR();
            result = await httpClient.Update<EnvironmentXR>(url, dataString, callbackOnSuccess, OnErrorHttpResponse, authorizationToken);
        }



        public async void PostSession(Session dataObject, UnityAction<BasicHttpResponse> callbackOnSuccess, string authorizationToken)
        {
            // Request info about this environment to the server
            string url = SERVER_HOST + string.Format(Urls.SESSIONS_ROOT);//, data.application_name);

            // Convert the object to json
            //string data_string = data_object.Stringify(pretty:false);

            // Prepare element
            string dataString = dataObject.Stringify();//JsonConvert.SerializeObject(data_object);
            Dictionary<string, object> dataDict = JsonSerializationOption.ParseJsonToDictionary(dataString);
            dataDict.Remove("_id");
            dataDict.Remove("created_at");
            dataDict.Remove("start_time");
            dataDict.Remove("end_time");
            dataDict.Remove("duration_in_secs");
            dataDict.Remove("bio_data");
            dataDict.Remove("environment_data");
            dataDict.Remove("adaptations");
            dataDict.Remove("report_results");

            // Dict to json
            dataString = JsonSerializationOption.ParseDictionaryToJson(dataDict);

            // Post request
            BasicHttpResponse result = new BasicHttpResponse();
            result = await httpClient.Post<BasicHttpResponse>(url, dataString, callbackOnSuccess, OnErrorHttpResponse, authorizationToken);
        }


        public async void PostSessionBioDataAppend(string sessionId, BioData dataObject, UnityAction<BasicHttpResponse> callbackOnSuccess)
        {
            // Request info about this environment to the server
            string url = SERVER_HOST + string.Format(Urls.ENDPOINT_BIO_DATA, sessionId);

            // Convert the object to json
            //string data_string = data_object.Stringify(pretty:false);

            // Prepare element
            string dataString = JsonUtility.ToJson(dataObject);
            Dictionary<string, object> dataDict = JsonSerializationOption.ParseJsonToDictionary(dataString);
            ////dataDict.Remove("sum_value");
            ////dataDict.Remove("num_samples");

            // Dict to json
            dataString = JsonSerializationOption.ParseDictionaryToJson(dataDict);

            // Post request
            BasicHttpResponse result = new BasicHttpResponse();
            result = await httpClient.Post<BasicHttpResponse>(url, dataString, callbackOnSuccess, OnErrorHttpResponse);
        }

        public async void PostSessionEnvironmentDataAppend(string sessionId, EnvironmentData dataObject, UnityAction<BasicHttpResponse> callbackOnSuccess)
        {
            // Request info about this environment to the server
            string url = SERVER_HOST + string.Format(Urls.ENDPOINT_ENVIRONMENT_DATA, sessionId);

            // Convert the object to json
            //string data_string = data_object.Stringify(pretty:false);

            // Prepare element
            string dataString = JsonUtility.ToJson(dataObject);
            Dictionary<string, object> dataDict = JsonSerializationOption.ParseJsonToDictionary(dataString);

            // Dict to json
            dataString = JsonSerializationOption.ParseDictionaryToJson(dataDict);

            // Post request
            BasicHttpResponse result = new BasicHttpResponse();
            result = await httpClient.Post<BasicHttpResponse>(url, dataString, callbackOnSuccess, OnErrorHttpResponse);
        }


        public async void PostSessionControlActionDataAppend(string sessionId, ControlAction dataObject, UnityAction<BasicHttpResponse> callbackOnSuccess)
        {
            // Request info about this environment to the server
            string url = SERVER_HOST + string.Format(Urls.ENDPOINT_CONTROL_ACTION, sessionId);

            // Convert the object to json
            //string data_string = data_object.Stringify(pretty:false);

            // Prepare element
            string dataString = JsonUtility.ToJson(dataObject);//JsonConvert.SerializeObject(data_object);
            Dictionary<string, object> dataDict = JsonSerializationOption.ParseJsonToDictionary(dataString);

            // Dict to json
            dataString = JsonSerializationOption.ParseDictionaryToJson(dataDict);

            // Post request
            BasicHttpResponse result = new BasicHttpResponse();
            result = await httpClient.Post<BasicHttpResponse>(url, dataString, callbackOnSuccess, OnErrorHttpResponse);
        }

        public async void PostReportResults(Session sessionObject, ReportResults dataObject, UnityAction<BasicHttpResponse> callbackOnSuccess)
        {
            // Request info about this environment to the server
            string url = SERVER_HOST + string.Format(Urls.ENDPOINT_REPORT_RESULTS, sessionObject.ObjectId);

            // Convert the object to json
            string dataString = dataObject.Stringify(pretty: false);

            // Prepare element
            //string dataString = JsonConvert.SerializeObject(dataObject);//JsonConvert.SerializeObject(data_object);
            Dictionary<string, object> dataDict = JsonSerializationOption.ParseJsonToDictionary(dataString);
            dataDict.Remove("_id");

            // Dict to json
            dataString = JsonSerializationOption.ParseDictionaryToJson(dataDict);

            // Post request
            BasicHttpResponse result = new BasicHttpResponse();
            result = await httpClient.Post<BasicHttpResponse>(url, dataString, callbackOnSuccess, OnErrorHttpResponse);
        }
    }
}