//Create a venue or return 0
public int CreateVenue(VenueDto venueDto)
{
VenueType type;
VenuePrivacy privacy;
//parse type and privacy
if (!Enum.TryParse <VenueType>(venueDto.Type, true, out type)
||
!Enum.TryParse <VenuePrivacy>(venueDto.Privacy, true, out privacy))
{
return(0);
}
try
{
var venue = new Venue()
{
Name = venueDto.Name,
Address = venueDto.Address,
Capacity = venueDto.Capacity,
Type = type,
Privacy = privacy
};
Context.Add(venue);
Context.SaveChanges();
return(venue.id);
}
catch (Exception)
{
return(0);
}
}
//update a venue
public Status UpdateVenue(int id, VenueDto venueDto)
{
var venue = Context.Venues.SingleOrDefault(v => v.id == id);
if (venue == null)
{
return(Status.NotFound);
}
VenueType type;
VenuePrivacy privacy;
//parse type and privacy
if (!Enum.TryParse <VenueType>(venueDto.Type, true, out type)
||
!Enum.TryParse <VenuePrivacy>(venueDto.Privacy, true, out privacy))
{
return(Status.Error);
}
//update venue data
venue.Name = venueDto.Name;
venue.Address = venueDto.Address;
venue.Capacity = venueDto.Capacity;
venue.Type = type;
venue.Privacy = privacy;
Context.Update(venue);
Context.SaveChanges();
return(Status.Success);
}
public async Task <ActionResult <VenueDto> > CreateVenue(
[FromRoute] Guid classroomId,
[FromBody] VenueDto venueDto)
{
var user = (ApplicationUser)HttpContext.Items["ApplicationUser"];
Debug.Assert(user != null, nameof(user) + " != null");
try
{
var classroom = await _classroomService.FindAsync(classroomId);
var authorization = await _authorizationService.AuthorizeAsync(User, classroom, "IsOwner");
if (!authorization.Succeeded)
{
return(Forbid());
}
var venue = venueDto.ToVenue();
venue = await _classroomService.CreateVenueAsync(venue);
await _classroomService.AddVenueAsync(classroom, venue);
return(Ok(venue.ToDto()));
}
catch (Exception e)
{
Console.WriteLine(e);
return(BadRequest());
}
}
/// <summary>
/// Create a venue. A venue can not be created without layouts
/// </summary>
/// <param name="entity"></param>
/// <returns></returns>
public async Task Create(VenueDto entity)
{
if (entity == null)
{
throw new ArgumentNullException();
}
if (!IsNameUnique(entity, true))
{
throw new VenueException("Such venue already exists");
}
if (entity.LayoutList == null || !entity.LayoutList.Any())
{
throw new VenueException("Incorrect state of the venue. The venue must have at least one layout");
}
var venueAdd = VenueParser.MapToVenue(entity);
using (var transaction = CustomTransactionScope.GetTransactionScope())
{
_context.VenueRepository.Create(venueAdd);
await _context.SaveAsync();
entity.Id = venueAdd.Id;
foreach (var layout in entity.LayoutList)
{
layout.VenueId = venueAdd.Id;
await _layoutService.Create(layout);
}
transaction.Complete();
}
}
private TMLayoutDto CreateDefaultLayoutForVenue(VenueDto obj)
{
var layout = new TMLayoutDto {
Description = "defailt", VenueId = obj.Id
};
var area = new AreaDto
{
CoordX = 0,
CoordY = 0,
Description = "all size area",
};
var seats = new List <SeatDto>();
for (int j = 0; j < obj.Lenght; j++)
{
for (int i = 0; i < obj.Weidth; i++)
{
seats.Add(new SeatDto {
Row = j, Number = i
});
}
}
return(CreateLayout(layout, new List <AreaDto> {
area
}, seats));
}
public async Task <ActionResult <VenueDto> > Put(int venueId, [FromBody] VenueDto dto)
{
try
{
var events = await _eventRepository.GetEvents();
var oldVenue = events.Where(v => v.VenueId == venueId).Select(c => c.Venue).FirstOrDefault();
if (oldVenue == null)
{
return(NotFound($"Could not find venue with id {venueId}"));
}
var newVenue = _mapper.Map(dto, oldVenue);
_eventRepository.Update(newVenue);
if (await _eventRepository.Save())
{
return(NoContent());
}
}
catch (Exception ex)
{
return(this.StatusCode(StatusCodes.Status500InternalServerError, "Database Failure"));
}
return(BadRequest());
}
public static void ImportVenues()
{
using (WeddingsPlannerContext context = new WeddingsPlannerContext())
{
XDocument documentNode = XDocument.Load(Constants.VenuesPath);
IEnumerable <XElement> venuesNode = documentNode.XPathSelectElements("venues/venue");
foreach (XElement venueNode in venuesNode)
{
string venueNodeName = venueNode.Attribute("name")?.Value;
int venueNodeNameCapacity = int.Parse(venueNode.Element("capacity").Value);
string venueNodeTown = venueNode.Element("town")?.Value;
VenueDto venueDto = new VenueDto()
{
Name = venueNodeName,
Capacity = venueNodeNameCapacity,
Town = venueNodeTown
};
Venue venueEntity = new Venue()
{
Name = venueDto.Name,
Capacity = venueDto.Capacity,
Town = venueDto.Town
};
try
{
context.Venues.Add(venueEntity);
context.SaveChanges();
Console.WriteLine($"Successfully imported {venueEntity.Name}");
}
catch (DbEntityValidationException)
{
context.Venues.Remove(venueEntity);
Console.WriteLine(Messages.InvalidData);
}
}
Random random = new Random();
foreach (Wedding wedding in context.Weddings.ToList())
{
int randomId = random.Next(1, context.Venues.Count() + 1);
Venue venue = context.Venues.Find(randomId);
wedding.Venues.Add(venue);
randomId = random.Next(1, context.Venues.Count() + 1);
venue = context.Venues.Find(randomId);
wedding.Venues.Add(venue);
}
context.SaveChanges();
}
}
public void CreateVenueTest()
{
List <Venue> venues = new List <Venue>();
venues.Add(new Venue {
Id = 1, Address = "a", Description = "d"
});
venues.Add(new Venue {
Id = 2, Address = "a2", Description = "d2"
});
venues.Add(new Venue {
Id = 3, Address = "a3", Description = "d3"
});
VenueDto venueCreate_service = new VenueDto {
Address = "a4", Description = "d4"
};
Venue venuePost = new Venue {
Id = 4, Address = "a4", Description = "d4"
};
VenueDto venuePost_service = new VenueDto {
Id = 4, Address = "a4", Description = "d4"
};
Mock <IVenueRepository> mockVenueRepository = new Mock <IVenueRepository>();
mockVenueRepository.Setup(x => x.GetAll()).Returns(venues);
mockVenueRepository.Setup(x => x.Create(It.IsAny <Venue>())).Returns(venuePost);
Mock <ISeatService> mockSeatService = new Mock <ISeatService>();
mockSeatService.Setup(x => x.CreateSeat(It.IsAny <SeatDto>()))
.Returns(new SeatDto {
Id = 1
});
Mock <ITMLayoutService> mockTMLayoutService = new Mock <ITMLayoutService>();
mockTMLayoutService.Setup(x => x.CreateTMLayout(It.IsAny <TMLayoutDto>()))
.Returns(new TMLayoutDto {
Id = 1
});
Mock <IAreaService> mockAreaService = new Mock <IAreaService>();
mockAreaService.Setup(x => x.CreateArea(It.IsAny <AreaDto>()))
.Returns(new AreaDto {
Id = 1
});
VenueService venueService = new VenueService(mockVenueRepository.Object,
mockTMLayoutService.Object, mockAreaService.Object, mockSeatService.Object);
VenueDto venue = venueService.CreateVenue(venueCreate_service);
venue.Should().BeEquivalentTo(venuePost_service);
}
private async Task EnsureAddressAndNameIsUnique(VenueDto item)
{
var venues = (await _venueEntityService.GetAll().ToListAsync()).AsReadOnly();
if (venues.Any(v => v.Location == item.Location && v.Name == item.Name && v.Id != item.Id))
{
throw new ValidationException(Resources.StringRes.NotUniqueAddressNameMsg);
}
}
public void Create_venue_without_layout_expected_exception()
{
//Arrange
var venue = new VenueDto {
Name = "Club Koko", LayoutList = new List <LayoutDto>()
};
var venueService = _container.Resolve <IVenueService>();
//Assert
Assert.ThrowsAsync <VenueException>(async() => await venueService.Create(venue));
}
public async Task Update(VenueDto entity)
{
if (entity == null)
{
throw new ArgumentNullException();
}
if (!IsNameUnique(entity, false))
{
throw new VenueException("Such venue already exists");
}
if (entity.LayoutList == null || !entity.LayoutList.Any())
{
throw new VenueException("Incorrect state of the venue. The venue must have at least one layout");
}
using (var transaction = CustomTransactionScope.GetTransactionScope())
{
var update = await _context.VenueRepository.GetAsync(entity.Id);
update.Name = entity.Name;
update.Phone = entity.Phone;
update.Description = entity.Description;
update.Address = entity.Address;
update.Timezone = entity.Timezone;
_context.VenueRepository.Update(update);
await _context.SaveAsync();
var existingLayouts = await _context.LayoutRepository.FindByAsync(x => x.VenueId == entity.Id);
//find and remove layouts which were deleted
existingLayouts.Where(list2 => entity.LayoutList.All(list1 => list1.Id != list2.Id)).ToList()
.ForEach(x =>
{
_context.LayoutRepository.Delete(x);
});
foreach (var layout in entity.LayoutList)
{
if (layout.Id == 0)
{
layout.VenueId = update.Id;
await _layoutService.Create(layout);
}
else
{
await _layoutService.Update(layout);
}
}
transaction.Complete();
}
}
public static Venue MapToVenue(VenueDto from)
{
return(new Venue
{
Address = from.Address,
Description = from.Description,
Name = from.Name,
Phone = from.Phone,
Timezone = from.Timezone
});
}
public static VenueResponse MapDtoToResponse(this IEnumerable <VenueDto> venueDtos, List <SpaceResponse> spacesToAddToVenue)
{
VenueDto venueDto = venueDtos.FirstOrDefault();
VenueResponse model = new VenueResponse
{
VenueId = venueDto.VenueId,
Description = venueDto.Description,
MUrl = venueDto.MUrl,
Summary = venueDto.Summary,
Title = venueDto.Title,
Testimonial = venueDto.Testimonial,
TestimonialContactEmail = venueDto.TestimonialContactEmail,
TestimonialContactName = venueDto.TestimonialContactName,
TestimonialContactOrganisation = venueDto.TestimonialContactOrganisation,
Spaces = spacesToAddToVenue,
VenueImages = new List <VenueImageDto>(),
VenueType = new VenueTypeDto
{
VenueTypeId = venueDto.VenueTypeId,
Description = venueDto.VenueTypeDescription
},
Address = new VenueAddress
{
Postcode = venueDto.Postcode,
BuildingNameOrNumber = venueDto.BuildingNameOrNumber,
Road = venueDto.Road,
Country = venueDto.Country,
County = venueDto.County,
State = venueDto.State,
Suburb = venueDto.Suburb,
Town = venueDto.Town,
Village = venueDto.Village
}
};
model.Address.DisplayName = model.Address.MapDisplayNameProperties();
foreach (VenueDto venue in venueDtos)
{
if (venue.VenueImageId != Guid.Empty && !model.VenueImages.Any(x => x.VenueImageId == venue.VenueImageId))
{
model.VenueImages.Add(new VenueImageDto
{
Base64VenueImageString = venue.Base64VenueImageString,
VenueId = venue.VenueId,
VenueImageId = venue.VenueImageId
});
}
}
return(model);
}
public void Should_Map()
{
// Arrange
Venue venue = FakeVenues.WeiherhofSchule;
VenueDto expectedDto = VenueDtoData.WeiherhofSchule;
// Act
VenueDto dto = _mapper.Map <VenueDto>(venue);
// Assert
dto.Should().BeEquivalentTo(expectedDto);
}
private static Venue ConvertToEntity(VenueDto obj)
{
return(new Venue
{
Id = obj.Id,
Description = obj.Description,
Address = obj.Address,
Lenght = obj.Lenght,
Phone = obj.Phone,
Weidth = obj.Weidth,
});
}
public async Task <VenueResponse> EditVenueAsync(VenueRequest venue, Guid venueId)
{
LocationIqReverseResponse locationResponse = await _locationIqProvider.GetLocationDetailsAsync(venue.Postcode);
VenueAddress venueAddress = locationResponse.MapAddressProperties(venue.BuildingNameOrNumber);
VenueDto venueDto = venue.MapRequestToDto(Guid.Empty, venueAddress);
await _venueRepo.EditVenueAsync(venueDto);
return(await GetVenueAsync(venueId));
}
private bool IsNameUnique(VenueDto entity, bool isCreating)
{
var data = from venues in _context.VenueRepository.GetList()
where venues.Name.Equals(entity.Name, StringComparison.OrdinalIgnoreCase)
select venues;
return(isCreating ?
!data.Any() :
!(from venues in data
where venues.Id != entity.Id
select venues).Any());
}
public int CreateVenue(VenueDto venue)
{
ModelValidation.IsValidModel(venue);
if (IsVenueExist(venue))
{
throw new ValidationException("Venue can't be created for this name");
}
var ven = _mapper.Map <Venue>(venue);
return(_venueRepository.Add(ven));
}
public void CreateVenue_WhenModelValid_ShouldReturnNewId()
{
var venue = new VenueDto
{
Name = "New Venue", Description = "Description", Address = "Address",
Phone = "8-800-555-35-35"
};
var result = _venueService.CreateVenue(venue);
Assert.AreEqual(result, ReturnIdVenue);
}
public void CreateVenue_WhenVenueExists_ShouldReturnValidationException()
{
var venue = new VenueDto
{
Name = "First Venue", Description = "Description", Address = "Address",
Phone = "8-800-555-35-35"
};
var exception = Assert.Throws <ValidationException>(() => _venueService.CreateVenue(venue));
Assert.AreEqual("Venue can't be created for this name", exception.Message);
}
public static Venue ToVenueContract(VenueDto from)
{
return(new Venue
{
Address = from.Address,
Description = from.Description,
Id = from.Id,
Name = from.Name,
Phone = from.Phone,
Timezone = from.Timezone,
LayoutList = from.LayoutList.Select(x => LayoutParser.ToLayoutContract(x)).ToList()
});
}
public void CreateVenue_WhenVenueExists_ShouldReturnValidationException()
{
using (var scope = new TransactionScope())
{
var venue = new VenueDto
{
Name = "First Venue", Description = "Description", Address = "Address",
Phone = "8-800-555-35-35"
};
Assert.Throws <ValidationException>(() => _venueService.CreateVenue(venue));
}
}
public ActionResult <VenueDto> CreateVenue(VenueDto dto)
{
var adding = dataContext.Set <Venue>().Add(new Venue
{
Name = dto.Name,
Capacity = dto.Capacity
});
dataContext.SaveChanges();
dto.Id = adding.Entity.Id;
return(Created($"/api/venues/{adding.Entity.Id}", dto));
}
public void CreateVenue_WhenModelNotValid_ShouldReturnArgumentException()
{
var venue = new VenueDto
{
Name = null,
Description = "Description",
Address = "Address",
Phone = "8-800-555-35-35"
};
var exception = Assert.Throws <ArgumentException>(() => _venueService.CreateVenue(venue));
Assert.AreEqual("The Name field is required.", exception.Message);
}
public void Venue_name__is_unique_expected_exception(string venueName)
{
//Arrange
var venue = new VenueDto {
Name = venueName
};
var venueService = _container.Resolve <IVenueService>();
//Act
var exception = Assert.CatchAsync <VenueException>(async() => await venueService.Create(venue));
//Assert
StringAssert.AreEqualIgnoringCase(exception.Message, "Such venue already exists");
}
public void Venue_name_is_unique(string venueName)
{
//Arrange
var venue = new VenueDto {
Name = venueName
};
var venueService = _container.Resolve <IVenueService>();
//Act
var exception = Assert.CatchAsync(async() => await venueService.Create(venue));
//Assert
Assert.That(exception.Message, Is.Not.EqualTo("Such venue already exists"));
}
public async Task <bool> EditVenueAsync(VenueDto venue)
{
using (SqlConnection con = new SqlConnection(_connectionString))
{
bool updateVenueResult = await con.UpdateAsync(venue);
if (!updateVenueResult)
{
throw new HttpStatusCodeResponseException(HttpStatusCode.NotModified);
}
return(updateVenueResult);
}
}
public IActionResult PostVenue([FromBody] VenueDto venueDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var id = VenueRepository.CreateVenue(venueDto);
if (id == 0)
{
return(BadRequest());
}
venueDto.id = id;
return(CreatedAtAction(nameof(GetVenue), new { id = id }, venueDto));
}
public void CreateVenue_WhenModelValid_ShouldInsertNewVenue()
{
using (var scope = new TransactionScope())
{
var venue = new VenueDto
{
Name = "New Venue", Description = "Description", Address = "Address",
Phone = "8-800-555-35-35"
};
var result = _venueService.CreateVenue(venue);
venue.Should().BeEquivalentTo(_venueService.GetVenue(result), options => options.Excluding(x => x.Id));
}
}
public static Venue ToVenue(this VenueDto venueDto)
{
var validId = Guid.TryParse(venueDto.Id, out var id);
if (!validId && !string.IsNullOrWhiteSpace(venueDto.Id))
{
throw new Exception("Invalid Venue.Id");
}
return(new Venue
{
Id = id,
Name = venueDto.Name
});
}
