public void TestGetById_ValidId()
{
//Get a valid tour
TourDto validTour = GetTour();
//Try to get this tour
TourDto tourResult = _controller.GetById(validTour.Id);
Assert.IsNotNull(tourResult);
Assert.IsNotNull(tourResult.Id);
Assert.AreEqual(validTour.Id, tourResult.Id);
}
public TourDto EditTour(TourDto TourDto, int userId, int tenantId, List <MemoryStream> files, string path, int imageCounter)
{
var TourObj = _TourService.Query(x => x.TourId == TourDto.TourId && x.TenantId == tenantId).Select().FirstOrDefault();
if (TourObj == null)
{
throw new NotFoundException(ErrorCodes.ProductNotFound);
}
// ValidateTour(TourDto, tenantId);
foreach (var TourName in TourDto.TitleDictionary)
{
var TourTranslation = TourObj.TourTranslations.FirstOrDefault(x => x.Language.ToLower() == TourName.Key.ToLower() &&
x.TourId == TourDto.TourId);
if (TourTranslation == null)
{
TourObj.TourTranslations.Add(new TourTranslation
{
Title = TourName.Value,
Description = TourDto.DescriptionDictionary[TourName.Key],
Language = TourName.Key
});
}
else
{
TourTranslation.Title = TourName.Value;
TourTranslation.Description = TourDto.DescriptionDictionary[TourName.Key];
}
}
TourObj.StartFrom = TourDto.StartFrom;
TourObj.StartTo = TourDto.StartTo;
TourObj.HotelTitle = TourDto.HotelTitle;
TourObj.MekkaDays = TourDto.MekkaDays;
TourObj.MadinaDays = TourDto.MadinaDays;
TourObj.Price = TourDto.Price;
TourObj.LastModificationTime = Strings.CurrentDateTime;
TourObj.LastModifierUserId = userId;
TourObj.IsDeleted = TourDto.IsDeleted;
TourObj.CurrencyId = TourDto.CurrencyId;
_TourService.Update(TourObj);
SaveChanges();
var imageId = 1;// imageCounter + 1;
foreach (var memoryStream in files)
{
_manageStorage.UploadImage(path + "\\" + "Tour-" + TourObj.TourId, memoryStream, imageId.ToString());
imageId++;
}
return(TourDto);
}
//tourNumber?
public void UpdateTour(TourDto tourDto)
{
var tour = _context.Tours.Find(tourDto.TourId);
if (tour == null)
{
throw new KeyNotFoundException("no tour with Id = " + tourDto.TourId);
}
tour.StartDate = tourDto.StartDate;
tour.EndDate = tourDto.EndDate;
_context.SaveChanges();
}
TourDto CreateTestTour()
{
TourDto tour = new TourDto()
{
Name = "Test",
Description = "Test",
AgeGroup = AgeGroup.Adult
};
tour = _controller.Create(tour);
return(tour);
}
public void ShouldReturnTourWithTheId()
{
int id = 3;
TourDto retrieved = service.GetTourById(id);
fakeToursStorage.Verify(r => r.GetById(id), Times.Once);
Assert.AreEqual(id, retrieved.Id);
Assert.AreEqual("Tour 3", retrieved.Title);
Assert.AreEqual("description 3", retrieved.Description);
Assert.AreEqual("GREEN_SITES", retrieved.Category);
Assert.AreEqual(2, retrieved.LandmarksIds.Count());
Assert.AreEqual("tourTestImage.jpg", retrieved.ImageFile);
}
private void SetTour(TourDto dto)
{
if (dto.Excursion != null)
{
var ex = _excursionService.SetExcursion(dto.Excursion.Name, dto.Excursion.ExcursionSights);
dto.Excursion = _excursionService.Get(ex);
}
if (dto.Client != null && dto.Client.Id == Guid.Empty)
{
var cl = _clientSerivce.SetClient(dto.Client.Name);
dto.Client = _clientSerivce.Get(cl);
}
}
private TourDto BuildDto(Tour retrieved)
{
TourDto conversion = new TourDto
{
Id = retrieved.Id,
Title = retrieved.Title,
Description = retrieved.Description,
LandmarksIds = retrieved.Landmarks.Select(t => t.Id),
Category = retrieved.Category.ToString(),
ImageFile = retrieved.ImageBaseName
};
return(conversion);
}
public void ShouldReturnTheTourOfIdGiven()
{
int id = 1;
IActionResult result = controller.Get(id);
OkObjectResult ok = result as OkObjectResult;
TourDto tour = ok.Value as TourDto;
fakeToursStorage.Verify(r => r.GetTourById(id));
Assert.IsNotNull(result);
Assert.IsNotNull(ok);
Assert.AreEqual(200, ok.StatusCode);
Assert.IsNotNull(tour);
Assert.AreEqual(id, tour.Id);
}
private void ValidateTour(TourDto TourDto, long tenantId)
{
foreach (var name in TourDto.TitleDictionary)
{
if (name.Value.Length > 300)
{
throw new ValidationException(ErrorCodes.MenuNameExceedLength);
}
if (_TourTranslationService.CheckNameExist(name.Value, name.Key, TourDto.TourId, tenantId))
{
throw new ValidationException(ErrorCodes.NameIsExist);
}
}
}
// GET: TourDtoes/Details/5
public async Task <ActionResult> Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
var request = new HTTPrequest();
TourDto tour = await request.Get <TourDto>("api/tour/" + id);
if (tour == null)
{
return(HttpNotFound());
}
return(View(tour));
}
public void TestGetFiltered_AllFilters()
{
//Create Tour for getfiltered validation
TourDto validTour = CreateTestTour();
var results = _controller.GetFiltered(new TourFilter()
{
isDeleted = false, numPerPage = 100, pageNumber = 0
});
Assert.IsNotNull(results);
Assert.IsTrue(!results.Any(m => m.IsDeleted));
Assert.IsTrue(results.Count <= 100);
Assert.IsTrue(results.Count == results.Distinct().Count());
}
public void TestUpdate_InvalidId()
{
//Get valid tour
TourDto tour = GetTour();
TourDto updatedTour = new TourDto()
{
Id = 0,
Name = tour.Name,
Description = tour.Description,
AgeGroup = AgeGroup.Adult
};
_controller.Update(updatedTour);
}
public IActionResult Get(int id)
{
IActionResult result;
try
{
TourDto retrieved = tours.GetTourById(id);
result = Ok(retrieved);
}
catch (ServiceException e)
{
result = errorFactory.GenerateError(e);
}
return(result);
}
async void Init()
{
eventBus.Subscribe <Events.DataUpdated <Insurance>, OrderDataViewModel>(OnDbUpdated, false);
await ReloadInsurance();
_tour = toursService.GetTour(orderService.TourId);
cost = _tour.Cost;
costChild = _tour.ChildCost;
OrderDto = orderService.GetOrder();
Old = OrderDto.PeopleCount - OrderDto.ChildCount;
Child = OrderDto.ChildCount;
IsAutorized = userService.IsAutorized;
}
public TourDto CreateTour(TourDto TourDto, int userId, int tenantId, List <MemoryStream> files, string path)
{
if (GetTour(TourDto.TourId, tenantId) != null)
{
return(EditTour(TourDto, userId, tenantId, files, path, 1));
}
ValidateTour(TourDto, tenantId);
var TourObj = Mapper.Map <Tour>(TourDto);
foreach (var TourName in TourDto.TitleDictionary)
{
TourObj.TourTranslations.Add(new TourTranslation
{
Title = TourName.Value,
Description = TourDto.DescriptionDictionary[TourName.Key],
Language = TourName.Key,
});
}
TourObj.TenantId = tenantId;
TourObj.StartFrom = TourDto.StartFrom;
TourObj.StartTo = TourDto.StartTo;
TourObj.HotelTitle = TourDto.HotelTitle;
TourObj.MekkaDays = TourDto.MekkaDays;
TourObj.MadinaDays = TourDto.MadinaDays;
TourObj.Price = TourDto.Price;
TourObj.CreationTime = Strings.CurrentDateTime;
TourObj.CreatorUserId = userId;
TourObj.CurrencyId = TourDto.CurrencyId;
_TourTranslationService.InsertRange(TourObj.TourTranslations);
_TourService.Insert(TourObj);
SaveChanges();
var imageId = 1;
foreach (var memoryStream in files)
{
_manageStorage.UploadImage(path + "\\" + "Tour-" + TourObj.TourId, memoryStream, imageId.ToString());
imageId++;
}
return(TourDto);
}
public TourDto Update(TourDto dto)
{
if (string.IsNullOrEmpty(dto.Name))
{
throw new ArgumentNullException("Name");
}
Tour tour = Db.Tours.FirstOrDefault(m => m.Id == dto.Id);
if (tour == null)
{
NotFoundException();
}
tour.Name = dto.Name;
tour.Description = dto.Description;
tour.AgeGroup = (int)dto.AgeGroup;
tour.ModifiedDate = DateTime.UtcNow;
tour.IsDeleted = dto.IsDeleted;
//Handle Artefacts
var toRemove = tour.Artefacts.Where(m => !dto.Artefacts.Any(a => a.Id == m.Id)).ToList();
if (toRemove != null && toRemove.Any())
{
foreach (var artefact in toRemove)
{
tour.Artefacts.Remove(artefact);
}
}
if (dto.Artefacts != null && dto.Artefacts.Any())
{
foreach (var artefact in dto.Artefacts)
{
var artefactEntity = Db.TourArtefacts.Find(artefact.Id);
if (artefactEntity != null)
{
tour.Artefacts.Add(artefactEntity);
}
}
}
Db.SaveChanges();
return(Mapper.Map <TourDto>(tour));
}
public IHttpActionResult CreateTour(TourDto tourDto)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
//throw new HttpResponseException(HttpStatusCode.BadRequest);
var tour = Mapper.Map <TourDto, Tour>(tourDto);
_context.Tours.Add(tour);
_context.SaveChanges();
tourDto.Id = tour.Id;
return(Created(new Uri(Request.RequestUri + "/" + tour.Id), tour));
}
public void TestUpdate_NoImage()
{
//Get valid tour
TourDto tour = GetTour();
tour.Name = "Test Edit";
tour.Description = "Test Edit";
tour.AgeGroup = AgeGroup.Adult;
TourDto updatedTour = _controller.Update(tour);
Assert.IsNotNull(updatedTour);
Assert.IsNotNull(updatedTour.Id);
Assert.AreEqual(tour.Id, updatedTour.Id);
Assert.AreEqual(tour.Name, updatedTour.Name);
Assert.AreEqual(tour.Description, updatedTour.Description);
}
public async Task <List <TourDto> > GetAllMindfightTours(long mindfightId)
{
var user = await _userManager.Users.IgnoreQueryFilters().FirstOrDefaultAsync(u => u.Id == _userManager.AbpSession.UserId);
if (user == null)
{
throw new UserFriendlyException("Vartotojas neegzistuoja!");
}
var currentMindfight = await _mindfightRepository
.GetAllIncluding(x => x.Tours, x => x.Evaluators)
.FirstOrDefaultAsync(x => x.Id == mindfightId);
if (currentMindfight == null)
{
throw new UserFriendlyException("Protmūšis su nurodytu id neegzistuoja!");
}
if (!(currentMindfight.CreatorId == _userManager.AbpSession.UserId ||
_permissionChecker.IsGranted("ManageMindfights") ||
currentMindfight.Evaluators.Any(x => x.UserId == _userManager.AbpSession.UserId)))
{
throw new AbpAuthorizationException("jūs neturite visų turų gavimo teisių");
}
var toursDto = new List <TourDto>();
var tours = await _tourRepository
.GetAllIncluding(tour => tour.Questions)
.Where(x => x.MindfightId == mindfightId)
.OrderBy(x => x.OrderNumber)
.ToListAsync();
foreach (var tour in tours)
{
var tourDto = new TourDto();
_objectMapper.Map(tour, tourDto);
tourDto.QuestionsCount = tour.Questions.Count;
toursDto.Add(tourDto);
}
if (toursDto.Count > 0)
{
toursDto[toursDto.Count - 1].IsLastTour = true;
}
return(toursDto);
}
public void TestDelete_ValidId()
{
//Get valid tour
TourDto validTour = GetTour();
//Delete tour
bool result = _controller.Delete(validTour.Id);
Assert.IsTrue(result);
//Get tour for comparison
TourDto tourResult = _controller.GetById(validTour.Id);
Assert.IsNotNull(tourResult);
Assert.IsNotNull(tourResult.Id);
Assert.AreEqual(validTour.Id, tourResult.Id);
Assert.IsTrue(tourResult.IsDeleted);
}
public void TestGetFiltered_IsDeleted()
{
//Create a tour to test on
TourDto validTour = CreateTestTour();
//delete for test
_controller.Delete(validTour.Id);
var results = _controller.GetFiltered(new TourFilter()
{
isDeleted = true, numPerPage = 100, pageNumber = 0
});
Assert.IsNotNull(results);
Assert.IsTrue(!results.Any(m => !m.IsDeleted));
Assert.IsTrue(results.Count <= 100);
Assert.IsTrue(results.Count == results.Distinct().Count());
}
public void TestCreate_NoImage()
{
//Set up dto
TourDto tour = new TourDto()
{
Name = "Test",
Description = "Test",
AgeGroup = AgeGroup.Adult
};
//Make test request
TourDto tourResult = _controller.Create(tour);
//Assert Values
Assert.IsNotNull(tourResult);
Assert.IsNotNull(tourResult.Id);
Assert.IsTrue(tourResult.Id != 0);
}
//[Authorize(Roles = nameof(PermissionProvider.AddArea))]
public HttpResponseMessage Create(HttpRequestMessage request, TourDto tourDto)
{
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage reponse = null;
if (!ModelState.IsValid)
{
reponse = request.CreateResponse(HttpStatusCode.BadRequest, ModelState);
}
else
{
this.msg = "Trùng code";
if (_tourService.CheckCode(tourDto.Code))
{
reponse = request.CreateResponse(HttpStatusCode.BadRequest, msg);
}
var modelTour = Mapper.Map <Tour>(tourDto);
modelTour.Code = modelTour.Code.Trim().ToUpper();
modelTour.FromDate = modelTour.FromDate.UtcDateTime;
modelTour.ToDate = modelTour.ToDate.UtcDateTime;
modelTour.CreatedDate = GetDateTimeNowUTC();
modelTour.CreatedBy = User.Identity.GetUserId();
modelTour.Alias = StringHelper.ToUrlFriendlyWithDateTime(modelTour.Name, modelTour.CreatedDate.Value.DateTime);
_uow.BeginTran();
_tourService.Add(modelTour);
if (tourDto.TourAttr.Count > 0)
{
foreach (var item in tourDto.TourAttr)
{
item.TourId = modelTour.Id;
}
}
var modelAttrs = Mapper.Map <List <TourAttributeValue> >(tourDto.TourAttr);
_tourAttributeValueService.Add(modelAttrs);
_uow.CommitTran();
reponse = request.CreateResponse(HttpStatusCode.Created, modelTour);
}
return reponse;
}));
}
public void Edit(TourDto dto)
{
if (dto == null || dto.Client == null || dto.Excursion == null)
{
throw new Exception("no correct Tour");
}
var tour = _uow.Tours.GetEntity(dto.Id);
if (tour == null)
{
throw new Exception("not found tour");
}
SetTour(dto);
AddSnapshotSights(tour);
_uow.Tours.Update(TypeAdapter.Adapt <Tour>(dto));
_uow.Save();
}
public async Task <ActionResult> Create(TourDto tour, HttpPostedFileBase imageFile)
{
if (string.IsNullOrEmpty(tour.Name))
{
ViewBag.ValidationName = "Name field is required.";
return(View(tour));
}
if (ModelState.IsValid)
{
tour.CreatedDate = DateTime.Now;
var request = new HTTPrequest();
tour = await request.Post <TourDto>("api/tour", tour);
return(RedirectToAction("Index", new { recentAction = "Created", recentName = tour.Name, recentId = tour.Id }));
}
return(View());
}
public async void AddTourAsync_ValidTour_Success()
{
// Arrange
var mock = new Mock <IUnitOfWork>();
mock.Setup(unitOfWork => unitOfWork.TourRepository.AddAsync(It.IsAny <TourEntity>())).Verifiable();
mock.Setup(unitOfWork => unitOfWork.CommitAsync()).Verifiable();
var tourService = new TourService(mock.Object);
TourDto tour = new TourDto()
{
Name = "TourId",
Price = 5
};
// Act
await tourService.AddTourAsync(tour);
// Assert
mock.Verify(moq => moq.CommitAsync(), Times.Once);
}
public IHttpActionResult UpdateTour(int id, TourDto tourDto)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var tourInDb = _context.Tours.SingleOrDefault(c => c.Id == id);
if (tourInDb == null)
{
return(NotFound());
}
Mapper.Map(tourDto, tourInDb);
_context.SaveChanges();
return(Ok());
}
public void AddTour_ValidTour_ReturnTrue()
{
// Arrange
var mock = new Mock <IUnitOfWork>();
mock.Setup(unitOfWork => unitOfWork.TourRepository.AddAsync(It.IsAny <TourEntity>())).Verifiable();
mock.Setup(unitOfWork => unitOfWork.Commit()).Verifiable();
var tourService = new TourService(mock.Object);
TourDto tour = new TourDto()
{
Name = "TourId",
Price = 5
};
// Act
var result = tourService.AddTour(tour);
// Assert
mock.Verify(moq => moq.Commit(), Times.Once);
Assert.True(result);
}
public void TestCreate_ShouldSucceed()
{
//Set up dto
TourDto tour = new TourDto()
{
Name = "Test",
Description = "Test",
AgeGroup = AgeGroup.Adult
};
//Make test request
TourDto tourResult = _controller.Create(tour);
//Assert Values
Assert.IsNotNull(tourResult);
Assert.IsNotNull(tourResult.Id);
Assert.IsTrue(tourResult.Id != 0);
Assert.AreEqual(tour.Name, tourResult.Name);
Assert.AreEqual(tour.Description, tourResult.Description);
Assert.IsNotNull(tourResult.CreatedDate);
Assert.IsNotNull(tourResult.ModifiedDate);
}
public void Create(TourDto dto)
{
SetTour(dto);
var newTour = TypeAdapter.Adapt <Tour>(dto);
newTour.Id = Guid.NewGuid();
if (_uow.Excursions.FindByName(newTour?.Excursion.Name) != null)
{
AddSnapshotSights(newTour);
newTour.Excursion = null;
}
if (_uow.Clients.FindByName(newTour?.Client.Name) != null)
{
newTour.Client = null;
}
_uow.Tours.Create(newTour);
_uow.Save();
}
public void UpdateTour(TourDto input)
{
var instanse = Mapper.Map<Tour>(input);
this.unitOfWork.Entities<Tour, int>().Update(instanse);
}
