internal void RequestEngagement(string request)
        {
            Action action = delegate() {
                JSONObject engagement = null;
                try {
                    engagement = Json.Deserialize(request) as JSONObject;
                } catch (Exception exception) {
                    Logger.LogError("Failed to deserialise engage request: " + exception.Message);
                }

                if (engagement != null)
                {
                    var decisionPoint = engagement["decisionPoint"] as string;
                    var flavour       = engagement["flavour"] as string;
                    var parameters    = engagement["parameters"] as JSONObject;
                    var id            = engagement["id"] as string;

                    EngageResponse engageResponse = (response, statusCode, error) => {
                        manager.EngageResponse(id, response, statusCode, error);
                    };

                    EngageRequest engageRequest = new EngageRequest(decisionPoint);
                    engageRequest.Flavour    = flavour;
                    engageRequest.Parameters = parameters;

                    StartCoroutine(Engage.Request(this, engageRequest, engageResponse));
                }
            };

            actions.Enqueue(action);
        }
        ////////////////////////////////////////////////////////////////////
        // Publisher MetaGame Engage Campaign Check
        ////////////////////////////////////////////////////////////////////
        public void MetaGameRequestEngagement(Engagement engagement, Action <Engagement> onCompleted, Action <Exception> onError)
        {
            DeltaDNA.Logger.LogDebug("MetaGame Campaign Check Click");
            if (String.IsNullOrEmpty(ENGAGE_REST_API_URL))
            {
                throw new Exception("Engage URL not configured.");
            }

            try
            {
                var dict = engagement.AsDictionary();

                var request = new EngageRequest(dict["decisionPoint"] as string);
                request.Flavour    = dict["flavour"] as string;
                request.Parameters = dict["parameters"] as Dictionary <string, object>;

                EngageResponse handler = (string response, int statusCode, string error) => {
                    engagement.Raw        = response;
                    engagement.StatusCode = statusCode;
                    engagement.Error      = error;

                    onCompleted(engagement);
                };

                StartCoroutine(MetaGameEngageRequest(this, request, handler));
            }
            catch (Exception ex)
            {
                DeltaDNA.Logger.LogWarning("Engagement request failed: " + ex.Message);
            }
        }
        /// <summary>
        /// Requests an Engagement with Engage.  The engagement is populated with the result of the request and
        /// returned in the onCompleted callback.  The engagement's json field can be queried for the returned json.
        /// A cache is maintained that will return the last valid response if available.
        /// </summary>
        /// <param name="engagement">The engagement the request is for.</param>
        /// <param name="onCompleted">Method called with the Engagement populated by Engage.</param>
        /// <exception cref="System.Exception">Thrown if the SDK has not been started, and if the Engage URL has not been set.</exception>
        public void RequestEngagement(Engagement engagement, Action <Engagement> onCompleted, Action <Exception> onError)
        {
            if (!this.started)
            {
                throw new Exception("You must first start the SDK via the StartSDK method.");
            }

            if (String.IsNullOrEmpty(this.EngageURL))
            {
                throw new Exception("Engage URL not configured.");
            }

            try {
                var dict = engagement.AsDictionary();

                var request = new EngageRequest(dict["decisionPoint"] as string);
                request.Flavour    = dict["flavour"] as string;
                request.Parameters = dict["parameters"] as Dictionary <string, object>;

                EngageResponse handler = (string response, int statusCode, string error) => {
                    engagement.Raw        = response;
                    engagement.StatusCode = statusCode;
                    engagement.Error      = error;

                    onCompleted(engagement);
                };

                StartCoroutine(Engage.Request(this, request, handler));
            } catch (Exception ex) {
                Logger.LogWarning("Engagement request failed: " + ex.Message);
            }
        }
Example #4
0
        internal static IEnumerator Request(MonoBehaviour caller, EngageRequest request, EngageResponse response)
        {
            string requestJSON = request.ToJSON();
            string url = DDNA.Instance.ResolveEngageURL(requestJSON);

            HttpRequest httpRequest = new HttpRequest(url);
            httpRequest.HTTPMethod = HttpRequest.HTTPMethodType.POST;
            httpRequest.HTTPBody = requestJSON;
            httpRequest.TimeoutSeconds = DDNA.Instance.Settings.HttpRequestEngageTimeoutSeconds;
            httpRequest.setHeader("Content-Type", "application/json");

            System.Action<int, string, string> httpHandler = (statusCode, data, error) => {

                string engagementKey = "DDSDK_ENGAGEMENT_" + request.DecisionPoint + "_" + request.Flavour;
                if (error == null && statusCode >= 200 && statusCode < 300) {
                    try {
                        PlayerPrefs.SetString(engagementKey, data);
                    } catch (Exception exception) {
                        Logger.LogWarning("Unable to cache engagement: "+exception.Message);
                    }
                } else {
                    Logger.LogDebug("Engagement failed with "+statusCode+" "+error);
                    if (PlayerPrefs.HasKey(engagementKey)) {
                        Logger.LogDebug("Using cached response");
                        data = "{\"isCachedResponse\":true," + PlayerPrefs.GetString(engagementKey).Substring(1);
                    } else {
                        data = "{}";
                    }
                }

                response(data, statusCode, error);
            };

            yield return caller.StartCoroutine(Network.SendRequest(httpRequest, httpHandler));
        }
Example #5
0
        override internal void RequestEngagement(Engagement engagement, Action <Dictionary <string, object> > callback)
        {
            if (!this.started)
            {
                throw new Exception("You must first start the SDK via the StartSDK method.");
            }
            else if (whitelistDps.Count != 0 &&
                     !whitelistDps.Contains(engagement.GetDecisionPointAndFlavour()))
            {
                Logger.LogDebug(string.Format(
                                    "Decision point {0} is not whitelisted",
                                    engagement.GetDecisionPointAndFlavour()));
                engagement.StatusCode = 200;
                engagement.Raw        = "{}";
                callback(engagement.JSON);
                return;
            }

            if (String.IsNullOrEmpty(this.EngageURL))
            {
                throw new Exception("Engage URL not configured.");
            }

            try {
                var dict = engagement.AsDictionary();

                var request = new EngageRequest(dict["decisionPoint"] as string);
                request.Flavour    = dict["flavour"] as string;
                request.Parameters = dict["parameters"] as Dictionary <string, object>;

                EngageResponse handler = (string response, int statusCode, string error) => {
                    JSONObject responseJSON = new JSONObject();
                    if (response != null)
                    {
                        try {
                            responseJSON = DeltaDNA.MiniJSON.Json.Deserialize(response) as JSONObject;
                        } catch (Exception exception) {
                            Logger.LogError("Engagement " + engagement.DecisionPoint + " responded with invalid JSON: " + exception.Message);
                        }
                    }
                    callback(responseJSON);
                };

                StartCoroutine(Engage.Request(ddna, engageCache, request, handler));
            } catch (Exception ex) {
                Logger.LogWarning("Engagement request failed: " + ex.Message);
            }
        }
Example #6
0
        internal static IEnumerator Request(
            MonoBehaviour caller,
            EngageCache cache,
            EngageRequest request,
            EngageResponse response,
            bool useConfigurationTimeout = false)
        {
            string requestJSON = request.ToJSON();
            string url         = DDNA.Instance.ResolveEngageURL(requestJSON);

            HttpRequest httpRequest = new HttpRequest(url);

            httpRequest.HTTPMethod     = HttpRequest.HTTPMethodType.POST;
            httpRequest.HTTPBody       = requestJSON;
            httpRequest.TimeoutSeconds = useConfigurationTimeout ? DDNA.Instance.Settings.HttpRequestConfigurationTimeoutSeconds : DDNA.Instance.Settings.HttpRequestEngageTimeoutSeconds;
            httpRequest.setHeader("Content-Type", "application/json");

            Action <int, string, string> httpHandler = (statusCode, data, error) => {
                if (error == null && statusCode >= 200 && statusCode < 300)
                {
                    cache.Put(request.DecisionPoint, request.Flavour, data);
                }
                else
                {
                    Logger.LogDebug("Engagement failed with " + statusCode + " " + error);
                    var isClientError = statusCode >= 400 && statusCode < 500;
                    var cached        = cache.Get(request.DecisionPoint, request.Flavour);
                    if (cached != null && !isClientError)
                    {
                        Logger.LogDebug("Using cached response");
                        data = "{\"isCachedResponse\":true," + cached.Substring(1);
                    }
                    else
                    {
                        data = "{}";
                    }
                }

                response(data, statusCode, error);
            };

            yield return(caller.StartCoroutine(Network.SendRequest(httpRequest, httpHandler)));
        }
Example #7
0
        override internal void RequestEngagement(Engagement engagement, Action <Engagement> onCompleted, Action <Exception> onError)
        {
            if (!this.started)
            {
                throw new Exception("You must first start the SDK via the StartSDK method.");
            }
            else if (whitelistDps.Count != 0 &&
                     !whitelistDps.Contains(engagement.GetDecisionPointAndFlavour()))
            {
                Logger.LogDebug(string.Format(
                                    "Decision point {0} is not whitelisted",
                                    engagement.GetDecisionPointAndFlavour()));
                engagement.StatusCode = 200;
                engagement.Raw        = "{}";
                onCompleted(engagement);
                return;
            }

            if (String.IsNullOrEmpty(this.EngageURL))
            {
                throw new Exception("Engage URL not configured.");
            }

            try {
                var dict = engagement.AsDictionary();

                var request = new EngageRequest(dict["decisionPoint"] as string);
                request.Flavour    = dict["flavour"] as string;
                request.Parameters = dict["parameters"] as Dictionary <string, object>;

                EngageResponse handler = (string response, int statusCode, string error) => {
                    engagement.Raw        = response;
                    engagement.StatusCode = statusCode;
                    engagement.Error      = error;

                    onCompleted(engagement);
                };

                StartCoroutine(Engage.Request(ddna, engageCache, request, handler));
            } catch (Exception ex) {
                Logger.LogWarning("Engagement request failed: " + ex.Message);
            }
        }
        /// <summary>
        /// Makes an Engage request.  The result of the engagement will be passed as a dictionary object to your callback method. The dictionary
        /// will be empty if engage couldn't be reached on a campaign is not running.
        /// A cache is maintained that will return the last valid response if available.
        /// </summary>
        /// <param name="engagement">The engagement the request is for.</param>
        /// <param name="callback">Method called with the response from Engage.</param>
        /// <exception cref="System.Exception">Thrown if the SDK has not been started, and if the Engage URL has not been set.</exception>
        public void RequestEngagement(Engagement engagement, Action <Dictionary <string, object> > callback)
        {
            if (!this.started)
            {
                throw new Exception("You must first start the SDK via the StartSDK method.");
            }

            if (String.IsNullOrEmpty(this.EngageURL))
            {
                throw new Exception("Engage URL not configured.");
            }

            try {
                var dict = engagement.AsDictionary();

                var request = new EngageRequest(dict["decisionPoint"] as string);
                request.Flavour    = dict["flavour"] as string;
                request.Parameters = dict["parameters"] as Dictionary <string, object>;

                EngageResponse handler = (string response, int statusCode, string error) => {
                    JSONObject responseJSON = new JSONObject();
                    if (response != null)
                    {
                        try {
                            responseJSON = DeltaDNA.MiniJSON.Json.Deserialize(response) as JSONObject;
                        } catch (Exception exception) {
                            Logger.LogError("Engagement " + engagement.DecisionPoint + " responded with invalid JSON: " + exception.Message);
                        }
                    }
                    callback(responseJSON);
                };

                StartCoroutine(Engage.Request(this, request, handler));
            } catch (Exception ex) {
                Logger.LogWarning("Engagement request failed: " + ex.Message);
            }
        }
        internal static IEnumerator MetaGameEngageRequest(MonoBehaviour caller, EngageRequest request, EngageResponse response)
        {
            string requestJSON = request.ToJSON();
            string url         = String.Format("{0}/{1}", ENGAGE_REST_API_URL, ENVIRONMENT_KEY);

            HttpRequest httpRequest = new HttpRequest(url);

            httpRequest.HTTPMethod     = HttpRequest.HTTPMethodType.POST;
            httpRequest.HTTPBody       = requestJSON;
            httpRequest.TimeoutSeconds = DDNA.Instance.Settings.HttpRequestEngageTimeoutSeconds;
            httpRequest.setHeader("Content-Type", "application/json");

            System.Action <int, string, string> httpHandler = (statusCode, data, error) => {
                string engagementKey = "DDSDK_ENGAGEMENT_" + request.DecisionPoint + "_" + request.Flavour;
                if (error == null && statusCode >= 200 && statusCode < 300)
                {
                    try
                    {
                        PlayerPrefs.SetString(engagementKey, data);
                    }
                    catch (Exception exception)
                    {
                        DeltaDNA.Logger.LogWarning("Unable to cache engagement: " + exception.Message);
                    }
                }
                else
                {
                    DeltaDNA.Logger.LogDebug("Engagement failed with " + statusCode + " " + error);
                    if (PlayerPrefs.HasKey(engagementKey))
                    {
                        DeltaDNA.Logger.LogDebug("Using cached response");
                        data = "{\"isCachedResponse\":true," + PlayerPrefs.GetString(engagementKey).Substring(1);
                    }
                    else
                    {
                        data = "{}";
                    }
                }

                response(data, statusCode, error);
            };

            yield return(caller.StartCoroutine(DeltaDNA.Network.SendRequest(httpRequest, httpHandler)));
        }