Exemplo n.º 1
0
 public PropertyReviewInfoDTO(PropertyReviews review)
 {
     ReviewScore = review.ReviewScore;
     ReviewText  = review.ReviewText;
 }
Exemplo n.º 2
0
        /// <summary>
        /// Create Review if the user has made review to this entity it updates the review
        /// </summary>
        /// <param name="review"></param>
        /// <param name="userId"></param>
        /// <param name="reviewType"></param>
        /// <returns></returns>
        private async Task <Reviews> ReviewsCreateFactory(CreateReviewViewModel review, string userId, ReviewTypes reviewType)
        {
            Reviews reviewResult;
            bool    isExisting = false;

            switch (reviewType)
            {
            case ReviewTypes.Property:
                if (!await unitOfWork.PropertiesRepository.GetAll().AnyAsync(p => p.Id == (int)review.ReviewForeignKey))
                {
                    throw new ContentNotFoundException("Имотът не е намерен!");
                }
                var propertyId = (int)review.ReviewForeignKey;
                reviewResult = await unitOfWork.ReviewsRepository.GetAll()
                               .OfType <PropertyReviews>()
                               .FirstOrDefaultAsync(r => r.PropertyId == propertyId && r.UserId == userId);

                if (reviewResult != null)
                {
                    isExisting = true;
                }
                else
                {
                    reviewResult = new PropertyReviews {
                        PropertyId = propertyId
                    };
                }
                break;

            case ReviewTypes.Sight:
                if (!await unitOfWork.SightsRepository.GetAll().AnyAsync(p => p.SightId == (int)review.ReviewForeignKey))
                {
                    throw new ContentNotFoundException("Забележителността не е намерен!");
                }
                var sightId = (int)review.ReviewForeignKey;
                reviewResult = await unitOfWork.ReviewsRepository.GetAll()
                               .OfType <SightReviews>()
                               .FirstOrDefaultAsync(r => r.SightId == sightId && r.UserId == userId);

                if (reviewResult != null)
                {
                    isExisting = true;
                }
                else
                {
                    reviewResult = new SightReviews()
                    {
                        ReviewId = (int)review.ReviewForeignKey
                    };
                }
                break;

            case ReviewTypes.City:
                if (!await unitOfWork.CitiesRepository.GetAll().AnyAsync(p => p.CityId == (int)review.ReviewForeignKey))
                {
                    throw new ContentNotFoundException("Градът не е намерен!");
                }
                var cityId = (int)review.ReviewForeignKey;
                reviewResult = await unitOfWork.ReviewsRepository.GetAll()
                               .OfType <CityReviews>()
                               .FirstOrDefaultAsync(r => r.CityId == cityId && r.UserId == userId);

                if (reviewResult != null)
                {
                    isExisting = true;
                }
                else
                {
                    reviewResult = new CityReviews()
                    {
                        CityId = (int)review.ReviewForeignKey
                    };
                }
                break;

            case ReviewTypes.Owner:
                if (!await userManager.Users.AnyAsync(p => p.Id == (string)review.ReviewForeignKey))
                {
                    throw new ContentNotFoundException("Собственикът не е намерен!");
                }
                if (!await userManager.IsInRoleAsync((string)review.ReviewForeignKey, OwnerRole))
                {
                    throw new ContentNotFoundException("Потребителят не е собственик на имот!");
                }
                var ownerId = (string)review.ReviewForeignKey;
                reviewResult = await unitOfWork.ReviewsRepository.GetAll()
                               .OfType <OwnerReviews>()
                               .FirstOrDefaultAsync(r => r.OwnerId == ownerId && r.UserId == userId);

                if (reviewResult != null)
                {
                    isExisting = true;
                }
                else
                {
                    reviewResult = new OwnerReviews()
                    {
                        OwnerId = (string)review.ReviewForeignKey
                    };
                }
                break;

            case ReviewTypes.Agent:
                if (!await userManager.Users.AnyAsync(p => p.Id == (string)review.ReviewForeignKey))
                {
                    throw new ContentNotFoundException("Собственикът не е намерен!");
                }
                if (!await userManager.IsInRoleAsync((string)review.ReviewForeignKey, OwnerRole))
                {
                    throw new ContentNotFoundException("Потребителят не е собственик на имот!");
                }
                var agentId = (string)review.ReviewForeignKey;
                reviewResult = await unitOfWork.ReviewsRepository.GetAll()
                               .OfType <AgentReviews>()
                               .FirstOrDefaultAsync(r => r.AgentId == agentId && r.UserId == userId);

                if (reviewResult != null)
                {
                    isExisting = true;
                }
                else
                {
                    reviewResult = new AgentReviews()
                    {
                        AgentId = (string)review.ReviewForeignKey
                    };
                }
                break;

            default:
            {
                throw new ArgumentOutOfRangeException();
            }
            }

            reviewResult.ReviewScore = review.ReviewScore;
            reviewResult.ReviewText  = review.ReviewText;
            reviewResult.UserId      = userId;

            if (isExisting)
            {
                unitOfWork.ReviewsRepository.Edit(reviewResult);
            }
            else
            {
                unitOfWork.ReviewsRepository.Add(reviewResult);
            }

            return(reviewResult);
        }