Beispiel #1
0
        public void SetUp()
        {
            messenger         = new Mock <IMvxMessenger>();
            countersService   = new Mock <ICountersService>();                //creates a mock counters service
            navigationService = new Mock <IMvxNavigationService>();           //Creates a mock of the navigation service
            viewModel         = new CountersViewModel(countersService.Object, //uses the mock counters service to create the view model
                                                      messenger.Object,
                                                      navigationService.Object);

            //listing 8.34 page 277  Sets up the subscribe method on the messenger so the action is stored
            messenger = new Mock <IMvxMessenger>();
            messenger.Setup(m => m.SubscribeOnMainThread
                                (It.IsAny <Action <CountersChangedMessage> >(),

                                It.IsAny <MvxReference>(),

                                It.IsAny <string>()))
            .Callback <Action <CountersChangedMessage>,
                       MvxReference,
                       string>((a, m, s) => publishAction = a);

            viewModel = new CountersViewModel(countersService.Object,
                                              messenger.Object,
                                              navigationService.Object);
        }
        public void ExecutingAddNewCounterCommandShouldNavigateToTheNewCounterActivity()
        {
            var vm = new CountersViewModel(_mockDatabaseHelper.Object, _mockNavigationService.Object, _mockDialogService.Object);

            vm.AddNewCounterCommand.Execute(null);
            _mockNavigationService.Verify(n => n.NavigateTo(ViewModelLocator.NewCounterPageKey), Times.Once);
        }
Beispiel #3
0
        public async Task <IViewComponentResult> InvokeAsync()
        {
            CountersViewModel model = new CountersViewModel();

            OperationResultVo <int> gamesCount = gameAppService.Count(CurrentUserId);

            if (gamesCount.Success)
            {
                model.GamesCount = gamesCount.Value;
            }

            OperationResultVo <int> usersCount = profileAppService.Count(CurrentUserId);

            if (usersCount.Success)
            {
                model.UsersCount = usersCount.Value;
            }

            model.ArticlesCount = contentService.CountArticles();

            OperationResultVo <int> teamCount = teamAppService.CountNotSingleMemberGroups(CurrentUserId);

            if (teamCount.Success)
            {
                model.TeamCount = teamCount.Value;
            }

            return(await Task.Run(() => View(model)));
        }
        public override void ViewDidLoad()
        {
            base.ViewDidLoad();

            try
            {
                viewModel = SimpleIoc.Default.GetInstance <CountersViewModel>();

                var source = new CountersTableViewSource();
                TableView.Source = source;

                addCounterButton = new UIBarButtonItem(UIBarButtonSystemItem.Add);
                addCounterButton.AccessibilityIdentifier = "add_counter_button";
                NavigationItem.SetRightBarButtonItem(addCounterButton, false);

                bindings.Add(this.SetBinding(() => viewModel.Counters, () => DataSource));

                // Using this - new view controller is shown
                //addCounterButton.Clicked += (sender, e) =>
                //{
                //    var storyboard = UIStoryboard.FromName("Main", null);
                //    var vc = storyboard.InstantiateViewController("CounterView");
                //    ShowViewController(vc, this);
                //};

                // Using this - app crashes
                addCounterButton.SetCommand(nameof(UIBarButtonItem.Clicked), viewModel.ShowAddNewCounterCommand);
            }
            catch { }
        }
        public void MatchAndChanged(IProgressBarDisplayable progress, IUnitOfWork uow)
        {
            if (Columns.Any(x => x.DataType == DataTypeEmployee.PersonnelNumber))
            {
                dataParser.MatchByNumber(uow, UsedRows, Columns, matchSettingsViewModel, progress);
            }
            else
            {
                dataParser.MatchByName(uow, UsedRows, Columns, progress);
            }

            dataParser.FillExistEntities(uow, UsedRows, Columns, progress);
            dataParser.FindChanges(
                uow,
                UsedRows,
                Columns
                .Where(x => x.DataType != DataTypeEmployee.Unknown)
                .OrderBy(x => x.DataType)
                .ToArray(),
                progress,
                matchSettingsViewModel);
            OnPropertyChanged(nameof(DisplayRows));

            RecalculateCounters();
            CanSave = CountersViewModel.GetCount(CountersEmployee.ChangedEmployee) > 0 ||
                      CountersViewModel.GetCount(CountersEmployee.NewEmployee) > 0 ||
                      CountersViewModel.GetCount(CountersEmployee.NewPosts) > 0 ||
                      CountersViewModel.GetCount(CountersEmployee.NewDepartments) > 0 ||
                      CountersViewModel.GetCount(CountersEmployee.NewSubdivisions) > 0;
        }
 public void SetUp()
 {
     _service           = A.Fake <ICountersService> ();
     _messenger         = A.Fake <IMvxMessenger> ();
     _navigationService = A.Fake <IMvxNavigationService> ();
     _subject           = new CountersViewModel(_service, _messenger, _navigationService);
 }
Beispiel #7
0
 private void RecalculateCounters()
 {
     CountersViewModel.SetCount(CountersWorkwearItems.SkipRows, UsedRows.Count(x => x.Skipped));
     CountersViewModel.SetCount(CountersWorkwearItems.UsedEmployees, UsedRows.Select(x => x.Employee).Distinct().Count(x => x != null));
     CountersViewModel.SetCount(CountersWorkwearItems.NewOperations, UsedRows.Count(x => x.Operation != null && x.Operation.Id == 0));
     CountersViewModel.SetCount(CountersWorkwearItems.WorkwearItemNotFound, UsedRows.Count(x => x.Employee != null && x.WorkwearItem == null));
     CountersViewModel.SetCount(CountersWorkwearItems.NewNomenclatures, dataParser.UsedNomeclature.Count(x => x.Id == 0));
 }
        public void CountersChangingInTheDatabaseShouldReloadTheCounters()
        {
            var vm = new CountersViewModel(_mockDatabaseHelper.Object, _mockNavigationService.Object, _mockDialogService.Object);

            _mockDatabaseHelper.Raise(d => d.CountersChanged += null, new EventArgs());
            _mockDatabaseHelper.Verify(d => d.GetAllCountersAsync(), Times.Once);
            GC.KeepAlive(vm);
        }
Beispiel #9
0
        public void MatchAndChanged(IProgressBarDisplayable progress, IUnitOfWork uow)
        {
            dataParser.MatchChanges(progress, settingsWorkwearItemsViewModel, CountersViewModel, uow, UsedRows, Columns);
            OnPropertyChanged(nameof(DisplayRows));

            RecalculateCounters();
            CanSave = CountersViewModel.GetCount(CountersWorkwearItems.NewOperations) > 0;
        }
Beispiel #10
0
 public TopViewModel()
 {
     Keypad                 = new KeypadSerial();
     CurrentPage            = Page.Keybinds;
     keybindsVm             = new KeybindsViewModel(Keypad);
     countersVm             = new CountersViewModel(Keypad);
     debounceVm             = new DebounceViewModel(Keypad);
     lightingVm             = new LightingViewModel(Keypad);
     debugVm                = new DebugViewModel(Keypad);
     TopView.DeviceChanged += CheckConnection;
 }
        private void RecalculateCounters()
        {
            CountersViewModel.SetCount(CountersEmployee.SkipRows, UsedRows.Count(x => x.Skipped));
            CountersViewModel.SetCount(CountersEmployee.MultiMatch, UsedRows.Count(x => !x.Skipped && x.Employees.Count > 1));
            CountersViewModel.SetCount(CountersEmployee.NewEmployee, UsedRows.Count(x => !x.Skipped && x.EditingEmployee.Id == 0));
            CountersViewModel.SetCount(CountersEmployee.NotChangedEmployee, UsedRows.Count(x => !x.Skipped && !x.HasChanges));
            CountersViewModel.SetCount(CountersEmployee.ChangedEmployee, UsedRows.Count(x => !x.Skipped && x.HasChanges && x.EditingEmployee.Id > 0));

            CountersViewModel.SetCount(CountersEmployee.NewPosts, dataParser.UsedPosts.Count(x => x.Id == 0));
            CountersViewModel.SetCount(CountersEmployee.NewDepartments, dataParser.UsedDepartment.Count(x => x.Id == 0));
            CountersViewModel.SetCount(CountersEmployee.NewSubdivisions, dataParser.UsedSubdivisions.Count(x => x.Id == 0));
        }
        public async Task LoadCountersAsyncShouldLoadTheCountersFromTheDatabase()
        {
            _mockDatabaseHelper.Setup(d => d.GetAllCountersAsync()).ReturnsAsync(new List <Counter> {
                _monkeyCounter, _platypusCounter
            });
            var vm = new CountersViewModel(_mockDatabaseHelper.Object, _mockNavigationService.Object, _mockDialogService.Object);
            await vm.LoadCountersAsync();

            vm.Counters.Should().HaveCount(2);
            vm.Counters.Should().Contain(c => Matches(c, _monkeyCounter));
            vm.Counters.Should().Contain(c => Matches(c, _platypusCounter));
        }
Beispiel #13
0
        public void SetUp()
        {
            countersService = new Mock <ICountersService>();
            messenger       = new Mock <IMvxMessenger>();
            messenger.Setup(m => m.SubscribeOnMainThread(It.IsAny <Action <CountersChangedMessage> >(),
                                                         It.IsAny <MvxReference>(),
                                                         It.IsAny <string>()))
            .Callback <Action <CountersChangedMessage>, MvxReference, string>((a, m, s) => publishAction = a);
            navigationService = new Mock <IMvxNavigationService>();

            viewModel = new CountersViewModel(countersService.Object, messenger.Object, navigationService.Object);
        }
        public void MatchAndChanged(IProgressBarDisplayable progress, IUnitOfWork uow)
        {
            dataParser.MatchWithExist(uow, UsedRows, Columns, progress);
            dataParser.FindChanges(UsedRows, Columns.Where(x => x.DataType != DataTypeNorm.Unknown).ToArray());
            OnPropertyChanged(nameof(DisplayRows));

            RecalculateCounters();
            CanSave = CountersViewModel.GetCount(CountersNorm.ChangedNormItems) > 0 ||
                      CountersViewModel.GetCount(CountersNorm.NewNormItems) > 0 ||
                      CountersViewModel.GetCount(CountersNorm.NewNorms) > 0 ||
                      CountersViewModel.GetCount(CountersNorm.NewPosts) > 0 ||
                      CountersViewModel.GetCount(CountersNorm.NewSubdivisions) > 0 ||
                      CountersViewModel.GetCount(CountersNorm.NewProtectionTools) > 0;
        }
        private void RecalculateCounters()
        {
            CountersViewModel.SetCount(CountersNorm.SkipRows, UsedRows.Count(x => x.Skipped));
            CountersViewModel.SetCount(CountersNorm.AmbiguousNorms, dataParser.MatchPairs.Count(x => x.Norms.Count > 1));
            CountersViewModel.SetCount(CountersNorm.NewNorms, dataParser.UsedNorms.Count(x => x.Id == 0));
            CountersViewModel.SetCount(CountersNorm.NewNormItems, UsedRows.Count(x => !x.Skipped && x.NormItem.Id == 0 && x.ChangedColumns.Any()));
            CountersViewModel.SetCount(CountersNorm.ChangedNormItems, UsedRows.Count(x => !x.Skipped && x.NormItem.Id > 0 && x.ChangedColumns.Any()));

            CountersViewModel.SetCount(CountersNorm.NewPosts, dataParser.UsedPosts.Count(x => x.Id == 0));
            CountersViewModel.SetCount(CountersNorm.NewSubdivisions, dataParser.UsedSubdivisions.Count(x => x.Id == 0));
            CountersViewModel.SetCount(CountersNorm.NewProtectionTools, dataParser.UsedProtectionTools.Count(x => x.Id == 0));
            CountersViewModel.SetCount(CountersNorm.NewItemTypes, dataParser.UsedItemTypes.Count(x => x.Id == 0));
            CountersViewModel.SetCount(CountersNorm.UndefinedItemTypes, dataParser.UndefinedProtectionNames.Count);
        }
Beispiel #16
0
        public void MatchChanges(
            IProgressBarDisplayable progress,
            SettingsWorkwearItemsViewModel settings,
            CountersViewModel counters,
            IUnitOfWork uow,
            IEnumerable <SheetRowWorkwearItems> list,
            List <ImportedColumn <DataTypeWorkwearItems> > columns)
        {
            var personnelNumberColumn = columns.FirstOrDefault(x => x.DataType == DataTypeWorkwearItems.PersonnelNumber);
            var protectionToolsColumn = columns.FirstOrDefault(x => x.DataType == DataTypeWorkwearItems.ProtectionTools);
            var nomenclatureColumn    = columns.FirstOrDefault(x => x.DataType == DataTypeWorkwearItems.Nomenclature);
            var issueDateColumn       = columns.FirstOrDefault(x => x.DataType == DataTypeWorkwearItems.IssueDate);
            var countColumn           = columns.FirstOrDefault(x => x.DataType == DataTypeWorkwearItems.Count);
            var postColumn            = columns.FirstOrDefault(x => x.DataType == DataTypeWorkwearItems.Post);
            var subdivisionColumn     = columns.FirstOrDefault(x => x.DataType == DataTypeWorkwearItems.Subdivision);
            var sizeAndGrowthColumn   = columns.FirstOrDefault(x => x.DataType == DataTypeWorkwearItems.SizeAndGrowth);
            var sizeColumn            = columns.FirstOrDefault(x => x.DataType == DataTypeWorkwearItems.Size);
            var growthColumn          = columns.FirstOrDefault(x => x.DataType == DataTypeWorkwearItems.Growth);

            progress.Start(list.Count() * 2 + 3, text: "Загрузка сотрудников");
            var personnelNumbers = list.Select(x => GetPersonalNumber(settings, x, personnelNumberColumn.Index))
                                   .Where(x => !String.IsNullOrWhiteSpace(x)).Distinct().ToArray();

            var employees = uow.Session.QueryOver <EmployeeCard>()
                            .Where(x => x.PersonnelNumber.IsIn(personnelNumbers))
                            .Fetch(SelectMode.Fetch, x => x.WorkwearItems)
                            .List();

            foreach (var row in list)
            {
                progress.Add(text: "Сопоставление");
                row.Date = ParseDateOrNull(row.CellStringValue(issueDateColumn.Index));
                if (row.Date == null)
                {
                    row.ProgramSkipped = true;
                    row.AddColumnChange(issueDateColumn, ChangeType.ParseError);
                    continue;
                }

                if (row.CellIntValue(countColumn.Index) == null)
                {
                    row.ProgramSkipped = true;
                    row.AddColumnChange(countColumn, ChangeType.ParseError);
                    continue;
                }

                row.Employee = employees.FirstOrDefault(x => x.PersonnelNumber == GetPersonalNumber(settings, row, personnelNumberColumn.Index));
                if (row.Employee == null)
                {
                    logger.Warn(
                        $"Не найден сотрудник в табельным номером [{GetPersonalNumber(settings, row, personnelNumberColumn.Index)}]. Пропускаем.");
                    row.ProgramSkipped = true;
                    row.AddColumnChange(personnelNumberColumn, ChangeType.NotFound);
                    counters.AddCount(CountersWorkwearItems.EmployeeNotFound);
                    continue;
                }

                var protectionToolName = row.CellStringValue(protectionToolsColumn.Index);
                row.WorkwearItem = row.Employee.WorkwearItems.FirstOrDefault(x => x.ProtectionTools.Name == protectionToolName);
                if (row.WorkwearItem == null && postColumn != null && subdivisionColumn != null)
                {
                    if (!TryAddNorm(uow, row.CellStringValue(postColumn.Index),
                                    row.CellStringValue(subdivisionColumn.Index), row.Employee))
                    {
                        row.AddColumnChange(postColumn, ChangeType.NotFound);
                        row.AddColumnChange(subdivisionColumn, ChangeType.NotFound);
                    }
                    else
                    {
                        counters.AddCount(CountersWorkwearItems.EmployeesAddNorm);
                    }
                }

                if (row.WorkwearItem != null)
                {
                    continue;
                }
                row.ProgramSkipped = true;
                row.AddColumnChange(protectionToolsColumn, ChangeType.NotFound);
            }

            progress.Add(text: "Загрузка номенклатуры");
            var nomenclatureTypes = new NomenclatureTypes(uow, sizeService, true);
            var nomenclatureNames =
                list.Select(x => x.CellStringValue(nomenclatureColumn.Index)).Where(x => x != null).Distinct().ToArray();
            var nomenclatures = nomenclatureRepository.GetNomenclatureByName(uow, nomenclatureNames);

            progress.Add(text: "Загрузка операций выдачи");
            var dates = list
                        .Select(x => x.Date)
                        .Where(x => x != null)
                        .Select(x => x.Value);
            var startDate   = dates.Min();
            var endDate     = dates.Max();
            var employeeIds = list.Where(x => x.Employee != null)
                              .Select(x => x.Employee.Id).Distinct().ToArray();
            var operations = uow.Session.QueryOver <EmployeeIssueOperation>()
                             .Where(x => x.Employee.Id.IsIn(employeeIds))
                             .Where(x => x.OperationTime >= startDate)
                             .Where(x => x.OperationTime < endDate.AddDays(1))
                             .List()
                             .GroupBy(x => x.Employee);

            foreach (var row in list)
            {
                progress.Add(text: "Обработка операций выдачи");
                if (row.Skipped)
                {
                    continue;
                }
                var nomenclatureName = row.CellStringValue(nomenclatureColumn.Index);
                if (String.IsNullOrWhiteSpace(nomenclatureName))
                {
                    row.AddColumnChange(nomenclatureColumn, ChangeType.NotFound);
                    continue;
                }

                var nomenclature =
                    UsedNomeclature.FirstOrDefault(x => String.Equals(x.Name, nomenclatureName, StringComparison.CurrentCultureIgnoreCase));
                if (nomenclature == null)
                {
                    nomenclature =
                        nomenclatures.FirstOrDefault(x => String.Equals(x.Name, nomenclatureName, StringComparison.CurrentCultureIgnoreCase));
                    if (nomenclature == null)
                    {
                        nomenclature = new Nomenclature {
                            Name    = nomenclatureName,
                            Type    = row.WorkwearItem.ProtectionTools.Type,
                            Comment = "Создана при импорте выдачи из Excel",
                        };
                        nomenclature.Sex = nomenclatureTypes.ParseSex(nomenclature.Name) ?? ClothesSex.Universal;
                        row.WorkwearItem.ProtectionTools.AddNomeclature(nomenclature);
                    }
                    UsedNomeclature.Add(nomenclature);
                }

                row.Operation = operations.FirstOrDefault(group => group.Key == row.Employee)
                                ?.FirstOrDefault(x => x.OperationTime.Date == row.Date && x.Nomenclature == nomenclature);

                if (row.Operation != null)
                {
                    //TODO Обновление операций не реализовано
                    continue;
                }

                if (row.Operation != null)
                {
                    continue;
                }
                {
                    var count       = row.CellIntValue(countColumn.Index).Value;
                    var expenseDate = row.WorkwearItem.ActiveNormItem.CalculateExpireDate(row.Date.Value, count);
                    row.Operation = new EmployeeIssueOperation {
                        OperationTime    = row.Date.Value,
                        Employee         = row.Employee,
                        Issued           = count,
                        Nomenclature     = nomenclature,
                        AutoWriteoffDate = expenseDate,
                        ExpiryByNorm     = expenseDate,
                        NormItem         = row.WorkwearItem.ActiveNormItem,
                        ProtectionTools  = row.WorkwearItem.ProtectionTools,
                        Returned         = 0,
                        StartOfUse       = row.Date,
                        UseAutoWriteoff  = expenseDate != null,
                    };
                    //Обрабатываем размер.
                    if (TryParseSizeAndGrowth(uow, row, columns, out var sizeAndGrowth))
                    {
                        row.Operation.WearSize = sizeAndGrowth.Size;
                        row.Operation.Height   = sizeAndGrowth.Growth;
                        var sizeOk   = nomenclature.Type.SizeType == sizeAndGrowth.Size.SizeType;
                        var growthOk = nomenclature.Type.HeightType == sizeAndGrowth.Growth.SizeType;
                        if (sizeAndGrowthColumn != null)
                        {
                            row.ChangedColumns.Add(sizeAndGrowthColumn, new ChangeState(sizeOk && growthOk ? ChangeType.NewEntity : ChangeType.ParseError));
                        }
                        if (sizeColumn != null)
                        {
                            row.ChangedColumns.Add(sizeColumn, new ChangeState(sizeOk ? ChangeType.NewEntity : ChangeType.ParseError));
                        }
                        if (growthColumn != null)
                        {
                            row.ChangedColumns.Add(growthColumn, new ChangeState(growthOk ? ChangeType.NewEntity : ChangeType.ParseError));
                        }
                    }
                    //Проставляем размер в сотрудника.
                    if (row.Operation.Height != null)
                    {
                        var employeeSize = row.Employee.Sizes.FirstOrDefault(x => x.SizeType == row.Operation.Height.SizeType);
                        if (employeeSize is null)
                        {
                            employeeSize = new EmployeeSize
                            {
                                Size = row.Operation.Height, SizeType = row.Operation.Height.SizeType, Employee = row.Employee
                            };
                            row.Employee.Sizes.Add(employeeSize);
                        }
                        else
                        {
                            employeeSize.Size = row.Operation.Height;
                        }
                        ChangedEmployees.Add(row.Employee);
                        counters.AddCount(CountersWorkwearItems.EmployeesSetSize);
                    }
                    if (row.Operation.WearSize != null)
                    {
                        var employeeSize = row.Employee.Sizes.FirstOrDefault(x => x.SizeType == row.Operation.WearSize.SizeType);
                        if (employeeSize is null)
                        {
                            employeeSize = new EmployeeSize
                            {
                                Size = row.Operation.WearSize, SizeType = row.Operation.WearSize.SizeType, Employee = row.Employee
                            };
                            row.Employee.Sizes.Add(employeeSize);
                        }
                        else
                        {
                            employeeSize.Size = row.Operation.WearSize;
                        }
                        ChangedEmployees.Add(row.Employee);
                        counters.AddCount(CountersWorkwearItems.EmployeesSetSize);
                    }
                    var toSetChangeColumns = columns.Where(
                        x => x.DataType != DataTypeWorkwearItems.Unknown &&
                        x.DataType != DataTypeWorkwearItems.SizeAndGrowth &&
                        x.DataType != DataTypeWorkwearItems.Size &&
                        x.DataType != DataTypeWorkwearItems.Growth
                        );
                    foreach (var column in toSetChangeColumns)
                    {
                        if (!row.ChangedColumns.ContainsKey(column))
                        {
                            row.ChangedColumns.Add(column, new ChangeState(ChangeType.NewEntity));
                        }
                    }
                }
            }
            progress.Close();
        }
 public MainViewModel()
 {
     Categories = new CategoriesViewModel();
     Counters   = new CountersViewModel(Categories);
 }
 protected ImportModelBase(IDataParser <TDataTypeEnum> dataParser, Type countersEnum, ViewModelBase matchSettingsViewModel = null)
 {
     this.dataParser             = dataParser;
     this.MatchSettingsViewModel = matchSettingsViewModel;
     CountersViewModel           = new CountersViewModel(countersEnum);
 }
Beispiel #19
0
 public void SetUp()
 {
     mockCountersService = new Mock <ICountersService>();
     messenger           = new Mock <IMvxMessenger>();
     countersViewModel   = new CountersViewModel(mockCountersService.Object, messenger.Object);
 }
 public MainViewModel()
 {
     Categories = new CategoriesViewModel();
     Counters = new CountersViewModel(Categories);
 }
Beispiel #21
0
 public SwipeItemTouchHelperCallback(CountersViewModel viewModel) : base(0, ItemTouchHelper.Start)
 {
     this.viewModel = viewModel;
 }
Beispiel #22
0
 public SwipeItemTouchHelperCallback(CountersViewModel viewModel) //Stores an instance of the CountersViewModel that you can use to delete a counter
     : base(0, ItemTouchHelper.Start)                             //Specifies the supported swipe directions
 {
     this.viewModel = viewModel;
 }