public Feedback AddFeedback(Feedback feedback)
{
var feedbackAdded = _repo.Add(feedback);
_eventService.AddEvent(new FeedbackEvent(Guid.NewGuid().ToString(), feedbackAdded.Id, feedback.Text, DateTime.Now));
return(feedbackAdded);
}
public async Task <HttpResponseMessage> AddFeedback(Models.Models.Domain.Feedback feedback)
{
await _feedbackRepository.Add(feedback);
var response = Request.CreateResponse <Models.Models.Domain.Feedback>(System.Net.HttpStatusCode.Created, feedback);
return(response);
}
public async Task <bool> Add(Feedback feedback)
{
if (!ExecuteValidation(new FeebackValidation(), feedback))
{
return(false);
}
await _feedbackRepository.Add(feedback);
return(true);
}
public IActionResult Index(FeedbackAddRequest feedbackRequest)
{
if (ModelState.IsValid)
{
feedbackRepository.Add(mapper.Map <Feedback>(feedbackRequest));
feedbackRepository.Save();
return(RedirectToAction("FeedbackComplete"));
}
return(View(mapper.Map <FeedbackViewModel>(feedbackRequest)));
}
public ActionResult Create([Bind("CustomerName,CustomerEmail, CustomerPhone,Rating,Comment, Ip, Country, City, Region")] Feedback feedbackData)
{
if (ModelState.IsValid)
{
_feedbackRepository.Add(feedbackData);
_feedbackRepository.Commit();
TempData["message"] = "Feedback was created successfully";
}
return(RedirectToAction("index"));
}
public void Add(AddFeedbackDTO feedback)
{
FeedbackMemento memento = new FeedbackMemento()
{
Comment = feedback.Comment,
IsAllowedToPublish = feedback.IsAllowedToPublish,
IsPublished = false,
DateOfCreation = DateTime.Now,
Commentator = GetCommentator(feedback.IsAnonymous, feedback.CommentatorJmbg)
};
_feedbackRepository.Add(new Feedback(memento));
}
/// <summary>
/// Creates feedback.
/// </summary>
/// <param name="feedbackToCreate">Feedback to create.</param>
public void Create(Feedback feedbackToCreate)
{
if (feedbackToCreate == null)
{
throw new ArgumentNullException("feedback");
}
UpdateFeedbackDate(feedbackToCreate);
_feedbackRepository.Add(feedbackToCreate);
_feedbackRepository.UnitOfWork.Commit();
NotifyUser(feedbackToCreate.UsersEmail);
NotifyAdmins(feedbackToCreate);
}
public void Add_Success()
{
var sample = _repo.Add(new Random().Next(), new Guid(), DateTime.UtcNow, Lorem.Sentence(), new List <Guid>());
var result = _repo.GetById(sample.Id);
Assert.IsNotNull(result);
//tidy up
_repo.DeleteById(sample.Id);
}
public virtual IActionResult Index(Feedback model)
{
try
{
if (ModelState.IsValid)
{
_feedbackRepository.Add(model);
return(RedirectToAction("FeedbackComplete"));
}
return(View(model));
}
catch (System.Exception)
{
return(BadRequest());
}
}
public async Task <bool> Handle(CreateFeedbackCommand request, CancellationToken cancellationToken)
{
var myId = Guid.Parse(_httpContextAccessor.HttpContext.User.FindFirst(ClaimTypes.NameIdentifier).Value);
var feedback = new Feedback(request.Text, request.Image1, request.Image2, request.Image3, myId);
_feedbackRepository.Add(feedback);
if (await _feedbackRepository.UnitOfWork.SaveEntitiesAsync(cancellationToken))
{
await SendUserFeedbackCreatedEventAsync(myId);
return(true);
}
throw new ApplicationException("操作失败");
}
public async Task <IActionResult> PostFeedback(FeedbackDTO dto)
{
try
{
var entity = mapper.Map <Feedback>(dto);
repo.Add(entity);
if (await repo.Save())
{
return(Created($"/api/v1.0/feedback/{dto.FeedbackID}", mapper.Map <FeedbackDTO>(entity)));
}
return(BadRequest());
}
catch (Exception e)
{
return(StatusCode(StatusCodes.Status500InternalServerError, $"Database failure {e.Message}"));
}
}
public async Task <ActionResult <FeedbackModel> > PostFeedback(AddFeedbackRequest addFeedbackPost)
{
if (addFeedbackPost?.Description == null || addFeedbackPost.DueDate == default)
{
return(BadRequest());
}
var feedback = FeedbackMapper.MapToDomainFromAddRequest(addFeedbackPost);
//if (feedback.Data.DueDate < feedback.Data.DateAdded) return BadRequest();
var result = await _repository.Add(feedback);
if (result.Data == null)
{
return(Conflict());
}
return(CreatedAtAction("GetFeedback", new { id = result.Data.Id }, FeedbackMapper.MapToModel(result)));
}
public async Task <IActionResult> Add(Feedback feedback)
{
string jsonResponse;
try
{
await feedbackRepo.Add(feedback);
jsonResponse = JsonConvert.SerializeObject(feedback);
}
catch (Exception ex)
{
Dictionary <string, string> dict = new Dictionary <string, string>
{
{ "Error", ex.Message }
};
jsonResponse = JsonConvert.SerializeObject(dict);
}
return(Content(jsonResponse, "application/json"));
}
public IActionResult VerstuurFeedback(int id, string feedback)
{
if (feedback.Length > 1000)
{
TempData["error"] = "De feedback mag niet langer zijn dan 1000 tekens.";
return(RedirectToAction(nameof(VerstuurFeedback)));
}
else
{
Feedback fb = new Feedback()
{
SessieId = id,
Tekst = feedback
};
_feedbackRepository.Add(fb);
_feedbackRepository.SaveChanges();
TempData["message"] = "Je feedback werd succesvol toegevoegd.";
return(RedirectToAction(nameof(GebruikerIndex)));
}
}
public IActionResult GeefFeedback(int id, FeedbackViewModel viewmodel)
{
if (ModelState.IsValid)
{
try
{
Gebruiker gebruiker = _gebruikerRepository.GetByGebruikersnaam(User.Identity.Name);
Sessie sessie = _sessieRepository.GetById(id);
Feedback feedback = new Feedback(sessie, gebruiker, viewmodel.Tekst, DateTime.Now);
sessie.AddFeedback(feedback);
_feedbackRepository.Add(feedback);
_feedbackRepository.SaveChanges();
_sessieRepository.SaveChanges();
TempData["message"] = $"Uw feedback werd toegevoegd aan de sessie";
}
catch
{
TempData["error"] = $"Er is iets misgelopen, er is geen feedback toegevoegd.";
}
return(RedirectToAction(nameof(ToonFeedback), new { id }));
}
return(View(viewmodel));
}
public IActionResult Vote([FromBody] VoteViewModel model)
{
try
{
if (_feedbackRepository.GetSingle(f => f.UserId == model.UserId && f.PhotoId == model.PhotoId) != null)
{
throw new InvalidOperationException("You have been already voted");
}
var newFeedback = new UserFeedback(model.UserId, model.PhotoId, model.Vote);
_feedbackRepository.Add(newFeedback);
_feedbackRepository.Commit();
var allRelatedFeedBacks = _feedbackRepository.FindBy(f => f.PhotoId == model.PhotoId).ToList();
var photo = _photoRepository.GetSingle(model.PhotoId);
var newRating = (float)(allRelatedFeedBacks.Sum(x => x.Mark) / allRelatedFeedBacks.Count);
photo.Rating = newRating;
_photoRepository.Edit(photo);
_photoRepository.Commit();
return(new ObjectResult(new GenericResult()
{
Succeeded = true,
Message = "Your vote has been counted"
}));
} catch (Exception e)
{
return(new ObjectResult(new GenericResult()
{
Succeeded = false,
Message = e.Message
}));
}
}
public Feedback Create(Feedback feedback)
{
return(_feedbackRepository.Add(feedback));
}
public void Add(FeedbackViewModel feedbackVm)
{
var page = _mapper.Map <FeedbackViewModel, Feedback>(feedbackVm);
_feedbackRepository.Add(page);
}
public Task AddAsync(CreateFeedbackRequest request)
{
_repository.Add(new Feedback(request.FirstName, request.LastName, request.Email, request.Text));
return(_repository.SaveChangesAsync());
}
public void Create(Feedback feedback)
{
_feedbackRepository.Add(feedback);
}
public Feedback Create(Feedback feedback)
{
feedback.Status = true;
return(_feedbackRepository.Add(feedback));
}
public Feedback Add(Feedback entity)
{
return(_feedback.Add(entity));
}
public async Task Add(FeedbackViewModel feedbackVm)
{
var page = new FeedbackViewModel().Map(feedbackVm);
await _feedbackRepository.Add(page);
}
public void AddFeedback(FeedbackViewModel feedbackViewModel)
{
var feedback = Mapper.Map <FeedbackViewModel, Feedback>(feedbackViewModel);
_feedbackRepository.Add(feedback);
}
public void Add(Feedback feedback)
{
feedback.DateCreated = DateTime.UtcNow;
_feedback.Add(feedback);
}
public void CreateFeedback(Feedback Feedback)
{
feedbackRepository.Add(Feedback);
}
public void Add(Feedback feedback)
{
repository.Add(feedback);
}
public Feedback Add(Feedback feedBack)
{
return(_feedbackRepository.Add(feedBack));
}
public void CreateFeedback(Feedback feedback)
{
feedbacksRepository.Add(feedback);
}
// POST: api/Feedback
public void Post([FromBody] Feedback value)
{
_repository.Add(value);
}
