Пример #1
0
        public async Task <IDataResult <MessageDto> > Update(MessageUpdateDto messageUpdateDto, string modifiedByName)
        {
            var message = _mapper.Map <Message>(messageUpdateDto);

            message.ModifiedByName = modifiedByName;
            var updatedMessage = await _unitOfWork.Message.UpdateAsync(message);

            await _unitOfWork.SaveAsync();

            return(new DataResult <MessageDto>(ResultStatus.Success, $"{updatedMessage.Subject} konulu mesaj başarılı bir şekilde güncellenmiştir.", new MessageDto
            {
                ResultStatus = ResultStatus.Success,
                Message = $"{updatedMessage.Subject} konulu mesaj başarılı bir şekilde güncellenmiştir.",
                Messagee = updatedMessage
            }));
        }
Пример #2
0
        public ActionResult UpdateCommand(int id, MessageUpdateDto messageUpdateDto)
        {
            var messageModelFromRepo = _repository.GetMessageById(id);

            if (messageModelFromRepo == null)
            {
                return(NotFound());
            }

            _mapper.Map(messageUpdateDto, messageModelFromRepo);

            _repository.UpdateMessage(messageModelFromRepo);

            _repository.SaveChanges();

            return(NoContent());
        }
        public IActionResult UpdateMessage(int id, [FromBody] MessageUpdateDto updateMessage)
        {
            string userGuid = UserHelper.GetUserGuid(_httpContextAccessor);
            var    getUser  = _transActionRepo.GetUsers().FirstOrDefault(c => c.Guid == userGuid);

            var message = _transActionRepo.GetTopicMessage(id);

            var user = _transActionRepo.GetCurrentUser(getUser.Guid);

            if (user.Role.Name.ToLower() == "admin" || user.UserId == message.UserId)
            {
                var messageEntity = _transActionRepo.GetTopicMessage(id);
                var topic         = _transActionRepo.GetTopic(messageEntity.TopicId);
                topic.DbLastUpdateTimestamp = DateTime.Now;
                if (messageEntity == null)
                {
                    return(NotFound());
                }
                if (updateMessage == null)
                {
                    return(NotFound());
                }

                if (!ModelState.IsValid)
                {
                    return(BadRequest(ModelState));
                }
                _mapper.Map(updateMessage, messageEntity);


                if (!_transActionRepo.Save())
                {
                    return(StatusCode(500, "A problem happened while handling your request."));
                }

                var getMessage     = _transActionRepo.GetTopicMessage(id);
                var getTopicResult = _mapper.Map <MessageDto>(getMessage);
                return(Ok(getTopicResult));
            }
            else
            {
                return(BadRequest());
            }
        }
Пример #4
0
        public ActionResult UpdateMessage(int id, MessageUpdateDto messageUpdateDto)
        {
            messageUpdateDto.Text = _profanityFilter.CensorString(messageUpdateDto.Text);

            var messageModel = _onlineDOD.GetMessageById(id);

            if (messageModel == null)
            {
                return(NotFound());
            }

            _mapper.Map(messageUpdateDto, messageModel);

            _onlineDOD.UpdateMessage(messageModel);
            _onlineDOD.SaveChanges();

            //Serilog.Log.Information($"[{this.Request.Host.Host}] PUT /api/messages/{id}");

            return(NoContent());
        }
Пример #5
0
        public IActionResult UpdateMessage(int id, [FromBody] MessageUpdateDto updateMessage)
        {
            string userGuid = UserHelper.GetUserGuid(_httpContextAccessor);
            var    getUser  = _unitOfWork.User.GetByGuid(userGuid);

            var message = _unitOfWork.Message.GetMessageById(id);

            var user = _unitOfWork.User.GetCurrentUser(getUser.Guid);

            if (user.Role.Name.ToLower() == "admin" || user.UserId == message.UserId)
            {
                if (!ModelState.IsValid)
                {
                    return(BadRequest(new TransActionResponse(ModelState.ToString())));
                }
                var messageEntity = _unitOfWork.Message.GetMessageById(id);
                var topic         = _unitOfWork.Topic.GetTopicById(messageEntity.TopicId);
                topic.DbLastUpdateTimestamp = DateTime.Now;
                if (messageEntity == null)
                {
                    return(StatusCode(404, new TransActionResponse("Message Not Found")));
                }

                _mapper.Map(updateMessage, messageEntity);

                _unitOfWork.Message.Update(messageEntity);
                if (!_unitOfWork.Save())
                {
                    return(StatusCode(500, new TransActionResponse("A problem happened while handling your request")));
                }

                var getMessage     = _unitOfWork.Message.GetMessageById(id);
                var getTopicResult = _mapper.Map <MessageDto>(getMessage);
                return(StatusCode(200, new TransActionResponse(getTopicResult)));
            }
            else
            {
                return(StatusCode(StatusCodes.Status401Unauthorized, new TransActionResponse()));
            }
        }