public void Create(FeedbackDto feedback) { var newFeedback = new Feedback { Id = Guid.NewGuid(), Description = feedback.Description, IdIntern = feedback.IdIntern, IdMentor = feedback.IdMentor, Rating = feedback.Rating }; _repository.Insert(newFeedback); _repository.Save(); }
public async Task <FeedbackDto> CreateFeedbackAsync(FeedbackDto feedbackDto) { Feedback feedback = feedbackDto.ToEntity(); feedback.Date = DateTime.Now; Feedback created = await _repository.AddFeedbackAsync(feedback); if (created == null) { throw new Exception("Feedback already exists."); } return(new FeedbackDto(created)); }
public void FeedbackPost( [HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = "feedback")] FeedbackDto request, [SendGrid] out SendGridMessage message, ILogger log, ClaimsPrincipal principal ) { message = new SendGridMessage(); message.AddTo(Environment.GetEnvironmentVariable("FeedbackRecipient")); message.AddContent("text/html", request.Message); message.SetFrom(request.Email); message.SetSubject("Feedback for MaintenanceTracker"); log.LogInformation($"Sending feedback message from anonymous user"); }
public static Feedback FeedbackDtoToFeedback(FeedbackDto feedbackDto) { Feedback feedback = new Feedback { Id = feedbackDto.Id, PatientId = feedbackDto.PatientId, Text = feedbackDto.Text, Date = feedbackDto.Date, IsDeleted = feedbackDto.IsDeleted, IsVisible = feedbackDto.IsVisible }; return(feedback); }
public static FeedbackDto FeedbackToFeedbackDto(Feedback feedback) { FeedbackDto feedbackDto = new FeedbackDto { Id = feedback.Id, PatientId = feedback.PatientId, Text = feedback.Text, Date = feedback.Date, IsDeleted = feedback.IsDeleted, IsVisible = feedback.IsVisible }; return(feedbackDto); }
public void Start() { const string queryString = "SELECT [ID],[Name],[Description] FROM [dbo].[Feedbacks] ORDER BY [ID] ASC"; const string countString = "SELECT COUNT([ID]) AS COUNT FROM [dbo].[Feedbacks]"; const string connectionString = "Server=.;Database=TransactionManagement;User Id=stocktrading;Password=stocktrading;"; //Load from db using (var connection = new SqlConnection(connectionString)) { connection.Open(); using (var command = new SqlCommand(countString, connection)) { var count = (int)command.ExecuteScalar(); LoggingService.Info($" ({count})"); } using (var command = new SqlCommand(queryString, connection)) { using (var reader = command.ExecuteReader()) { while (reader.Read()) { var item = new FeedbackDto(); item.OldId = int.Parse(reader["ID"].ToString()); item.Name = reader["Name"].ToString(); item.Description = reader["Description"].ToString(); Items.Add(item.OldId, item); } } } } //Import foreach (var item in Items) { var cmd = new FeedbackAddCommand( item.Value.Id, -1, item.Value.Name, item.Value.Description); CommandDispatcher.Execute(cmd); LoggingService.Info($"Feedback {item.Value.Name} ({item.Value.OldId})"); } }
public void Create_ValidRequest_ShouldAddFeedback() { var feedback = new FeedbackDto { Rate = 8, PageUrl = _pageUrl, IsMainPage = _isMainPage, QuestionId = 1 }; var result = _repoitory.Create(_customerId, feedback); result.Should().Be(true); _mockFeedbacks.Should().HaveCount(1); }
[HttpPost] // POST /api/feedback Request body: {"message": "Some message", "isPublic": true, "isAnonymous": false} public IActionResult Create(FeedbackDto dto) { // validation in feedback validator, automatically called from startup Feedback feedback = FeedbackService.Create(dto); if (feedback == null) { return(BadRequest()); } else { return(Ok()); } }
public FeedbackDto Add(FeedbackDto feedbackDto) { if (feedbackDto == null) { return(null); } Patient myPatient = _dbContext.Patients.SingleOrDefault(patient => patient.Id == feedbackDto.PatientId); RemovePreviousFeedback(feedbackDto, myPatient); _dbContext.Feedbacks.Add(FeedbackAdapter.FeedbackDtoToFeedback(feedbackDto)); _dbContext.SaveChanges(); return(feedbackDto); }
public void Analyze(List <JavaTestClass> referenceTests, List <JavaTestClass> studentTests, out FeedbackDto feedbackDto) { feedbackDto = new FeedbackDto(); foreach (var referenceTest in referenceTests) { foreach (var referenceMethod in referenceTest.Methods) { if (referenceMethod.LearningConcepts != null) { var instructorTestDto = GetInstructorTestDto(referenceMethod, studentTests); feedbackDto.InstructorTests.Add(instructorTestDto); } } } }
public async Task <ActionResult <Feedback> > PostFeedback(FeedbackDto entry) { var profile = await GetLoggedInProfile(); var feedback = _mapper.Map <Feedback>(entry); feedback.CreatedDate = DateTime.Now; feedback.ProfileId = profile.Id; _context.Feedback.Add(feedback); await _context.SaveChangesAsync(); feedback.Profile = profile; await SendEmail(feedback); return(CreatedAtAction("PostFeedback", new { id = entry.Id }, entry)); }
public async Task SendFeedbackNotificationAsync(NotificationDto notification) { _logger.LogInformation($"Sending feedback notification..."); EmailMessage emailMessage = await _transactionalMailHelper.PrepareFeedbackMail(notification); await _messageQueue.SendMessageAsync(emailMessage); // Send feedback to slack as well var feedback = new FeedbackDto() { Content = notification.Content }; await _messageQueue.SendMessageAsync(feedback, "feedback", queueName : _pubSlackAppQueueName); return; }
/// <summary> /// Routes to a dynamically generated "Feedback Show" Page. Gathers information from the database. /// </summary> /// <param name="id">Id of the Feedback</param> /// <returns>A dynamic "Feedback Show" webpage which provides detailes for a selected blog.</returns> /// <example>GET : /Feedback/Show/5</example> public ActionResult Show(int id) { ShowFeedbackViewModel ViewModel = new ShowFeedbackViewModel(); string url = "feedbackapi/findfeedback/" + id; HttpResponseMessage response = client.GetAsync(url).Result; if (response.IsSuccessStatusCode) { FeedbackDto SelectedFeedback = response.Content.ReadAsAsync <FeedbackDto>().Result; ViewModel.Feedback = SelectedFeedback; return(View(ViewModel)); } else { return(RedirectToAction("Error")); } }
public async Task <ResultDto> AddNewFeedback(FeedbackDto feedbackDto, string userId) { var feedback = new Feedback { User = _context.Users.Where(u => u.UUID == userId).FirstOrDefault(), FeedbackBody = feedbackDto.FeedbackBody, CreatedAt = DateTime.Now, UpdatedAt = DateTime.Now, UUID = Guid.NewGuid().ToString(), Anonymous = feedbackDto.UserId.Length == 0 }; _context.Add(feedback); await _context.SaveChangesAsync(); return(new ResultDto(true, "Feedback added succesfully")); }
public async Task <IHttpActionResult> Feedback(int id, [FromBody] FeedbackDto dto) { var report = await _failureRepo.GetByIdAsync(id); if (report == null) { return(NotFound()); } var user = await User.GetEntityAsync(_identityRepo); var feedback = Mapper.Map <FeedbackDto, Feedback>(dto); report.SetFeedBack(user, feedback); await _failureRepo.SaveAsync(report); return(StatusCode(HttpStatusCode.Accepted)); }
public async Task <ActionResult <FeedbackDto> > CreateFeedback([FromBody] FeedbackDto feedbackDto) { if (feedbackDto == null) { return(BadRequest("Feedback data must be set!")); } try { FeedbackDto created = await _service.CreateFeedbackAsync(feedbackDto); return(Ok(created)); } catch (Exception e) { return(Conflict(e.Message)); } }
public Feedback Add(FeedbackDto feedbackDto) { var feedback = new Feedback { Id = Guid.NewGuid(), Body = feedbackDto.Body, StudentId = feedbackDto.StudentId, ProfessorId = feedbackDto.ProfessorId }; _repository.Insert(feedback); _repository.Save(); CreateNotification(feedback); return(feedback); }
public async Task <ActionResult <Feedback> > PostFeedback([FromBody] FeedbackDto feedbackDto) { var userId = User.FindFirst(ClaimTypes.NameIdentifier)?.Value; var user = await _userManager.FindByIdAsync(userId); var feedback = new Feedback { Content = feedbackDto.Content, PostDateTime = DateTime.Now, RemoteIp = HttpContext.Connection.RemoteIpAddress.ToString(), Username = user.UserName }; _context.Feedbacks.Add(feedback); await _context.SaveChangesAsync(); return(Ok(feedback)); }
public ActionResult Update(int id, FeedbackDto FeedbackInfo) { GetApplicationCookie(); string url = "feedbackapi/updatefeedback/" + id; HttpContent content = new StringContent(jss.Serialize(FeedbackInfo)); content.Headers.ContentType = new MediaTypeHeaderValue("application/json"); HttpResponseMessage response = client.PostAsync(url, content).Result; if (response.IsSuccessStatusCode) { return(RedirectToAction("Show", new { id })); } else { return(RedirectToAction("Error")); } }
public int AddFeedback(FeedbackDto feedback) { SqlParameter[] parameters = { new SqlParameter("@actualClassId", feedback.ActualClass.Id), new SqlParameter("@usefulness", feedback.Usefulness), new SqlParameter("@novelty", feedback.Novelty), new SqlParameter("@highScientificLevel", feedback.HighScientificLevel), new SqlParameter("@rigorousScientificLevel", feedback.RigorousScientificLevel), new SqlParameter("@attractivenes", feedback.Attractiveness), new SqlParameter("@clearness", feedback.Clearness), new SqlParameter("@correctness", feedback.Correctness), new SqlParameter("@interactivity", feedback.Interactivity), new SqlParameter("@comprehension", feedback.Comprehension), new SqlParameter("@comment", feedback.Comment) }; return(DatabaseProvider.ExecuteCommand <int>(DatabaseProvider.GetSqlConnection(), ADD, CommandType.StoredProcedure, parameters)); }
public async Task <ResultDto> UpdateFeedback(FeedbackDto feedbackDto, string userId) { var originalFeedback = await _context.Feedbacks .Where(f => f.UUID == feedbackDto.UUID && f.User.UUID == userId && f.Anonymous != true) .Include(f => f.User) .FirstOrDefaultAsync(); if (originalFeedback == null) { return(new ResultDto(false, "Feedback not found")); } originalFeedback.UpdatedAt = DateTime.Now; originalFeedback.FeedbackBody = feedbackDto.FeedbackBody; _context.Entry(originalFeedback).State = EntityState.Modified; await _context.SaveChangesAsync(); return(new ResultDto(true, "Feedback updated succesfully")); }
public List <FeedbackDto> GetByProfId(Guid profId) { var feedback = _repository.GetAllByFilter <Feedback>(x => x.ProfessorId == profId); var feedbackDtos = new List <FeedbackDto>(); foreach (var value in feedback) { var feedbackDto = new FeedbackDto { Body = value.Body, StudentId = value.StudentId, ProfessorId = value.ProfessorId }; feedbackDtos.Add(feedbackDto); } return(feedbackDtos); }
public OutMsg UpdateFeedbackDetail(int id, FeedbackDto feedbackDto) { if (feedbackDto == null) { throw new ArgumentNullException(); } var message = new OutMsg { Status = false, Msg = "修改信息失败" }; var currentFeedback = _feedbackRepository.Get(id); var updateFeedback = QsMapper.CreateMap <FeedbackDto, Feedback>(feedbackDto); _feedbackRepository.Merge(currentFeedback, updateFeedback); _feedbackRepository.UnitOfWork.Commit(); message.Msg = "成功修改信息"; message.Status = true; return(message); }
public void Update(FeedbackDto feedback) { Feedback feedbackToUpdate = _repository.GetByFilter <Feedback>(p => p.IdIntern == feedback.IdIntern && p.IdMentor == feedback.IdMentor); if (feedbackToUpdate == null) { return; } if (feedback.Description != null) { feedbackToUpdate.Description = feedback.Description; } if (feedback.Rating != null) { feedbackToUpdate.Rating = feedback.Rating; } _repository.Update(feedbackToUpdate); _repository.Save(); }
public async Task <IActionResult> SendFeedback([FromBody] FeedbackDto feedback) { ResponseDto <NotificationDto> okResponse = new ResponseDto <NotificationDto>(true); ResponseDto <ErrorDto> errorResponse = new ResponseDto <ErrorDto>(false); NotificationDto notification = new NotificationDto(feedback.Content); try { await _notifier.SendFeedbackNotificationAsync(notification); okResponse.Data = notification; } catch (Exception e) { errorResponse.Data = new ErrorDto(e.Message); return(BadRequest(errorResponse)); } return(Ok(okResponse)); }
public async Task <IActionResult> Create([FromBody] FeedbackDto feedbackDto) { var feedback = Mapper.Map <Feedback>(feedbackDto); var candidateEmail = this.User.Identities.First().Name; var candidate = await _candidateRepository.GetSingleAsync(c => c.Email == candidateEmail); if (feedback.TestId == 0) { var test = await _testRepository.GetSingleAsync(t => t.Candidate.Email == candidateEmail); feedback.TestId = test != null ? test.Id : 0; } feedback.CandidateId = candidate.Id; _feedbackRepository.Add(feedback); _feedbackRepository.Commit(); return(Created(string.Empty, feedback)); }
public IList <FeedbackDto> GetAllFeedbacksForActualClass(int classId) { IList <FeedbackDto> feedbacks = new List <FeedbackDto>(); using (SqlConnection connection = DatabaseProvider.GetSqlConnection()) { SqlParameter[] parameters = { new SqlParameter("@actualClassId", classId) }; using (IDataReader reader = DatabaseProvider.ExecuteCommand <IDataReader>(connection, GETFEEDBACKS, CommandType.StoredProcedure, parameters)) { while (reader.Read()) { FeedbackDto fb = DtoHelper.GetDto <FeedbackDto>(reader); feedbacks.Add(fb); } } } return(feedbacks); }
public async Task <IActionResult> SubmitFeedback([FromForm] FeedbackDto feedbackDto) { if (!ModelState.IsValid) { return(View("Index")); } if (feedbackDto.Anonymous) { feedbackDto.Name = null; feedbackDto.Email = null; } var feedback = new Feedback(feedbackDto); _context.Add(feedback); await _context.SaveChangesAsync(); var hooks = await _context.Webhooks.Where(w => w.FeedbackType == feedback.Type).ToListAsync(); using (var client = new HttpClient()) { foreach (var hook in hooks) { var data = new StringContent(JsonConvert.SerializeObject(feedback), Encoding.UTF8, "application/json"); try { _logger.LogInformation( $"Notifying '{hook.CallbackUrl}' with type = {feedback.Type}," + $"anonymous = {feedback.Anonymous}, " + $"name = {feedback.Name}, email = {feedback.Email}"); var result = await client.PostAsync(hook.CallbackUrl, data); _logger.LogInformation($"Notification result: {result.StatusCode}"); } catch (HttpRequestException e) { _logger.LogError($"Failed to notify {hook.CallbackUrl}:\n{e.Message}"); } } } return(RedirectToAction("Index", "Feedback")); }
public async Task <IActionResult> PostFeedBack(FeedbackDto model) { if (!ModelState.IsValid) { return(BadRequest()); } try { var feedback = new Feedback() { Comment = model.Comment, UserId = model.UserId, SpotId = model.SpotId }; return(Ok(_feedBackBusiness.PostFeedBack(feedback))); } catch (Exception ex) { return(BadRequest(ex.Message)); // return BadRequest(ex.Message); } }
public IHttpActionResult FindFeedback(int id) { FeedbackModel Feedback = db.Feedback.Find(id); if (Feedback == null) { return(NotFound()); } FeedbackDto FeedbackDto = new FeedbackDto { feedback_id = Feedback.feedback_id, date = Feedback.date, fname = Feedback.fname, lname = Feedback.lname, email = Feedback.email, title = Feedback.title, text = Feedback.text }; return(Ok(FeedbackDto)); }