public void AuditoriumService_UpdateAuditorium_Returns_AuditoriumResultModel_AuditoriumUpdateError()
{
//Arrange
AuditoriumResultModel expectedResultModel = new AuditoriumResultModel()
{
ErrorMessage = "Error happened when auditorium was updating. "
};
AuditoriumDomainModel auditoriumDomainModel = _auditoriumDomainModel;
Auditorium auditorium = null;
IEnumerable <Projection> projections = null;
IEnumerable <Seat> seats = null;
_mockProjectionRepository = new Mock <IProjectionsRepository>();
_mockProjectionRepository.Setup(x => x.GetAllOfSpecificAuditorium(It.IsAny <int>())).Returns(projections);
_mockSeatsRepository = new Mock <ISeatsRepository>();
_mockSeatsRepository.Setup(x => x.GetAllOfSpecificAuditorium(It.IsAny <int>())).Returns(seats);
_mockAuditoriumsRepository = new Mock <IAuditoriumsRepository>();
_mockAuditoriumsRepository.Setup(x => x.Update(It.IsAny <Auditorium>())).Returns(auditorium);
AuditoriumService auditoriumController = new AuditoriumService(_mockAuditoriumsRepository.Object, _mockCinemasRepository.Object, _mockSeatsRepository.Object, _mockProjectionRepository.Object, _mockTicketService.Object);
//Act
var resultAction = auditoriumController.UpdateAuditorium(auditoriumDomainModel).ConfigureAwait(false).GetAwaiter().GetResult();
//Assert
Assert.IsNotNull(resultAction);
Assert.IsFalse(resultAction.IsSuccessful);
Assert.AreEqual(expectedResultModel.ErrorMessage, resultAction.ErrorMessage);
Assert.IsInstanceOfType(resultAction, typeof(AuditoriumResultModel));
}
public void AuditoriumService_DeleteAuditorium_AuditoriumResultModel_PROJECTION_IN_FUTURE()
{
//Arrange
AuditoriumResultModel expectedResultModel = new AuditoriumResultModel()
{
ErrorMessage = "Cannot delete projection as it is scheduled in the future. "
};
Auditorium auditorium = _auditorium;
IEnumerable <Projection> projections = _listOfProjections;
_mockAuditoriumsRepository = new Mock <IAuditoriumsRepository>();
Task <Auditorium> responseTask = Task.FromResult(auditorium);
_mockAuditoriumsRepository.Setup(x => x.GetByIdAsync(It.IsAny <int>())).Returns(responseTask);
_mockProjectionRepository = new Mock <IProjectionsRepository>();
_mockProjectionRepository.Setup(x => x.GetAllOfSpecificAuditorium(It.IsAny <int>())).Returns(projections);
AuditoriumService auditoriumController = new AuditoriumService(_mockAuditoriumsRepository.Object, _mockCinemasRepository.Object, _mockSeatsRepository.Object, _mockProjectionRepository.Object, _mockTicketService.Object);
//Act
var resultAction = auditoriumController.DeleteAuditorium(It.IsAny <int>()).ConfigureAwait(false).GetAwaiter().GetResult();
//Assert
Assert.IsNotNull(resultAction);
Assert.IsFalse(resultAction.IsSuccessful);
Assert.AreEqual(expectedResultModel.ErrorMessage, resultAction.ErrorMessage);
Assert.IsInstanceOfType(resultAction, typeof(AuditoriumResultModel));
}
public async Task <AuditoriumResultModel> CreateAuditorium(AuditoriumDomainModel createAuditorium)
{
AuditoriumEntity newAuditorium = new AuditoriumEntity
{
AuditoriumId = createAuditorium.AuditoriumId,
AuditoriumName = createAuditorium.NameOfAuditorium,
MuseumId = createAuditorium.MuseumId,
NumberOfSeats = createAuditorium.NumberOfSeats
};
bool museum = false;
var listOfMuseums = await _museumsRepository.GetAll();
foreach (var item in listOfMuseums)
{
if (item.MuseumId == createAuditorium.MuseumId)
{
museum = true;
}
;
}
if (museum == false)
{
return(new AuditoriumResultModel
{
IsSuccessful = false,
ErrorMessage = Messages.MUSEUM_DOES_NOT_EXIST,
Auditorium = null
});
}
var auditorium = _auditoriumRepository.Insert(newAuditorium);
if (auditorium == null)
{
return(new AuditoriumResultModel
{
IsSuccessful = false,
ErrorMessage = Messages.AUDITORIUM_WITH_THIS_ID_ALREADY_EXISTS,
Auditorium = null
});
}
AuditoriumResultModel result = new AuditoriumResultModel
{
IsSuccessful = true,
ErrorMessage = null,
Auditorium = new AuditoriumDomainModel
{
AuditoriumId = auditorium.AuditoriumId,
NameOfAuditorium = auditorium.AuditoriumName,
MuseumId = auditorium.MuseumId,
NumberOfSeats = auditorium.NumberOfSeats
}
};
return(result);
}
public async Task <AuditoriumResultModel> DeleteAuditorium(int id)
{
var existingAuditorium = await _auditoriumsRepository.GetByIdAsync(id);
if (existingAuditorium == null)
{
return(new AuditoriumResultModel
{
ErrorMessage = Messages.AUDITORIUM_DOES_NOT_EXIST,
IsSuccessful = false
});
}
var projectionsInAuditorium = _projectionsRepository.GetAllOfSpecificAuditorium(id);
if (projectionsInAuditorium != null)
{
foreach (var projection in projectionsInAuditorium)
{
if (projection.DateTime > DateTime.Now)
{
return(new AuditoriumResultModel
{
ErrorMessage = Messages.PROJECTION_IN_FUTURE,
IsSuccessful = false
});
}
_projectionsRepository.Delete(projection.Id);
await _ticketService.DeleteTicketFromProjection(projection.Id);
}
}
var seatsInAuditorium = _seatsRepository.GetAllOfSpecificAuditorium(id);
if (seatsInAuditorium != null)
{
foreach (var seat in seatsInAuditorium)
{
_seatsRepository.Delete(seat.Id);
}
}
var data = _auditoriumsRepository.Delete(id);
_auditoriumsRepository.Save();
AuditoriumResultModel domainModel = new AuditoriumResultModel
{
ErrorMessage = null,
IsSuccessful = true,
Auditorium = new AuditoriumDomainModel
{
CinemaId = existingAuditorium.CinemaId,
Id = existingAuditorium.Id,
Name = existingAuditorium.Name
}
};
return(domainModel);
}
public async Task <AuditoriumResultModel> UpdateAuditorium(AuditoriumDomainModel updateAuditorium)
{
var data = await _auditoriumRepository.GetByIdAsync(updateAuditorium.AuditoriumId);
AuditoriumEntity auditorium = new AuditoriumEntity
{
AuditoriumId = updateAuditorium.AuditoriumId,
MuseumId = updateAuditorium.MuseumId,
AuditoriumName = updateAuditorium.NameOfAuditorium,
NumberOfSeats = updateAuditorium.NumberOfSeats
};
var auditoriumUpdate = _auditoriumRepository.Update(auditorium);
if (auditoriumUpdate == null)
{
return(new AuditoriumResultModel
{
IsSuccessful = false,
ErrorMessage = Messages.AUDITORIUM_UPDATE_ERROR,
Auditorium = null
});
}
_auditoriumRepository.Save();
AuditoriumResultModel result = new AuditoriumResultModel
{
IsSuccessful = true,
ErrorMessage = null,
Auditorium = new AuditoriumDomainModel
{
MuseumId = auditoriumUpdate.MuseumId,
AuditoriumId = auditoriumUpdate.AuditoriumId,
NameOfAuditorium = auditoriumUpdate.AuditoriumName,
NumberOfSeats = auditoriumUpdate.NumberOfSeats
}
};
return(result);
}
public void AuditoriumService_UpdateAuditorium_Returns_AuditoriumResultModel_AuditoriumUpdateError_ProjectionInFuture()
{
//Arrange
AuditoriumResultModel expectedResultModel = new AuditoriumResultModel()
{
ErrorMessage = "Unable to update auditorium, please make sure there no upcoming projections and then try again. "
};
AuditoriumDomainModel auditoriumDomainModel = _auditoriumDomainModel;
IEnumerable <Projection> projections = _listOfProjections;
_mockProjectionRepository = new Mock <IProjectionsRepository>();
_mockProjectionRepository.Setup(x => x.GetAllOfSpecificAuditorium(It.IsAny <int>())).Returns(_listOfProjections);
AuditoriumService auditoriumController = new AuditoriumService(_mockAuditoriumsRepository.Object, _mockCinemasRepository.Object, _mockSeatsRepository.Object, _mockProjectionRepository.Object, _mockTicketService.Object);
//Act
var resultAction = auditoriumController.UpdateAuditorium(auditoriumDomainModel).ConfigureAwait(false).GetAwaiter().GetResult();
//Assert
Assert.IsNotNull(resultAction);
Assert.IsFalse(resultAction.IsSuccessful);
Assert.AreEqual(expectedResultModel.ErrorMessage, resultAction.ErrorMessage);
Assert.IsInstanceOfType(resultAction, typeof(AuditoriumResultModel));
}
public void AuditoriumService_DeleteAuditorium_AuditoriumResultModel_AUDITORIUM_DOES_NOT_EXIST()
{
//Arrange
AuditoriumResultModel expectedResultModel = new AuditoriumResultModel()
{
ErrorMessage = "Auditorium does not exist."
};
Auditorium auditorium = null;
_mockAuditoriumsRepository = new Mock <IAuditoriumsRepository>();
Task <Auditorium> responseTask = Task.FromResult(auditorium);
_mockAuditoriumsRepository.Setup(x => x.GetByIdAsync(It.IsAny <int>())).Returns(responseTask);
AuditoriumService auditoriumController = new AuditoriumService(_mockAuditoriumsRepository.Object, _mockCinemasRepository.Object, _mockSeatsRepository.Object, _mockProjectionRepository.Object, _mockTicketService.Object);
//Act
var resultAction = auditoriumController.DeleteAuditorium(It.IsAny <int>()).ConfigureAwait(false).GetAwaiter().GetResult();
//Assert
Assert.IsNotNull(resultAction);
Assert.IsFalse(resultAction.IsSuccessful);
Assert.AreEqual(expectedResultModel.ErrorMessage, resultAction.ErrorMessage);
Assert.IsInstanceOfType(resultAction, typeof(AuditoriumResultModel));
}
public async Task <AuditoriumResultModel> DeleteAuditoriumAsync(int id)
{
var exhibitions = await _exhibitionsRepository.GetAll();
AuditoriumResultModel result;
List <int[]> entitiesToBeDeleted = new List <int[]>();
//&& exhibition.StartTime > DateTime.Now ) || (exhibition.AuditoriumId == id && exhibition.EndTime > DateTime.Now)
var entities = await testForDeletionAsync(id);
if (entities == null)
{
return new AuditoriumResultModel
{
Auditorium = null,
IsSuccessful = false,
ErrorMessage = Messages.AUDITORIUM_DELETE_ERROR
}
}
;
else
{
entitiesToBeDeleted.AddRange(entities);
}
foreach (var entity in entitiesToBeDeleted)
{
switch (entity[1])
{
case 3:
_exhibitionsRepository.Delete(entity[0]);
break;
}
}
var deletedAuditorium = _auditoriumRepository.Delete(id);
if (deletedAuditorium == null)
{
return new AuditoriumResultModel
{
Auditorium = null,
IsSuccessful = false,
ErrorMessage = Messages.AUDITORIUM_NOT_FOUND_ERROR
}
}
;
result = new AuditoriumResultModel
{
Auditorium = new AuditoriumDomainModel
{
AuditoriumId = deletedAuditorium.AuditoriumId,
NameOfAuditorium = deletedAuditorium.AuditoriumName,
MuseumId = deletedAuditorium.MuseumId,
NumberOfSeats = deletedAuditorium.NumberOfSeats
},
IsSuccessful = true,
ErrorMessage = ""
};
return(result);
}
public async Task <CreateCinemaResultModel> DeleteCinema(int id)
{
var existingCinema = await _cinemasRepository.GetByIdAsync(id);
var auditoriumsInCinema = _auditoriumService.GetAllOfSpecificCinema(id);
if (existingCinema == null)
{
CreateCinemaResultModel errorModel = new CreateCinemaResultModel
{
ErrorMessage = Messages.CINEMA_DOES_NOT_EXIST,
IsSuccessful = false
};
return(errorModel);
}
foreach (var item in auditoriumsInCinema)
{
var existingAuditorium = await _auditoriumsRepository.GetByIdAsync(item.Id);
if (existingAuditorium == null)
{
return(new CreateCinemaResultModel
{
ErrorMessage = Messages.AUDITORIUM_DOES_NOT_EXIST,
IsSuccessful = false
});
}
var projectionsInAuditorium = _projectionsRepository.GetAllOfSpecificAuditorium(item.Id);
if (projectionsInAuditorium != null)
{
foreach (var projection in projectionsInAuditorium)
{
if (projection.DateTime > DateTime.Now)
{
return(new CreateCinemaResultModel
{
ErrorMessage = Messages.PROJECTION_IN_FUTURE,
IsSuccessful = false,
Cinema = new CinemaDomainModel
{
Id = existingCinema.Id,
Name = existingCinema.Name
}
});
}
_projectionsRepository.Delete(projection.Id);
await _ticketService.DeleteTicketFromProjection(projection.Id);
}
}
var seatsInAuditorium = _seatsRepository.GetAllOfSpecificAuditorium(item.Id);
if (seatsInAuditorium != null)
{
foreach (var seat in seatsInAuditorium)
{
_seatsRepository.Delete(seat.Id);
}
}
var deleteVariable = _auditoriumsRepository.Delete(item.Id);
AuditoriumResultModel auditoriumModel = new AuditoriumResultModel
{
ErrorMessage = null,
IsSuccessful = true,
Auditorium = new AuditoriumDomainModel
{
CinemaId = existingAuditorium.CinemaId,
Id = existingAuditorium.Id,
Name = existingAuditorium.Name
}
};
if (!auditoriumModel.IsSuccessful)
{
CreateCinemaResultModel errorModel = new CreateCinemaResultModel
{
ErrorMessage = Messages.CINEMA_DELETION_ERROR,
IsSuccessful = false,
Cinema = new CinemaDomainModel
{
Id = existingCinema.Id,
Name = existingCinema.Name
}
};
return(errorModel);
}
}
var data = _cinemasRepository.Delete(id);
_cinemasRepository.Save();
CreateCinemaResultModel domainModel = new CreateCinemaResultModel
{
ErrorMessage = null,
IsSuccessful = true,
Cinema = new CinemaDomainModel
{
Id = existingCinema.Id,
Name = existingCinema.Name
}
};
return(domainModel);
}
public async Task <AuditoriumResultModel> UpdateAuditorium(AuditoriumDomainModel auditoriumToUpdate)
{
var projectionsInAuditorium = _projectionsRepository.GetAllOfSpecificAuditorium(auditoriumToUpdate.Id);
if (projectionsInAuditorium != null)
{
foreach (var item in projectionsInAuditorium)
{
if (item.DateTime > DateTime.Now)
{
return(new AuditoriumResultModel
{
IsSuccessful = false,
ErrorMessage = Messages.AUDITORIUM_UPDATE_ERROR_PROJECTION_IN_FUTURE
});
}
}
}
var seatsInAuditorium = _seatsRepository.GetAllOfSpecificAuditorium(auditoriumToUpdate.Id);
if (seatsInAuditorium != null)
{
foreach (var item in seatsInAuditorium)
{
await _ticketService.DeleteTicket(item.Id);
_seatsRepository.Delete(item.Id);
}
}
Auditorium auditorium = new Auditorium()
{
Id = auditoriumToUpdate.Id,
Name = auditoriumToUpdate.Name,
CinemaId = auditoriumToUpdate.CinemaId,
Seats = new List <Seat>()
};
for (int i = 1; i <= auditoriumToUpdate.SeatRows; i++)
{
for (int j = 1; j <= auditoriumToUpdate.NumberOfSeats; j++)
{
Seat newSeat = new Seat()
{
Row = i,
Number = j
};
auditorium.Seats.Add(newSeat);
}
}
var data = _auditoriumsRepository.Update(auditorium);
if (data == null)
{
return(new AuditoriumResultModel
{
IsSuccessful = false,
ErrorMessage = Messages.AUDITORIUM_UPDATE_ERROR
});
}
_auditoriumsRepository.Save();
AuditoriumResultModel domainModel = new AuditoriumResultModel
{
ErrorMessage = null,
IsSuccessful = true,
Auditorium = new AuditoriumDomainModel
{
CinemaId = data.CinemaId,
Id = data.Id,
Name = data.Name,
NumberOfSeats = data.Seats.Select(x => x.Number).Count(),
SeatRows = data.Seats.Select(x => x.Row).Count(),
}
};
return(domainModel);
}
