Exemple #1
0
        /// <summary>
        /// Registers the single pilot for a contest.
        /// </summary>
        /// <param name="pilotToRegister">The pilot reg.</param>
        /// <returns></returns>
        public async Task <Result <PilotRegistration> > CreateAsync(PilotRegistration pilotToRegister)
        {
            if (pilotToRegister == null)
            {
                return(Error <PilotRegistration>(null, $"{nameof(pilotToRegister)} cannot be null"));
            }

            if (!string.IsNullOrEmpty(pilotToRegister.Id))
            {
                return(Error <PilotRegistration>(null, "The Id already has a value"));
            }

            var allPilotRegistrations = (await GetAll <PilotRegistration>())?.ToList() ?? new List <PilotRegistration>();

            if (allPilotRegistrations == null)
            {
                allPilotRegistrations = new List <PilotRegistration>();
            }

            // Assign a new GUID for the ID
            pilotToRegister.Id = Guid.NewGuid().ToString();

            allPilotRegistrations.Add(pilotToRegister);

            try
            {
                var success = await WriteAll(allPilotRegistrations);
            }
            catch (Exception ex)
            {
                return(Error <PilotRegistration>(null, ex));
            }

            return(Success((allPilotRegistrations.Where(p => p.Id == pilotToRegister.Id)).First(), nameof(CreateAsync)));
        }
Exemple #2
0
        /// <summary>
        /// Uns the register pilot for contest.
        /// </summary>
        /// <param name="pilotToUnregister">The pilot to unregister.</param>
        /// <returns></returns>
        public async Task <Result <bool> > UnRegisterPilotForContestAsync(PilotRegistration pilotToUnregister)
        {
            var validationResult = ValidatePilotRegistration(pilotToUnregister, true);

            if (!validationResult.IsValid)
            {
                return(Error <bool>(false, $"The {nameof(pilotToUnregister)} parameter is not valid."));
            }

            try
            {
                var result = await this.pilotRegistrationRepository.DeleteAsync(pilotToUnregister.Id);

                if (result.IsFaulted || !result.Value)
                {
                    return(Error <bool>(false, $"An error occured while unregistering a pilot."));
                }

                return(Success(result.Value, nameof(RegisterPilotsForContestAsync)));
            }
            catch (Exception ex)
            {
                return(Error <bool>(false, ex));
            }
        }
        public async Task PilotRegistrationStorageCmdInteractor_RegisterSinglePilotForContestAsync_BadRegistrationParameter()
        {
            PilotRegistration pilotRegistration = GenerateValidPilotRegistration(1).First();

            pilotRegistration.ContestId = string.Empty;
            mockPilotRegistrationRepository.Setup(prr => prr.CreateAsync(It.IsAny <PilotRegistration>())).Returns(Task.FromResult(new Result <PilotRegistration>(pilotRegistration)));
            var prci   = new PilotRegistrationStorageCmdInteractor(mockPilotRegistrationRepository.Object, mockLogger.Object);
            var result = await prci.RegisterSinglePilotForContestAsync(pilotRegistration);

            // Invalid Contest Id should fail
            Assert.IsTrue(result.IsFaulted);

            pilotRegistration.ContestId = null;
            mockPilotRegistrationRepository.Setup(prr => prr.CreateAsync(It.IsAny <PilotRegistration>())).Returns(Task.FromResult(new Result <PilotRegistration>(pilotRegistration)));
            prci   = new PilotRegistrationStorageCmdInteractor(mockPilotRegistrationRepository.Object, mockLogger.Object);
            result = await prci.RegisterSinglePilotForContestAsync(pilotRegistration);

            // Null Contest Id should fail
            Assert.IsTrue(result.IsFaulted);

            pilotRegistration.ContestId          = "1";
            pilotRegistration.AirframesSignedOff = false;
            mockPilotRegistrationRepository.Setup(prr => prr.CreateAsync(It.IsAny <PilotRegistration>())).Returns(Task.FromResult(new Result <PilotRegistration>(pilotRegistration)));
            result = await prci.RegisterSinglePilotForContestAsync(pilotRegistration);

            // It should be ok to register a pilot w/ a failed airframe sign-off
            Assert.IsFalse(result.IsFaulted);

            pilotRegistration.AirframesSignedOff          = true;
            pilotRegistration.AirframeRegistrationNumbers = null;
            mockPilotRegistrationRepository.Setup(prr => prr.CreateAsync(It.IsAny <PilotRegistration>())).Returns(Task.FromResult(new Result <PilotRegistration>(pilotRegistration)));
            result = await prci.RegisterSinglePilotForContestAsync(pilotRegistration);

            // It should be ok to not have any airframes registered
            Assert.IsFalse(result.IsFaulted);

            pilotRegistration.AirframeRegistrationNumbers = new List <string> {
                "1", "2"
            };
            pilotRegistration.IsPaid = false;
            mockPilotRegistrationRepository.Setup(prr => prr.CreateAsync(It.IsAny <PilotRegistration>())).Returns(Task.FromResult(new Result <PilotRegistration>(pilotRegistration)));
            result = await prci.RegisterSinglePilotForContestAsync(pilotRegistration);

            // It should be ok to have a pilot register that is not paid
            Assert.IsFalse(result.IsFaulted);

            pilotRegistration.PilotId = string.Empty;
            mockPilotRegistrationRepository.Setup(prr => prr.CreateAsync(It.IsAny <PilotRegistration>())).Returns(Task.FromResult(new Result <PilotRegistration>(pilotRegistration)));
            result = await prci.RegisterSinglePilotForContestAsync(pilotRegistration);

            // Empty Pilot ID should fail.
            Assert.IsTrue(result.IsFaulted);

            pilotRegistration.PilotId = null;
            mockPilotRegistrationRepository.Setup(prr => prr.CreateAsync(It.IsAny <PilotRegistration>())).Returns(Task.FromResult(new Result <PilotRegistration>(pilotRegistration)));
            result = await prci.RegisterSinglePilotForContestAsync(pilotRegistration);

            // Null Pilot ID should fail.
            Assert.IsTrue(result.IsFaulted);
        }
        public async Task PilotRegistrationStorageCmdInteractor_RegisterSinglePilotForContestAsync_RepositoryException()
        {
            PilotRegistration pilotRegistration = GenerateValidPilotRegistration(1).First();

            mockPilotRegistrationRepository.Setup(prr => prr.CreateAsync(It.IsAny <PilotRegistration>())).ThrowsAsync(new Exception());
            var prci   = new PilotRegistrationStorageCmdInteractor(mockPilotRegistrationRepository.Object, mockLogger.Object);
            var result = await prci.RegisterSinglePilotForContestAsync(pilotRegistration);

            Assert.IsTrue(result.IsFaulted);
        }
        /// <summary>
        /// Validates the pilot registration.
        /// </summary>
        /// <param name="pilotRegistration">The pilot registration.</param>
        /// <returns></returns>
        public static ValidationResult ValidatePilotRegistration(PilotRegistration pilotRegistration)
        {
            if (pilotRegistration == null)
            {
                return(new ValidationResult(false, "The pilot registration submitted cannot be null"));
            }

            if (string.IsNullOrEmpty(pilotRegistration.PilotId))
            {
                return(new ValidationResult(false, "The pilot registration's pilot id submitted cannot be null or empty"));
            }

            if (string.IsNullOrEmpty(pilotRegistration.ContestId))
            {
                return(new ValidationResult(false, "The pilot registration's contest id submitted cannot be null or empty"));
            }

            return(new ValidationResult(true));
        }
Exemple #6
0
        /// <summary>
        /// Validates the pilot registration.
        /// </summary>
        /// <param name="pilotRegistration">The pilot registration.</param>
        /// <returns></returns>
        private static ValidationResult ValidatePilotRegistration(PilotRegistration pilotRegistration, bool isUnregister = false)
        {
            if (pilotRegistration == null)
            {
                return(new ValidationResult(false, "Pilot registration cannot be null."));
            }

            if (string.IsNullOrEmpty(pilotRegistration.PilotId))
            {
                return(new ValidationResult(false, "Pilot Id cannot be null or empty."));
            }

            if (string.IsNullOrEmpty(pilotRegistration.ContestId))
            {
                return(new ValidationResult(false, "Contest Id cannot be null or empty."));
            }

            return(new ValidationResult(true));
        }
Exemple #7
0
        /// <summary>
        /// Saves the and continue.
        /// </summary>
        /// <returns></returns>
        public async Task SaveAndContinue()
        {
            // This might be a new pilot registration, handle it.
            if (isNewPilot)
            {
                var pilotToAdd = new Pilot(this.FirstName, this.LastName, string.Empty, this.AmaNumber, this.Airframe);

                try
                {
                    // Create the pilot
                    var createPilotResult = await this.pilotCmdInteractor.Value.CreateNewPilotAsync(pilotToAdd);

                    if (createPilotResult.IsFaulted)
                    {
                        base.Alert($"{nameof(EditPilotRegistrationPageViewModel)}:{nameof(SaveAndContinue)} - Failed to add new pilot.");
                        return;
                    }

                    // Update the contest to make sure the pilot roster is update w/ the new pilot...
                    this.contest.PilotRoster.Add(createPilotResult.Value.Id);
                    // Be sure to add the new pilot id back into the viewmodel
                    pilotId = createPilotResult.Value.Id;
                }
                catch (Exception ex)
                {
                    App.Logger.LogException(ex);
                    base.Alert($"An error occured creating a new pilot for the registration.");
                    return;
                }

                var updateContestResult = await this.contestCmdIntr.Value.UpdateContestAsync(contest);

                if (updateContestResult.IsFaulted)
                {
                    base.Alert($"{nameof(EditPilotRegistrationPageViewModel)}:{nameof(SaveAndContinue)} - Failed to update the contest.");
                    return;
                }
            }
            else
            {
                // Save any changes to the pilot object
                var storedPilotsResult = await pilotQueryInteractor.Value.GetAllPilotsAsync();

                if (storedPilotsResult.IsFaulted)
                {
                    base.Alert($"{nameof(EditPilotRegistrationPageViewModel)}:{nameof(SaveAndContinue)} - Failed to save changes to the pilot.");
                    return;
                }

                var storedPilotToUpdate = storedPilotsResult.Value.Where(p => p.Id == pilotId).FirstOrDefault();
                if (storedPilotToUpdate == null)
                {
                    return;
                }                                            //TODO: Throw an error message here...

                storedPilotToUpdate.FirstName       = this.FirstName;
                storedPilotToUpdate.LastName        = this.LastName;
                storedPilotToUpdate.StandardsBodyId = this.AmaNumber;
                storedPilotToUpdate.Airframe        = this.Airframe;

                var updatePilotResult = await pilotCmdInteractor.Value.UpdatePilotAsync(storedPilotToUpdate);

                if (updatePilotResult.IsFaulted)
                {
                    base.Alert($"{nameof(EditPilotRegistrationPageViewModel)}:{nameof(SaveAndContinue)} - Failed to update the pilot.");
                    return;
                }
            }

            // Save the registration
            var registrationToSave = new PilotRegistration
            {
                ContestId          = this.contest.Id,
                Id                 = registrationId,
                IsPaid             = IsPaid,
                AirframesSignedOff = AirframesSignedOff,
                PilotId            = pilotId
            };

            try
            {
                var registerPilotResult = await registrationCmdInteractor.Value.RegisterSinglePilotForContestAsync(registrationToSave);

                if (registerPilotResult.IsFaulted)
                {
                    base.Alert($"{nameof(EditPilotRegistrationPageViewModel)}:{nameof(SaveAndContinue)} - Failed to save the registration.");
                    return;
                }
            }
            catch
            {
                base.Alert("An error occured creating a new pilot registration.");
            }

            this.NavigationService.Navigate(typeof(PilotRegistrationPage), this.contest);
        }
Exemple #8
0
        /// <summary>
        /// Registers the single pilot for contest.
        /// </summary>
        /// <param name="pilotToRegister">The pilot registration.</param>
        /// <returns></returns>
        public async Task <Result <PilotRegistration> > RegisterSinglePilotForContestAsync(PilotRegistration pilotToRegister)
        {
            var validationResult = ValidatePilotRegistration(pilotToRegister);

            if (!validationResult.IsValid)
            {
                return(Error <PilotRegistration>(null, validationResult.Message));
            }

            try
            {
                var result = await this.pilotRegistrationRepository.CreateAsync(pilotToRegister);

                if (result.IsFaulted || result.Value == null)
                {
                    return(Error <PilotRegistration>(null, $"An error occured while registering pilots."));
                }

                return(Success(result.Value, nameof(RegisterPilotsForContestAsync)));
            }
            catch (Exception ex)
            {
                return(Error <PilotRegistration>(null, ex));
            }
        }