public void SelectionTest()
        {
            IEntityService entityService = Container.GetExportedValue <IEntityService>();

            entityService.Persons.Add(new Person()
            {
                Firstname = "Harry"
            });
            entityService.Persons.Add(new Person()
            {
                Firstname = "Ron"
            });

            PersonController personController = Container.GetExportedValue <PersonController>();

            personController.Initialize();

            // Check that Initialize shows the PersonListView and PersonView
            ShellService shellService = Container.GetExportedValue <ShellService>();

            Assert.IsInstanceOfType(shellService.PersonListView, typeof(IPersonListView));
            Assert.IsInstanceOfType(shellService.PersonView, typeof(IPersonView));

            // Check that the first Person is selected
            IPersonListView     personListView      = Container.GetExportedValue <IPersonListView>();
            PersonListViewModel personListViewModel = ViewHelper.GetViewModel <PersonListViewModel>(personListView);

            Assert.AreEqual(entityService.Persons.First(), personListViewModel.SelectedPerson);

            // Change the selection
            PersonViewModel personViewModel = Container.GetExportedValue <PersonViewModel>();

            personListViewModel.SelectedPerson = entityService.Persons.Last();
            Assert.AreEqual(entityService.Persons.Last(), personViewModel.Person);
        }
 public PersonList(string projectID)
 {
     InitializeComponent();
     _viewmodel          = new PersonListViewModel(Navigation, projectID);
     this.BindingContext = _viewmodel;
     _viewmodel.Fetch();
 }
Example #3
0
        //
        // GET: /Person/

        public ActionResult Index(String name, bool?gender, String school, String major, int?edu, int page = 1)
        {
            if (page <= 0)
            {
                page = 1;
            }
            int maxPage = (int)Math.Ceiling(dbContext.Persons.Count() / (float)pageSize);

            if (page > maxPage)
            {
                page = maxPage;
            }

            IEnumerable <Person> persons = Filter(name, gender, school, major, edu);

            PersonListViewModel model = new PersonListViewModel
            {
                // Persons = dbContext.Persons.OrderBy(x => x.ID).Skip((page - 1) * pageSize).Take(pageSize).ToList(),
                Persons    = persons.OrderBy(x => x.ID).Skip((page - 1) * pageSize).Take(pageSize).ToList(),
                PagingInfo = new PagingInfo {
                    CurrentPage  = page,
                    ItemsPerPage = pageSize,
                    // TotalItems = dbContext.Persons.Count()
                    TotalItems = persons.Count()
                }
            };

            return(View(model));
        }
 public PersonListView(IRepositoryFactory factory)
 {
     InitializeComponent();
     _factory    = factory;
     Model       = new PersonListViewModel(factory);
     DataContext = Model;
 }
Example #5
0
        public void PersonListViewModelPersonsTest()
        {
            var persons = new List <Person>()
            {
                new Person()
                {
                    Firstname = "Harry"
                },
                new Person()
                {
                    Firstname = "Ron"
                }
            };
            var personListView      = new MockPersonListView();
            var personListViewModel = new PersonListViewModel(personListView)
            {
                Persons = persons
            };

            Assert.AreEqual(persons, personListViewModel.Persons);
            Assert.IsNull(personListViewModel.SelectedPerson);
            Assert.IsFalse(personListViewModel.SelectedPersons.Any());

            // Select the first person
            AssertHelper.PropertyChangedEvent(personListViewModel, x => x.SelectedPerson,
                                              () => personListViewModel.SelectedPerson = persons.First());
            Assert.AreEqual(persons.First(), personListViewModel.SelectedPerson);

            personListViewModel.AddSelectedPerson(persons.First());
            AssertHelper.SequenceEqual(new Person[] { persons.First() }, personListViewModel.SelectedPersons);

            // Select both persons
            personListViewModel.AddSelectedPerson(persons.Last());
            AssertHelper.SequenceEqual(persons, personListViewModel.SelectedPersons);
        }
Example #6
0
 private void InitializeModels()
 {
     FilmModel     = new FilmListViewModel(this);
     PersonModel   = new PersonListViewModel(this);
     CountryModel  = new CountryListViewModel(this);
     LocationModel = new LocationListViewModel(this);
 }
Example #7
0
        public ActionResult Index()
        {
            PersonListViewModel m = new PersonListViewModel();

            m.Persons = GetPersons().ToList <DtoPerson>();

            return(View(m));
        }
Example #8
0
        // GET: /<controller>/
        public IActionResult Index()
        {
            var viewModel = new PersonListViewModel();

            viewModel.Persons = _personRetRepository.GetAllActive();

            return(View(viewModel));
        }
Example #9
0
 public PersonView(PersonListViewModel model)
 {
     InitializeComponent();
     Model       = model;
     Person      = Model.CurrentPerson;
     DataContext = Person;
     firstNameTextBox.Focus();
 }
Example #10
0
        // GET: Person
        public ActionResult Index()
        {
            var personList = new PersonListViewModel
            {
                People = new List <PersonViewModel>
                {
                    new PersonViewModel {
                        PersonId = 1, LastName = "Halpert", FirstName = "Jim"
                    },
                    new PersonViewModel {
                        PersonId = 2, LastName = "Beesly", FirstName = "Pam"
                    },
                    new PersonViewModel {
                        PersonId = 3, LastName = "Scott", FirstName = "Michael"
                    },
                    new PersonViewModel {
                        PersonId = 4, LastName = "Schrute", FirstName = "Dwight"
                    },
                    new PersonViewModel {
                        PersonId = 5, LastName = "Martin", FirstName = "Angela"
                    },
                    new PersonViewModel {
                        PersonId = 6, LastName = "Bernard", FirstName = "Andy"
                    },
                    new PersonViewModel {
                        PersonId = 7, LastName = "Malone", FirstName = "Kevin"
                    },
                    new PersonViewModel {
                        PersonId = 8, LastName = "Kapoor", FirstName = "Kelly"
                    },
                    new PersonViewModel {
                        PersonId = 9, LastName = "Palmer", FirstName = "Meredith"
                    },
                    new PersonViewModel {
                        PersonId = 10, LastName = "Flenderson", FirstName = "Toby"
                    },
                    new PersonViewModel {
                        PersonId = 11, LastName = "Hudson", FirstName = "Stanley"
                    },
                    new PersonViewModel {
                        PersonId = 12, LastName = "Bratton", FirstName = "Creed"
                    },
                    new PersonViewModel {
                        PersonId = 13, LastName = "Vance", FirstName = "Phyllis"
                    },
                    new PersonViewModel {
                        PersonId = 14, LastName = "Howard", FirstName = "Ryan"
                    },
                    new PersonViewModel {
                        PersonId = 15, LastName = "Philbin", FirstName = "Darryl"
                    }
                }
            };

            personList.TotalPeople = personList.People.Count;

            return(View(personList));
        }
        public IActionResult list()
        {
            var personListViewModel = new PersonListViewModel
            {
                People = _personRepo.GetPeople()
            };

            return(View(personListViewModel));
        }
        public ViewResult ListAllPerson()
        {
            ViewBag.Title = "Страница с претендентами";
            PersonListViewModel obj = new PersonListViewModel();

            obj.GetAllPersons = _allPersons.Persons;
            obj.currCategory  = "Люди";
            return(View(obj));
        }
Example #13
0
        public PersonList(PersonListViewModel vm)
        {
            _PersonListViewModel = vm;
            DataContext          = vm;
            InitializeComponent();

            _movieCollection         = (CollectionViewSource)(Resources["PersonCollection"]);
            _movieCollection.Filter += _personCollection_Filter;
        }
Example #14
0
        public async Task <IActionResult> List()
        {
            var personListViewModel = new PersonListViewModel
            {
                List = await faceClient.GetAllAsync()
            };

            return(View(personListViewModel));
        }
Example #15
0
        public IActionResult PersonList()
        {
            var viewModel = new PersonListViewModel();

            var persons = _personData.ReadLastAddedPersonsWithAllData(10);

            viewModel.AddPersonsToViewModel(persons.ToList());

            return(View(viewModel));
        }
        public async Task <IActionResult> Index(PagedPeopleResultRequestDto reques)
        {
            var people = (await _peopleAppService.GetPeopleAsync(new PagedPeopleResultRequestDto())).Items;
            var model  = new PersonListViewModel()
            {
                People = people
            };

            return(View(model));
        }
        public void CreateNewEmailTest()
        {
            Person harry = new Person()
            {
                Firstname = "Harry", Email = "*****@*****.**"
            };
            Person ron = new Person()
            {
                Firstname = "Ron", Email = "Wrong Address"
            };

            IEntityService entityService = Container.GetExportedValue <IEntityService>();

            entityService.Persons.Add(harry);
            entityService.Persons.Add(ron);

            PersonController personController = Container.GetExportedValue <PersonController>();

            personController.Initialize();

            MockPersonListView  personListView      = Container.GetExportedValue <MockPersonListView>();
            PersonListViewModel personListViewModel = ViewHelper.GetViewModel <PersonListViewModel>(personListView);
            MockPersonView      personView          = Container.GetExportedValue <MockPersonView>();
            PersonViewModel     personViewModel     = ViewHelper.GetViewModel <PersonViewModel>(personView);

            ICommand command = personListViewModel.CreateNewEmailCommand;

            Assert.AreEqual(command, personViewModel.CreateNewEmailCommand);

            MockEmailService emailService = Container.GetExportedValue <MockEmailService>();

            command.Execute(harry);
            Assert.AreEqual(harry.Email, emailService.ToEmailAddress);

            // An error message should occur when the email address is invalid.

            MockMessageService messageService = Container.GetExportedValue <MockMessageService>();

            messageService.Clear();
            emailService.ToEmailAddress = null;
            command.Execute(ron);
            Assert.AreEqual(MessageType.Error, messageService.MessageType);
            Assert.AreEqual(Resources.CorrectEmailAddress, messageService.Message);
            Assert.IsNull(emailService.ToEmailAddress);

            // An error message should occur when no email address was entered.

            messageService.Clear();
            emailService.ToEmailAddress = null;
            ron.Email = null;
            command.Execute(ron);
            Assert.AreEqual(MessageType.Error, messageService.MessageType);
            Assert.AreEqual(Resources.CorrectEmailAddress, messageService.Message);
            Assert.IsNull(emailService.ToEmailAddress);
        }
Example #18
0
        public ActionResult Index(int?groupId = null)
        {
            var personListViewModel = new PersonListViewModel()
            {
                List = groupId.HasValue ?
                       personManager.GetAllByGroupId(groupId.Value).Select(person => new PersonViewModel(person)) :
                       personManager.GetAll().Select(person => new PersonViewModel(person))
            };

            return(View(personListViewModel));
        }
Example #19
0
        public void AddPersonViewModelTest()
        {
            // Arrange
            var systemUnderTest = new PersonListViewModel();

            //Act
            systemUnderTest.AddPersonViewModel(m_mockPersonVM.Object);

            //Assert
            Assert.IsTrue(systemUnderTest.People.Contains(m_mockPersonVM.Object));
        }
Example #20
0
        public IActionResult Person()
        {
            PersonListViewModel model = new PersonListViewModel();

            model._context = _context;

            model.PopulatePerson(1);

            ViewData.Model = model;
            return(View());
        }
Example #21
0
        internal PersonList()
        {
            InitializeComponent();
#if DEBUG
            if (System.ComponentModel.DesignerProperties.GetIsInDesignMode(this))
            {
                return;
            }
#endif
            StationManager.Instance.Initialize(new SerializedDataStorage());
            DataContext = new PersonListViewModel();
        }
        public ActionResult List(int courseId)
        {
            PersonListViewModel model = null;
            var people = _personRepo.GetPersonsByCourseId(courseId);

            model = new PersonListViewModel
            {
                CourseId = courseId,
                People   = people
            };
            return(View(model));
        }
Example #23
0
        public PersonListViewModelTests()
        {
            _personRepositoryMock = new Mock <IPersonRepository>();
            _mediatorMock         = new Mock <Mediator> {
                CallBase = true
            };

            _personRepositoryMock.Setup(repository => repository.GetAll())
            .Returns(() => new List <PersonListModel>());

            _personListViewModelSUT = new PersonListViewModel(_personRepositoryMock.Object, _mediatorMock.Object);
        }
 private void CheckCommand(ICommand command, PersonListViewModel personListViewModel, PersonViewModel personViewModel)
 {
     Assert.IsTrue(command.CanExecute(null));
     AssertHelper.CanExecuteChangedEvent(command, () => personListViewModel.IsValid = false);
     Assert.IsFalse(command.CanExecute(null));
     AssertHelper.CanExecuteChangedEvent(command, () => personListViewModel.IsValid = true);
     Assert.IsTrue(command.CanExecute(null));
     AssertHelper.CanExecuteChangedEvent(command, () => personViewModel.IsValid = false);
     Assert.IsFalse(command.CanExecute(null));
     AssertHelper.CanExecuteChangedEvent(command, () => personViewModel.IsValid = true);
     Assert.IsTrue(command.CanExecute(null));
 }
Example #25
0
 public PersonController(IMessageService messageService, IShellService shellService, IEntityService entityService, IEmailService emailService,
                         PersonListViewModel personListViewModel, PersonViewModel personViewModel)
 {
     this.messageService      = messageService;
     this.shellService        = shellService;
     this.entityService       = entityService;
     this.emailService        = emailService;
     this.personListViewModel = personListViewModel;
     this.personViewModel     = personViewModel;
     addNewCommand            = new DelegateCommand(AddNewPerson, CanAddPerson);
     removeCommand            = new DelegateCommand(RemovePerson, CanRemovePerson);
     createNewEmailCommand    = new DelegateCommand(CreateNewEmail !);
 }
        public async Task <ActionResult> Index(int skipCount = 0, int maxResultCount = 10)
        {
            var dtos = await _personAppService.GetPagedPersonAsync(new PhoneBooks.dtos.GetPersonInput
            {
                SkipCount      = skipCount,
                MaxResultCount = maxResultCount
            });

            var model = new PersonListViewModel {
                Items = dtos.Items
            };

            return(View(model));
        }
Example #27
0
 public PersonController(IMessageService messageService, IShellService shellService,
     IEntityService entityService, IEmailService emailService, 
     PersonListViewModel personListViewModel, PersonViewModel personViewModel)
 {
     this.messageService = messageService;
     this.shellService = shellService;
     this.entityService = entityService;
     this.emailService = emailService;
     this.personListViewModel = personListViewModel;
     this.personViewModel = personViewModel;
     this.addNewCommand = new DelegateCommand(AddNewPerson, CanAddPerson);
     this.removeCommand = new DelegateCommand(RemovePerson, CanRemovePerson);
     this.createNewEmailCommand = new DelegateCommand(CreateNewEmail);
 }
Example #28
0
        public IActionResult Index()
        {
            var people = (from d in DataContext.People orderby d.Name where !d.IsDeleted select d);
            var doors  = (from d in DataContext.Doors where !d.IsDeleted select d);
            //if there is a recorded scan which has not been linked to a person
            var isAssignAvailable = (from dr in DataContext.DoorReads where dr.PersonId == null select dr.Id).Any();
            var model             = new PersonListViewModel
            {
                Items             = people.ToList(),
                IsCreateAvailable = doors.Any(),
                IsAssignAvailable = isAssignAvailable
            };

            return(View(model));
        }
        // GET:Person List
        public async Task <IActionResult> List()
        {
            var result = await _schoolDataDbContext.Persons.ToListAsync();

            var personList = new PersonListViewModel()
            {
                People = result
            };

            if (personList == null)
            {
                ModelState.AddModelError("ListHata", "Model hatası");
                return(RedirectToAction("Index"));
            }
            return(View(personList));
        }
Example #30
0
        public void Initialize()
        {
            personViewModel.CreateNewEmailCommand = createNewEmailCommand;
            AddWeakEventListener(personViewModel, PersonViewModelPropertyChanged);
            
            IPersonListView personListView = container.GetExportedValue<IPersonListView>();
            personListViewModel = new PersonListViewModel(personListView, entityService.Persons);
            personListViewModel.AddNewCommand = addNewCommand;
            personListViewModel.RemoveCommand = removeCommand;
            personListViewModel.CreateNewEmailCommand = createNewEmailCommand;
            AddWeakEventListener(personListViewModel, PersonListViewModelPropertyChanged);

            shellService.PersonListView = personListViewModel.View;
            shellService.PersonView = personViewModel.View;

            personListViewModel.SelectedPerson = personListViewModel.Persons.FirstOrDefault();
        }
        public IActionResult getByPersonID2(int id)
        {
            var per = personService.getPersonById(id).Result;
            PersonListViewModel pn = new PersonListViewModel();

            pn.PersonID   = per.PersonID;
            pn.SVC_NO     = per.SVC_NO;
            pn.LastName   = per.LastName;
            pn.FirstName  = per.FirstName;
            pn.MiddleName = per.MiddleName;
            pn.rank       = per.rank;
            pn.accountno  = per.accountno;
            pn.Sex        = per.Sex;


            return(Ok(new { responseCode = 200, pn }));
        }
        public ActionResult Index()
        {
            var personList = new PersonListViewModel
            {
                //Convert each Person to a PersonViewModel
                People = People.Select(p => new PersonViewModel
                {
                    PersonId  = p.PersonId,
                    LastName  = p.LastName,
                    FirstName = p.FirstName
                }).ToList()
            };

            personList.TotalPeople = personList.People.Count;

            return(View(personList));
        }
        public void PersonListViewModelCommandsTest()
        {
            MockPersonListView personListView = new MockPersonListView();
            PersonListViewModel personListViewModel = new PersonListViewModel(personListView) { Persons = new List<Person>() };

            DelegateCommand mockCommand = new DelegateCommand(() => {});
            AssertHelper.PropertyChangedEvent(personListViewModel, x => x.AddNewCommand, () =>
                personListViewModel.AddNewCommand = mockCommand);
            Assert.AreEqual(mockCommand, personListViewModel.AddNewCommand);

            mockCommand = new DelegateCommand(() => { });
            AssertHelper.PropertyChangedEvent(personListViewModel, x => x.RemoveCommand, () =>
                personListViewModel.RemoveCommand = mockCommand);
            Assert.AreEqual(mockCommand, personListViewModel.RemoveCommand);

            mockCommand = new DelegateCommand(() => { });
            AssertHelper.PropertyChangedEvent(personListViewModel, x => x.CreateNewEmailCommand, () =>
                personListViewModel.CreateNewEmailCommand = mockCommand);
            Assert.AreEqual(mockCommand, personListViewModel.CreateNewEmailCommand);
        }
        public void PersonListViewModelFilterTest()
        {
            List<Person> persons = new List<Person>()
            {
                new Person() { Firstname = "Harry", Lastname = "Potter" },
                new Person() { Firstname = "Ron", Lastname = "Weasley" }
            };

            MockPersonListView personListView = new MockPersonListView();
            PersonListViewModel personListViewModel = new PersonListViewModel(personListView) { Persons = persons };

            Assert.IsTrue(personListViewModel.Filter(persons[0]));
            Assert.IsTrue(personListViewModel.Filter(persons[1]));

            AssertHelper.PropertyChangedEvent(personListViewModel, x => x.FilterText, () => personListViewModel.FilterText = "r");
            Assert.AreEqual("r", personListViewModel.FilterText);
            Assert.IsTrue(personListViewModel.Filter(persons[0]));
            Assert.IsTrue(personListViewModel.Filter(persons[1]));

            personListViewModel.FilterText = "arr";
            Assert.IsTrue(personListViewModel.Filter(persons[0]));
            Assert.IsFalse(personListViewModel.Filter(persons[1]));

            personListViewModel.FilterText = "eas";
            Assert.IsFalse(personListViewModel.Filter(persons[0]));
            Assert.IsTrue(personListViewModel.Filter(persons[1]));

            personListViewModel.FilterText = "xyz";
            Assert.IsFalse(personListViewModel.Filter(persons[0]));
            Assert.IsFalse(personListViewModel.Filter(persons[1]));

            persons.Add(new Person());
            Assert.IsTrue(personListViewModel.Filter(persons[2]));
            persons[2].Firstname = "Hermione";
            Assert.IsTrue(personListViewModel.Filter(persons[2]));
        }
Example #35
0
 private void CheckCommand(ICommand command, PersonListViewModel personListViewModel, PersonViewModel personViewModel)
 {
     Assert.IsTrue(command.CanExecute(null));
     AssertHelper.CanExecuteChangedEvent(command, () => personListViewModel.IsValid = false);
     Assert.IsFalse(command.CanExecute(null));
     AssertHelper.CanExecuteChangedEvent(command, () => personListViewModel.IsValid = true);
     Assert.IsTrue(command.CanExecute(null));
     AssertHelper.CanExecuteChangedEvent(command, () => personViewModel.IsValid = false);
     Assert.IsFalse(command.CanExecute(null));
     AssertHelper.CanExecuteChangedEvent(command, () => personViewModel.IsValid = true);
     Assert.IsTrue(command.CanExecute(null));
 }
        public void PersonListViewModelPersonsTest()
        {
            List<Person> persons = new List<Person>()
            {
                new Person() { Firstname = "Harry" },
                new Person() { Firstname = "Ron" }
            };

            MockPersonListView personListView = new MockPersonListView();

            PersonListViewModel personListViewModel = new PersonListViewModel(personListView) { Persons = persons };

            Assert.AreEqual(persons, personListViewModel.Persons);
            Assert.IsNull(personListViewModel.SelectedPerson);
            Assert.IsFalse(personListViewModel.SelectedPersons.Any());

            // Select the first person
            AssertHelper.PropertyChangedEvent(personListViewModel, x => x.SelectedPerson,
                () => personListViewModel.SelectedPerson = persons.First());
            Assert.AreEqual(persons.First(), personListViewModel.SelectedPerson);

            personListViewModel.AddSelectedPerson(persons.First());
            Assert.IsTrue(personListViewModel.SelectedPersons.SequenceEqual(new Person[] { persons.First() }));

            // Select both persons
            personListViewModel.AddSelectedPerson(persons.Last());
            Assert.IsTrue(personListViewModel.SelectedPersons.SequenceEqual(persons));
        }