public async Task <IActionResult> PostReviewAsync([FromRoute] Guid bookId, [FromBody] ReviewRequest review)
{
review.BookId = bookId;
var id = await service.SaveAsync(mapper.Map <Review>(review));
return(CreatedAtAction(nameof(GetReviewAsync), new { id }, null));
}
public IHttpActionResult AddReview(ReviewRequest reviewRequest)
{
try
{
ControllerHelper.CalidateAndSetUserInReviewRequest(Request, reviewRequest);
reviewService.AddReview(reviewRequest);
List <PendingReviewDTO> pendingReviews = cartService.GetPendingReviewsForUser(reviewRequest.UserId);
UserContextDTO userContext = GetUserContextFromRequest(Request);
userContext.PendingsReviewDTO = pendingReviews;
LoginContext.GetInstance().SaveContext(userContext);
ControllerResponse response = ControllerHelper.CreateSuccessResponse("La review se dió de alta satisfactoriamente");
response.Data = userContext;
return(Ok(response));
}
catch (BadRequestException e)
{
return(CreateBadResponse(e.Message));
}
catch (RepositoryException e)
{
return(CreateBadResponse(e.Message));
}
catch (OperationException e)
{
return(CreateBadResponse(e.Message));
}
catch (Exception)
{
return(CreateBadResponse("Ocurrió un error al agregar review"));
}
}
/// <summary>
/// 审核页面
/// </summary>
/// <param name="pageid"></param>
/// <param name="version"></param>
/// <returns></returns>
public async Task <bool> ReviewPage(string pageid, int version)
{
string apitype = JsonApiType.reviewPage;
BaseRequest bj = GetCommonBaseRequest(apitype);
ReviewRequest re = new ReviewRequest(version, pageid);
bj.api_type = apitype;
bj.data = re;
try
{
var result = await Post(bj);
BaseReturn brj = JsonController.DeSerializeToClass <BaseReturn>(result);
CommonReturn cr = JsonController.DeSerializeToClass <CommonReturn>(brj.data.ToString());
if (cr.error_code.Equals(ReturnConst.right))
{
return(true);
}
else
{
return(false);
}
}
catch
{
return(false);
}
}
public IActionResult LeaveReview([FromBody] ReviewRequest review, [FromRoute] int groupId)
{
var userId = Request.GetUserId();
_groupFacade.AddReview(groupId, userId, review.Title, review.Text);
return(Ok());
}
public async Task <ActionResult <ReviewResponse> > PostReview(long placeId, ReviewRequest reviewRequest)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var userAlreadyReviewed = await _context.Reviews.AnyAsync(r => r.PlaceID == placeId && r.UserID == CurrentUserId);
if (userAlreadyReviewed)
{
return(BadRequest("This user already reviewed this place"));
}
var review = _mapper.Map <Review>(reviewRequest);
review.PlaceID = placeId;
review.UserID = CurrentUserId;
review.Time = DateTime.Now;
_context.Reviews.Add(review);
await _context.SaveChangesAsync();
review = await _context.Reviews
.Include(r => r.User)
.FirstOrDefaultAsync(r => r.ID == review.ID);
var reviewResponse = _mapper.Map <ReviewResponse>(review);
return(CreatedAtAction(nameof(GetReview), new { placeId, reviewId = review.ID }, reviewResponse));
}
public ReviewControllerTest()
{
LoginContext.GetInstance().Reset();
reviewRequest = new ReviewRequest {
CartItemId = "1", ProductId = "1", UserId = "1"
};
}
public ActionResult AjaxList(ReviewRequest request)
{
var create = _unityContainer.Resolve <ListReviews>();
var table = create.AjaxQuery(request);
return(Json(new { tables = table, html = create.pageHtml }));
}
public ReviewResponseInfoDto SendReviewResponse(ReviewResponseCreateDto reviewResponseCreateDto)
{
ReviewRequest request = _context
.ReviewRequests
.Include(s => s.ProjectInfo)
.ThenInclude(p => p.Skills)
.Include(s => s.User)
.FirstOrDefault(r => r.Id == reviewResponseCreateDto.ReviewRequestId);
if (request == null)
{
throw RecademyException.ReviewRequestNotFound(reviewResponseCreateDto.ReviewRequestId);
}
if (request.State == ProjectState.Completed || request.State == ProjectState.Abandoned)
{
throw new RecademyException("Failed to send review. It is already closed.");
}
var newReview = new ReviewResponse
{
ReviewRequestId = reviewResponseCreateDto.ReviewRequestId,
Description = reviewResponseCreateDto.ReviewText,
ReviewerId = reviewResponseCreateDto.UserId,
CreationTime = DateTime.UtcNow,
ReviewConclusion = reviewResponseCreateDto.ReviewConclusion
};
request.State = ProjectState.Reviewed;
_context.ReviewResponses.Add(newReview);
_context.SaveChanges();
newReview.ReviewRequest = request;
return(new ReviewResponseInfoDto(newReview));
}
public static async Task Run(
[QueueTrigger("github-pullrequestreview")] JObject review,
[FromConfig(Name = "github-app-id")] string githubAppId,
[FromConfig(Name = "github-app-key")] string githubAppKey,
ILogger log)
{
var reviewRequest = new ReviewRequest
{
RepositoryId = review["repository"]["id"].Value <long>(),
PullRequestComment = review["pull_request"]["body"].Value <string>(),
ReviewState = review["review"]["state"].Value <string>().ToLowerInvariant(),
PullRequestNumber = review["pull_request"]["number"].Value <int>(),
InstallationId = review["installation"]["id"].Value <int>()
};
log.LogInformation($"Processing: {JsonConvert.SerializeObject(reviewRequest, Formatting.Indented)}");
var githubClient = await new GitHubClientProvider().CreateForInstallation(
githubAppId,
githubAppKey,
reviewRequest.InstallationId);
var pullRequestLabeler = new PullRequestLabeler(
githubClient,
new LabelMaker(githubClient, log),
new IssueLabelManager(githubClient, log),
log);
await pullRequestLabeler.Process(reviewRequest);
}
public void CreateReview()
{
List <ReviewRequest> revrequests = new List <ReviewRequest>();
List <KeyValue> mData = new List <KeyValue>();
KeyValue kv = new KeyValue()
{
Key = "a",
Value = "True"
};
mData.Add(kv);
kv = new KeyValue()
{
Key = "r",
Value = "False"
};
mData.Add(kv);
ReviewRequest req1 = new ReviewRequest()
{
CallbackEndpoint = string.Empty,
Content = "https://moderatorsampleimages.blob.core.windows.net/samples/sample.jpg",
ContentId = "sample.jpg",
Type = ContentType.Image,
Metadata = mData
};
revrequests.Add(req1);
var task = this.client.CreateReview(this.reviewTeamName, revrequests);
var result = task.Result;
Assert.IsNotNull(result);
}
public static Review ToDomain(this ReviewRequest request) => new Review
{
Description = request.Description,
Grade = request.Grade,
Anonymous = request.Anonymous,
BookingNumber = request.BookingNumber
};
//Here call to restApi to saveReview
private async void SubmitReview()
{
ShowProgressBarIndicator(10);
ReviewRequest review = MaterializeReview();
HttpClient client = new HttpClient();
client.BaseAddress = new Uri("http://localhost:55558/api/v1/");
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(
new MediaTypeWithQualityHeaderValue("application/json"));
ShowProgressBarIndicator(50);
var response = await client.PostAsJsonAsync("reviews", review);
var data = await response.Content.ReadAsAsync <ReviewDto>();
ShowProgressBarIndicator(100);
if (!string.IsNullOrEmpty(data.Message))
{
MessageBox.Show(data.Message, "Response", MessageBoxButtons.OK, MessageBoxIcon.Information);
HideProgressBarIndicator();
}
}
public ReviewRequestInfoDto AddReviewRequest(ReviewRequestAddDto reviewRequestAddDto)
{
ProjectInfo project = _projectRepository.Get(reviewRequestAddDto.ProjectId);
var projectReviewRequest = _reviewRepository.FindForProject(project);
var lastActiveReview = projectReviewRequest.FirstOrDefault(rr => rr.State == ProjectState.Requested ||
rr.State == ProjectState.Reviewed);
if (lastActiveReview != null)
{
throw new RecademyException(
$"Review for this project already exist. Close it before adding new. Review id: {lastActiveReview.Id}");
}
//TODO: check if project belong to review author
var newRequest = new ReviewRequest
{
DateCreate = DateTime.UtcNow,
State = ProjectState.Requested,
Description = reviewRequestAddDto.Description,
ProjectId = reviewRequestAddDto.ProjectId,
UserId = reviewRequestAddDto.UserId,
};
return(_reviewRepository
.Create(newRequest)
.To(rr => new ReviewRequestInfoDto(rr)));
}
public async Task <IActionResult> PutReviewAsync([FromRoute] Guid id, [FromBody] ReviewRequest review)
{
review.Id = id;
await service.UpdateAsync(mapper.Map <Review>(review));
return(NoContent());
}
public void ValidateRequest(ReviewRequest request)
{
ValidateUserId(request.UserId);
ValidatePoints(request.Points);
ValidateProductId(request.ProductId);
ValidateDescription(request.Description);
ValidateCartItemId(request.CartItemId);
}
public void TestReviewRequestPoints()
{
int POINTS = 5;
ReviewRequest request = new ReviewRequest();
request.Points = POINTS;
Assert.AreEqual(request.Points, POINTS);
}
public void TestReviewRequestUserId()
{
string USER_ID = "admin";
ReviewRequest request = new ReviewRequest();
request.UserId = USER_ID;
Assert.AreEqual(request.UserId, USER_ID);
}
public void TestReviewRequestDescription()
{
string DESCRIPTION = "Excelente";
ReviewRequest request = new ReviewRequest();
request.Description = DESCRIPTION;
Assert.AreEqual(request.Description, DESCRIPTION);
}
public void TestReviewRequestProductId()
{
string PRODUCT_ID = "1";
ReviewRequest request = new ReviewRequest();
request.ProductId = PRODUCT_ID;
Assert.AreEqual(request.ProductId, PRODUCT_ID);
}
public ReviewRequestInfoDto AbandonReview(int requestId)
{
ReviewRequest reviewRequest = _reviewRepository.Get(requestId);
//TODO: check state
return(_reviewRepository
.UpdateState(reviewRequest, ProjectState.Abandoned)
.To(rr => new ReviewRequestInfoDto(rr)));
}
public ReviewRequestInfoDto(ReviewRequest request)
{
Id = request.Id;
ProjectId = request.ProjectId;
DateCreate = request.DateCreate;
State = request.State;
ProjectInfo = request.ProjectInfo.Maybe(p => new ProjectInfoDto(p));
User = request.User.Maybe(u => new UserInfoDto(u));
}
/// <summary>
/// Handles the specified request.
/// </summary>
/// <param name="request">The request.</param>
/// <returns>The mono type.</returns>
protected override IMono <Unit> Handle(ReviewRequest request)
{
var candidate = this.candidateRepository.Find(request.CandidateId);
var employee = this.employeeRepository.Find(request.EmployeeId);
var review = Review.Create(employee, candidate, request.Feedback);
candidate.Subscribe(c => c.AddReview(review));
return(review.Map(_ => Unit.Value));
}
public async Task <IActionResult> PutReview([FromBody] ReviewRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
CultureInfo cultureInfo = new CultureInfo(request.CultureInfo);
Resource.Culture = cultureInfo;
UserEntity userEntity = await _context.Users.FindAsync(request.User);
if (userEntity == null)
{
return(BadRequest(new Response
{
IsSuccess = false,
Message = Resource.UserDoesntExists
}));
}
DocumentEntity documentEntity = await _context.Documents.FindAsync(request.Document);
if (documentEntity == null)
{
return(BadRequest(new Response
{
IsSuccess = false,
Message = Resource.DocumentDoesntexist
}));
}
ReviewEntity reviewEntity = await _context.Reviews
.FirstOrDefaultAsync(p => p.User.Id == userEntity.Id && p.Document.Id == documentEntity.Id);
if (reviewEntity == null)
{
return(BadRequest(Resource.UserDoesntExists));
}
reviewEntity.User = userEntity;
reviewEntity.Document = documentEntity;
reviewEntity.Comment = request.Comment;
reviewEntity.Rating = request.Rating;
reviewEntity.Favorite = request.Favorite;
_context.Update(reviewEntity);
await _context.SaveChangesAsync();
return(Ok(new Response
{
IsSuccess = true,
Message = Resource.TheReviewWasEditedSuccessfully
}));
}
public IActionResult Put([FromBody] ReviewRequest review)
{
if (_reviewService.UpdateReview(AutoMapper.Mapper.Map <Review>(review)))
{
return(NoContent());
}
return(BadRequest());
}
public IActionResult Post([FromBody] ReviewRequest review)
{
if (!_reviewService.AddNewReview(AutoMapper.Mapper.Map <Review>(review)))
{
return(BadRequest());
}
return(Ok());
}
public void AddReviewForRestaurant(ReviewRequest review)
{
using (var context = new CMMIContext())
{
IUnitOfWork unitOfWork = new UnitOfWork(context);
unitOfWork.Reviews.Add(review);
unitOfWork.Save();
}
}
public IActionResult Put(int reviewId, [FromBody] ReviewRequest reviewRequest)
{
var review = AutoMapper.Mapper.Map <Review>(reviewRequest);
review.Id = reviewId;
_reviewService.UpdateReview(review);
return(Ok());
}
internal static Review MapToReview(this ReviewRequest reviewRequest) =>
new Review
{
Id = Guid.NewGuid(),
Name = reviewRequest.Name,
ReviewBody = reviewRequest.ReviewBody,
Rating = UserRating.From(reviewRequest.Rating),
BookId = reviewRequest.BookId
};
public ReviewResponse GetResponse(ReviewRequest reviewRequest, int reviewerId) =>
new ReviewResponse
{
ReviewRequest = reviewRequest,
Description = $"Some Description#{Utilities.Random.Next()}",
ReviewRequestId = reviewRequest.Id,
ReviewerId = reviewerId,
CreationTime = GetRandomDay()
};
public List <Review> AddReview(ReviewRequest request)
{
Review review = new Review();
review.MovieId = request.movieid;
review.Comment = request.comment;
_db.Review.Add(review);
_db.SaveChanges();
return(_db.Review.ToList());
}
//public DataTable reviewInfo(int userId)
//{
// DataTable dt = new DataTable();
// DataSet ds = new DataSet();
// SqlConnection sqlConn = new SqlConnection(ConfigurationManager.ConnectionStrings["AppConnectionString"].ConnectionString);
// SqlDataAdapter sda = new SqlDataAdapter("sp_reviewRead", sqlConn);
// sda.SelectCommand.CommandType = CommandType.StoredProcedure;
// sda.SelectCommand.Parameters.Add("@OwnerId", SqlDbType.Int).Value = userId;
// try
// {
// sda.Fill(ds);
// dt = ds.Tables[0];
// }
// catch (Exception ex)
// {
// }
// finally
// {
// sqlConn.Close();
// sda.Dispose();
// sqlConn.Dispose();
// }
// return dt;
//}
public ReviewRequest reviewInfo(int userId)
{
DataTable dt = new DataTable();
DataSet ds = new DataSet();
SqlConnection sqlConn = new SqlConnection(ConfigurationManager.ConnectionStrings["AppConnectionString"].ConnectionString);
SqlDataAdapter sda = new SqlDataAdapter("sp_reviewRead", sqlConn);
sda.SelectCommand.CommandType = CommandType.StoredProcedure;
sda.SelectCommand.Parameters.Add("@OwnerId", SqlDbType.Int).Value = userId;
//try
//{
sda.Fill(ds);
dt = ds.Tables[0];
//}
//catch (Exception ex)
//{
//}
//finally
//{
sqlConn.Close();
sda.Dispose();
sqlConn.Dispose();
//}
if (dt.Rows.Count != 0)
{
ReviewRequest myReviewRequest = new ReviewRequest(
Convert.ToInt64(dt.Rows[0]["ReviewRequestId"].ToString()),
Convert.ToInt32(dt.Rows[0]["UserId"].ToString()),
Convert.ToInt64(dt.Rows[0]["EventId"].ToString()),
dt.Rows[0]["FirstName"].ToString(),
dt.Rows[0]["LastName"].ToString(),
Convert.ToBoolean(dt.Rows[0]["HasPhoto"].ToString()),
Convert.ToBoolean(dt.Rows[0]["EventOwnerHasPhoto"].ToString()),
Convert.ToInt32(dt.Rows[0]["EventOwnerId"].ToString()),
dt.Rows[0]["EventName"].ToString(),
Convert.ToInt32(dt.Rows[0]["TypeId"].ToString()),
Convert.ToInt32(dt.Rows[0]["CoverId"].ToString()),
true);
return myReviewRequest;
}
else
{
ReviewRequest myReviewRequest = new ReviewRequest(
0,
0,
0,
"",
"",
false,
false,
0,
"",
0,
0,
false);
return myReviewRequest;
}
}
