private void UploadFeedbackNow(FeedbackDTO dto)
{
foreach (var uploader in _uploaders)
{
uploader.UploadFeedback(dto);
}
}
public async Task CallAccountServiceOnce_WhenModelIsValid()
{
var id = 1;
var text = "text";
var author = "pesho";
var isDeleted = false;
var rating = 5;
var businessId = 1;
var feedbackServiceMocked = new Mock <IFeedbackService>();
var userHelperMocked = new Mock <IUserHelper>();
var feedbackDTO = new FeedbackDTO()
{
Id = id,
Text = text,
Author = author,
IsDeleted = isDeleted,
Rate = rating,
BusinessId = businessId
};
var feedbackController = new FeedbackController(feedbackServiceMocked.Object, userHelperMocked.Object);
await feedbackController.EditFeedback(feedbackDTO);
feedbackServiceMocked.Verify(a => a.EditFeedback(id, author, text, rating, isDeleted), Times.Once);
}
public FeedbackDTO GetDetail(string ID)
{
FeedbackDTO item = new FeedbackDTO();
try
{
GetFeedbackRequest paraBody = new GetFeedbackRequest();
paraBody.ID = ID;
paraBody.PageIndex = 1;
paraBody.PageSize = 5000;
NSLog.Logger.Info("Feedbacks Get Detail Request", paraBody);
var result = (NSApiResponse)ApiResponse.Post <NSApiResponse>(Commons.FeedbackAPIGetList, null, paraBody);
NSLog.Logger.Info("Feedbacks Get Detail Response", paraBody);
dynamic data = result.Data;
var lstDataRaw = data["ListFeedback"];
var lstObject = JsonConvert.SerializeObject(lstDataRaw);
item = JsonConvert.DeserializeObject <List <FeedbackDTO> >(lstObject)[0];
NSLog.Logger.Info("FeedbackGetDetail", item);
return(item);
}
catch (Exception e)
{
NSLog.Logger.Error("FeedbackGetDetail_Fail", e);
return(item);
}
}
public async Task ReturnCorrectViewResult()
{
var id = 1;
var text = "text";
var author = "pesho";
var isDeleted = false;
var rating = 5;
var businessId = 1;
var feedbackServiceMocked = new Mock <IFeedbackService>();
var userHelperMocked = new Mock <IUserHelper>();
var feedbackDTO = new FeedbackDTO()
{
Id = id,
Text = text,
Author = author,
IsDeleted = isDeleted,
Rate = rating,
BusinessId = businessId
};
var feedbackController = new FeedbackController(feedbackServiceMocked.Object, userHelperMocked.Object);
var result = await feedbackController.EditFeedback(feedbackDTO);
Assert.IsInstanceOfType(result, typeof(JsonResult));
}
// Get feedbackDto from Web, create feedback object and save to database
public void AddFeedback(FeedbackDTO feedbackDto)
{
Feedback feedback = Mapper.Map <FeedbackDTO, Feedback>(feedbackDto);
_unitOfWork.Feedbacks.Create(feedback);
_unitOfWork.Save();
}
public async Task <JsonResult> Feedback(int id, FeedbackRequestModel model)
{
try
{
FeedbackDTO feedbackDTO = Mapper.Map <FeedbackRequestModel, FeedbackDTO>(model);
if (base.CurrentUser != null)
{
feedbackDTO.UserId = base.CurrentUser.UserId;
}
feedbackDTO.PlaceId = id;
try
{
feedbackDTO.IpAddress = this.Request.HttpContext.Connection
.RemoteIpAddress
.ToString();
}
catch (Exception ex)
{
LoggerExtensions.LogError(_logger, ex, "IP Address error", Array.Empty <object>());
}
return(this.Json((object)(await _feedbackService.AddFeedbackAsync(feedbackDTO))));
}
catch (Exception ex2)
{
return(this.Json((object)Result.Fail("İşleminiz gerçekleştirilemedi", ex2)));
}
}
public async void GetFeedbackById_IfIdExist_ExpectedFeedbackId(int feedbackId, int expected)
{
//Arrange
var profile = new MappedProfile();
var configuration = new MapperConfiguration(x => x.AddProfile(profile));
IMapper mapper = new Mapper(configuration);
var testFeedback = GetFeedbacks();
//mock dataContext
var contextMock = new Mock <DataContext>();
contextMock.Setup(x => x.Feedbacks).ReturnsDbSet(testFeedback);
//mockRepo
var logger = Mock.Of <ILogger <FeedbackRepository> >();
var feedbackRepo = new FeedbackRepository(contextMock.Object, logger);
//Mock actionDescriptor
var action = new List <ActionDescriptor>();
var mockDescriptorProvider = new Mock <IActionDescriptorCollectionProvider>();
mockDescriptorProvider.Setup(x => x.ActionDescriptors).Returns(new ActionDescriptorCollection(action, 0));
//create new controller
var controller = new FeedbackController(feedbackRepo, mapper, mockDescriptorProvider.Object);
//Act
var result = await controller.GetFeedbackByID(feedbackId, false);
var contentResult = result as OkObjectResult;
FeedbackDTO dto = (FeedbackDTO)contentResult.Value;
//Assert
Assert.Equal(feedbackId, expected);
}
public void SendFeedback(FeedbackDTO feedbackDTO)
{
var feedback = MappingDTO.MapFeedback(feedbackDTO);
_dataBase.Feedbacks.Create(feedback);
_dataBase.Save();
}
/// <inheritdoc/>
public async Task SendFeedback(FeedbackDTO feedbackDTO)
{
try
{
var subject = CreateFeedbackBodySubject();
var clientBodyInner = await CreateFeedbackBody(
feedbackDTO,
_emailServiceOptions.FeedbackClientTemplateName,
GetFeedbackClientTextBody(feedbackDTO)
);
var adminBodyInner = await CreateFeedbackBody(
feedbackDTO,
_emailServiceOptions.FeedbackAdminTemplateName,
GetFeedbackAdminTextBody()
);
await Task.WhenAll(
_emailSender.SendEmailAsync(feedbackDTO.Email, subject, clientBodyInner),
_emailSender.SendEmailAsync(_emailServiceOptions.ReplyToMail, subject, adminBodyInner)
);
}
catch (Exception ex)
{
var msg = $"Ошибка при отправке письма обратной формы: {ex.Message}";
_logger.LogError(ex, $"{msg} Модель:\n{JsonHelper.Serialize(feedbackDTO)}");
throw new Exception(msg, ex);
}
}
public bool CreateOrEdit(FeedbackDTO model, ref string msg)
{
try
{
CreateOrEditFeedbackRequest paraBody = new CreateOrEditFeedbackRequest();
paraBody.Feedback = model;
paraBody.CreatedUser = model.CreatedUser;
var result = (NSApiResponse)ApiResponse.Post <NSApiResponse>(Commons.FeedbackAPICreateOrEdit, null, paraBody);
if (result != null)
{
if (result.Success)
{
return(true);
}
else
{
msg = result.Message;
//msg = Commons.ErrorMsg;
NSLog.Logger.Info("Feedback_CreateOrEdit", result.Message);
return(false);
}
}
else
{
NSLog.Logger.Info("Feedback_CreateOrEdit", result);
return(false);
}
}
catch (Exception e)
{
NSLog.Logger.Error("Employee_CreateOrEdit_Fail", e);
return(false);
}
}
public IActionResult Add(FeedbackDTO dto)
{
if (ModelState.IsValid)
{
_feedbackService.Create(dto);
}
return(Ok());
}
public Guid Create(FeedbackDTO entityDTO)
{
Feedback feedback = CreateFeedbackFromDTO(entityDTO);
_feedbackRepository.Create(feedback);
return(feedback.Id);
}
public int Add(FeedbackDTO feedback)
{
using (IDbConnection connection = Connection.GetConnection())
{
string sqlExpression = "Feedback_Add";
return(connection.Query <int>(sqlExpression, feedback).FirstOrDefault());
}
}
public void Update(FeedbackDTO feedback)
{
using (IDbConnection connection = Connection.GetConnection())
{
string sqlExpression = "Feedback_Update";
connection.Query <int>(sqlExpression, feedback);
}
}
public void Delete(FeedbackDTO feedback)
{
using (IDbConnection connection = Connection.GetConnection())
{
string sqlExpression = "Feedback_Delete @ID";
connection.Query <int>(sqlExpression, feedback.ID);
}
}
public CheckOutViewModels()
{
ListProduct = new List <Item>();
//============
InputStore = new InputStoreViewModels();
TermsAndConditions = new TermsAndConditionsViewModels();
CheckOut = new CheckOutView();
Feedback = new FeedbackDTO();
}
public Guid Create(FeedbackDTO entityDTO)
{
Feedback feedback = FeedbackMapper.CreateFeedbackFromDTO(entityDTO);
FeedbackEvent feedbackEvent = new FeedbackEvent(FeedbackEventType.CREATED, feedback.Id);
_feedbackRepository.Create(feedback);
_eventRepository.Create(feedbackEvent);
return(feedback.Id);
}
////тест, найденный по тэгам
//public TestOutputModel SearchTestByTagDTOToTestOutputModel(SearchTestByTagDTO searchTestByTagDTO)
//{
// return new TestOutputModel()
// {
// ID = searchTestByTagDTO.Id,
// Name = searchTestByTagDTO.Name,
// };
//}
//public List<TestOutputModel> SearchTestByTagDTOToTestModelList(List<SearchTestByTagDTO> dtoList)
//{
// List<TestOutputModel> modelList = new List<TestOutputModel>();
// foreach (SearchTestByTagDTO searchtestDTO in dtoList)
// {
// modelList.Add(SearchTestByTagDTOToTestOutputModel(searchtestDTO));
// }
// return modelList;
//}
public FeedbackOutputModel ConvertFeedbackDTOToFeedbackOutputModel(FeedbackDTO feedbackDTO)
{
return(new FeedbackOutputModel()
{
ID = feedbackDTO.ID,
Message = feedbackDTO.Message,
DateTime = feedbackDTO.DateTime,
Processed = feedbackDTO.Processed,
});
}
public async Task <IHttpActionResult> Postfeedback([FromBody] FeedbackDTO model)
{
if (model.UserId == default(int) || string.IsNullOrWhiteSpace(model.Feedbacks))
{
return(BadRequest());
}
var response = await _repository.SaveFeedback(model);
return(Ok(response));
}
public async Task SendFeedback(FeedbackDTO feedbackDTO)
{
var email = _httpContextAccessor.HttpContext.User.FindFirst(ClaimsIdentity.DefaultNameClaimType).Value;
var user = await(await _userRepository.GetAllAsync(t => t.Email.ToUpper().Equals(email.ToUpper())))
.FirstOrDefaultAsync();
var feedback = _mapper.Map <Feedback>(feedbackDTO);
feedback.User = user ?? throw new EntityNotExistException("User does not exist.");
await _feedbackRepository.InsertAsync(feedback);
}
public void Should_not_throw_exception_when_ThrowExceptions_is_true_and_feedback_upload_succeeds()
{
var uri = new Uri($"http://localhost:{_listener.LocalPort}/coderr/");
var feedbackDto = new FeedbackDTO {
Description = "Hello world"
};
var sut = new UploadToCoderr(uri, "api", "secret", () => false, () => true);
sut.UploadFeedback(feedbackDto);
}
public void UploadFeedback(FeedbackDTO feedback)
{
if (_queueReportsAccessor())
{
_feedbackQueue.Enqueue(feedback);
}
else
{
UploadFeedbackNow(feedback);
}
}
public FeedbackDTO GetFeedback(int FeedbackId)
{
FeedbackDTO feedback = null;
Feedback feedbackBoof = DataBase.FeedbackManager.Get(FeedbackId);
if (feedbackBoof != null)
{
feedback = Mapper.Map <Feedback, FeedbackDTO>(feedbackBoof);
}
return(feedback);
}
private void ConfirmBugReport(object sender, RoutedEventArgs e)
{
String type = typeOfFeedback.SelectedValue.ToString();
String desc = feedbackDescription.Text.ToString();
FeedbackDTO newFeedback = new FeedbackDTO(type, desc);
App app = App.Current as App;
app.FeedbackController.Save(newFeedback);
this.Close();
}
public FeedbackDTO GetFeedbackClientById(int id)
{
string query = "ClientsAgregatorDB.GetFeedbacks";
FeedbackDTO feedback = new FeedbackDTO();
using (IDbConnection conn = new SqlConnection(Options.connectionString))
{
feedback = conn.Query <FeedbackDTO>(query, new { id }, commandType: CommandType.StoredProcedure).FirstOrDefault();
}
return(feedback);
}
/// <summary>
/// Upload feedback.
/// </summary>
/// <param name="dto">Feedback provided by the user.</param>
/// <exception cref="ArgumentNullException">dto</exception>
public void Upload(FeedbackDTO dto)
{
if (dto == null)
{
throw new ArgumentNullException("dto");
}
foreach (var uploader in _uploaders)
{
uploader.UploadFeedback(dto);
}
}
//public IEnumerable<FeedbackDTO> GetFeedbackById(int id)
//{
// return from f in _repo.GetFeedbackById()
// where f.BusinessId == id
// select new FeedbackDTO
// {
// Id = f.Id,
// Title = f.Title,
// Message = f.Message,
// TimePosted = f.TimePosted,
// StarRating = f.StarRating,
// isAnonymous = f.isAnonymous,
// Comments = (from c in f.Comments
// select new CommentDTO
// {
// Id = c.Id,
// Message = c.Message,
// TimePosted = c.TimePosted
// }).ToList()
// };
//}
public void Add(FeedbackDTO feedbackDTO, string username, int id)
{
Feedback newfeedback = new Feedback
{
Message = feedbackDTO.Message,
Title = feedbackDTO.Title,
ApplicationUserId = username,
BusinessId = id
};
_repo.Add(newfeedback);
}
private async void updateFeedback(FeedbackDTO dto)
{
HttpResponseMessage response = await client.PutAsJsonAsync(BASE_URL + "Feedbacks/" + dto.id, dto);
try
{
response.EnsureSuccessStatusCode();
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
public void Create(FeedbackDTO feedback)
{
try
{
var addFeedback = Mapper.Map <Feedback>(feedback);
_unitOfWork.Repository <Feedback>().Create(addFeedback);
_unitOfWork.Commit();
}
catch (Exception e)
{
Log.Error(e, "Ошибка возникла при добавлениее нового отзыва.", e);
}
}
public FeedbackDTO GetDetail(string id)
{
try
{
FeedbackDTO model = _factory.GetDetail(id);
return(model);
}
catch (Exception ex)
{
NSLog.Logger.Error("FeedbacksDetail: ", ex);
return(null);
}
}
