public QueueMessageDetailsPage(CloudQueueMessage message, ASECloudQueue queue)
        {
            InitializeComponent();
            BindingContext = vm = new QueueMessageDetailsViewModel(Navigation, message, queue);

            if (Device.RuntimePlatform == Device.Android)
            {
                ToolbarItems.Add(new ToolbarItem
                {
                    Order   = ToolbarItemOrder.Secondary,
                    Text    = "Delete Queue Message",
                    Command = vm.DeleteQueueMessageCommand
                });
            }
            else if (Device.RuntimePlatform == Device.iOS)
            {
                ToolbarItems.Add(new ToolbarItem
                {
                    Text    = "More",
                    Icon    = "toolbar_overflow.png",
                    Command = new Command(async() =>
                    {
                        string[] items = new[] { "Delete Queue Message" };

                        var action = await DisplayActionSheet("Options", "Cancel", null, items);
                        if (action == items[0])
                        {
                            vm.DeleteQueueMessageCommand.Execute(null);
                        }
                    })
                });
            }
        }
        async Task ExecuteTapQueueCommandAsync(ASECloudQueue queue)
        {
            if (queue == null)
            {
                return;
            }

            MessagingService.Current.Subscribe <MessageArgsDeleteQueue>(MessageKeys.DeleteQueue, async(m, argsDeleteQueue) =>
            {
                Navigation.PopAsync();
                IProgressDialog deletingDialog = UserDialogs.Loading("Deleting Queue");
                deletingDialog.Show();
                try
                {
                    var aseQueue = Queues.Where(c => c.QueueName == argsDeleteQueue.QueueName &&
                                                c.StorageAccountName == argsDeleteQueue.StorageAccountName).FirstOrDefault();
                    if (aseQueue == null)
                    {
                        return;
                    }

                    await aseQueue.BaseQueue.DeleteAsync();
                    App.Logger.Track(AppEvent.DeleteQueue.ToString());

                    Queues.Remove(aseQueue);
                    SortQueues();
                    var realm = App.GetRealm();
                    await realm.WriteAsync(temprealm =>
                    {
                        temprealm.Remove(temprealm.All <RealmCloudQueue>()
                                         .Where(c => c.QueueName == argsDeleteQueue.QueueName &&
                                                c.StorageAccountName == argsDeleteQueue.StorageAccountName).First());
                    });
                }
                catch (Exception ex)
                {
                    Logger.Report(ex, "Method", "HandleMessageArgsDeleteQueue");
                    MessagingService.Current.SendMessage(MessageKeys.Error, ex);
                }
                finally
                {
                    if (deletingDialog != null)
                    {
                        if (deletingDialog.IsShowing)
                        {
                            deletingDialog.Hide();
                        }
                        deletingDialog.Dispose();
                    }
                }
            });
            var queueMessagesPage = new QueueMessagesPage(queue);

            App.Logger.TrackPage(AppPage.QueueMessages.ToString());
            await NavigationService.PushAsync(Navigation, queueMessagesPage);
        }
        public QueueMessagesPage(ASECloudQueue queue)
        {
            InitializeComponent();
            BindingContext = new QueueMessagesViewModel(Navigation, UserDialogs.Instance, queue);

            Title = queue.BaseQueue.Name;
            ViewModel.LoadQueueMessagesCommand.Execute(false);

            if (Device.RuntimePlatform == Device.Android)
            {
                ToolbarItems.Add(new ToolbarItem
                {
                    Order   = ToolbarItemOrder.Secondary,
                    Text    = "Add Message",
                    Command = vm.AddQueueMessageCommand
                });
                ToolbarItems.Add(new ToolbarItem
                {
                    Order   = ToolbarItemOrder.Secondary,
                    Text    = "Delete Queue",
                    Command = vm.DeleteQueueCommand
                });
            }
            else if (Device.RuntimePlatform == Device.iOS)
            {
                ToolbarItems.Add(new ToolbarItem
                {
                    Text    = "More",
                    Icon    = "toolbar_overflow.png",
                    Command = new Command(async() =>
                    {
                        string[] items = new[] { "Add Message", "Delete Queue" };

                        var action = await DisplayActionSheet("Options", "Cancel", null, items);
                        if (action == items[0])
                        {
                            vm.AddQueueMessageCommand.Execute(null);
                        }
                        else if (action == items[1])
                        {
                            vm.DeleteQueueCommand.Execute(null);
                        }
                    })
                });
            }

            lvQueueMessages.ItemSelected += (sender, e) =>
            {
                lvQueueMessages.SelectedItem = null;
            };
        }
Exemple #4
0
 public QueueMessagesViewModel(INavigation navigation, IUserDialogs userDialogs, ASECloudQueue queue) : base(navigation, userDialogs)
 {
     Queue = queue;
     NoQueueMessagesFoundMessage = "No Queue Messages Found";
 }
 public QueueMessageDetailsViewModel(INavigation navigation, CloudQueueMessage message, ASECloudQueue queue) : base(navigation)
 {
     QueueMessage = message;
     this.queue   = queue;
 }
 public void AddQueue(ASECloudQueue aseCloudQueue)
 {
     Queues.Add(aseCloudQueue);
     SortQueues();
 }