protected string SerializeMessageFromProperties(Platform?platform)
        {
            if (!platform.HasValue)
            {
                GCMNotificationPayload  gcmPayload  = model.GCMNotificationPayload ?? new GCMNotificationPayload(model.NotificationPayload);
                APNSNotificationPayload apnsPayload = model.APNSNotificationPayload ?? new APNSNotificationPayload(model.NotificationPayload);

                APNSPushMessage generatedApns = GenerateAPNSMessageFromPayload(apnsPayload);
                GCMPushMessage  generatedGcm  = GenerateGCMMessageFromPayload(gcmPayload);
                return(CreateSNSNotificationMessage(generatedApns, generatedGcm, model.TargetEnvironment, apnsPayload.CustomPayload, gcmPayload.CustomPayload, model.SnsDefaultMessage));
            }

            switch (platform.Value)
            {
            case Platform.APNS:
                APNSNotificationPayload apnsPayload   = model.APNSNotificationPayload ?? new APNSNotificationPayload(model.NotificationPayload);
                APNSPushMessage         generatedApns = GenerateAPNSMessageFromPayload(apnsPayload);
                return(CreateSNSNotificationMessage(generatedApns, null, model.TargetEnvironment, apnsPayload.CustomPayload, null, model.SnsDefaultMessage));

            case Platform.GCM:
                GCMNotificationPayload gcmPayload   = model.GCMNotificationPayload ?? new GCMNotificationPayload(model.NotificationPayload);
                GCMPushMessage         generatedGcm = GenerateGCMMessageFromPayload(gcmPayload);
                return(CreateSNSNotificationMessage(null, generatedGcm, model.TargetEnvironment, null, gcmPayload.CustomPayload, model.SnsDefaultMessage));

            default:
                return("");
            }
        }
        protected GCMPushMessage GenerateGCMMessageFromPayload(GCMNotificationPayload payload)
        {
            GCMPushMessage gcmMessage = new GCMPushMessage();

            gcmMessage.title = payload.Title;
            gcmMessage.body  = payload.Body;
            gcmMessage.badge = payload.Badge;
            gcmMessage.sound = payload.Sound;

            return(gcmMessage);
        }
Example #3
0
        private string GetPayload(GCMPushMessage msg)
        {
            var json = new JObject();

            json["to"] = msg.Destination;

            if (!string.IsNullOrEmpty(msg.CollapseKey))
            {
                json["collapse_key"] = msg.CollapseKey;
            }

            if (msg.TimeToLive.HasValue)
            {
                json["time_to_live"] = msg.TimeToLive.Value;
            }

            if (msg.RegistrationIds != null && msg.RegistrationIds.Count > 0)
            {
                json["registration_ids"] = new JArray(msg.RegistrationIds.ToArray());
            }

            if (msg.DelayWhileIdle.HasValue)
            {
                json["delay_while_idle"] = msg.DelayWhileIdle.Value;
            }

            if (msg.DryRun.HasValue && msg.DryRun.Value)
            {
                json["dry_run"] = true;
            }

            if (!string.IsNullOrEmpty(msg.JsonData))
            {
                var jsonData = JObject.Parse(msg.JsonData);

                if (jsonData != null)
                {
                    json["data"] = jsonData;
                }
            }

            if (!string.IsNullOrWhiteSpace(msg.NotificationKey))
            {
                json["notification_key"] = msg.NotificationKey;
            }

            if (!string.IsNullOrWhiteSpace(msg.RestrictedPackageName))
            {
                json["restricted_package_name"] = msg.RestrictedPackageName;
            }

            return(json.ToString());
        }
Example #4
0
        /// <summary>
        /// Creates the HTTP request.
        /// </summary>
        /// <param name="req">The req.</param>
        /// <returns></returns>
        private HttpRequestMessage CreateHttpRequest(GCMPushMessage req)
        {
            var payload = GetPayload(req);

            Info("Payload: {0}", payload);
            var request = new HttpRequestMessage(HttpMethod.Post, GCMSendEndpoint)
            {
                Content = new StringContent(payload, Encoding.UTF8, "application/json")
            };

            request.Headers.Add("Authorization", "key=" + req.AuthorizationToken);

            return(request);
        }
        protected string CreateSNSNotificationMessage(APNSPushMessage apnsPushMessage, GCMPushMessage gcmPushMessage, TargetEnvironmentType targetEnvironment,
                                                      Dictionary <string, object> APNSCustomPayload, Dictionary <string, object> GCMCustomPayload, string snsDefaultMessage)
        {
            if (apnsPushMessage == null && gcmPushMessage == null)
            {
                return("");
            }

            var eo = new ExpandoObject();

            dynamic eoDynamic    = eo;
            string  apnsContents = null;
            string  gcmContents  = null;

            if (apnsPushMessage != null)
            {
                var dict = APNSCustomPayload;

                if (dict != null)
                {
                    var eoColl = (ICollection <KeyValuePair <string, object> >)eo;

                    foreach (var kvp in dict)
                    {
                        eoColl.Add(kvp);
                    }
                }

                eoDynamic.aps = apnsPushMessage;
                apnsContents  = JsonConvert.SerializeObject(eoDynamic).Replace("\"", "\"");
            }
            if (gcmPushMessage != null)
            {
                var dict = GCMCustomPayload;

                dynamic dataFieldValue = gcmPushMessage.ToDynamic();
                if (dict != null)
                {
                    var eoColl = (ICollection <KeyValuePair <string, object> >)dataFieldValue;

                    foreach (var kvp in dict)
                    {
                        eoColl.Add(kvp);
                    }
                }

                eoDynamic.data = dataFieldValue;
                gcmContents    = JsonConvert.SerializeObject(eoDynamic).Replace("\"", "\"");
            }

            SNSNotificationMessage notification = new SNSNotificationMessage(snsDefaultMessage);

            bool isSandbox = targetEnvironment == TargetEnvironmentType.Sandbox;

            if (isSandbox)
            {
                notification.APNS_SANDBOX = apnsContents;
                notification.GCM          = gcmContents;
            }
            else
            {
                notification.APNS = apnsContents;
                notification.GCM  = gcmContents;
            }
            return(JsonConvert.SerializeObject(notification));
        }