Example #1
0
        public virtual async Task <UpdateResponse <ApiDirectTweetServerResponseModel> > Update(
            int tweetId,
            ApiDirectTweetServerRequestModel model)
        {
            var validationResult = await this.DirectTweetModelValidator.ValidateUpdateAsync(tweetId, model);

            if (validationResult.IsValid)
            {
                DirectTweet record = this.DalDirectTweetMapper.MapModelToEntity(tweetId, model);
                await this.DirectTweetRepository.Update(record);

                record = await this.DirectTweetRepository.Get(tweetId);

                ApiDirectTweetServerResponseModel apiModel = this.DalDirectTweetMapper.MapEntityToModel(record);
                await this.mediator.Publish(new DirectTweetUpdatedNotification(apiModel));

                return(ValidationResponseFactory <ApiDirectTweetServerResponseModel> .UpdateResponse(apiModel));
            }
            else
            {
                return(ValidationResponseFactory <ApiDirectTweetServerResponseModel> .UpdateResponse(validationResult));
            }
        }
Example #2
0
        public virtual async Task <UpdateResponse <ApiFollowingServerResponseModel> > Update(
            int userId,
            ApiFollowingServerRequestModel model)
        {
            var validationResult = await this.FollowingModelValidator.ValidateUpdateAsync(userId, model);

            if (validationResult.IsValid)
            {
                Following record = this.DalFollowingMapper.MapModelToEntity(userId, model);
                await this.FollowingRepository.Update(record);

                record = await this.FollowingRepository.Get(userId);

                ApiFollowingServerResponseModel apiModel = this.DalFollowingMapper.MapEntityToModel(record);
                await this.mediator.Publish(new FollowingUpdatedNotification(apiModel));

                return(ValidationResponseFactory <ApiFollowingServerResponseModel> .UpdateResponse(apiModel));
            }
            else
            {
                return(ValidationResponseFactory <ApiFollowingServerResponseModel> .UpdateResponse(validationResult));
            }
        }
Example #3
0
        public virtual async Task <UpdateResponse <ApiMessengerServerResponseModel> > Update(
            int id,
            ApiMessengerServerRequestModel model)
        {
            var validationResult = await this.MessengerModelValidator.ValidateUpdateAsync(id, model);

            if (validationResult.IsValid)
            {
                Messenger record = this.DalMessengerMapper.MapModelToEntity(id, model);
                await this.MessengerRepository.Update(record);

                record = await this.MessengerRepository.Get(id);

                ApiMessengerServerResponseModel apiModel = this.DalMessengerMapper.MapEntityToModel(record);
                await this.mediator.Publish(new MessengerUpdatedNotification(apiModel));

                return(ValidationResponseFactory <ApiMessengerServerResponseModel> .UpdateResponse(apiModel));
            }
            else
            {
                return(ValidationResponseFactory <ApiMessengerServerResponseModel> .UpdateResponse(validationResult));
            }
        }