public void CanAddNewAthlete()
        {
            var athleteDto = new AthleteDto();
            athleteDto.Nickname = "sheredia";
            athleteDto.FirstName = "Sarah";
            athleteDto.LastName = "Heredia";
            athleteDto.Gender = 'F';
            athleteDto.TrainerSizeW = 9;
            athleteDto.SpikeSizeW = 9.5;
            athleteDto.Notes = "Some notes on Sarah";
            athleteDto.Status = "Current";

            var poleVault = new EventAreaDto() { EventName = Constants.EventAreas.POLE_VAULT, IsParticipant = true };
            var sprints = new EventAreaDto() { EventName = Constants.EventAreas.SPRINTS, IsParticipant = true };

            athleteDto.EventParticipation.Add(poleVault);
            athleteDto.EventParticipation.Add(sprints);

            AthleteService.SaveAthlete(athleteDto);

            var fromDb = ObjectFactory.GetInstance<IAthleteRepository>().GetByNickname(athleteDto.Nickname);

            Assert.IsNotNull(fromDb);
            Assert.AreEqual(athleteDto.Nickname, fromDb.Nickname);
            Assert.AreEqual(athleteDto.FirstName, fromDb.FirstName);
            Assert.AreEqual(athleteDto.LastName, fromDb.LastName);
            Assert.AreEqual(athleteDto.Gender, fromDb.Gender);
            Assert.AreEqual(athleteDto.SpikeSizeW, fromDb.SpikeSizeW);
            Assert.AreEqual(athleteDto.Notes, fromDb.Notes);
            Assert.AreEqual(athleteDto.Status, fromDb.Status);
            Assert.AreEqual(athleteDto.EventParticipation.Count, fromDb.EventAreas.Count);
        }
        public void CanGetAllEventParticipants()
        {
            var poleVaulter = new AthleteDto() { Nickname = "poleVaulter", FirstName = "Pole", LastName = "Vaulter1", Gender = 'M', Status = "Current" };
            var poleVaultingSprinter = new AthleteDto() { Nickname = "poleVaulingSprinter", FirstName = "PoleVaulting", LastName = "Sprinter", Gender = 'F', Status = "Future" };
            var sprinter = new AthleteDto() { Nickname = "sprinter", FirstName = "Sprint", LastName = "er", Gender = 'M', Status = "Past" };
            var poleVault = new EventAreaDto() { EventName = "PoleVault" };
            var sprints = new EventAreaDto() { EventName = "Sprints" };
            var modelDto = new ModelDto() { ModelNumber = "1234", ModelName = "name", Type = "runner", Color = "white", Price = 105, IsDiscontinued = false };
            var shoe1 = new InventoryItemDto() { ModelDto = modelDto, SizeM = 9, SizeW = 11, Width = 'N', RequestName = "request1", Status = "Requested", StatusLastChanged = DateTime.Now };
            var shoe2 = new InventoryItemDto() { ModelDto = modelDto, SizeM = 9, SizeW = 11, Width = 'N', RequestName = "request1", Status = "Requested", StatusLastChanged = DateTime.Now };
            var shoe3 = new InventoryItemDto() { ModelDto = modelDto, SizeM = 9, SizeW = 11, Width = 'N', RequestName = "request1", Status = "Requested", StatusLastChanged = DateTime.Now };

            poleVaulter.EventParticipation.Add(poleVault);
            poleVaultingSprinter.EventParticipation.Add(poleVault);
            poleVaultingSprinter.EventParticipation.Add(sprints);
            sprinter.EventParticipation.Add(sprints);
            poleVaulter.Inventory.Add(shoe1);
            poleVaulter.Inventory.Add(shoe2);
            poleVaultingSprinter.Inventory.Add(shoe3);

            CoreAthleteService.SaveAthlete(poleVaulter);
            CoreAthleteService.SaveAthlete(poleVaultingSprinter);
            CoreAthleteService.SaveAthlete(sprinter);

            var poleVaultersList = CoreAthleteService.GetAllAthletesForEventArea("PoleVault");

            Assert.IsNotNull(poleVaultersList);
            Assert.AreEqual(2, poleVaultersList.Count);
            Assert.IsNotNull(poleVaultersList.ToList().First(x => x.Nickname == poleVaulter.Nickname));
            Assert.IsNotNull(poleVaultersList.ToList().First(x => x.Nickname == poleVaultingSprinter.Nickname));
            Assert.IsNull(poleVaultersList.ToList().FirstOrDefault(x => x.Nickname == sprinter.Nickname));
        }
        public void AssemblerCorrectlyReadsInventoryItemDto()
        {
            var eventAreaDto = new EventAreaDto() { EventName = Constants.EventAreas.POLE_VAULT };
            var poleVaulter = new AthleteDto() { Nickname = "poleVaulter", FirstName = "Pole", LastName = "Vaulter1", Gender = 'M', Status = "Current" };
            var modelDto = new ModelDto();
            var model = new Model();
            var inventoryItemDto = new InventoryItemDto()
                {
                    SerialNumber = 1,
                    ModelDto = modelDto,
                    SizeM = 9,
                    SizeW = 11,
                    Width = "N",
                    RequestName = "request1",
                    EventAreaAssignmentDto = eventAreaDto,
                    Status = "Requested",
                };
            var historyDto = new InventoryMovementDto() { EventType = new InventoryEventTypeDto() { EventType = Constants.InventoryEventTypes.ORDER } };

            inventoryItemDto.MovementHistory.Add(historyDto);

            _mockModelAssembler.Setup(x => x.ReadDto(modelDto)).Returns(model);
            _mockAthleteRepository.Setup(x => x.GetByNickname(It.IsAny<String>())).Returns(new Athlete());
            _mockInventoryRepository.Setup(x => x.GetBySerialNumber(inventoryItemDto.SerialNumber));
            _mockInventoryMovementAssembler.Setup(x => x.ReadDto(historyDto)).Returns(new InventoryMovement());
            _mockEventAreaAssembler.Setup(x => x.ReadDto(eventAreaDto)).Returns(new EventArea() { EventName = eventAreaDto.EventName });

            var inventoryItem = _assembler.ReadDto(inventoryItemDto);

            _mockInventoryRepository.VerifyAll();
            _mockModelAssembler.VerifyAll();
            _mockAthleteRepository.VerifyAll();
            _mockInventoryMovementAssembler.VerifyAll();
            _mockEventAreaAssembler.VerifyAll();
        }
        public void AssemblerCorrectlyReadsUserDto()
        {
            var userDto = new UserDto();
            userDto.Id = 1;
            userDto.Username = "******";
            userDto.FirstName = "user";
            userDto.LastName = "name";
            userDto.IsAdmin = true;
            userDto.Status = Constants.Users.ACTIVE;
            var eventAreaDto = new EventAreaDto() { EventName = Constants.EventAreas.CROSS_COUNTRY };

            userDto.EventAreaResponsibilities.Add(eventAreaDto);
            var eventArea = new EventArea() { EventName = Constants.EventAreas.CROSS_COUNTRY };

            _mockUserRepository.Setup(x => x.GetById(userDto.Id)).Returns(It.IsAny<User>());
            _mockEventAreaRepository.Setup(x => x.FindByEventName(It.IsAny<String>())).Returns(new EventArea());

            var user = _assembler.ReadDto(userDto);

            Assert.IsNotNull(user);
            Assert.AreEqual(userDto.Id, user.Id);
            Assert.AreEqual(userDto.Username, user.Username);
            Assert.AreEqual(userDto.FirstName, user.FirstName);
            Assert.AreEqual(userDto.LastName, user.LastName);
            Assert.AreEqual(userDto.IsAdmin, user.IsAdmin);
            Assert.AreEqual(userDto.Status, user.Status);
            Assert.AreEqual(1, user.EventAreaResponsibilities.Count);

            _mockUserRepository.VerifyAll();
            _mockEventAreaRepository.VerifyAll();
        }
        public EventAreaDto WriteDto(EventArea eventArea)
        {
            if (eventArea == null)
                throw new ArgumentNullException();

            var eventAreaDto = new EventAreaDto();

            eventAreaDto.EventName = eventArea.EventName;
            eventAreaDto.IsParticipant = true;

            return eventAreaDto;
        }
        public EventArea ReadDto(EventAreaDto eventAreaDto)
        {
            if (eventAreaDto == null)
                throw new ArgumentNullException();

            var eventArea = ObjectFactory.GetInstance<IEventAreaRepository>().FindByEventName(eventAreaDto.EventName);

            return eventArea == null ? new EventArea()
                                            {
                                                EventName = eventAreaDto.EventName,
                                                Athletes = new HashedSet<Athlete>()
                                            }
                                            : eventArea;
        }
        public void AssemblerCorrectlyReadsEventAreaParticipationDto()
        {
            var eventAreaDto = new EventAreaDto();
            eventAreaDto.EventName = Constants.EventAreas.CROSS_COUNTRY;

            var mockEventAreaRepository = new Mock<IEventAreaRepository>();
            mockEventAreaRepository.Setup(x => x.FindByEventName(eventAreaDto.EventName)).Returns(new EventArea() { /*Id = eventAreaDto.Id,*/ EventName = eventAreaDto.EventName });
            ObjectFactory.Inject(typeof(IEventAreaRepository), mockEventAreaRepository.Object);

            var eventArea = _assembler.ReadDto(eventAreaDto);

            Assert.IsNotNull(eventArea);
            Assert.AreEqual(eventAreaDto.EventName, eventArea.EventName);
            mockEventAreaRepository.VerifyAll();
        }
        public void AssemblerCorrectlyReadsAthleteDto()
        {
            var athleteDto = new AthleteDto();
            athleteDto.Id = 123456;
            athleteDto.Nickname = "TestNickname";
            athleteDto.FirstName = "TestFirstName";
            athleteDto.LastName = "TestLastName";
            athleteDto.Gender = 'M';
            athleteDto.TrainerSizeM = 9.5;
            athleteDto.SpikeSizeM = 8.5;
            athleteDto.Notes = "Some test notes";
            athleteDto.Status = "Current";

            var eventAreaDto = new EventAreaDto();
            eventAreaDto.EventName = Constants.EventAreas.POLE_VAULT;
            eventAreaDto.IsParticipant = true;

            var modelDto = new ModelDto();
            modelDto.ModelNumber = "1234";
            modelDto.ModelName = "model name";
            modelDto.Type = "model type";
            modelDto.Price = 105.00;
            modelDto.Color = "white";
            modelDto.IsDiscontinued = false;

            var inventoryItemDto = new InventoryItemDto();
            inventoryItemDto.SerialNumber = 1;
            inventoryItemDto.ModelDto = modelDto;
            inventoryItemDto.SizeM = 9;
            inventoryItemDto.SizeW = 11;
            inventoryItemDto.Width = "N";
            inventoryItemDto.RequestName = "request1";
            inventoryItemDto.Status = "Requested";
            inventoryItemDto.StatusLastChanged = new DateTime(2012, 10, 31, 12, 0, 0);

            athleteDto.EventParticipation.Add(eventAreaDto);
            athleteDto.Inventory.Add(inventoryItemDto);

            _mockAthleteRepository.Setup(x => x.GetByNickname(athleteDto.Nickname));
            _mockEventAreaAssembler.Setup(x => x.ReadDto(eventAreaDto)).Returns(new EventArea());
            _mockInventoryItemAssembler.Setup(x => x.ReadDto(inventoryItemDto)).Returns(new InventoryItem());

            var athleteFromDb = _assembler.ReadDto(athleteDto);

            _mockAthleteRepository.VerifyAll();
            _mockEventAreaAssembler.VerifyAll();
            _mockInventoryItemAssembler.VerifyAll();
        }
        public void LoadData_ReturnsPopulatedOfEventAreaParticipants()
        {
            var userDto = new UserDto();
            var eventAreaDto = new EventAreaDto() { EventName = Constants.EventAreas.POLE_VAULT };
            var athlete = new Athlete();
            var eventArea = new EventArea();
            userDto.EventAreaResponsibilities.Add(eventAreaDto);
            eventArea.Athletes.Add(athlete);

            _mockEventAreaAssembler.Setup(x => x.ReadDto(eventAreaDto)).Returns(eventArea);
            _mockAthleteAssembler.Setup(x => x.WriteDto(athlete)).Returns(new AthleteDto());

            var athletesList = InitialDataProvider.LoadData(userDto);

            _mockEventAreaAssembler.VerifyAll();
            _mockAthleteAssembler.VerifyAll();

            Assert.IsNotNull(athletesList);
            Assert.AreEqual(1, athletesList.Count());
        }
        public void CanAddNewAthlete()
        {
            var athleteDto = new AthleteDto();
            athleteDto.Nickname = "sheredia";
            athleteDto.FirstName = "Sarah";
            athleteDto.LastName = "Heredia";
            athleteDto.Gender = 'F';
            athleteDto.TrainerSizeW = 9;
            athleteDto.SpikeSizeW = 9.5;
            athleteDto.Notes = "Some notes on Sarah";
            athleteDto.Status = "Current";

            var poleVault = new EventAreaDto() { EventName = "PoleVault" };
            var sprints = new EventAreaDto() { EventName = "Sprints" };
            var modelDto = new ModelDto() { ModelNumber = "1234", ModelName = "name", Type = "runner", Color = "white", Price = 105, IsDiscontinued = false };

            var shoe1 = new InventoryItemDto() { ModelDto = modelDto, SizeM = 9, SizeW = 11, Width = 'N', RequestName = "request1", Status = "Requested", Athlete = athleteDto, StatusLastChanged = DateTime.Now };
            var shoe2 = new InventoryItemDto() { ModelDto = modelDto, SizeM = 9, SizeW = 11, Width = 'N', RequestName = "request1", Status = "Requested", Athlete = athleteDto , StatusLastChanged = DateTime.Now };

            athleteDto.EventParticipation.Add(poleVault);
            athleteDto.EventParticipation.Add(sprints);
            athleteDto.Inventory.Add(shoe1);
            athleteDto.Inventory.Add(shoe2);

            CoreAthleteService.SaveAthlete(athleteDto);

            var fromDb = ObjectFactory.GetInstance<IAthleteRepository>().GetByNickname(athleteDto.Nickname);

            Assert.IsNotNull(fromDb);
            Assert.AreEqual(athleteDto.Nickname, fromDb.Nickname);
            Assert.AreEqual(athleteDto.FirstName, fromDb.FirstName);
            Assert.AreEqual(athleteDto.LastName, fromDb.LastName);
            Assert.AreEqual(athleteDto.Gender, fromDb.Gender);
            Assert.AreEqual(athleteDto.SpikeSizeW, fromDb.SpikeSizeW);
            Assert.AreEqual(athleteDto.Notes, fromDb.Notes);
            Assert.AreEqual(athleteDto.Status, fromDb.Status);
            Assert.AreEqual(athleteDto.EventParticipation.Count, fromDb.EventAreas.Count);
            Assert.AreEqual(athleteDto.Inventory.Count, fromDb.Inventory.Count);
        }
        public void SaveAthlete()
        {
            #region Setup objects
            var athleteDto = new AthleteDto();
            athleteDto.Nickname = "sheredia";
            athleteDto.FirstName = "Sarah";
            athleteDto.LastName = "Heredia";
            athleteDto.Gender = 'F';
            athleteDto.TrainerSizeW = 9;
            athleteDto.SpikeSizeW = 9.5;
            athleteDto.Notes = "Some notes on Sarah";
            athleteDto.Status = "Current";

            var eventAreaDto = new EventAreaDto();
            eventAreaDto.EventName = "Pole Vault";

            var modelDto = new ModelDto();
            modelDto.ModelNumber = "1234";
            modelDto.ModelName = "Model name";
            modelDto.Type = "Runner";
            modelDto.Color = "White";
            modelDto.Price = 105.00;
            modelDto.IsDiscontinued = false;

            var inventoryItemDto = new InventoryItemDto();
            inventoryItemDto.ModelDto = modelDto;
            inventoryItemDto.SizeM = 9;
            inventoryItemDto.SizeW = 11;
            inventoryItemDto.Width = "N";
            inventoryItemDto.RequestName = "request1";
            inventoryItemDto.Status = "Requested";
            //inventoryItemDto.AthleteDto = athleteDto;
            inventoryItemDto.StatusLastChanged = DateTime.Now;

            athleteDto.EventParticipation.Add(eventAreaDto);
            athleteDto.Inventory.Add(inventoryItemDto);

            var athlete = new Athlete();
            athlete.Nickname = "sheredia";
            athlete.FirstName = "Sarah";
            athlete.LastName = "Heredia";
            athlete.Gender = 'F';
            athlete.TrainerSizeW = 9;
            athlete.SpikeSizeW = 9.5;
            athlete.Notes = "Some notes on Sarah";
            athlete.Status = "Current";

            var eventArea = new EventArea();
            eventArea.EventName = "Pole Vault";

            var model = new Model();
            model.ModelNumber = "1234";
            model.ModelName = "Model name";
            model.Type = "Runner";
            model.Color = "White";
            model.Price = 105.00;
            model.IsDiscontinued = false;

            var inventoryItem = new InventoryItem();
            inventoryItem.Model = model;
            inventoryItem.SizeM = 9;
            inventoryItem.SizeW = 11;
            inventoryItem.Width = "N";
            inventoryItem.RequestName = "request1";
            inventoryItem.Status = "Requested";
            inventoryItem.Athlete = athlete;
            inventoryItem.StatusLastChanged = DateTime.Now;

            athlete.EventAreas.Add(eventArea);
            athlete.Inventory.Add(inventoryItem);
            #endregion

            _mockAthleteAssembler.Setup(x => x.ReadDto(athleteDto)).Returns(athlete);
            _mockAthleteRepository.Setup(x => x.Save(athlete));
            _mockAthleteAssembler.Setup(x => x.WriteDto(athlete)).Returns(new AthleteDto());

            AthleteService.SaveAthlete(athleteDto);

            _mockAthleteAssembler.VerifyAll();
            _mockAthleteRepository.VerifyAll();
        }
        public void ReadDto_InitializesNewListWhenAthleteDoesNotHaveInventory()
        {
            var athleteDto = new AthleteDto();
            athleteDto.Id = 123456;
            athleteDto.Nickname = "TestNickname";
            athleteDto.FirstName = "TestFirstName";
            athleteDto.LastName = "TestLastName";
            athleteDto.Gender = 'M';
            athleteDto.TrainerSizeM = 9.5;
            athleteDto.SpikeSizeM = 8.5;
            athleteDto.Notes = "Some test notes";
            athleteDto.Status = "Current";

            var eventAreaDto = new EventAreaDto();
            eventAreaDto.EventName = Constants.EventAreas.POLE_VAULT;
            eventAreaDto.IsParticipant = true;

            athleteDto.EventParticipation.Add(eventAreaDto);

            _mockAthleteRepository.Setup(x => x.GetByNickname(athleteDto.Nickname));
            _mockEventAreaAssembler.Setup(x => x.ReadDto(eventAreaDto)).Returns(new EventArea());

            var athleteFromDb = _assembler.ReadDto(athleteDto);

            Assert.AreEqual(0, athleteFromDb.Inventory.Count);
            _mockAthleteRepository.VerifyAll();
            _mockEventAreaAssembler.VerifyAll();
        }
 public EventAreaModel(EventAreaDto eventAreaDto)
 {
     IsChecked = true;
     EventName = eventAreaDto.EventNamek__BackingField;
 }