public PushNotificationSender(Action<string> log)
{
this.log = log;
string notificationHubName = ConfigurationManager.AppSettings["MS_NotificationHubName"];
string notificationHubConnection = ConfigurationManager.ConnectionStrings["MS_NotificationHubConnectionString"].ConnectionString;
this.hubClient = NotificationHubClient.CreateClientFromConnectionString(notificationHubConnection, notificationHubName);
}
private static void SendTemplateToast()
{
_hub = NotificationHubClient.CreateClientFromConnectionString(_ep, _notHubPath);
Dictionary<string, string> temp = new Dictionary<string, string>();
temp.Add("meters", "10");
temp.Add("feet", "33");
_hub.SendTemplateNotificationAsync(temp).Wait();
}
private Notifier()
{
var testSend = false;
#if DEBUG
testSend = true;
#endif
var hubConnectionString = ConfigurationManager.ConnectionStrings["MS_NotificationHubConnectionString"].ToString();
var hubName = ConfigurationManager.AppSettings["MS_NotificationHubName"];
hub = NotificationHubClient.CreateClientFromConnectionString(hubConnectionString, hubName, testSend);
}
private static void SendTaggedToast()
{
_hub = NotificationHubClient.CreateClientFromConnectionString(_ep, _notHubPath);
string tag = Console.ReadLine();
do
{
_hub.SendWindowsNativeNotificationAsync(_toast,tag).Wait();
tag = Console.ReadLine();
} while (tag.CompareTo("q") != 0);
}
private async Task RegisterNotificationHub()
{
try
{
Hub = NotificationHubClient.CreateClientFromConnectionString(
@"Endpoint=sb://fundoraxamarinhub-ns.servicebus.windows.net/;SharedAccessKeyName=DefaultFullSharedAccessSignature;SharedAccessKey=L5pOQdUuSBd7klcuHXE6fAN69It5iLRDnm7q3mm2tfo=",
"fundoraxamarinhub");
}
catch (Exception ex)
{
ex.ToString();
}
}
public ClientNotificationHub(string connectionString, string hubName)
{
if (string.IsNullOrEmpty(connectionString))
{
throw new ArgumentNullException("connectionString");
}
if (string.IsNullOrEmpty(hubName))
{
throw new ArgumentNullException("hubName");
}
_hub = NotificationHubClient.CreateClientFromConnectionString(connectionString, hubName);
}
static void ReceiveMessageAndSendNotification(string connectionString)
{
// Initialize the Notification Hub
string hubConnectionString = CloudConfigurationManager.GetSetting
("Microsoft.NotificationHub.ConnectionString");
hub = NotificationHubClient.CreateClientFromConnectionString
(hubConnectionString, "[hubName]");
SubscriptionClient Client =
SubscriptionClient.CreateFromConnectionString
(connectionString, sampleTopic, sampleSubscription);
Client.Receive();
// Continuously process messages received from the subscription
while (true)
{
BrokeredMessage message = Client.Receive();
var toastMessage = @"<toast><visual><binding template=""ToastText01""><text id=""1"">{messagepayload}</text></binding></visual></toast>";
if (message != null)
{
try
{
Console.WriteLine(message.MessageId);
Console.WriteLine(message.SequenceNumber);
string messageBody = message.GetBody<string>();
Console.WriteLine("Body: " + messageBody + "\n");
toastMessage = toastMessage.Replace("{messagepayload}", messageBody);
SendNotificationAsync(toastMessage);
// Remove message from subscription
message.Complete();
}
catch (Exception)
{
// Indicate a problem, unlock message in subscription
message.Abandon();
}
}
}
}
protected override void Initialize(HttpControllerContext controllerContext)
{
base.Initialize(controllerContext);
// Get the Mobile App settings.
MobileAppSettingsDictionary settings =
Configuration.GetMobileAppSettingsProvider().GetMobileAppSettings();
// Get the Notification Hubs credentials for the Mobile App.
string notificationHubName = settings.NotificationHubName;
string notificationHubConnection = settings
.Connections[MobileAppSettingsKeys.NotificationHubConnectionString]
.ConnectionString;
// Create the notification hub client.
hubClient = NotificationHubClient
.CreateClientFromConnectionString(notificationHubConnection,
notificationHubName);
}
private async Task sendNotification(string content)
{
if (hub == null)
hub = NotificationHubClient.CreateClientFromConnectionString(connectionStr, hubPath);
//var toast = @"<toast launch=""MainPage.xaml?param=neworder""><visual><binding template=""ToastText01""><text id=""1"">" + msg + @"</text></binding></visual></toast>";
if (rawCheck.IsChecked == true)
{
Notification notification = new WindowsNotification(content);
notification.Headers.Add("X-WNS-Type", "wns/raw");
await hub.SendNotificationAsync(notification);
}
else
{
await hub.SendWindowsNativeNotificationAsync(content);
}
}
public RegisterAPIController()
{
hub = Notifications.Instance.Hub;
}
private Notifications()
{
Hub = NotificationHubClient.CreateClientFromConnectionString("Endpoint=sb://gardenrnotif.servicebus.windows.net/;SharedAccessKeyName=DefaultFullSharedAccessSignature;SharedAccessKey=8bPfKiz9h4jY/e0JtAUqN/tCybd+dOtj3X/tA6zndxM=", "notific");
}
public NotificationHubConnectionSettings()
{
Hub = NotificationHubClient.CreateClientFromConnectionString(ConfigurationManager.AppSettings["Microsoft.Azure.NotificationHubs.ConnectionString"], ConfigurationManager.AppSettings["NotificationHub"]);
}
public NotificationGateway()
{
hub = NotificationHubClient.CreateClientFromConnectionString(MyFitnessTrackerLibrary.Globals.MyFitAppSettings.NotificationHubConnectionString, MyFitnessTrackerLibrary.Globals.MyFitAppSettings.NotificationHubName);
}
public Notifications()
{
Hub = NotificationHubClient.CreateClientFromConnectionString("Endpoint=sb://nmct-ns.servicebus.windows.net/;SharedAccessKeyName=DefaultFullSharedAccessSignature;SharedAccessKey=5SUkAJCmNcT97g9AazjlebbVHukTBX3im4FR7Jvk7LU=", "nmct");
}
public PushController(NotificationHubClient hub)
{
_hub = hub;
}
public NotificationManager(IOptions <NotificationHubConfig> hubConfigOptions)
{
config = hubConfigOptions.Value;
Hub = NotificationHubClient.CreateClientFromConnectionString(config.NotificationHub, config.NotificationHubName);
registeredDevices = new List <UserDevice>();
}
public DevopenspaceNotifications()
{
Hub = NotificationHubClient.CreateClientFromConnectionString(ConfigurationManager.AppSettings["HubConnection"], ConfigurationManager.AppSettings["HubEndpiont"]);
}
private Notifications()
{
Hub = NotificationHubClient.CreateClientFromConnectionString(
"Endpoint=sb://transcendence-notification.servicebus.windows.net/;SharedAccessKeyName=DefaultFullSharedAccessSignature;SharedAccessKey=DyQ5ZODDJQV1E6QXW9zF9vmtyctoJtKzVOPAyoPHMio=",
"transcendence-notification");
}
public NotificationHubRepository(string listenConnString, string hubName)
{
var notificationHub = new NotificationHub(listenConnString, hubName);
_hub = notificationHub.Hub;
}
public TournamentsController()
{
hub = NotificationHubClient.CreateClientFromConnectionString("Endpoint=sb://zuluhub2.servicebus.windows.net/;SharedAccessKeyName=DefaultFullSharedAccessSignature;SharedAccessKey=J9t78uCQkWHaOeg7q+FhOYBOeGXd3rdx6xHdTQ012sg=", "Zulu2");
}
private Notifications()
{
Hub = NotificationHubClient.CreateClientFromConnectionString("Endpoint=sb://findmenotificationnamespace.servicebus.windows.net/;SharedAccessKeyName=DefaultFullSharedAccessSignature;SharedAccessKey=ksAz8K+npvyXolDze03luDoKi3zaRnSIP5K9HHaWoBk=",
"FindMeNotification");
}
private static async Task <NotificationDetails> WaitForThePushStatusAsync(string pnsType, NotificationHubClient nhClient, NotificationOutcome notificationOutcome)
{
var notificationId = notificationOutcome.NotificationId;
var state = NotificationOutcomeState.Enqueued;
var count = 0;
NotificationDetails outcomeDetails = null;
while ((state == NotificationOutcomeState.Enqueued || state == NotificationOutcomeState.Processing) && ++count < 10)
{
try
{
Console.WriteLine($"{pnsType} status: {state}");
outcomeDetails = await nhClient.GetNotificationOutcomeDetailsAsync(notificationId);
state = outcomeDetails.State;
}
catch (MessagingEntityNotFoundException)
{
// It's possible for the notification to not yet be enqueued, so we may have to swallow an exception
// until it's ready to give us a new state.
}
Thread.Sleep(1000);
}
return(outcomeDetails);
}
public NotificationService(string hubName, string connectionString)
{
_hub = NotificationHubClient.CreateClientFromConnectionString(connectionString, hubName);
}
public Ntfy()
{
hub = NotificationHubClient.CreateClientFromConnectionString(R.NTFHUB_CSTR, R.NTFHUB_NAME);
}
private static void SendSimpleToast()
{
_hub = NotificationHubClient.CreateClientFromConnectionString(_ep, _notHubPath);
_hub.SendWindowsNativeNotificationAsync(_toast).Wait();
Console.ReadLine();
}
public Notifications(UserContext userContext)
{
Hub = NotificationHubClient.CreateClientFromConnectionString("Endpoint=sb://mobeyeapp.servicebus.windows.net/;SharedAccessKeyName=DefaultFullSharedAccessSignature;SharedAccessKey=QQRATZQhKXCCm5LuHgZLC8BBIBsyzFYlNqvx1Guq5OM=",
"MobeyeApp");
this.userContext = userContext;
}
public RegisterController()
{
hub = DevopenspaceNotifications.Instance.Hub;
}
/// <summary>
/// Initialize an instance of notification hub for registration.
/// </summary>
public NotificationRegistrationController()
{
_hub = Models.NotificationsHubModel.Instance.Hub;
}
public NotificationsController()
{
hub = NotificationHubClient.CreateClientFromConnectionString(
ConfigurationManager.ConnectionStrings["MS_NotificationHubConnectionString"].ConnectionString,
ConfigurationManager.AppSettings["MS_NotificationHubName"]);
}
public Task OpenAsync(PartitionContext context)
{
// get the manifests for the profile and biometrics services
_config = new ConfigM { ApiUrl = RoleEnvironment.GetConfigurationSettingValue("ConfigM") };
var profileManifest = _config.GetByName("ProfileM");
_profile = new ProfileM { ApiUrl = profileManifest.lineitems["PublicAPI"] };
var biometricsManifest = _config.GetByName("BiometricsAPI");
_biometricsApi = biometricsManifest.lineitems["PublicAPI"] + "/alarm";
// connect to notification hub
_hub = NotificationHubClient.CreateClientFromConnectionString(
RoleEnvironment.GetConfigurationSettingValue("NotificationHubConnectionString"),
RoleEnvironment.GetConfigurationSettingValue("NotificationHubName"));
return Task.FromResult<object>(null);
}
static async Task SendNotificationAsync(string connectionString, string hubName, string message)
{
NotificationHubClient hub = NotificationHubClient.CreateClientFromConnectionString(connectionString, hubName);
await hub.SendGcmNativeNotificationAsync(message);
}
public static async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)]
HttpRequest req,
ILogger log,
ExecutionContext context)
{
log.LogInformation(string.Format("start"));
// Load configuration
var config = new ConfigurationBuilder()
.SetBasePath(context.FunctionAppDirectory)
.AddJsonFile("local.settings.json", optional: true, reloadOnChange: true)
.AddEnvironmentVariables().Build();
var hubConfig = new ConnectorConfig(config);
// Compose message
var message = req.Query["message"].ToString();
var user = req.Query["user"].ToString();
log.LogInformation(string.Format("user: {0}", user));
log.LogInformation(string.Format("message: {0}", message));
if (string.IsNullOrEmpty(message))
{
message = string.Format(hubConfig.DefaultMessage, DateTime.Now.ToString("dd/MM/yy HH:mm:ss"));
}
// If you want to implement tag ..
var tag = req.Query["tag"].ToString();
if (string.IsNullOrEmpty(tag))
{
if (string.IsNullOrEmpty(user))
{
tag = hubConfig.DefaultTag;
}
else
{
var bcConnector = new BusinessCentralConnector(hubConfig, log);
var result = await bcConnector.GetUser(user, "APP365TEUsers");
if (result != null && result.Value != null && result.Value.Count > 0)
{
tag = result.Value[0].UserCode;
}
}
}
var hub =
NotificationHubClient.CreateClientFromConnectionString(
hubConfig.ConnectionString,
hubConfig.NotificationHubName);
if (hubConfig.SendApple)
{
log.LogInformation(string.Format("SendApple {0}", tag));
// Create class for AzureNotification Hub (APPLE)
var appleAps = new AppleBaseAps()
{
InAppMessage = message,
Aps = new AppleAps()
{
Badge = hubConfig.DefaultBadge, Sound = "default", Alert = message
}
};
// Dispatch push message (APPLE)
if (!String.IsNullOrEmpty(tag))
{
hub.SendAppleNativeNotificationAsync(JsonConvert.SerializeObject(appleAps), tag).Wait();
}
else
{
hub.SendAppleNativeNotificationAsync(JsonConvert.SerializeObject(appleAps)).Wait();
}
}
if (hubConfig.SendAndroid)
{
log.LogInformation(string.Format("SendAndroid {0}", tag));
// Create class for AzureNotification Hub (GOOGLE FIREBASE FCM)
// Dispatch push message (GOOGLE FIREBASE FCM)
var firebaseAps = new FirebaseBaseAps()
{
data = new FirebaseAps()
{
Message = message
}
};
if (!String.IsNullOrEmpty(tag))
{
hub.SendFcmNativeNotificationAsync(JsonConvert.SerializeObject(firebaseAps), tag).Wait();
}
else
{
hub.SendFcmNativeNotificationAsync(JsonConvert.SerializeObject(firebaseAps)).Wait();
}
}
if (hubConfig.SendMail && !string.IsNullOrEmpty(user))
{
var composer = new MessageComposer(hubConfig, log);
var messenger = new MessageConnector(hubConfig, log);
// Message is composed
var messageHtml = composer.DataBindEmail(message);
log.LogInformation(String.Format("Send Email Message : {0}", messageHtml));
// Message sent
var messageEmail = messenger.SendMail(messageHtml, user);
log.LogInformation(String.Format("Email Message result : {0}", messageEmail.Status));
}
return(new StatusCodeResult(200));
}
public RegisterDeviceService(NotificationHubClient _notificationHubClient) =>
public NotificationRegisterController(INotificationHub hub)
{
_hub = hub.GetHub();
}
public ProfileController()
{
hub = NotificationsHubHelper.Hub;
}
private Notifications()
{
Hub = NotificationHubClient.CreateClientFromConnectionString("Endpoint=sb://popbookings.servicebus.windows.net/;SharedAccessKeyName=DefaultFullSharedAccessSignature;SharedAccessKey=YMcwcPP8fCefQR/5cjope5OMM39gZr9kY5P5aB1VX3U=", "pb-nh-eastus");
}
static async Task Main(string[] args)
{
// Getting connection key from the new resource
var config = LoadConfiguration(args);
var nhClient = NotificationHubClient.CreateClientFromConnectionString(config.PrimaryConnectionString, config.HubName);
// Register some fake devices
var fcmDeviceId1 = Guid.NewGuid().ToString();
var fcmInstallation1 = new Installation
{
InstallationId = "fake-fcm-install-id1",
Platform = NotificationPlatform.Fcm,
PushChannel = fcmDeviceId1,
PushChannelExpired = false,
Tags = new [] { "fcm" }
};
var fcmDeviceId2 = Guid.NewGuid().ToString();
var fcmInstallation2 = new Installation
{
InstallationId = "fake-fcm-install-id2",
Platform = NotificationPlatform.Fcm,
PushChannel = fcmDeviceId2,
PushChannelExpired = false,
Tags = new[] { "fcm" }
};
await nhClient.CreateOrUpdateInstallationAsync(fcmInstallation1);
await nhClient.CreateOrUpdateInstallationAsync(fcmInstallation2);
await Task.Delay(5000);
// Send notifications to all users
var outcomeFcm = await nhClient.SendFcmNativeNotificationAsync(FcmSampleNotificationContent);
// The Notification ID is only available for Standard SKUs. For Basic and Free SKUs the API to get notification outcome details can not be called.
if (string.IsNullOrEmpty(outcomeFcm.NotificationId))
{
Console.WriteLine($"FCM has no outcome, due to it is only available for Standard SKU pricing tier.");
return;
}
// Gather send outcome
var fcmOutcomeDetails = await WaitForThePushStatusAsync("FCM", nhClient, outcomeFcm);
Console.WriteLine($"FCM error details URL: {fcmOutcomeDetails.PnsErrorDetailsUri}");
if (fcmOutcomeDetails.PnsErrorDetailsUri != null)
{
var httpClient = new HttpClient();
var pnsFeedbackXmlStrings = await httpClient.GetStringAsync(fcmOutcomeDetails.PnsErrorDetailsUri);
// Parse XML
var pnsFeedbackXmlStringsSplit = pnsFeedbackXmlStrings.Split(new[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries);
foreach (var pnsFeedbackXmlString in pnsFeedbackXmlStringsSplit)
{
var xdoc = XDocument.Parse(pnsFeedbackXmlString);
XNamespace ns = "http://schemas.microsoft.com/netservices/2010/10/servicebus/connect";
Console.WriteLine($"FCM PNS Feedback Content: \n{xdoc}");
PnsFeedback feedback = new PnsFeedback
{
FeedbackTime = DateTime.Parse(xdoc.Root.Element(ns + "FeedbackTime").Value),
NotificationSystemError = Enum.Parse <PnsError>(xdoc.Root.Element(ns + "NotificationSystemError").Value),
Platform = xdoc.Root.Element(ns + "Platform").Value,
PnsHandle = xdoc.Root.Element(ns + "PnsHandle").Value,
InstallationId = xdoc.Root.Element(ns + "InstallationId").Value,
NotificationId = xdoc.Root.Element(ns + "NotificationId").Value
};
}
}
}
public NotificationHubProxy(NotificationHubConfiguration configuration)
{
_configuration = configuration;
_hubClient = NotificationHubClient.CreateClientFromConnectionString(_configuration.ConnectionString, _configuration.HubName);
}
/// <summary>
/// Get the Azure notificatio hub to management
/// </summary>
private Notifications()
{
Hub = NotificationHubClient.CreateClientFromConnectionString("",
"mdenet-notification-hub", true);
}
public AuthServController(IEnumerable <ICreditInfoRetr> retrievers, DataContext context, NotificationHubClient notificationClient, MobileServiceClient mobileCLient)
{
_retrievers = retrievers;
_tsk = new List <Task <CreditInfo> >(retrievers.Count());
_exc = new List <Exception>(retrievers.Count());
_context = context;
_notificationClient = notificationClient;
_mobileClient = mobileCLient;
}
private Notifications()
{
Hub = NotificationHubClient.CreateClientFromConnectionString(
"Endpoint=sb://inner6notifications-ns.servicebus.windows.net/;SharedAccessKeyName=DefaultFullSharedAccessSignature;SharedAccessKey=Lu8wegPXUSHfRCqQ2Xfcv6WKF9s7Xai30r1PirMsdLU=",
"inner6notifications");
}
public NotificationHubProxy(NotificationHubSettings settings)
{
_settings = settings;
_hubClient = NotificationHubClient.CreateClientFromConnectionString(settings.ConnectionString, settings.HubName);
}
protected override void Initialize(HttpControllerContext controllerContext)
{
base.Initialize(controllerContext);
hubClient = NotificationHubClient.CreateClientFromConnectionString("Endpoint=sb://anhdemomimins.servicebus.windows.net/;SharedAccessKeyName=DefaultListenSharedAccessSignature;SharedAccessKey=DNp1PtTziv2lG6+kH9LLFhYihFeBciLrnp1KPWfYauw=", "fieldengineerdemomimi");
}
private Notifications()
{
Hub = NotificationHubClient.CreateClientFromConnectionString(MyFitnessTrackerLibrary.Globals.MyFitAppSettings.NotificationHubConnectionString, MyFitnessTrackerLibrary.Globals.MyFitAppSettings.NotificationHubName);
}
public RegisterController()
{
_hub = Notifications.Instance.Hub;
}
private Notifications()
{
Hub = NotificationHubClient.CreateClientFromConnectionString(
"Endpoint=sb://kinder-chat.servicebus.windows.net/;SharedAccessKeyName=DefaultFullSharedAccessSignature;SharedAccessKey=fJTzehXef3r9GTuhaouH47Qm92naTGkbNMZl2I1GtGE=",
"kinder-chat-messages");
}
private void InitializeData()
{
// Get NotificationHubClient
notificationHubClient = GetNotificationHubClient();
// Authorization Rules
BindingList<NotificationHubAuthorizationRuleWrapper> bindingList;
if (notificationHubDescription.Authorization.Count > 0)
{
var enumerable = notificationHubDescription.Authorization.Select(r => new NotificationHubAuthorizationRuleWrapper(r));
bindingList = new BindingList<NotificationHubAuthorizationRuleWrapper>(enumerable.ToList())
{
AllowEdit = true,
AllowNew = true,
AllowRemove = true
};
}
else
{
bindingList = new BindingList<NotificationHubAuthorizationRuleWrapper>(new List<NotificationHubAuthorizationRuleWrapper>())
{
AllowEdit = true,
AllowNew = true,
AllowRemove = true
};
}
bindingList.ListChanged += bindingList_ListChanged;
authorizationRulesBindingSource.DataSource = new BindingList<NotificationHubAuthorizationRuleWrapper>(bindingList);
authorizationRulesDataGridView.DataSource = authorizationRulesBindingSource;
// Initialize property grid
var propertyList = new List<string[]>();
propertyList.AddRange(new[]
{
new[] {DailyMaxActiveDevices, notificationHubDescription.DailyMaxActiveDevices.ToString("N0")},
new[] {DailyMaxActiveRegistrations, notificationHubDescription.DailyMaxActiveRegistrations.ToString("N0")},
new[] {DailyOperations, notificationHubDescription.DailyOperations.ToString("N0")}
});
propertyListView.Items.Clear();
foreach (var array in propertyList)
{
propertyListView.Items.Add(new ListViewItem(array));
}
// Path
if (!string.IsNullOrWhiteSpace(notificationHubDescription.Path))
{
txtPath.Text = notificationHubDescription.Path;
}
// UserMetadata
if (!string.IsNullOrWhiteSpace(notificationHubDescription.UserMetadata))
{
txtUserMetadata.Text = notificationHubDescription.UserMetadata;
}
// RegistrationTtl
if (notificationHubDescription.RegistrationTtl != null)
{
txtRegistrationTimeToLiveWindowDays.Text = notificationHubDescription.RegistrationTtl.Value.Days.ToString(CultureInfo.InvariantCulture);
txtRegistrationTimeToLiveWindowHours.Text = notificationHubDescription.RegistrationTtl.Value.Hours.ToString(CultureInfo.InvariantCulture);
txtRegistrationTimeToLiveWindowMinutes.Text = notificationHubDescription.RegistrationTtl.Value.Minutes.ToString(CultureInfo.InvariantCulture);
txtRegistrationTimeToLiveWindowSeconds.Text = notificationHubDescription.RegistrationTtl.Value.Seconds.ToString(CultureInfo.InvariantCulture);
txtRegistrationTimeToLiveWindowMilliseconds.Text = notificationHubDescription.RegistrationTtl.Value.Milliseconds.ToString(CultureInfo.InvariantCulture);
}
if (notificationHubDescription.WnsCredential != null)
{
if (!string.IsNullOrWhiteSpace(notificationHubDescription.WnsCredential.PackageSid))
{
txtPackageSid.Text = notificationHubDescription.WnsCredential.PackageSid;
}
if (!string.IsNullOrWhiteSpace(notificationHubDescription.WnsCredential.SecretKey))
{
txtClientSecret.Text = notificationHubDescription.WnsCredential.SecretKey;
}
}
else
{
txtPackageSid.Text = string.Empty;
txtClientSecret.Text = string.Empty;
}
if (notificationHubDescription.GcmCredential != null)
{
if (!string.IsNullOrWhiteSpace(notificationHubDescription.GcmCredential.GoogleApiKey))
{
txtGcmApiKey.Text = notificationHubDescription.GcmCredential.GoogleApiKey;
}
if (!string.IsNullOrWhiteSpace(notificationHubDescription.GcmCredential.GcmEndpoint))
{
txtGcmEndpoint.Text = notificationHubDescription.GcmCredential.GcmEndpoint;
}
}
else
{
txtGcmApiKey.Text = string.Empty;
}
if (notificationHubDescription.MpnsCredential != null)
{
if (!string.IsNullOrWhiteSpace(notificationHubDescription.MpnsCredential.MpnsCertificate) &&
!string.IsNullOrWhiteSpace(notificationHubDescription.MpnsCredential.CertificateKey))
{
var certificate = new X509Certificate2(Convert.FromBase64String(notificationHubDescription.MpnsCredential.MpnsCertificate),
notificationHubDescription.MpnsCredential.CertificateKey);
if (!string.IsNullOrWhiteSpace(certificate.Thumbprint))
{
txtMpnsCredentialCertificateThumbprint.Text = certificate.Thumbprint;
}
}
else
{
txtMpnsCredentialCertificateThumbprint.Text = string.Empty;
checkBoxEnableUnauthenticatedMpns.Checked = true;
}
}
if (notificationHubDescription.ApnsCredential != null)
{
if (!string.IsNullOrWhiteSpace(notificationHubDescription.ApnsCredential.ApnsCertificate) &&
!string.IsNullOrWhiteSpace(notificationHubDescription.ApnsCredential.CertificateKey))
{
var certificate = new X509Certificate2(Convert.FromBase64String(notificationHubDescription.ApnsCredential.ApnsCertificate),
notificationHubDescription.ApnsCredential.CertificateKey);
if (!string.IsNullOrWhiteSpace(certificate.Thumbprint))
{
txtApnsCredentialCertificateThumbprint.Text = certificate.Thumbprint;
}
}
else
{
txtApnsCredentialCertificateThumbprint.Text = string.Empty;
}
if (!string.IsNullOrWhiteSpace(notificationHubDescription.ApnsCredential.Endpoint))
{
txtApnsEndpoint.Text = notificationHubDescription.ApnsCredential.Endpoint;
}
}
// Show or hide test pages
EnablePage(TemplateNotificationPage);
if (notificationHubDescription.MpnsCredential == null &&
(notificationHubDescription.WnsCredential == null ||
string.IsNullOrWhiteSpace(notificationHubDescription.WnsCredential.WindowsLiveEndpoint)) &&
(notificationHubDescription.ApnsCredential == null ||
string.IsNullOrWhiteSpace(notificationHubDescription.ApnsCredential.Endpoint)) &&
(notificationHubDescription.GcmCredential == null ||
string.IsNullOrWhiteSpace(notificationHubDescription.GcmCredential.GcmEndpoint)))
{
DisablePage(TemplateNotificationPage);
}
else
{
EnablePage(TemplateNotificationPage);
}
if (notificationHubDescription.MpnsCredential == null)
{
DisablePage(WindowsPhoneNativeNotificationPage);
}
else
{
EnablePage(WindowsPhoneNativeNotificationPage);
}
if (notificationHubDescription.WnsCredential == null ||
string.IsNullOrWhiteSpace(notificationHubDescription.WnsCredential.WindowsLiveEndpoint))
{
DisablePage(WindowsNativeNotificationPage);
}
else
{
EnablePage(WindowsNativeNotificationPage);
}
if (notificationHubDescription.ApnsCredential == null ||
string.IsNullOrWhiteSpace(notificationHubDescription.ApnsCredential.Endpoint))
{
DisablePage(AppleNativeNotificationPage);
}
else
{
EnablePage(AppleNativeNotificationPage);
}
if (notificationHubDescription.GcmCredential == null ||
string.IsNullOrWhiteSpace(notificationHubDescription.GcmCredential.GcmEndpoint))
{
DisablePage(GoogleNativeNotificationPage);
}
else
{
EnablePage(GoogleNativeNotificationPage);
}
}
public RegisterController()
{
hub = EvolveNotifications.Instance.Hub;
}
public PushNotificationController()
{
hub = NotificationHubClient.CreateClientFromConnectionString("Endpoint=sb://pickmeupmobilehub-ns.servicebus.windows.net/;SharedAccessKeyName=RootManageSharedAccessKey;SharedAccessKey=x2zZENLZPkhFzkVJO8cxBQupv4oW4yrPT1wZADjjcUg=", "pickmeupmobilehub");
}
private Notifications()
{
// Hub = NotificationHubClient.CreateClientFromConnectionString("<Enter your connection string with full access", "your hub name");
Hub = NotificationHubClient.CreateClientFromConnectionString("Endpoint=sb://wesmc-hub-ns.servicebus.windows.net/;SharedAccessKeyName=DefaultFullSharedAccessSignature;SharedAccessKey=Ztd5lKYAovSs+g3gs0M/EkbVRuIVw7ft4BUylZRtcss=", "wesmc-hub");
}
public static async Task <IEnumerable <RegistrationDescription> > GetRegistrationsByTagExpressionAsync(this NotificationHubClient client, string tagExpression)
{
// タグ式を分解して、元々のオブジェクトに戻す
var andExpressions = tagExpression.Split(new[] { "&&" }, StringSplitOptions.RemoveEmptyEntries).Select(p => p.Trim()).ToArray();
var tags = (from expression in andExpressions
let body = expression.Trim('!', '(', ')')
let orExpressions = body.Split(new[] { "||" }, StringSplitOptions.RemoveEmptyEntries).Select(p => p.Trim()).ToArray()
let key = orExpressions[0].Split(':')[0]
select new TagModel
{
Key = key,
Values = orExpressions.Select(p => p.Substring(key.Length + 1)).ToArray(),
Exclude = expression.StartsWith("!")
}).ToArray();
IEnumerable <RegistrationDescription> results;
// 否定が入っている場合には全件取得する必要がある
if (tags.Any(p => p.Exclude))
{
results = await client.GetAllRegistrationsAsync(0);
}
else
{
// フィルタリングに最低限必要なタグのみ取得する
results = (await Task.WhenAll(tags.SelectMany(p => p.Values.Select(q => client.GetRegistrationsByTagAsync(p.Key + ":" + q, 0))))).SelectMany(p => p).Distinct(new RegistrationDescriptionComparer());
}
// フィルタリングした結果を返す
return(results.Where(p => tags.All(q =>
{
if (q.Exclude)
{
return !q.Values.Any(r => p.Tags.Contains(q.Key + ":" + r));
}
return q.Values.Any(r => p.Tags.Contains(q.Key + ":" + r));
})));
}
public async Task RegisterPush(PushUri pushUri)
{
if (String.IsNullOrWhiteSpace(pushUri.DeviceId))
{
return;
}
if (pushUri.UnitId.HasValue)
{
var hubClient = NotificationHubClient.CreateClientFromConnectionString(Config.ServiceBusConfig.AzureUnitNotificationHub_FullConnectionString, Config.ServiceBusConfig.AzureUnitNotificationHub_PushUrl);
var unitTags = new string[]
{
string.Format("pushUriId:{0}", pushUri.PushUriId),
string.Format("deviceId:{0}", pushUri.DeviceId.GetHashCode()), // Device Id is the registration token
string.Format("unitId:{0}", pushUri.UnitId),
string.Format("uuid:{0}", pushUri.PushLocation),
string.Format("did:{0}", pushUri.DepartmentId)
};
CollectionQueryResult <RegistrationDescription> registrations = null;
try
{
registrations = await hubClient.GetRegistrationsByTagAsync(string.Format("deviceId:{0}", pushUri.DeviceId.GetHashCode()), 50);
}
catch
{
// So this just fails, like whenever it wants. I would rather people get 2 or 3 push messages for a fire then none.
}
// Loop through all Azure registrations for this Hashed DeviceId and remove them
if (registrations != null && registrations.Any())
{
foreach (var registration in registrations)
{
try
{
await hubClient.DeleteRegistrationAsync(registration);
}
catch (Microsoft.Azure.NotificationHubs.Messaging.MessagingEntityNotFoundException menfe)
{
// Eat me
}
catch (Exception ex)
{
Framework.Logging.LogException(ex);
}
}
}
if (pushUri.PlatformType == (int)Platforms.UnitWin)
{
try
{
var result = await hubClient.CreateMpnsNativeRegistrationAsync(pushUri.PushLocation, unitTags);
}
catch (ArgumentException ex)
{
}
}
else if (pushUri.PlatformType == (int)Platforms.UnitAndroid)
{
try
{
var result = await hubClient.CreateFcmNativeRegistrationAsync(pushUri.DeviceId, unitTags);
}
catch (ArgumentException ex)
{
}
}
else if (pushUri.PlatformType == (int)Platforms.UnitIOS)
{
try
{
var result = await hubClient.CreateAppleNativeRegistrationAsync(pushUri.DeviceId, unitTags);
}
catch (ArgumentException ex)
{
}
}
}
}
public GCMRegistrationController()
{
hub = Notifications.Instance.Hub;
}
//private readonly TopicDescription td = new TopicDescription("turnbasednotify");
public AzureHubNotification(ILogger <AzureHubNotification> logger, IOptions <ConnectionStrings> connectionStrings)
{
_logger = logger;
_connectionStrings = connectionStrings.Value;
hub = NotificationHubClient.CreateClientFromConnectionString(connectionStrings.Value.NotificationHubConnectionString, "notifyhub"); //todo: move to config
}
private async Task<bool> VerifyTags(string channelUri, string installationId, NotificationHubClient nhClient)
{
IPrincipal user = this.User;
int expectedTagsCount = 1;
if (user.Identity != null && user.Identity.IsAuthenticated)
{
expectedTagsCount = 2;
}
string continuationToken = null;
do
{
CollectionQueryResult<RegistrationDescription> regsForChannel = await nhClient.GetRegistrationsByChannelAsync(channelUri, continuationToken, 100);
continuationToken = regsForChannel.ContinuationToken;
foreach (RegistrationDescription reg in regsForChannel)
{
RegistrationDescription registration = await nhClient.GetRegistrationAsync<RegistrationDescription>(reg.RegistrationId);
if (registration.Tags == null || registration.Tags.Count() != expectedTagsCount)
{
return false;
}
if (!registration.Tags.Contains("$InstallationId:{" + installationId + "}"))
{
return false;
}
ClaimsIdentity identity = user.Identity as ClaimsIdentity;
Claim userIdClaim = identity.Claims.FirstOrDefault(c => c.Type == ClaimTypes.NameIdentifier);
string userId = (userIdClaim != null) ? userIdClaim.Value : string.Empty;
if (expectedTagsCount > 1 && !registration.Tags.Contains("_UserId:" + userId))
{
return false;
}
}
} while (continuationToken != null);
return true;
}
private static async Task SendNotificationAsync(string alert, string tag)
{
NotificationHubClient Hub = NotificationHubClient.CreateClientFromConnectionString("Endpoint=sb://vishalnotificationnamespace.servicebus.windows.net/;SharedAccessKeyName=RootManageSharedAccessKey;SharedAccessKey=jZZF8a/J08TUXMxI/4ML5LhzIveVVInr7PEehL6FTLE", "vishalnotificationhub");
NotificationOutcome toast = await Hub.SendAppleNativeNotificationAsync(alert, tag);
}
private Notifications()
{
Hub = NotificationHubClient.CreateClientFromConnectionString("Endpoint=sb://khunotificationsnamespace.servicebus.windows.net/;SharedAccessKeyName=DefaultFullSharedAccessSignature;SharedAccessKey=5N5VDMUjJT2XcFKPKKIllk3zcCFGeXd2kypmIUhIuV0=", "khunotifications");
}
private Notifications()
{
Hub = NotificationHubClient.CreateClientFromConnectionString("Endpoint=sb://homesecurityhub-ns.servicebus.windows.net/;SharedAccessKeyName=DefaultFullSharedAccessSignature;SharedAccessKey=/zIgiUyNvlgnIxFInyvQUNFLeIYZcjWK/IAnmx7Ryoo=",
"homesecurityhub");
}
