示例#1
0
        public async Task <IActionResult> Index(SortFilterBirdIndexOptions options)
        {
            if (!ModelState.IsValid)
            {
                var errors = ModelStateErrorsExtensions.GetModelStateErrorMessages(ModelState);
                return(BadRequest(errors));
            }

            if (options.Page == 0)
            {
                options.Page = 1;
            }

            try
            {
                var viewModel = new BirdIndexViewModel();
                viewModel.AllBirdsDropDownList = await _context.Bird.ToListAsync();

                viewModel.BirdsList = await _context.Bird.AsNoTracking().GetPaged(options.Page, pageSize);

                viewModel.ShowAll     = options.ShowAll;
                viewModel.ShowInTable = options.ShowInTable;
                return(View(viewModel));
            }
            catch (Exception ex)
            {
                return(NotFound());
            }
        }
示例#2
0
        public async Task <IActionResult> CreateObservationAsync(ObservationAddDto model)
        {
            try
            {
                var requestingUser = await _userManager.FindByNameAsync(User.Identity.Name);

                if (requestingUser is null)
                {
                    _logger.LogError(LoggingEvents.GetItem, "requesting user not found");
                    return(StatusCode(500, "requesting user not found"));
                }

                var observedBirdSpecies = await _birdRepository.GetBirdAsync(model.Bird.BirdId);

                if (observedBirdSpecies is null)
                {
                    string message = $"Bird species with id '{model.BirdId}' was not found.";
                    _logger.LogError(LoggingEvents.GetItem, message);
                    return(StatusCode(500, message));
                }

                // date from client model is already Utc....
                // model.ObservationDateTime = model.ObservationDateTime.ToLocalTime();
                // var x = model.ObservationDateTime;
                // var y = model.ObservationDateTime = model.ObservationDateTime.ToLocalTime();
                // var z = model.ObservationDateTime = model.ObservationDateTime.ToUniversalTime();

                var observation = _mapper.Map <ObservationAddDto, Observation>(model);

                DateTime createdDate = _systemClock.GetNow;

                observation.ApplicationUser = requestingUser;
                observation.Bird            = observedBirdSpecies;
                observation.CreationDate    = createdDate;
                observation.LastUpdateDate  = createdDate;

                //rerun validation on observation model
                if (!TryValidateModel(observation, nameof(observation)))
                {
                    _logger.LogError(LoggingEvents.UpdateItem, "Observation model state is invalid: " + ModelStateErrorsExtensions.GetModelStateErrorMessages(ModelState));
                    return(StatusCode(500, "observation ModelState is invalid"));
                }

                _observationPositionRepository.Add(observation.Position);
                _observationRepository.Add(observation);
                _observationNoteRepository.AddRange(observation.Notes);
                await _unitOfWork.CompleteAsync();

                return(CreatedAtAction(nameof(CreateObservationAsync), _mapper.Map <Observation, ObservationDto>(observation)));
            }
            catch (Exception ex)
            {
                _logger.LogError(LoggingEvents.GetListNotFound, ex, "An error occurred creating an observation.");
                return(StatusCode(500, "an unexpected error occurred"));
            }
        }
示例#3
0
        public async Task <IActionResult> PutObservationAsync(int id, ObservationEditDto model)
        {
            try
            {
                if (id != model.ObservationId)
                {
                    _logger.LogError(LoggingEvents.UpdateItem, $"Id '{id}' not equal to model id '{model.ObservationId}'");
                    return(BadRequest("An error occurred (id)"));
                }

                var observation = await _observationRepository.GetObservationAsync(id, false);

                if (observation is null)
                {
                    string message = $"observation with id '{model.ObservationId}' was not found.";
                    _logger.LogError(LoggingEvents.UpdateItem, message);
                    return(StatusCode(500, message));
                }

                var username = User.Identity.Name;

                if (username != observation.ApplicationUser.UserName)
                {
                    return(Unauthorized("Requesting user is not allowed to edit this observation"));
                }

                // date from client model is already Utc....
                // model.ObservationDateTime = model.ObservationDateTime.ToLocalTime();
                // var x = model.ObservationDateTime;
                // var y = model.ObservationDateTime = model.ObservationDateTime.ToLocalTime();
                // var z = model.ObservationDateTime = model.ObservationDateTime.ToUniversalTime();

                _mapper.Map <ObservationEditDto, Observation>(model, observation);

                var bird = await _birdRepository.GetBirdAsync(model.Bird.BirdId);

                if (bird is null)
                {
                    string message = $"The observed bird could not be found for observation with id '{model.ObservationId}'.";
                    _logger.LogError(LoggingEvents.UpdateItem, message);
                    return(StatusCode(500, message));
                }

                observation.Bird = bird;

                var position = await _observationPositionRepository.SingleOrDefaultAsync(o => o.ObservationId == observation.ObservationId);

                if (position is null)
                {
                    string message = $"The position could not be found for observation with id '{model.ObservationId}'.";
                    _logger.LogError(LoggingEvents.UpdateItem, message);
                    return(StatusCode(500, message));
                }

                position.Latitude         = model.Position.Latitude;
                position.Longitude        = model.Position.Longitude;
                position.FormattedAddress = model.Position.FormattedAddress;
                position.ShortAddress     = model.Position.ShortAddress;

                // ToDo: separate ObservationNotesController to handle this stuff.
                // ...need to redesign UI first...
                var notes = await _observationNoteRepository.FindAsync(x => x.Observation.ObservationId == id);

                var notesDeleted = ObservationNotesHelper.GetDeletedNotes(notes, model.Notes);
                if (notesDeleted.Any())
                {
                    _observationNoteRepository.RemoveRange(notesDeleted);
                }

                var notesAdded = ObservationNotesHelper.GetAddedNotes(model.Notes);
                if (notesAdded.Any())
                {
                    var added = _mapper.Map(notesAdded, new List <ObservationNote>());
                    added.ForEach(a => a.Observation = observation);
                    _observationNoteRepository.AddRange(added);
                }

                // ToDo: is the condition necessary here?
                if (notes.Any())
                {
                    _mapper.Map <List <ObservationNoteDto>, IEnumerable <ObservationNote> >(model.Notes, notes);
                }

                observation.LastUpdateDate = _systemClock.GetNow;

                if (!TryValidateModel(observation, nameof(observation)))
                {
                    _logger.LogError(LoggingEvents.UpdateItemNotFound, "Observation has an invalid model state: " + ModelStateErrorsExtensions.GetModelStateErrorMessages(ModelState), id);
                    return(StatusCode(500, "observation ModelState is invalid"));
                }

                await _unitOfWork.CompleteAsync();

                return(Ok(_mapper.Map <Observation, ObservationEditDto>(observation)));
            }
            catch (Exception ex)
            {
                _logger.LogError(LoggingEvents.UpdateItemNotFound, ex, "An error occurred updating (PUT) observation with id: {ID}", id);
                return(StatusCode(500, "an unexpected error occurred"));
            }
        }
        public async Task <IActionResult> GetConfirmEmailAsync(string username, string code)
        {
            try
            {
                if (string.IsNullOrEmpty(username) || code == null)
                {
                    _logger.LogError(LoggingEvents.GetItemNotFound, $"Null arguments passed to ConfirmEmailAsync: username = {username}; code = {code}.");
                    return(BadRequest("An error occurred"));
                }

                var user = await _userManager.FindByNameAsync(username);

                if (user == null)
                {
                    _logger.LogError(LoggingEvents.GetItemNotFound, $"User with username '{username}' not found");
                    return(NotFound("User not found"));
                }

                var result = await _userManager.ConfirmEmailAsync(user, code);

                if (!result.Succeeded)
                {
                    ModelStateErrorsExtensions.AddIdentityErrors(ModelState, result);
                    _logger.LogError(LoggingEvents.UpdateItemNotFound, "Invalid model state:" + ModelStateErrorsExtensions.GetModelStateErrorMessages(ModelState));
                    return(BadRequest("An error occurred"));
                }

                return(Redirect("/confirmed-email"));
            }
            catch (Exception ex)
            {
                _logger.LogError(LoggingEvents.UpdateItemNotFound, ex, "An error occurred in email confirmation.");
                return(BadRequest("An error occurred"));
            }
        }
        public async Task <IActionResult> PostRegisterAsync([FromBody] RegisterViewModel model)
        {
            try
            {
                //if (!ModelState.IsValid)
                //{
                //    _logger.LogError(LoggingEvents.UpdateItemNotFound, "Invalid model state:" + ModelStateErrorsExtensions.GetModelStateErrorMessages(ModelState));
                //    return BadRequest(ModelState);
                //}

                var newUser = new ApplicationUser
                {
                    UserName = model.UserName,
                    Email    = model.Email,
                    DefaultLocationLatitude  = 54.972237,
                    DefaultLocationLongitude = -2.4608560000000352,
                    Avatar           = "https://img.icons8.com/color/96/000000/user.png", // "https://birderstorage.blob.core.windows.net/profile/default.png",
                    RegistrationDate = _systemClock.GetNow
                };

                var result = await _userManager.CreateAsync(newUser, model.Password);

                if (result.Succeeded)
                {
                    var code = await _userManager.GenerateEmailConfirmationTokenAsync(newUser);

                    var url          = _urlService.GetConfirmEmailUrl(newUser.UserName, code);
                    var templateData = new { username = newUser.UserName, url = url };
                    await _emailSender.SendTemplateEmail("d-882e4b133cae40268364c8a929e55ea9", newUser.Email, templateData);

                    return(Ok()); //ToDo: Is this adequate?  Created reponse?
                }

                ModelStateErrorsExtensions.AddIdentityErrors(ModelState, result);
                _logger.LogError(LoggingEvents.UpdateItemNotFound, "Invalid model state:" + ModelStateErrorsExtensions.GetModelStateErrorMessages(ModelState));
                return(BadRequest(ModelState));
            }
            catch (Exception ex)
            {
                _logger.LogError(LoggingEvents.UpdateItemNotFound, ex, "An error occurred in new user registration.");
                return(BadRequest("An error occurred"));
            }
        }
        public async Task <IActionResult> PostResetPasswordAsync(ResetPasswordViewModel model)
        {
            try
            {
                var user = await _userManager.FindByEmailAsync(model.Email);

                if (user == null)
                {
                    return(Ok()); // Don't reveal that the user does not exist
                }
                var result = await _userManager.ResetPasswordAsync(user, model.Code, model.Password);

                if (result.Succeeded)
                {
                    return(Ok());
                }

                ModelStateErrorsExtensions.AddIdentityErrors(ModelState, result);
                _logger.LogError(LoggingEvents.UpdateItemNotFound, "Invalid model state:" + ModelStateErrorsExtensions.GetModelStateErrorMessages(ModelState));
                return(BadRequest("An error occurred"));
            }
            catch (Exception ex)
            {
                _logger.LogError(LoggingEvents.UpdateItemNotFound, ex, "An error occurred in forgot password.");
                return(BadRequest("An error occurred"));
            }
        }