public ActionResult <MateReviewsModel> ReviewMate(int mate, MateReviewsModel revModel)
        {
            int?employerID = ClaimHelper.GetIdFromClaimIdentity((ClaimsIdentity)this.ControllerContext.HttpContext.User.Identity);

            // caso o mate id seja nulo
            if (employerID == null)
            {
                return(Unauthorized(new ErrorMessageModel("Utilizador não existe!")));
            }

            MateReview       review        = _mapper.Map <MateReview>(revModel);
            IReviewMateDAO   ReviewMateDAO = new ReviewMateDAO(_connection);
            MateReviewsModel reviewModel   = _mapper.Map <MateReviewsModel>(ReviewMateDAO.ReviewMate((int)employerID, mate, review));

            return(Ok(reviewModel));
        }
        public void CanEmployerAddReviewTest()
        {
            IEmployerDAO <Employer> EmployerDAO = new EmployerDAO(_connection);
            Employer testEmployer = new Employer();

            testEmployer.FirstName   = "Marcelo";
            testEmployer.LastName    = "Carvalho";
            testEmployer.UserName    = "******";
            testEmployer.Password    = "******";
            testEmployer.Email       = "*****@*****.**";
            testEmployer.Description = "Lorem Ipsum is simply dummy text of the printing and typesetting industry.";
            testEmployer.Address     = "Lixa";

            Employer returnedEmp = EmployerDAO.Create(testEmployer);

            IMateDAO <Mate> MateDAO  = new MateDAO(_connection);
            Mate            testMate = new Mate();

            testMate.FirstName   = "Miguel";
            testMate.LastName    = "Dev";
            testMate.UserName    = "******";
            testMate.Password    = "******";
            testMate.Email       = "*****@*****.**";
            testMate.Description = "Lorem Ipsum is simply dummy text of the printing and typesetting industry.";
            testMate.Address     = "Figueir";
            testMate.Categories  = new[] { Categories.CLEANING, Categories.PLUMBING };
            testMate.Rank        = Ranks.SUPER_MATE;
            testMate.Range       = 20;

            Mate returned = MateDAO.Create(testMate);

            IReviewMateDAO ReviewMateDAO = new ReviewMateDAO(_connection);
            MateReview     reviewsTest   = new MateReview();

            reviewsTest.Id      = 5;
            reviewsTest.Rating  = 4;
            reviewsTest.Comment = "O trolha fez um trabalho excelente!";

            MateReview revReturned = ReviewMateDAO.ReviewMate(returnedEmp.Id, returned.Id, reviewsTest);

            Assert.Equal(reviewsTest.Id, revReturned.Id);
            Assert.Equal(reviewsTest.Rating, revReturned.Rating);
            Assert.Equal(reviewsTest.Comment, revReturned.Comment);

            _fixture.Dispose();
        }
        /// <summary>
        /// Método para criar uma Review ao Mate
        /// Neste método também é possível obter a media das ratings que um mate tenha através da tabela MateReview
        /// E de seguida é crucial colocar essa média na tabela de Users associado ao ID do mate respetivo à review
        /// </summary>
        /// <param name="employer">Id do Employer autor da review</param>
        /// <param name="mate">Id do Mate que vai ser feita a review</param>
        /// <param name="model">Modelo com as informações do review a ser publicada</param>
        /// <returns>Retorna o MateReview criado</returns>
        public MateReview ReviewMate(int employer, int mate, MateReview model)
        {
            using (SqlCommand cmd = _connection.Fetch().CreateCommand())
            {
                cmd.CommandText = "INSERT INTO dbo.[MateReview] (Comment, MateId, EmployerId, Rating)" +
                                  "VALUES (@com, @mateId, @empId, @rat); SELECT @@Identity";

                cmd.Parameters.Add("@com", SqlDbType.NVarChar).Value = model.Comment;
                cmd.Parameters.Add("@mateId", SqlDbType.Int).Value   = mate;
                cmd.Parameters.Add("@empId", SqlDbType.Int).Value    = employer;
                cmd.Parameters.Add("@rat", SqlDbType.Float).Value    = model.Rating;

                model.Id = int.Parse(cmd.ExecuteScalar().ToString());
            }

            // Calculo da media das ratings do mate que está na tabela do MateReview
            using (SqlCommand cmdAvg = _connection.Fetch().CreateCommand())
            {
                cmdAvg.CommandText = "SELECT AVG([dbo].[MateReview].Rating)" +
                                     "FROM dbo.[MateReview]" +
                                     "WHERE dbo.[MateReview].MateId = @id";

                cmdAvg.Parameters.Add("@id", SqlDbType.Int).Value = mate;

                double Avg = Double.Parse(cmdAvg.ExecuteScalar().ToString());

                // Update da média na tabela de Users, onde se encontra o ID do mate
                using (SqlCommand cmdSetAvg = _connection.Fetch().CreateCommand())
                {
                    cmdSetAvg.CommandText = "UPDATE dbo.[User]" +
                                            "SET AverageRating = @avg " +
                                            "WHERE dbo.[User].Id = @id";

                    cmdSetAvg.Parameters.Add("@avg", SqlDbType.Float).Value = Avg;
                    cmdSetAvg.Parameters.Add("@id", SqlDbType.Int).Value    = mate;

                    cmdSetAvg.ExecuteScalar();
                }
            }
            return(model);
        }
        public void CanReturnMateReviewsTest()
        {
            IEmployerDAO <Employer> EmployerDAO = new EmployerDAO(_connection);
            Employer testEmployer = new Employer();

            testEmployer.FirstName   = "Marcelo";
            testEmployer.LastName    = "Carvalho";
            testEmployer.UserName    = "******";
            testEmployer.Password    = "******";
            testEmployer.Email       = "*****@*****.**";
            testEmployer.Description = "Lorem Ipsum is simply dummy text of the printing and typesetting industry.";
            testEmployer.Address     = "Lixa";

            Employer returnedEmp = EmployerDAO.Create(testEmployer);

            IMateDAO <Mate> MateDAO  = new MateDAO(_connection);
            Mate            testMate = new Mate();

            testMate.FirstName   = "Miguel";
            testMate.LastName    = "Dev";
            testMate.UserName    = "******";
            testMate.Password    = "******";
            testMate.Email       = "*****@*****.**";
            testMate.Description = "Lorem Ipsum is simply dummy text of the printing and typesetting industry.";
            testMate.Address     = "Figueir";
            testMate.Categories  = new[] { Categories.CLEANING, Categories.PLUMBING };
            testMate.Rank        = Ranks.SUPER_MATE;
            testMate.Range       = 20;

            Mate returned = MateDAO.Create(testMate);

            MateReview reviewsTest = new MateReview();

            reviewsTest.Rating  = 4;
            reviewsTest.Comment = "O trolha fez um trabalho excelente!";

            MateReview reviewsTest2 = new MateReview();

            reviewsTest2.Rating  = 2;
            reviewsTest2.Comment = "O trolha fez um trabalho mau!";

            IReviewMateDAO ReviewMateDAO   = new ReviewMateDAO(_connection);
            MateReview     returnedReview1 = ReviewMateDAO.ReviewMate(returnedEmp.Id, returned.Id, reviewsTest);
            MateReview     returnedReview2 = ReviewMateDAO.ReviewMate(returnedEmp.Id, returned.Id, reviewsTest2);

            List <MateReviewsModel> ReviewsList = ReviewMateDAO.MateReviewsList(returned.Id);

            MateReviewsModel[] array = ReviewsList.ToArray();

            Assert.Equal(2, array.Length);

            Assert.Equal(reviewsTest.Rating, array[0].Rating);
            Assert.Equal(reviewsTest.Comment, array[0].Comment);
            Assert.Equal(returnedEmp.UserName, array[0].Author);

            Assert.Equal(reviewsTest2.Rating, array[1].Rating);
            Assert.Equal(reviewsTest2.Comment, array[1].Comment);
            Assert.Equal(returnedEmp.UserName, array[1].Author);

            _fixture.Dispose();
        }