Example #1
0
 public static async Task RemoveAtOffset(this PaginatorController pie, int offset)
 => await pie.RemoveAtOffset(await pie.GetCurrentFocusPage(), offset);
Example #2
0
 public static async Task AddOffset(this PaginatorController pie, object item, int offset)
 => await pie.AddOffset(await pie.GetCurrentFocusPage(), item, offset);
Example #3
0
 public static async Task RemoveAt(this PaginatorController pie, int index)
 => await pie.RemoveAt(await pie.GetCurrentFocusPage(), index);
Example #4
0
 public static async Task MoveToLast(this PaginatorController pie, object item)
 => await pie.MoveToLast(await pie.GetCurrentFocusPage(), item);
Example #5
0
 public static async Task MoveCaretBy(this PaginatorController pie, int offset, bool throughPage = false)
 => await pie.MoveCaretBy(await pie.GetCurrentFocusPage(), offset, throughPage);
Example #6
0
 public static async Task <TItem> GetSelectedItem <TItem>(this PaginatorController pie) => (TItem)await pie.GetSelectedItem();
Example #7
0
        static async Task MainAsync(string[] args)
        {
            var evenItems = Enumerable.Range(0, 197).Select(x => (x * 2).ToString());
            var oddItems  = Enumerable.Range(0, 27).Select(x => (x * 2 + 1).ToString());
            var pdb       = new PagedDataSetBuilder <string, string>()
                            .WithName("Even page")
                            .WithStringPageGenerator()
                            .WithDefaultCapabilities()
                            .WithDataSource(evenItems)
                            .WithPageSize(10)
                            .WithItemFilter(new StringItemFilter());
            var evenPd = await pdb.BuildPagedDataSource();

            var oddPd = await pdb.WithDataSource(oddItems)
                        .WithName("Odd page")
                        .BuildPagedDataSource();

            PaginatorController controller = new PaginatorController();

            controller.Add(evenPd);
            controller.Add(oddPd);
            await controller.SetFocusPage(evenPd);

            var ic = StringComparison.OrdinalIgnoreCase;

            while (true)
            {
                Console.Clear();
                foreach (var item in await controller.GetPageContents())
                {
                    Console.WriteLine("Header".Center(50, '-'));
                    Console.WriteLine(await item.GetHeader());
                    Console.WriteLine("Content".Center(50, '-'));
                    Console.WriteLine(await item.GetContent());
                    Console.WriteLine("-".Multiply(50));
                }

                var cmd = Console.ReadKey(true);
                if (cmd.Key == ConsoleKey.Q && cmd.Modifiers == ConsoleModifiers.Shift)
                {
                    var pds = await controller.GetCurrentFocusPage();

                    await controller.MovePagedDataSetOffset(pds, -1);
                }
                else if (cmd.Key == ConsoleKey.E && cmd.Modifiers == ConsoleModifiers.Shift)
                {
                    var pds = await controller.GetCurrentFocusPage();

                    await controller.MovePagedDataSetOffset(pds, 1);
                }
                else if (cmd.Key == ConsoleKey.Q)
                {
                    await controller.SetFocusPageAtOffset(-1);
                }
                else if (cmd.Key == ConsoleKey.E)
                {
                    await controller.SetFocusPageAtOffset(1);
                }
                else if (cmd.Key == ConsoleKey.D)
                {
                    await controller.MoveCurrentPageIndex(1);
                }
                else if (cmd.Key == ConsoleKey.A)
                {
                    await controller.MoveCurrentPageIndex(-1);
                }
                else if (cmd.Key == ConsoleKey.W && cmd.Modifiers == ConsoleModifiers.Shift)
                {
                    var sel = await controller.GetSelectedItem();

                    await controller.MoveOffset(sel, -1);

                    await controller.SetSelectedItem(sel);
                }
                else if (cmd.Key == ConsoleKey.S && cmd.Modifiers == ConsoleModifiers.Shift)
                {
                    var sel = await controller.GetSelectedItem();

                    await controller.MoveOffset(sel, 1);

                    await controller.SetSelectedItem(sel);
                }
                else if (cmd.Key == ConsoleKey.W)
                {
                    await controller.MoveCaretBy(-1, true);
                }
                else if (cmd.Key == ConsoleKey.S)
                {
                    await controller.MoveCaretBy(1, true);
                }
                else if (cmd.Key == ConsoleKey.Enter && cmd.Modifiers == ConsoleModifiers.Shift)
                {
                    await controller.RemoveAtOffset(0);
                }
                else if (cmd.Key == ConsoleKey.Enter)
                {
                    await controller.AddOffset(DateTime.Now.ToString(), 0);
                }
                else if (cmd.Key == ConsoleKey.Spacebar)
                {
                    await controller.SetSelectedItem("20");
                }


                else if (cmd.KeyChar == '/')
                {
                    Console.WriteLine("Line Command: ");
                    string command = Console.ReadLine();
                    if (command.StartsWith("f", ic))
                    {
                        var sp = command.Split(' ');
                        if (sp.Length > 1)
                        {
                            await(await controller.GetCurrentFocusPage()).SetFilter(sp.Skip(1).Aggregate((l, r) => $"{l} {r}"));
                        }
                        else
                        {
                            await(await controller.GetCurrentFocusPage()).SetFilter(string.Empty);
                        }
                    }
                }
            }
        }
        /// <summary>
        /// Инициализация данных контроллера.
        /// </summary>
        public override void Initialize()
        {
            _orderModel                           = ClientCore.Instance.CreateInstance <RepairOrderViewModel>();
            _orderModel.Orders                    = new ObservableCollection <RepairOrderItemModel>();
            _orderModel.CurrentWorkItems          = new ObservableCollection <WorkItemModel>();
            _orderModel.CurrentDeviceItems        = new ObservableCollection <DeviceItemModel>();
            _orderModel.CurrentOrderTimelineItems = new ObservableCollection <OrderTimelineModel>();
            _view = new RepairOrderView {
                DataContext = _orderModel
            };

            _paginatorController = new PaginatorController();
            _paginatorController.SetView(_view.paginatorPanel, MaxPages, ItemsPerPage);
            _paginatorController.PageChanged += PaginatorControllerPageChanged;

            _filterBox = new RepairOrderFilterComboBoxController();
            _filterBox.SetView(_view.filterBox, null, true, false);

            _userBox = new UserComboBoxController();
            _userBox.SetView(_view.userBox, null, true, true);

            _statusBox = new OrderStatusController();
            _statusBox.SetView(_view.statusBox, null, true, true);

            _nameBox = new TextBoxController();
            _nameBox.SetView(_view.nameBox);

            _view.listView.SelectionChanged += RepairOrderListSelectionChanged;
            _view.listView.MouseDoubleClick += ListViewOnMouseDoubleClick;

            _view.editOrderItem.Click   += (sender, args) => SelectedRepairOrderStartEdit();
            _view.deleteOrderItem.Click += (sender, args) => SelectedRepairOrderStartDelete();

            _view.createButton.Click += (sender, args) => RepairOrderStartCreate();

            _nameBox.Model.PressKey  += NameBoxOnPressKey;
            _view.updateButton.Click += (sender, args) => StartUpdateOrderList(1);

            _orderDataController = new RepairOrderDataController();
            _orderDataController.Initialize();
            _orderDataController.CreateModelSaved += OrderDataControllerCreateModelSaved;
            _orderDataController.EditModelSaved   += OrderDataControllerOnEditModelSaved;

            _workItemDataController = new WorkItemDataController();
            _workItemDataController.Initialize();
            _workItemDataController.CreateModelSaved += WorkItemDataControllerOnCreateModelSaved;
            _workItemDataController.EditModelSaved   += WorkItemDataControllerOnEditModelSaved;
            _view.editWorkItem.Click     += (sender, args) => SelectedWorkItemStartEdit();
            _view.createWorkButton.Click += (sender, args) => WorkItemStartCreate();

            _deviceItemDataController = new DeviceItemDataController();
            _deviceItemDataController.Initialize();
            _deviceItemDataController.CreateModelSaved += DeviceItemDataControllerOnCreateModelSaved;
            _deviceItemDataController.EditModelSaved   += DeviceItemDataControllerOnEditModelSaved;
            _view.editDeviceItem.Click     += (sender, args) => SelectedDeviceItemStartEdit();
            _view.createDeviceButton.Click += (sender, args) => DeviceItemStartCreate();

            _commentDataController = new CommentDataController();
            _commentDataController.Initialize();
            _commentDataController.CreateModelSaved += CommentDataControllerOnCreateModelSaved;
            _view.createCommentButton.Click         += (sender, args) => CommentStartCreate();

            StartUpdateOrderList(1);

            _customReportPreviewController = new CustomReportPreviewController();
            _customReportPreviewController.Initialize();

            StartPopulateReportList();

            if (ClientCore.Instance.AuthService.SecurityToken.User.ProjectRoleID == ProjectRoleSet.Engineer.ProjectRoleID)
            {
                _view.createButton.IsEnabled = false;

                foreach (var editFormControlModel in _orderDataController.GetEditFormControlModels())
                {
                    if (!StringComparer.OrdinalIgnoreCase.Equals(editFormControlModel.Id, "RepairOrderStatusID"))
                    {
                        editFormControlModel.ReadOnly = true;
                    }
                }
            }
        }