public void CinemaService_DeleteCinemaAsync_ReturnsNullCinema()
{
//Arrange
Auditorium audit1 = new Auditorium
{
Id = 2,
AuditName = "Auditorium 1",
CinemaId = 11,
};
Auditorium audit2 = new Auditorium
{
Id = 3,
AuditName = "Auditorium 2",
CinemaId = 11,
};
List <Auditorium> auditsList = new List <Auditorium>();
auditsList.Add(audit1);
auditsList.Add(audit2);
_mockCinemaRepository.Setup(x => x.GetByIdAsync(It.IsAny <int>())).ReturnsAsync(null as Data.Cinema);
_mockAuditoriumRepository.Setup(x => x.GetAll()).ReturnsAsync(auditsList);
_mockCinemaRepository.Setup(x => x.Delete(It.IsAny <int>())).Returns(_cinema);
//Act
var resultAction = cinemaService.DeleteCinemaAsync(_cinema.Id).ConfigureAwait(false).GetAwaiter().GetResult();
//Assert
Assert.IsNull(resultAction);
}
public void AuditoriumService_GetAllAuditoriums_ReturnsListOfAuditoriums()
{
//Arrange
var expectedCount = 2;
Auditorium auditorium2 = new Auditorium
{
Id = 2,
CinemaId = 2,
AuditName = "Stari auditorium"
};
List <Auditorium> auditoriums = new List <Auditorium>();
auditoriums.Add(_auditorium);
auditoriums.Add(auditorium2);
List <AuditoriumDomainModel> auditoriumDomainModels = new List <AuditoriumDomainModel>();
auditoriumDomainModels.Add(_auditoriumDomainModel);
_mockAuditoriumRepository.Setup(x => x.GetAll()).ReturnsAsync(auditoriums);
//Act
var resultAction = _auditoriumService.GetAllAsync().ConfigureAwait(false).GetAwaiter().GetResult();
var result = resultAction.ToList();
//Assert
Assert.IsNotNull(resultAction);
Assert.AreEqual(expectedCount, result.Count);
Assert.AreEqual(result[0].Id, _auditoriumDomainModel.Id);
Assert.IsInstanceOfType(result[0], typeof(AuditoriumDomainModel));
}
public ActionResult Index(AuditoriumViewModel model)
{
var auditorium = new Auditorium
{
Id = Guid.NewGuid(),
Name = model.Name,
SeatsNr = model.Width * model.Length
};
_context.Auditoriums.Add(auditorium);
_context.SaveChanges();
for (var i = 1; i <= model.Length; i++)
{
for (var j = 1; j <= model.Width; j++)
{
var seats = new Seat
{
Id = Guid.NewGuid(),
Number = j,
Row = i,
AuditoriumId = auditorium.Id
};
_context.Seats.Add(seats);
_context.SaveChanges();
}
}
return(View());
}
public void AuditoriumService_GetAuditoriumsByCinemaId_ReturnsListOfAuditoriums()
{
//Arrange
var expectedCount = 2;
Auditorium audit2 = new Auditorium
{
Id = 111,
CinemaId = 1,
AuditName = "Dodatni auditorium"
};
List <Auditorium> audits = new List <Auditorium>();
audits.Add(_auditorium);
audits.Add(audit2);
_mockAuditoriumRepository.Setup(x => x.GetAuditoriumsByCinemaId(It.IsAny <int>())).Returns(audits);
//Act
var resultAction = _auditoriumService.GetAuditoriumsByCinemaId(_cinema.Id);
var result = resultAction.ToList();
//Assert
Assert.IsNotNull(resultAction);
Assert.AreEqual(expectedCount, result.Count);
Assert.AreEqual(result[0].Id, _auditorium.Id);
Assert.AreEqual(result[1].Name, audit2.AuditName);
Assert.IsInstanceOfType(result[0], typeof(AuditoriumDomainModel));
}
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 List <Auditorium> GetAuditoriumList()
{
try
{
List <Auditorium> auditoriumList = new List <Auditorium>();
using (var context = new BiografContext())
{
foreach (var auditorium in context.Auditoria)
{
Auditorium auditoriumModel = new Auditorium()
{
Id = auditorium.Id,
Name = auditorium.Name,
SeatsNumber = auditorium.SeatsNumber
};
auditoriumList.Add(auditoriumModel);
}
}
return(auditoriumList);
}
catch (Exception ex)
{
return(null);
}
}
public ActionResult Create(AuditoriumForm frm)
{
Auditorium aud;
if (frm.AuditoriumId > 0)
{
aud = auditoriumsRepo.GetById(frm.AuditoriumId);
aud.Name = frm.Name;
aud.Address = frm.Address;
}
else
{
aud = new Auditorium
{
ClubId = frm.ClubId,
UnionId = isClubUnderUnion(frm.ClubId) ? null : frm.UnionId,
SeasonId = isClubUnderUnion(frm.ClubId) ? null : frm.SeasonId,
Name = frm.Name,
Address = frm.Address
};
auditoriumsRepo.Create(aud);
}
auditoriumsRepo.Save();
TempData["SavedId"] = aud.AuditoriumId;
return(RedirectToAction("List", new { unionId = aud.UnionId, clubId = aud.ClubId, seasonId = frm.SeasonId }));
}
public AuditoriumEvent(string name, Calendar calendar, Ring ring, Auditorium auditorium)
{
Name = name;
Calendar = calendar;
Ring = ring;
Auditorium = auditorium;
}
public void TestInitialize()
{
_auditorium = new Auditorium
{
Id = 1,
CinemaId = 1,
AuditName = "Novi auditorium",
};
_auditoriumDomainModel = new AuditoriumDomainModel
{
Id = _auditorium.Id,
CinemaId = _auditorium.CinemaId,
Name = _auditorium.AuditName
};
_cinema = new Data.Cinema
{
Id = 1,
CityId = 1,
Name = "test bioskop 1"
};
_cinemaDomainModel = new CinemaDomainModel
{
Id = _cinema.Id,
CityId = _cinema.CityId,
Name = _cinema.Name
};
_mockAuditoriumRepository = new Mock <IAuditoriumsRepository>();
_mockCinemaRepository = new Mock <ICinemasRepository>();
_auditoriumService = new AuditoriumService(_mockAuditoriumRepository.Object, _mockCinemaRepository.Object);
}
private bool hasErrors()
{
if (!Int32.TryParse(TextBoxAuditoriumNumber.Text, out int auditoriumNumber))
{
MessageBox.Show("Невірно введено номер аудиторії");
return(true);
}
///check if auditorium with same internal number already exist
Auditorium existedAuditorium = (from a in SharedData.AuditoriumsFromDatabase where a.InternalNumber == auditoriumNumber select a).FirstOrDefault();
if (existedAuditorium != null)
{
MessageBox.Show("Зал з вказаним номером вже існує");
return(true);
}
if (!Int32.TryParse(TextBoxCountPlaces.Text, out int countPlaces))
{
MessageBox.Show("Невірно введено кількість місць");
return(true);
}
if (!Int32.TryParse(TextBoxCountRows.Text, out int countRows))
{
MessageBox.Show("Невірно введено кількість рядів");
return(true);
}
if (countPlaces % countRows != 0)
{
MessageBox.Show("Кількість місць у кожному ряді повинна бути однакова");
return(true);
}
return(false);
}
public void Execute(AuditoriumDto request)
{
_validator.ValidateAndThrow(request);
var auditorium = new Auditorium
{
Name = request.Name
};
_context.Auditoriums.Add(auditorium);
_context.SaveChanges();
int lastAuditoriumId = _context.Auditoriums.Max(item => item.Id);
for (var i = 1; i <= 10; i++)
{
var seat = new Seat
{
Number = i,
AuditoriumId = lastAuditoriumId
};
_context.Seats.Add(seat);
}
_context.SaveChanges();
}
public AuditoriumEvent(string name, Calendar calendar, Ring ring, Auditorium auditorium)
{
Name = name;
Calendar = calendar;
Ring = ring;
Auditorium = auditorium;
}
public AuditoriumView(Auditorium auditorium, List <Seat> occupiedSeats)
{
Rows = new List <AuditoriumRow>();
for (var i = 0; i < auditorium.Rows; i++)
{
var row = new AuditoriumRow
{
Seats = new List <AuditoriumSeat>(),
Number = i + 1
};
for (var j = 0; j < auditorium.Seats; j++)
{
var seat = new AuditoriumSeat
{
Row = row,
SeatNumber = j + 1,
IsFree = true
};
seat.PropertyChanged += SeatOnPropertyChanged;
row.Seats.Add(seat);
}
Rows.Add(row);
}
foreach (var seat in occupiedSeats)
{
Rows[seat.RowNumber - 1].Seats[seat.SeatNumber - 1].IsFree = false;
}
}
public async Task <IActionResult> Edit(int id, [Bind("ID,Seats")] Auditorium auditorium)
{
if (id != auditorium.ID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(auditorium);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!AuditoriumExists(auditorium.ID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(auditorium));
}
public Auditorium Delete(object id)
{
Auditorium existing = _cinemaContext.Auditoriums.Find(id);
var result = _cinemaContext.Auditoriums.Remove(existing);
return(result.Entity);
}
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 void AuditoriumService_DeleteAuditorium_AuditoriumResultModel_Successful()
{
//Arrange
Auditorium auditorium = _auditorium;
IEnumerable <Projection> projections = null;
IEnumerable <Seat> seats = null;
_mockAuditoriumsRepository = new Mock <IAuditoriumsRepository>();
Task <Auditorium> responseTaskAuditoriumsRepository = Task.FromResult(auditorium);
_mockAuditoriumsRepository.Setup(x => x.GetByIdAsync(It.IsAny <int>())).Returns(responseTaskAuditoriumsRepository);
_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);
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.IsTrue(resultAction.IsSuccessful);
Assert.IsNull(resultAction.ErrorMessage);
Assert.IsInstanceOfType(resultAction, typeof(AuditoriumResultModel));
Assert.AreEqual(auditorium.Name, resultAction.Auditorium.Name);
}
public void AuditoriumsService_CreateAuditorium_ReturnCreateAuditoriumResultModel_Successful()
{
IEnumerable <Auditorium> auditoriums = _listOFAuditoriums;
AuditoriumDomainModel auditoriumDomainModel = _auditoriumDomainModel;
Auditorium auditorium = _auditorium;
Auditorium newAuditorium = _newAuditorium;
var numberOfSeatsPerRow = 1;
var numberOfRows = 1;
Data.Cinema cinema = _cinema;
Task <Data.Cinema> responseTaskCinemasRepository = Task.FromResult(cinema);
_mockCinemasRepository = new Mock <ICinemasRepository>();
_mockCinemasRepository.Setup(x => x.GetByIdAsync(It.IsAny <int>())).Returns(responseTaskCinemasRepository);
_mockAuditoriumsRepository = new Mock <IAuditoriumsRepository>();
Task <IEnumerable <Auditorium> > responseTaskAuditoriumsRepository = Task.FromResult(auditoriums);
_mockAuditoriumsRepository.Setup(x => x.GetByAuditName(auditoriumDomainModel.Name, cinema.Id)).Returns(responseTaskAuditoriumsRepository);
_mockAuditoriumsRepository = new Mock <IAuditoriumsRepository>();
_mockAuditoriumsRepository.Setup(x => x.Insert(It.IsAny <Auditorium>())).Returns(newAuditorium);
AuditoriumService auditoriumController = new AuditoriumService(_mockAuditoriumsRepository.Object, _mockCinemasRepository.Object, _mockSeatsRepository.Object, _mockProjectionRepository.Object, _mockTicketService.Object);
//Act
var resultAction = auditoriumController.CreateAuditorium(_auditoriumDomainModel, numberOfRows, numberOfSeatsPerRow).ConfigureAwait(false).GetAwaiter().GetResult();
//Assert
Assert.IsNotNull(resultAction);
Assert.IsNull(resultAction.ErrorMessage);
Assert.IsTrue(resultAction.IsSuccessful);
Assert.IsInstanceOfType(resultAction, typeof(CreateAuditoriumResultModel));
Assert.AreEqual(1, resultAction.Auditorium.Id);
}
private void ButtonAddAuditorium_Click(object sender, RoutedEventArgs e)
{
if (hasErrors())
{
return;
}
Auditorium newAuditorium = new Auditorium()
{
InternalNumber = Convert.ToInt32(TextBoxAuditoriumNumber.Text),
CountPlaces = Convert.ToInt32(TextBoxCountPlaces.Text),
CountRows = Convert.ToInt32(TextBoxCountRows.Text)
};
int row = 0;
using (SQLiteConnection connection = new SQLiteConnection(SharedData.DatabaseLocation))
{
connection.CreateTable <Auditorium>();
row = connection.Insert(newAuditorium);
if (row == 0)
{
MessageBox.Show("Не вдалось додати аудиторію");
}
}
if (row > 0)
{
SharedData.AuditoriumsToView.Add(newAuditorium);
SharedData.AuditoriumsFromDatabase.Add(newAuditorium);
}
this.Close();
}
public void Import()
{
using (UniversitySheduleContainer cnt = new UniversitySheduleContainer("name=UniversitySheduleContainer"))
{
foreach (var g in readedauditoriums)
{
if (g.Add)
{
var deps = (from lt in cnt.Departments where lt.Id == g.Chair select lt);
if (deps.Count() == 0)
{
continue;
}
Auditorium newAudit = new Auditorium()
{
Building = g.Corpus,
Department = deps.First(),
Seats = g.Capacity,
Number = g.CorAndNum,
OpeningDate = "",
ClosingDate = "",
};
cnt.Auditoriums.AddObject(newAudit);
}
}
cnt.SaveChanges();
}
}
public async Task <IActionResult> Edit(int id, [Bind("Id,AuditoriumNumber,AuditoriumCapacity,AuditoriumType")] Auditorium auditorium)
{
if (id != auditorium.Id)
{
return(NotFound());
}
var gettype = await _context.AuditoriumTypes.FirstOrDefaultAsync(t =>
t.AuditoriumAbbreviation == auditorium.AuditoriumType.AuditoriumAbbreviation);
auditorium.AuditoriumType = gettype;
auditorium.AuditoriumType.Id = gettype.Id;
if (ModelState.IsValid)
{
try
{
_context.Update(auditorium);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!AuditoriumExists(auditorium.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["AuditoriumTypeId"] = new SelectList(_context.AuditoriumTypes, "Id", "Id", auditorium.AuditoriumTypeId);
return(View(auditorium));
}
public void AuditoriumService_DeleteAuditorium_AuditoriumRepositoryReturnsNull_ReturnsNull()
{
//Arrange
Auditorium nullAuditorium = null;
List <ProjectionDomainModel> projectionsModelsList = new List <ProjectionDomainModel>();
projectionsModelsList.Add(_projectionDomainModel);
IEnumerable <ProjectionDomainModel> projections = projectionsModelsList;
Task <IEnumerable <ProjectionDomainModel> > projectionsResponseTask = Task.FromResult(projections);
List <SeatDomainModel> seatsModelsList = new List <SeatDomainModel>();
seatsModelsList.Add(_seatDomainModel);
IEnumerable <SeatDomainModel> seats = seatsModelsList;
Task <IEnumerable <SeatDomainModel> > seatsResponseTask = Task.FromResult(seats);
AuditoriumService auditoriumService = new AuditoriumService(_mockAuditoriumsRepository.Object, _mockProjectionService.Object, _mockSeatService.Object);
_mockProjectionService.Setup(x => x.DeleteByAuditoriumId(It.IsAny <int>())).Returns(projectionsResponseTask);
_mockSeatService.Setup(x => x.DeleteByAuditoriumId(It.IsAny <int>())).Returns(seatsResponseTask);
_mockAuditoriumsRepository.Setup(x => x.Delete(It.IsAny <int>())).Returns(nullAuditorium);
//Act
var result = auditoriumService.DeleteAuditorium(_auditorium.Id).ConfigureAwait(false).GetAwaiter().GetResult();
//Assert
Assert.IsNull(result);
}
public Lesson(TeacherForDiscipline teacherForDiscipline, Calendar calendar,
Ring ring, Auditorium auditorium)
{
TeacherForDiscipline = teacherForDiscipline;
Calendar = calendar;
Ring = ring;
Auditorium = auditorium;
}
public Auditorium Update(Auditorium obj)
{
var updatedEntry = _cinemaContext.Auditoriums.Attach(obj);
_cinemaContext.Entry(obj).State = EntityState.Modified;
return(updatedEntry.Entity);
}
public async Task <IActionResult> Create([FromBody] Auditorium auditorium)
{
await Task.Run(() => dbContext.Auditorium.Add(auditorium));
await Task.Run(() => dbContext.SaveChanges());
return(Ok());
}
public Lesson(TeacherForDiscipline teacherForDiscipline, Calendar calendar,
Ring ring, Auditorium auditorium)
{
TeacherForDiscipline = teacherForDiscipline;
Calendar = calendar;
Ring = ring;
Auditorium = auditorium;
}
public async Task <Auditorium> UpdateAsync(Auditorium auditorium)
{
var housing = await Housings.FindOneAndUpdateAsync(
c => string.Equals(c.Id, auditorium.HousingId) && c.Auditoriums.Any(a => string.Equals(a.Id, auditorium.Id)),
Builders <Housing> .Update.Set(c => c.Auditoriums.ElementAt(-1), auditorium)); //-1 means first matching element of nested array
return(housing.Auditoriums.FirstOrDefault(c => string.Equals(c.Id, auditorium.Id)));
}
public IActionResult Delete(int id, Auditorium a1)
{
var movies = context.Movies.Where(x => x.MovieId == id).SingleOrDefault();
context.Movies.Remove(movies);
context.SaveChanges();
return(RedirectToAction("Index"));
}
} // readonly
//private Stream stream;
public Lecture(Teacher teacher, TimeSlot time, Subject subject, Auditorium auditorium, Stream stream)
{
Teacher = teacher;
TimeSlot = time;
Subject = subject;
Auditorium = auditorium;
Stream = stream;
}
public ActionResult Delete(int id, Auditorium a1)
{
var auditorium = context.Auditoriums.Where(x => x.AuditoriumId == id).SingleOrDefault();
context.Auditoriums.Remove(auditorium);
context.SaveChanges();
return(RedirectToAction("Index"));
}
public Practice(Teacher teacher, TimeSlot time, Subject subject, Auditorium auditorium, Group group)
{
Teacher = teacher;
TimeSlot = time;
Subject = subject;
Auditorium = auditorium;
this.group = group;
}
public async Task <Auditorium> Delete(int id)
{
Auditorium existing = await _theatreContext.Auditoriums.FindAsync(id);
var result = _theatreContext.Auditoriums.Remove(existing);
return(result.Entity);
}
public Lesson(int lessonId,
TeacherForDiscipline teacherForDiscipline, Calendar calendar,
Ring ring, Auditorium auditorium, bool isActive)
{
LessonId = lessonId;
TeacherForDiscipline = teacherForDiscipline;
Calendar = calendar;
Ring = ring;
Auditorium = auditorium;
IsActive = isActive;
}
