How to I make the call so that the GetRecords is completed before _reportViewerService.ShowReport starts. Using SignalR the setUi updates a txt field which displays names from part of the result calculated in getRecords, and the rest should be printed in report there after.
(whats happening now is both running the same time, then the report being showed before I see the live update status)
Thanks in advance
public async Task ViewReport()
{
var reportData = await _apiCallExecutor.ExecuteAsync(new GetRecords(queryModel, setUiHooks));
try
{
if (reportData.Count > 0)
{
var settings = new ReportSettings();
settings.ReportPath = "Utilities/SetDeliveryIdByBatchReport";
settings.ReportTitle = "Set Delivery ID By Batch - Exception Listing";
settings.DataSources.Add("DeliveryIdExceptionRecords", reportData);
ReportStatus = "Printing Exception Report...";
await _reportViewerService.ShowReport(settings);
}
}
finally
{
ViewModelState = ViewModelStates.Edit;
}
ReportStatus = "Done...";
}
You want to use some kind of "signal" from GetRecords, e.g., an IObservable or Task that completes when the data has arrived.
class GetRecords
{
...
public Task Done { get; }
// or: public IObservable<Unit> Done { get; }
}
then:
var getRecords = new GetRecords(queryModel, setUiHooks);
var reportData = await _apiCallExecutor.ExecuteAsync(getRecords);
await getRecords.Done;
...
Related
I'm developing a Xamarin application. It's a glorified audio player. I created a background task for the UWP part which extends IBackgroundTask from Windows.ApplicationModel.Background.
using Windows.ApplicationModel.Background;
public sealed class BackgroundServiceManager : IBackgroundTask {
private IIpcNode m_node;//Sends/Receive message powered by LocalSettings
private BackgroundTaskDeferral m_deferral;
public void Run(IBackgroundTaskInstance taskInstance) {
DebugUtils.Log("BackgroundServiceManager.Run()");
m_deferral = taskInstance.GetDeferral();
m_services = new List<IBackgroundService> {
(m_playbackService = new PlaybackService()),
(m_smartLightService = new SmartLightsService())
};
this.RegisterServices();
taskInstance.Task.Completed += OnTaskCompleted;
taskInstance.Canceled += OnTaskCanceled;
//Listen to messages powered by LocalSettings
m_node.StartListening();
}
//...
}
I start the task using an application trigger. The background task lives in a separate project.
public async Task InitializeBackgroundTask() {
var localSettings = Windows.Storage.ApplicationData.Current.LocalSettings;
localSettings.Values.Clear();
BackgroundExecutionManager.RemoveAccess();
var accessStatus = await BackgroundExecutionManager.RequestAccessAsync();
if (accessStatus == BackgroundAccessStatus.DeniedBySystemPolicy
|| accessStatus == BackgroundAccessStatus.DeniedByUser
|| accessStatus == BackgroundAccessStatus.Unspecified)
return;
UnregisterExistingTasks();
var builder = new BackgroundTaskBuilder() {
Name = BACKGROUND_TASK_NAME,
TaskEntryPoint = BACKGROUND_TASK_ENTRY_POINT,
};
var applicationTrigger = new ApplicationTrigger();
builder.SetTrigger(applicationTrigger);
var registration = (BackgroundTaskRegistration)null;
try {
registration = builder.Register();
}
catch (Exception ex) {
throw new Exception(string.Format("Unable to register {0} background task.", BACKGROUND_TASK_NAME), ex);
}
registration.Completed += OnBackgroundTaskCompleted;
registration.Progress += OnRegistrationProgress;
this.Node.StartListening();
var result = await applicationTrigger.RequestAsync();
if (result != ApplicationTriggerResult.Allowed)
throw new Exception("Unable to trigger background task.");
}
I have a background task declaration in my main UWP project. The task type is "general" and I provide the proper entry point.
Also, the Background Media Playback capability is checked.
The task works perfectly fine, but AudioGraph doesn't generate sounds on the background task. MediaPlayer does, however. I need AudioGraph as it allows for seamless audio looping.
Here's my AudioGraph test method. I created it to isolate AudioGraph-related code:
public static async Task TestAudioGraph(int toneFrequency) {
var audioFileInfo = await AudioUtils.CreateToneFile(toneFrequency);
var settings = new AudioGraphSettings(Windows.Media.Render.AudioRenderCategory.Media);
var createAudioGraphResult = await AudioGraph.CreateAsync(settings);
if (createAudioGraphResult.Status != AudioGraphCreationStatus.Success)
throw new Exception(createAudioGraphResult.Status.ToString());
var audioGraph = createAudioGraphResult.Graph;
var createDeviceOutputNodeResult = await audioGraph.CreateDeviceOutputNodeAsync();
if (createDeviceOutputNodeResult.Status != AudioDeviceNodeCreationStatus.Success)
throw new Exception(createDeviceOutputNodeResult.Status.ToString());
var deviceOutputNode = createDeviceOutputNodeResult.DeviceOutputNode;
var storageFile = await StorageFile.GetFileFromPathAsync(audioFileInfo.FileFullPath);
var createFileInputNodeResult = await audioGraph.CreateFileInputNodeAsync(storageFile);
if (createFileInputNodeResult.Status != AudioFileNodeCreationStatus.Success)
throw new Exception(createFileInputNodeResult.Status.ToString());
var fileInputNode = createFileInputNodeResult.FileInputNode;
fileInputNode.OutgoingGain = 1;
fileInputNode.LoopCount = Int32.MaxValue;
fileInputNode.AddOutgoingConnection(deviceOutputNode);
fileInputNode.Start();
audioGraph.Start();
await Task.Delay(3000);
}
Sending of sound test message from foreground:
public async Task TestSound() {
//Test sound on foreground first
await Task.Run(async () => await UWPUtils.TestAudioGraph(200));
var message = new UWPIpcMessage("TESTSOUND", null);
await this.Node.SendMessage(message, true);
}
Background's handling of sound test message:
m_node.Subscribe("TESTSOUND", async (message) => {
//Then test sound on background
await Task.Run(async () => await UWPUtils.TestAudioGraph(800));
return null;
});
Would you happen to know why AudioGraph doesn't work? Am I missing a setting or is this possible at all?
I look on the web and couldn't find examples or working samples, just hints that what I'm attempting is possible.
P-S: My task type is "general", because I found no way of triggering "audio" type of tasks.
Thank you
The idea is to process a list of items, individually and then batch up and then go back to processing individually seamlessly.
In the batch processing block, I may be querying or saving to the database. Hitting the DB with a batch is a lot more efficient than hitting it multiple times per each item in the list.
using System;
using System.Linq;
using System.Threading.Tasks;
using System.Threading.Tasks.Dataflow;
namespace DataflowTest
{
class Program
{
static async Task Main(string[] args)
{
var execOptions = new ExecutionDataflowBlockOptions { MaxDegreeOfParallelism = DataflowBlockOptions.Unbounded };
var block1 = new TransformBlock<WorkItem, WorkItem>(async item =>
{
// perform work on individual item
await Task.Delay(1000);
Console.WriteLine($"Block 1 - Item {item.Id}");
return item;
}, execOptions);
var block2 = new TransformBlock<WorkItem, WorkItem>(async item =>
{
// perform more work on individual item
await Task.Delay(1000);
Console.WriteLine($"Block 2 - Item {item.Id}");
return item;
}, execOptions);
var batch = new BatchBlock<WorkItem>(5);
var batchWork = new ActionBlock<WorkItem[]>(async items =>
{
Console.WriteLine($"batchWork - {items.Length} Items");
// perform batch work - query database, etc.
await Task.Delay(2000);
await Task.WhenAll(items.Select(x => block2.SendAsync(x)));
}, execOptions);
var batch2 = new BatchBlock<WorkItem>(10);
var save = new ActionBlock<WorkItem[]>(async items =>
{
Console.WriteLine($"save - {items.Length} Items");
// save items to the DB
await Task.Delay(2000);
}, execOptions);
var linkOptions = new DataflowLinkOptions { PropagateCompletion = true };
block1.LinkTo(batch, linkOptions);
batch.LinkTo(batchWork, linkOptions);
block2.LinkTo(batch2, linkOptions);
batch2.LinkTo(save, linkOptions);
Console.WriteLine("Starting work");
var workItems = Enumerable.Range(1, 10).Select(x => new WorkItem { Id = x }).ToArray();
await Task.WhenAll(workItems.Select(x => block1.SendAsync(x)));
block1.Complete();
await batchWork.Completion;
block2.Complete();
await save.Completion;
Console.WriteLine("All Done");
Console.WriteLine("Hit Enter");
Console.ReadLine();
}
}
class WorkItem
{
public int Id { get; set; }
}
}
I am looking for some feedback. Basically the above code sample seems to work.
The critical piece of code is within "batchWork" where I am queueing up to "block2" by calling SendAsync on each item. I don't know of a way to link up any other way. Perhaps there is a better approach to what I am trying to accomplish here.
Any suggestions?
You don't need to use SendAsync. You can change batchWork to a TransformManyBlock and connect it to the next block:
var batchWork = new TransformManyBlock<WorkItem[],WorkItem>(async items =>
{
Console.WriteLine($"batchWork - {items.Length} Items");
// perform batch work - query database, etc.
return items;
}, execOptions);
....
batch.LinkTo(batchWork, linkOptions);
batchWork.LinkTo(block2, linkOptions);
block2.LinkTo(batch2, linkOptions);
I am using the bot framework of V4. using an API call, I'm trying to get data and display it to the user and I defined a custom method to capture data from API and preprocess it, before sending it to the user through waterfall dialog and I made this method async and also using await where it is being called.
There are 2 scenarios where I'm facing the issue -
When two users send questions at an instance one of the responses captured as null instead of value acquired from API.
We are using the suggestive card to display result and when the user clicks on button cross-session was observed sporadically.
Help in this area is much appreciated.
The custom method defined to make API call and get data:
public static async Task<string>
GetEPcallsDoneAsync(ConversationData conversationData)
{
LogWriter.LogWrite("Info: Acessing end-points");
string responseMessage = null;
try
{
conversationData.fulFillmentMap = await
AnchorUtil.GetFulfillmentAsync(xxxxx);//response from API call to get data
if (conversationData.fulFillmentMap == null || (conversationData.fulFillmentMap.ContainsKey("status") && conversationData.fulFillmentMap["status"].ToString() != "200"))
{
responseMessage = "Sorry, something went wrong. Please try again later!";
}
else
{
conversationData.NLGresultMap = await
AnchorUtil.GetNLGAsync(conversationData.fulFillmentMap ,xxxx);//API call to get response to be displayed
if (conversationData.errorCaptureDict.ContainsKey("fulfillmentError") || conversationData.NLGresultMap.ContainsKey("NLGError"))
{
responseMessage = "Sorry, something went wrong:( Please try again later!!!";
}
else
{
responseMessage = FormatDataResponse(conversationData.NLGresultMap["REPLY"].ToString()); //response message
}
}
return responseMessage;
}
catch (HttpRequestException e)
{
LogWriter.LogWrite("Error: " + e.Message);
System.Console.WriteLine("Error: " + e.Message);
return null;
}
}
And the waterfall step of dialog class where the above function is being called:
private async Task<DialogTurnResult> DoProcessInvocationStep(WaterfallStepContext stepContext, CancellationToken cancellationToken)
{
conversationData.index = 0; //var for some other purpose
conversationData.result = await
AnchorUtil.GetEPcallsDoneAsync(conversationData);
await _conversationStateAccessor.SetAsync(stepContext.Context, conversationData, cancellationToken);
return await stepContext.NextAsync(cancellationToken);
}
ConversationData contains variables that are required to process data through waterfall dialogs, values to the object has been set and accessed through accessor as below in each step:
In a dialog class,
public class TopLevelDialog : ComponentDialog
{
private readonly IStatePropertyAccessor<ConversationData> _conversationStateAccessor;
ConversationData conversationData;
public TopLevelDialog(ConversationState conversationState)
: base(nameof(TopLevelDialog))
{
_conversationStateAccessor = conversationState.CreateProperty<ConversationData>(nameof(ConversationData));
AddDialog(new TextPrompt(nameof(TextPrompt)));
AddDialog(new ChoicePrompt(nameof(ChoicePrompt)));
AddDialog(new ReviewSelectionDialog(conversationState));
AddDialog(new ESSelectionDialog());
AddDialog(new WaterfallDialog(nameof(WaterfallDialog), new WaterfallStep[]
{
StartSelectionStepAsync,
GetESResultStep,
DoProcessInvocationStep,
ResultStepAsync,
IterationStepAsync
}));
InitialDialogId = nameof(WaterfallDialog);
}
private async Task<DialogTurnResult> StartSelectionStepAsync (WaterfallStepContext stepContext, CancellationToken cancellationToken)
{
conversationData = await _conversationStateAccessor.GetAsync(stepContext.Context, () => new ConversationData());
//code for functionality
await _conversationStateAccessor.SetAsync(stepContext.Context, conversationData, cancellationToken);
return await stepContext.NextAsync(null, cancellationToken);
}
//other dialog steps
}
Both of your issues likely stem from the same thing. You can't declare conversationData as a class-level property. You'll run into concurrency issues like this as every user will overwrite the conversationData for every other user. You must re-declare conversationData in each step function.
For example,
User A starts the waterfall dialog and gets half of the way through. conversationData is correct at this point and represents exactly what it should.
Now User B starts a dialog. At the StartSelectionStepAsync, they just reset conversationData for everybody because of conversationData = await _conversationStateAccessor.GetAsync(stepContext.Context, () => new ConversationData()); and all users share the same conversationData because of ConversationData conversationData;.
So now, when User A continues their conversation, conversationData will be null/empty.
How State Should Be Saved
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.
const { Channels, MessageFactory } = require('botbuilder');
const {
AttachmentPrompt,
ChoiceFactory,
ChoicePrompt,
ComponentDialog,
ConfirmPrompt,
DialogSet,
DialogTurnStatus,
NumberPrompt,
TextPrompt,
WaterfallDialog
} = require('botbuilder-dialogs');
const { UserProfile } = require('../userProfile');
const ATTACHMENT_PROMPT = 'ATTACHMENT_PROMPT';
const CHOICE_PROMPT = 'CHOICE_PROMPT';
const CONFIRM_PROMPT = 'CONFIRM_PROMPT';
const NAME_PROMPT = 'NAME_PROMPT';
const NUMBER_PROMPT = 'NUMBER_PROMPT';
const USER_PROFILE = 'USER_PROFILE';
const WATERFALL_DIALOG = 'WATERFALL_DIALOG';
/**
* This is a "normal" dialog, where userState is stored properly using the accessor, this.userProfile.
* In this dialog example, we create the userProfile using the accessor in the first step, transportStep.
* We then pass prompt results through the remaining steps using step.values.
* In the final step, summaryStep, we save the userProfile using the accessor.
*/
class UserProfileDialogNormal extends ComponentDialog {
constructor(userState) {
super('userProfileDialogNormal');
this.userProfileAccessor = userState.createProperty(USER_PROFILE);
this.addDialog(new TextPrompt(NAME_PROMPT));
this.addDialog(new ChoicePrompt(CHOICE_PROMPT));
this.addDialog(new ConfirmPrompt(CONFIRM_PROMPT));
this.addDialog(new NumberPrompt(NUMBER_PROMPT, this.agePromptValidator));
this.addDialog(new AttachmentPrompt(ATTACHMENT_PROMPT, this.picturePromptValidator));
this.addDialog(new WaterfallDialog(WATERFALL_DIALOG, [
this.transportStep.bind(this),
this.nameStep.bind(this),
this.nameConfirmStep.bind(this),
this.ageStep.bind(this),
this.pictureStep.bind(this),
this.confirmStep.bind(this),
this.saveStep.bind(this)
]));
this.initialDialogId = WATERFALL_DIALOG;
}
/**
* The run method handles the incoming activity (in the form of a TurnContext) and passes it through the dialog system.
* If no dialog is active, it will start the default dialog.
* #param {*} turnContext
* #param {*} accessor
*/
async run(turnContext, accessor) {
const dialogSet = new DialogSet(accessor);
dialogSet.add(this);
const dialogContext = await dialogSet.createContext(turnContext);
const results = await dialogContext.continueDialog();
if (results.status === DialogTurnStatus.empty) {
await dialogContext.beginDialog(this.id);
}
}
async transportStep(step) {
// Get the userProfile if it exists, or create a new one if it doesn't.
const userProfile = await this.userProfileAccessor.get(step.context, new UserProfile());
// Pass the userProfile through step.values.
// This makes it so we don't have to call this.userProfileAccessor.get() in every step.
step.values.userProfile = userProfile;
// Skip this step if we already have the user's transport.
if (userProfile.transport) {
// ChoicePrompt results will show in the next step with step.result.value.
// Since we don't need to prompt, we can pass the ChoicePrompt result manually.
return await step.next({ value: userProfile.transport });
}
// WaterfallStep always finishes with the end of the Waterfall or with another dialog; here it is a Prompt Dialog.
// Running a prompt here means the next WaterfallStep will be run when the user's response is received.
return await step.prompt(CHOICE_PROMPT, {
prompt: 'Please enter your mode of transport.',
choices: ChoiceFactory.toChoices(['Car', 'Bus', 'Bicycle'])
});
}
async nameStep(step) {
// Retrieve the userProfile from step.values.
const userProfile = step.values.userProfile;
// Set the transport property of the userProfile.
userProfile.transport = step.result.value;
// Pass the userProfile through step.values.
// This makes it so we don't have to call this.userProfileAccessor.get() in every step.
step.values.userProfile = userProfile;
// Skip the prompt if we already have the user's name.
if (userProfile.name) {
// We pass in a skipped bool so we know whether or not to send messages in the next step.
return await step.next({ value: userProfile.name, skipped: true });
}
return await step.prompt(NAME_PROMPT, 'Please enter your name.');
}
async nameConfirmStep(step) {
// Retrieve the userProfile from step.values and set the name property
const userProfile = step.values.userProfile;
// If userState is working correctly, we'll have userProfile.transport from the previous step.
if (!userProfile || !userProfile.transport) {
throw new Error(`transport property does not exist in userProfile.\nuserProfile:\n ${ JSON.stringify(userProfile) }`);
}
// Text prompt results normally end up in step.result, but if we skipped the prompt, it will be in step.result.value.
userProfile.name = step.result.value || step.result;
// step.values.userProfile.name is already set by reference, so there's no need to set it again to pass it to the next step.
// We can send messages to the user at any point in the WaterfallStep. Only do this if we didn't skip the prompt.
if (!step.result.skipped) {
await step.context.sendActivity(`Thanks ${ step.result }.`);
}
// WaterfallStep always finishes with the end of the Waterfall or with another dialog; here it is a Prompt Dialog.
// Skip the prompt if we already have the user's age.
if (userProfile.age) {
return await step.next('yes');
}
return await step.prompt(CONFIRM_PROMPT, 'Do you want to give your age?', ['yes', 'no']);
}
async ageStep(step) {
// Retrieve the userProfile from step.values
const userProfile = step.values.userProfile;
// If userState is working correctly, we'll have userProfile.name from the previous step.
if (!userProfile || !userProfile.name) {
throw new Error(`name property does not exist in userProfile.\nuserProfile:\n ${ JSON.stringify(userProfile) }`);
}
// Skip the prompt if we already have the user's age.
if (userProfile.age) {
// We pass in a skipped bool so we know whether or not to send messages in the next step.
return await step.next({ value: userProfile.age, skipped: true });
}
if (step.result) {
// User said "yes" so we will be prompting for the age.
// WaterfallStep always finishes with the end of the Waterfall or with another dialog; here it is a Prompt Dialog.
const promptOptions = { prompt: 'Please enter your age.', retryPrompt: 'The value entered must be greater than 0 and less than 150.' };
return await step.prompt(NUMBER_PROMPT, promptOptions);
} else {
// User said "no" so we will skip the next step. Give -1 as the age.
return await step.next(-1);
}
}
async pictureStep(step) {
// Retrieve the userProfile from step.values and set the age property
const userProfile = step.values.userProfile;
// We didn't set any additional properties on userProfile in the previous step, so no need to check for them here.
// Confirm prompt results normally end up in step.result, but if we skipped the prompt, it will be in step.result.value.
userProfile.age = step.result.value || step.result;
// step.values.userProfile.age is already set by reference, so there's no need to set it again to pass it to the next step.
if (!step.result.skipped) {
const msg = userProfile.age === -1 ? 'No age given.' : `I have your age as ${ userProfile.age }.`;
// We can send messages to the user at any point in the WaterfallStep. Only send it if we didn't skip the prompt.
await step.context.sendActivity(msg);
}
// Skip the prompt if we already have the user's picture.
if (userProfile.picture) {
return await step.next(userProfile.picture);
}
if (step.context.activity.channelId === Channels.msteams) {
// This attachment prompt example is not designed to work for Teams attachments, so skip it in this case
await step.context.sendActivity('Skipping attachment prompt in Teams channel...');
return await step.next(undefined);
} else {
// WaterfallStep always finishes with the end of the Waterfall or with another dialog; here it is a Prompt Dialog.
var promptOptions = {
prompt: 'Please attach a profile picture (or type any message to skip).',
retryPrompt: 'The attachment must be a jpeg/png image file.'
};
return await step.prompt(ATTACHMENT_PROMPT, promptOptions);
}
}
async confirmStep(step) {
// Retrieve the userProfile from step.values and set the picture property
const userProfile = step.values.userProfile;
// If userState is working correctly, we'll have userProfile.age from the previous step.
if (!userProfile || !userProfile.age) {
throw new Error(`age property does not exist in userProfile.\nuserProfile:\n ${ JSON.stringify(userProfile) }`);
}
userProfile.picture = (step.result && typeof step.result === 'object' && step.result[0]) || 'no picture provided';
// step.values.userProfile.picture is already set by reference, so there's no need to set it again to pass it to the next step.
let msg = `I have your mode of transport as ${ userProfile.transport } and your name as ${ userProfile.name }`;
if (userProfile.age !== -1) {
msg += ` and your age as ${ userProfile.age }`;
}
msg += '.';
await step.context.sendActivity(msg);
if (userProfile.picture && userProfile.picture !== 'no picture provided') {
try {
await step.context.sendActivity(MessageFactory.attachment(userProfile.picture, 'This is your profile picture.'));
} catch (err) {
await step.context.sendActivity('A profile picture was saved but could not be displayed here.');
}
}
// WaterfallStep always finishes with the end of the Waterfall or with another dialog; here it is a Prompt Dialog.
return await step.prompt(CONFIRM_PROMPT, { prompt: 'Would you like me to save this information?' });
}
async saveStep(step) {
if (step.result) {
// Get the current profile object from user state.
const userProfile = step.values.userProfile;
// Save the userProfile to userState.
await this.userProfileAccessor.set(step.context, userProfile);
await step.context.sendActivity('User Profile Saved.');
} else {
// Ensure the userProfile is cleared
await this.userProfileAccessor.set(step.context, {});
await step.context.sendActivity('Thanks. Your profile will not be kept.');
}
// WaterfallStep always finishes with the end of the Waterfall or with another dialog; here it is the end.
return await step.endDialog();
}
async agePromptValidator(promptContext) {
// This condition is our validation rule. You can also change the value at this point.
return promptContext.recognized.succeeded && promptContext.recognized.value > 0 && promptContext.recognized.value < 150;
}
async picturePromptValidator(promptContext) {
if (promptContext.recognized.succeeded) {
var attachments = promptContext.recognized.value;
var validImages = [];
attachments.forEach(attachment => {
if (attachment.contentType === 'image/jpeg' || attachment.contentType === 'image/png') {
validImages.push(attachment);
}
});
promptContext.recognized.value = validImages;
// If none of the attachments are valid images, the retry prompt should be sent.
return !!validImages.length;
} else {
await promptContext.context.sendActivity('No attachments received. Proceeding without a profile picture...');
// We can return true from a validator function even if Recognized.Succeeded is false.
return true;
}
}
}
module.exports.UserProfileDialogNormal = UserProfileDialogNormal;
my case similar the example, a user presses a 'report' button to start a long-running reporting job. You add this job to the queue and send the report's result to your user via email when it's completed. But, I don't need retries job execution when the job failed. I want job stop and send notification. And can cancel on service.
public void CancelAllMyJob()
{
var jobs = backgroundJobStore.GetWaitingJobsAsync(int.MaxValue).Result.Where(o => o.JobType.Contains(nameof(MyJob))).ToList();
if (jobs.Count > 0)
{
foreach (BackgroundJobInfo job in jobs)
{
backgroundJobStore.DeleteAsync(job).Wait();
}
}
}
public async Task StartMyJob(MyJobInput input)
{
MyJobArgs args = new MyJobArgs
{
TenantId = AbpSession.TenantId,
UserId = AbpSession.UserId.Value,
};
var id = await backgroundJobManager.EnqueueAsync<MyJob, MyJobArgs >(args);
(await backgroundJobStore.GetAsync(Convert.ToInt64(id))).TryCount = 0;
}
public async Task StartMyJob(MyJobInput input)
{
MyJobArgs args = new MyJobArgs
{
TenantId = AbpSession.TenantId,
UserId = AbpSession.UserId.Value,
};
await Task.Run(() =>
{
using (var uow = UnitOfWorkManager.Begin(TransactionScopeOption.RequiresNew))
{
myJob.Execute(args);
}
});
}
It's work, thanks!
This is a fairly long piece of code but I am getting nowhere with this and cannot see any issues, although I am new to using notification hubs. I am trying to register for targeted notifications (the logged on user) using the notification hub in Azure. After the registration, a test notification is sent.
The issue I am having is that sometimes the notification is sent to the device, and sometimes it is not. It mostly isn't but occasionally when I step through the code on the server, i will get the notification on the emulator come through. Once when I deployed the app to my phone the notification came though on the emulator! I cannot discover a pattern.
My Controller class looks like this;
private NotificationHelper hub;
public RegisterController()
{
hub = NotificationHelper.Instance;
}
public async Task<RegistrationDescription> Post([FromBody]JObject registrationCall)
{
var obj = await hub.Post(registrationCall);
return obj;
}
And the helper class (which is used elsewhere so is not directly in the controller) looks like this;
public static NotificationHelper Instance = new NotificationHelper();
public NotificationHubClient Hub { get; set; }
// Create the client in the constructor.
public NotificationHelper()
{
var cn = "<my-cn>";
Hub = NotificationHubClient.CreateClientFromConnectionString(cn, "<my-hub>");
}
public async Task<RegistrationDescription> Post([FromBody] JObject registrationCall)
{
// Get the registration info that we need from the request.
var platform = registrationCall["platform"].ToString();
var installationId = registrationCall["instId"].ToString();
var channelUri = registrationCall["channelUri"] != null
? registrationCall["channelUri"].ToString()
: null;
var deviceToken = registrationCall["deviceToken"] != null
? registrationCall["deviceToken"].ToString()
: null;
var userName = HttpContext.Current.User.Identity.Name;
// Get registrations for the current installation ID.
var regsForInstId = await Hub.GetRegistrationsByTagAsync(installationId, 100);
var updated = false;
var firstRegistration = true;
RegistrationDescription registration = null;
// Check for existing registrations.
foreach (var registrationDescription in regsForInstId)
{
if (firstRegistration)
{
// Update the tags.
registrationDescription.Tags = new HashSet<string>() {installationId, userName};
// We need to handle each platform separately.
switch (platform)
{
case "windows":
var winReg = registrationDescription as MpnsRegistrationDescription;
winReg.ChannelUri = new Uri(channelUri);
registration = await Hub.UpdateRegistrationAsync(winReg);
break;
case "ios":
var iosReg = registrationDescription as AppleRegistrationDescription;
iosReg.DeviceToken = deviceToken;
registration = await Hub.UpdateRegistrationAsync(iosReg);
break;
}
updated = true;
firstRegistration = false;
}
else
{
// We shouldn't have any extra registrations; delete if we do.
await Hub.DeleteRegistrationAsync(registrationDescription);
}
}
// Create a new registration.
if (!updated)
{
switch (platform)
{
case "windows":
registration = await Hub.CreateMpnsNativeRegistrationAsync(channelUri,
new string[] {installationId, userName});
break;
case "ios":
registration = await Hub.CreateAppleNativeRegistrationAsync(deviceToken,
new string[] {installationId, userName});
break;
}
}
// Send out a test notification.
await SendNotification(string.Format("Test notification for {0}", userName), userName);
return registration;
And finally, my SendNotification method is here;
internal async Task SendNotification(string notificationText, string tag)
{
try
{
var toast = PrepareToastPayload("<my-hub>", notificationText);
// Send a notification to the logged-in user on both platforms.
await NotificationHelper.Instance.Hub.SendMpnsNativeNotificationAsync(toast, tag);
//await hubClient.SendAppleNativeNotificationAsync(alert, tag);
}
catch (ArgumentException ex)
{
// This is expected when an APNS registration doesn't exist.
Console.WriteLine(ex.Message);
}
}
I suspect the issue is in my phone client code, which is here and SubscribeToService is called immediately after WebAPI login;
public void SubscribeToService()
{
_channel = HttpNotificationChannel.Find("mychannel");
if (_channel == null)
{
_channel = new HttpNotificationChannel("mychannel");
_channel.Open();
_channel.BindToShellToast();
}
_channel.ChannelUriUpdated += async (o, args) =>
{
var hub = new NotificationHub("<my-hub>", "<my-cn>");
await hub.RegisterNativeAsync(args.ChannelUri.ToString());
await RegisterForMessageNotificationsAsync();
};
}
public async Task RegisterForMessageNotificationsAsync()
{
using (var client = GetNewHttpClient(true))
{
// Get the info that we need to request registration.
var installationId = LocalStorageManager.GetInstallationId(); // a new Guid
var registration = new Dictionary<string, string>()
{
{"platform", "windows"},
{"instId", installationId},
{"channelUri", _channel.ChannelUri.ToString()}
};
var request = new HttpRequestMessage(HttpMethod.Post, new Uri(ApiUrl + "api/Register/RegisterForNotifications"));
request.Content = new StringContent(JsonConvert.SerializeObject(registration), Encoding.UTF8, "application/json");
string message;
try
{
HttpResponseMessage response = await client.SendAsync(request);
message = await response.Content.ReadAsStringAsync();
}
catch (Exception ex)
{
message = ex.Message;
}
_registrationId = message;
}
}
Any help would be greatly appriciated as I have been stuck on this now for days! I know this is a lot of code to paste up here but it is all relevant.
Thanks,
EDIT: The SubscribeToService() method is called when the user logs in and authenticates with the WebAPI. The method is here;
public async Task<User> SendSubmitLogonAsync(LogonObject lo)
{
_logonObject = lo;
using (var client = GetNewHttpClient(false))
{
var logonString = String.Format("grant_type=password&username={0}&password={1}", lo.username, lo.password);
var sc = new StringContent(logonString, Encoding.UTF8);
var response = await client.PostAsync("Token", sc);
if (response.IsSuccessStatusCode)
{
_logonResponse = await response.Content.ReadAsAsync<TokenResponseModel>();
var userInfo = await GetUserInfoAsync();
if (_channel == null)
SubscribeToService();
else
await RegisterForMessageNotificationsAsync();
return userInfo;
}
// ...
}
}
I have solved the issue. There are tons of fairly poorly organised howto's for azure notification hubs and only one of them has this note toward the bottom;
NOTE:
You will not receive the notification when you are still in the app.
To receive a toast notification while the app is active, you must
handle the ShellToastNotificationReceived event.
This is why I was experiencing intermittent results, as i assumed you would still get a notification if you were in the app. And this little note is pretty well hidden.
Have you used proper tag / tag expressions while register/send the message. Also, Where are you storing the id back from the notification hub. It should be used when you update the channel uri (it will expire).
I would suggest to start from scratch.
Ref: http://msdn.microsoft.com/en-us/library/dn530749.aspx