public IEnumerable <Feedback> GetByAllParams(bool publish, bool anonymous, bool approved)
{
using (MQuinceDbContext _context = new MQuinceDbContext(_dbContext))
{
return(FeedbackMapper.MapFeedbackPersistenceCollectionToFeedbackEntityCollection(_context.Feedbacks.Where(p => p.Publish == publish && p.Anonymous == anonymous && p.Approved == approved).ToList()));
}
}
[HttpGet] // GET /api/feedback
public IActionResult Get()
{
List <Domain.Entities.Feedback> approvedFeedback = _feedbackService.GetAllApprovedFeedback().ToList();
List <ApprovedFeedbackDTO> approvedFeedbackDTOs = FeedbackMapper.ListApprovedFeedbackToListApprovedFeedbackDTO(approvedFeedback);
return(Ok(approvedFeedbackDTOs));
}
public void EditFeedback(FeedbackViewModel feedback)
{
Feedback feedbacks = _feedbackRepository.GetById(feedback.Id);
if (feedbacks == null)
{
throw new Exception($"Feedback with id {feedback.Id} was not found");
}
List <Feedback> feedbackss = _feedbackRepository.GetAll().Where(x => x.Email == (FeedbackMapper.ToFeedback(feedback)).Email).ToList();
if (feedbackss.Count == 3)
{
throw new Exception("Can't post anymore feedbacks you have already posted three");
}
Regex regex = new Regex(@"^([\w\.\-]+)@([\w\-]+)((\.(\w){2,3})+)$");
Match match = regex.Match(feedback.Email);
if (!match.Success)
{
throw new Exception("Email is not in correct format");
}
Feedback editFeedback = FeedbackMapper.ToFeedback(feedback);
editFeedback.Id = feedback.Id;
_feedbackRepository.Update(editFeedback);
}
public IEnumerable <Feedback> GetAll()
{
using (MQuinceDbContext _context = new MQuinceDbContext(_dbContext))
{
return(FeedbackMapper.MapFeedbackPersistenceCollectionToFeedbackEntityCollection(_context.Feedbacks.ToList()));
}
}
public Feedback GetById(Guid id)
{
using (MQuinceDbContext _context = new MQuinceDbContext(_dbContext))
{
return(FeedbackMapper.MapFeedbackPersistenceToFeedbackEntity(_context.Feedbacks.SingleOrDefault(c => c.Id.Equals(id))));
}
}
public void Update(Feedback entity)
{
using (MQuinceDbContext _context = new MQuinceDbContext(_dbContext))
{
_context.Update(FeedbackMapper.MapFeedbackEntityToFeedbackPersistence(entity));
_context.SaveChanges();
}
}
public void Create(Feedback entity)
{
using (FeedbackDbContext _context = new FeedbackDbContext())
{
_context.Feedbacks.Add(FeedbackMapper.MapFeedbackEntityToFeedbackPersistence(entity));
_context.SaveChanges(); //ako ne sacuvamo nece se update-ovati baza
}
}
public IActionResult GetAllFeedback()
{
/*List<Feedback> allFeedback = feedbackService.GetAll().ToList();
* List<AllFeedbackDTO> allFeedbackDTOs = FeedbackAdapter.ListAllFeedbackToListAllFeedbackDTO(allFeedback);*/
List <Domain.Entities.Feedback> allFeedback = _feedbackService.GetAll().ToList();
List <AllFeedbackDTO> allFeedbackDTOs = FeedbackMapper.ListAllFeedbackToListAllFeedbackDTO(allFeedback);
return(Ok(allFeedbackDTOs));
}
public void Update(Feedback entity)
{
using (FeedbackDbContext _context = new FeedbackDbContext())
{
//Entity Framework ce po id-ju naci feedback i azurirati ga
_context.Update(FeedbackMapper.MapFeedbackEntityToFeedbackPersistence(entity));
_context.SaveChanges(); //moramo sacuvati promene
}
}
public Feedback GetById(Guid id)
{
using (FeedbackDbContext _context = new FeedbackDbContext())
{
//pomocu lambda izraza se izvuce korisnik sa Id-jem koji je isti kao prosledjeni
//isti rezultat ima i foreach gde se unutar nekog if-a porede id-jevi
return(FeedbackMapper.MapFeedbackPersistenceToFeedbackEntity(_context.Feedbacks.SingleOrDefault(c => c.Id.Equals(id))));
}
}
public void AddFeedbacks()
{
for (var i = 0; i < Count; i++)
{
var inputData = new AddFeedbackRequest {
Description = Fixture.Create <string>(), DueDate = Fixture.Create <DateTime>()
};
var l = Repository.Add(FeedbackMapper.MapToDomainFromAddRequest(inputData)).GetAwaiter().GetResult();
}
}
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 void MapToView_should_map_domain_to_view()
{
var data = Fixture.Create <FeedbackData>();
// Act
var view = FeedbackMapper.MapToModel(new Feedback(data));
// Assert
AssertArePropertyValuesEqual(view, data);
}
public async Task <ActionResult <FeedbackModel> > GetFeedback(int id)
{
var feedback = await _repository.Get(id);
if (feedback.Data == null)
{
return(NotFound());
}
return(Ok(FeedbackMapper.MapToModel(feedback)));
}
public ActuationTransport(bool listen)
{
// determine if the wheelspeeds should be used as the speed values
useWheelspeed = Settings.UseWheelSpeed;
if (listen)
{
// create the feedback mapper
using (Stream configStream = typeof(ActuationTransport).Assembly.GetManifestResourceStream(typeof(ActuationTransport), "FeedbackMapping.xml")) {
mapper = new FeedbackMapper(configStream, typeof(ActuationTransport), null);
}
}
}
public void MapToDomainFromInput_should_map_domain_from_input()
{
var inputData = new AddFeedbackRequest()
{
Description = Fixture.Create <string>(),
DueDate = Fixture.Create <DateTime>(),
};
// Act
var domain = FeedbackMapper.MapToDomainFromAddRequest(inputData);
// Assert
AssertArePropertyValuesEqual(inputData, domain.Data);
}
public void PopulateDatabase(int count)
{
for (int i = 0; i < count; i++)
{
var feedbackInput = new AddFeedbackRequest
{
Description = Fixture.Create <string>(),
DueDate = Fixture.Create <DateTime>()
};
var entityToBeAdded = FeedbackMapper.MapToDomainFromAddRequest(feedbackInput);
Sut.Add(entityToBeAdded).GetAwaiter().GetResult();
}
}
public void MapToDomain_should_map_view_to_domain()
{
var view = new FeedbackModel {
IsOverdue = false, IsCompleted = Fixture.Create <bool>(),
DateAdded = Fixture.Create <DateTime>(), Description = Fixture.Create <string>(), DueDate = Fixture.Create <DateTime>()
};
// Act
var data = FeedbackMapper.MapToDomain(view).Data;
view.IsOverdue = data.IsOverdue;
// Assert
AssertArePropertyValuesEqual(view, data);
}
public async Task <IActionResult> PutFeedback(int id, UpdateFeedbackRequest updateFeedbackRequest)
{
if (updateFeedbackRequest.Description == null || updateFeedbackRequest.DueDate == default)
{
return(BadRequest());
}
var feedbackToUpdate = await _repository.Get(id);
if (feedbackToUpdate.Data == null)
{
return(BadRequest());
}
await _repository.Update(FeedbackMapper.MapToDomainFromUpdateRequest(feedbackToUpdate, updateFeedbackRequest));
return(Ok());
}
public void MapToDomainFromUpdate_should_map_domain_from_input()
{
var updateData = new UpdateFeedbackRequest()
{
IsCompleted = false,
Description = Fixture.Create <string>(),
DueDate = Fixture.Create <DateTime>()
};
var domain = new Feedback();
domain.Data = Fixture.Create <FeedbackData>();
// Act
domain = FeedbackMapper.MapToDomainFromUpdateRequest(domain, updateData);
// Assert
AssertArePropertyValuesEqual(updateData, domain.Data);
}
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 void Add_should_store_a_feedback_in_database()
{
var feedbackInput = new AddFeedbackRequest
{
Description = Fixture.Create <string>(),
DueDate = Fixture.Create <DateTime>(),
};
var entityToBeAdded = FeedbackMapper.MapToDomainFromAddRequest(feedbackInput);
// Act
var initialDatabaseFeedback = Sut.Get(entityToBeAdded.Data.Id).GetAwaiter().GetResult();
var addedFeedback = Sut.Add(entityToBeAdded).GetAwaiter().GetResult();
// Assert
Assert.IsNull(initialDatabaseFeedback.Data);
AssertArePropertyValuesEqual(addedFeedback.Data, entityToBeAdded.Data);
EntityData = addedFeedback.Data;
}
public void Save_RawRecord_Saves()
{
FeedbackMapper feedbackMapper = new FeedbackMapper(this.client, this.database);
Guid applicationId = Guid.NewGuid();
Guid deviceId = Guid.NewGuid();
Feedback feedback = new Feedback()
{
ApplicationId = applicationId,
DeviceId = deviceId,
Message = "feedback",
Rating = FeedbackRatingType.Five,
ScreenName = "screenName",
SessionId = Guid.NewGuid(),
DateCreatedOnDevice = DateTime.Now,
Version = "1.1"
};
feedbackMapper.Save(feedback);
}
public void Update_should_update_existing_database_item()
{
PopulateDatabase(20);
var newFeedbackUpdate = new UpdateFeedbackRequest
{
IsCompleted = true,
Description = Fixture.Create <string>(),
DueDate = Fixture.Create <DateTime>()
};
// Act
var initialFeedbackData = Sut.Get().GetAwaiter().GetResult()[0];
var feedbackToUpdate = FeedbackMapper.MapToDomainFromUpdateRequest(initialFeedbackData, newFeedbackUpdate);
Sut.Update(feedbackToUpdate).GetAwaiter().GetResult();
// Assert
var initialFeedbackDataCopy2 = Sut.Get(initialFeedbackData.Data.Id).GetAwaiter().GetResult();
AssertArePropertyValuesEqual(initialFeedbackDataCopy2.Data, feedbackToUpdate.Data);
}
public IEnumerable <IdentifiableDTO <FeedbackDTO> > GetByParams(bool anonymous, bool approved) => _feedbackRepository.GetByParams(anonymous, approved).Select(c => FeedbackMapper.CreateDTOFromFeedback(c));
public IEnumerable <IdentifiableDTO <FeedbackDTO> > GetAll() => _feedbackRepository.GetAll().Select(c => FeedbackMapper.CreateDTOFromFeedback(c));
public void SetUp()
{
_targetFeedbackDatabase = new TestFeedbackDatabase();
_uut = new FeedbackMapper(TestFeedbackDatabase, _targetFeedbackDatabase, new NullLogger());
}
public IdentifiableDTO <FeedbackDTO> GetById(Guid id) => FeedbackMapper.CreateDTOFromFeedback(_feedbackRepository.GetById(id));
public void Save_SummaryRecord_MatchesSummary()
{
FeedbackMapper feedbackMapper = new FeedbackMapper(this.client, this.database);
Guid applicationId = Guid.NewGuid();
string screenName = "screenName";
FeedbackSummary expected = new FeedbackSummary()
{
ApplicationId = applicationId,
Count = 2,
Date = date,
PlatformId = platform,
Ratings = new List <RatingAggregate>()
{
new RatingAggregate(screenName, 8)
{
Count = 2
}
},
Version = version,
SumOfRatings = 8
};
Feedback feedback = new Feedback()
{
ApplicationId = applicationId,
DeviceId = Guid.NewGuid(),
Message = "feedback",
Rating = FeedbackRatingType.Five,
ScreenName = screenName,
SessionId = Guid.NewGuid(),
DateCreatedOnDevice = dateCreatedOnDevice,
Date = date,
DateCreated = DateTime.Now,
Version = version,
PlatformId = platform
};
FeedbackSummary summary = new FeedbackSummary(feedback);
feedbackMapper.Save(summary);
Feedback feedback2 = new Feedback()
{
ApplicationId = applicationId,
DeviceId = Guid.NewGuid(),
Message = "feedback",
Rating = FeedbackRatingType.Three,
ScreenName = screenName,
SessionId = Guid.NewGuid(),
DateCreatedOnDevice = dateCreatedOnDevice,
Date = date,
DateCreated = DateTime.Now,
Version = version,
PlatformId = platform
};
FeedbackSummary summary2 = new FeedbackSummary(feedback2);
feedbackMapper.Save(summary2);
IMongoQuery query = Query.And
(
Query <FeedbackSummary> .EQ <DateTime>(mem => mem.Date, date),
Query <FeedbackSummary> .EQ <Guid>(mem => mem.ApplicationId, applicationId),
Query <FeedbackSummary> .EQ <string>(mem => mem.Version, version),
Query <FeedbackSummary> .EQ <PlatformType>(mem => mem.PlatformId, platform)
);
FeedbackSummary actual = this.GetCollection <FeedbackSummary>().FindOne(query);
actual.ShouldHave().AllPropertiesBut(x => x.Id)
.IncludingNestedObjects().EqualTo(expected);
}
public IEnumerable <IdentifiableDTO <FeedbackDTO> > GetByStatus(bool publish, bool approved) => _feedbackRepository.GetByStatus(publish, approved).Select(c => FeedbackMapper.CreateDTOFromFeedback(c));
