public async Task <IActionResult> AddPhotoForUser(int userId,
                                                          [FromForm] PhotoForCreationDto photoForCreationDto)
        {
            if (userId != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value))
            {
                return(Unauthorized());
            }

            //create params for cloudinary and upload picture to cloudinary
            var file         = photoForCreationDto.File;
            var uploadResult = new ImageUploadResult();

            if (file.Length > 0)
            {
                using (var stream = file.OpenReadStream())
                {
                    var uploadParams = new ImageUploadParams()
                    {
                        File           = new FileDescription(file.Name, stream),
                        Transformation = new Transformation().Width(500)
                                         .Height(500).Crop("fill").Gravity("center")
                    };

                    uploadResult = _cloudinary.Upload(uploadParams);
                }
            }

            photoForCreationDto.Url      = uploadResult.Uri.ToString();
            photoForCreationDto.PublicId = uploadResult.PublicId;

            var photo = _mapper.Map <Photo>(photoForCreationDto);

            var userFromRepo = await _repo.GetUser(userId);

            if (!userFromRepo.Photos.Any(u => u.IsMain))
            {
                photo.IsMain = true;
            }

            userFromRepo.Photos.Add(photo);

            if (await _repo.SaveAll())
            {
                var photoForReturnDto = _mapper.Map <PhotoForReturnDto>(photo);
                return(CreatedAtRoute("GetPhoto", new { userId = userId, id = photo.Id },
                                      photoForReturnDto));
            }

            return(BadRequest("Could not add the photo"));
        }
        public async Task <IActionResult> Post([FromBody] OrderViewModel model)
        {
            //add it to the db
            try
            {
                if (ModelState.IsValid)
                {
                    var newOrder = new Order()
                    {
                        OrderDate   = model.OrderDate,
                        OrderNumber = model.OrderNumber,
                        Id          = model.OrderId
                    };
                    var currentUser = await _userManager.FindByNameAsync(User.Identity.Name);

                    newOrder.User = null;
                    _repository.AddEntity(newOrder);
                    if (_repository.SaveAll())
                    {
                        return(Created($"/api/order/{newOrder.Id}", model)); //201
                    }
                }
                else
                {
                    return(BadRequest(ModelState));
                }
            }
            catch (Exception ex)
            {
                _logger.LogError($"Failed to save a new order:{ex}");
            }
            return(BadRequest("Failed to save"));
        }
        public async Task <IActionResult> Post([FromBody] OrderViewModel model)
        {
            try
            {
                if (ModelState.IsValid)
                {
                    var order = _mapper.Map <OrderViewModel, Order>(model);

                    if (order.OrderDate == DateTime.MinValue)
                    {
                        order.OrderDate = DateTime.Now;
                    }

                    order.User = await _userManager.FindByNameAsync(User.Identity.Name);

                    _repository.AddEntity(order);
                    if (_repository.SaveAll())
                    {
                        var vm = _mapper.Map <Order, OrderViewModel>(order);
                        return(Created($"/api/orders/{vm.OrderId}", vm));
                    }
                }

                return(BadRequest(ModelState));
            }
            catch (Exception e)
            {
                _logger.LogError($"Failed to post order: {e}");
                return(BadRequest("Failed"));
            }
        }
        public async Task <IActionResult> CreateMessage(int userId, MessageForCreationDto messageForCreationDto)
        {
            if (userId != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value))
            {
                return(Unauthorized());
            }

            messageForCreationDto.SenderId = userId;
            var recipient = await _repo.GetUser(messageForCreationDto.RecipientId);

            if (recipient == null)
            {
                return(BadRequest("Could not find the user"));
            }

            var message = _mapper.Map <Message>(messageForCreationDto);

            _repo.Add(message);

            var messageToReturn = _mapper.Map <MessageForCreationDto>(message);

            if (await _repo.SaveAll())
            {
                return(CreatedAtRoute("GetMessage", new { userId = userId, id = message.Id }, messageToReturn));
            }

            throw new Exception("Creating the message failed on save");
        }
Exemple #5
0
        public async Task <IActionResult> UpdateUser(int id, UserForUpdateDto userForUpdateDto)
        {
            if (id != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value))
            {
                return(Unauthorized());
            }

            var userFromRop = await _repo.GetUser(id);

            _mapper.Map(userForUpdateDto, userFromRop);

            if (await _repo.SaveAll())
            {
                return(NoContent());
            }

            throw new Exception($"Updating user {id} failed on save");
        }
Exemple #6
0
        public async Task <IActionResult> MarkMessageAsRead(int userId, int id)
        {
            if (userId != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value))
            {
                return(Unauthorized());
            }

            var message = await _repo.GetMessage(id);

            if (message.RecipientId != userId)
            {
                return(Unauthorized());
            }

            message.IsRead   = true;
            message.DateRead = DateTime.Now;

            await _repo.SaveAll();

            return(NoContent());
        }
        public async Task <IActionResult> Post([FromBody] OrderViewModel model)
        {
            try
            {
                if (ModelState.IsValid)
                {
                    var newOrder = _mapper.Map <OrderViewModel, Order>(model);

                    if (newOrder.OrderDate == DateTime.MinValue)
                    {
                        newOrder.OrderDate = DateTime.Now;
                    }

                    var currentUser = await _userManager.FindByNameAsync(User.Identity.Name);

                    newOrder.User = currentUser;

                    _repository.AddOrder(newOrder);
                    if (_repository.SaveAll())
                    {
                        var vm = new OrderViewModel()
                        {
                            OrderId     = newOrder.Id,
                            OrderDate   = newOrder.OrderDate,
                            OrderNumber = newOrder.OrderNumber
                        };
                        return(Created($"api/order/{newOrder.Id}", _mapper.Map <Order,
                                                                                OrderViewModel>(newOrder)));
                    }
                }
                else
                {
                    return(BadRequest(ModelState));
                }
            }
            catch (Exception ex)
            {
                _logger.LogError($"Failed to post order {ex}");
            }
            return(BadRequest("Failed to save new order."));
        }