public async Task ItRefusesEntryIfTheLotIsFull()
{
// arrange
var config = new ParkingLotConfig {
MaxParkingSpaces = 3
};
var ticketService = new TicketService(_context, config);
var rateLevel = new RateLevel
{
Name = "Test Rate",
RateValue = 1.25M
};
var tickets = new[]
{
new Ticket {
Customer = "Test Customer 1", RateLevel = rateLevel
},
new Ticket {
Customer = "Test Customer 2", RateLevel = rateLevel
},
new Ticket {
Customer = "Test Customer 3", RateLevel = rateLevel
}
};
await _context.Tickets.AddRangeAsync(tickets);
await _context.SaveChangesAsync();
// act/assert
await Assert.ThrowsAsync <LotFullException>(async() => await ticketService.IssueNewTicket("Test Customer 4", 1));
}
public async Task ReOpenTicket(int ticketId, [Remainder] string reason = null)
{
var ticket = TicketService.GetTicket(Context, ticketId);
if (ticket == null)
{
await ReplyAsync("No ticket found with that id.");
return;
}
var tGuild = TicketService.GetTicketGuild(Context.Guild.Id);
if (!TicketService.IsManager(tGuild, Context.User as IGuildUser, ticket))
{
await ReplyAsync("You don't have enough permissions to modify that ticket.");
return;
}
ticket.SetState(Models.Ticket.TicketState.open, reason ?? $"Re-opened by {Context.User.Mention}");
TicketService.SaveTicket(ticket);
await TicketService.UpdateLiveMessageAsync(Context.Guild, tGuild, ticket);
await TryNotifyTicketCreator(tGuild, ticket);
await ReplyAsync("Re-opened.");
}
public async Task ItIssuesATicketIfThereIsASpace()
{
// arrange
var config = new ParkingLotConfig {
MaxParkingSpaces = 3
};
var ticketService = new TicketService(_context, config);
var rateLevel = new RateLevel
{
Name = "Test Rate",
RateValue = 1.25M
};
var tickets = new[]
{
new Ticket {
Customer = "Test Customer 1", RateLevel = rateLevel
},
new Ticket {
Customer = "Test Customer 2", RateLevel = rateLevel
}
};
await _context.Tickets.AddRangeAsync(tickets);
await _context.SaveChangesAsync();
// act
var newTicket = await ticketService.IssueNewTicket("cust", rateLevel.Id);
// assert
Assert.NotNull(newTicket);
Assert.Equal("cust", newTicket.Customer);
}
public KhachHangController()
{
customerService = new CustomerService();
ticketService = new TicketService();
showtimeService = new ShowtimeService();
seatService = new SeatService();
}
public TicketDetail(string id)
{
InitializeComponent();
pnl_AddFeedback.Hide();
this.authenticationService = AuthenticationService.GetInstance();
this.ticketService = new TicketService();
this.id = id;
// Get ticket details with the ID provided
this.ticket = ticketService.GetTicket(id);
if (authenticationService.GetCurrentUser().Type == UserType.Employee)
{
btnEditTicket.Visible = true;
}
else if (ticket.Status == TicketStatus.Resolved || ticket.Status == TicketStatus.Closed)
{
btnAddFeedback.Visible = true;
}
if (ticket == null)
{
MessageBox.Show("Could not retrieve ticket information");
this.Close();
}
else
{
FillTicketDetails();
}
}
public async Task <TicketSummaryResponse> AddTicket([FromBody] AddTicketArgs args)
{
var service = new TicketService();
var result = await service.AddTicket(args);
return(result);
}
public async Task <ResourceSummaryResponse> ResourceSummary([FromBody] int[] resources)
{
var service = new TicketService();
var result = await service.GetSummary(resources);
return(result);
}
public async Task <TicketDetailResponse> GetTicketDetail(string ticketID)
{
var service = new TicketService();
var result = await service.SelectTicketDetail(ticketID);
return(result);
}
public async Task <TicketDetailResponse> PostMessage([FromBody] string message, [FromUri] string ticketID)
{
var service = new TicketService();
var result = await service.PostMessage(ticketID, message);
return(result);
}
public async Task <TicketSummaryResponse> GetTickets(string email)
{
var service = new TicketService();
var result = await service.SelectTicketsByEmail(email);
return(result);
}
public async Task <TicketSummaryResponse> GetTickets(int resourceId)
{
var service = new TicketService();
var result = await service.SelectTicketsByResource(resourceId);
return(result);
}
public async Task <IActionResult> GetTicketsAsync(TicketSearchRequest req)
{
StringValues jwtToken;
try
{
Request.Headers.TryGetValue(Constants.JWTTokenHeader, out jwtToken);
}
catch
{
// Forbidden
return(Forbid(Constants.UnauthorizedRequest));
}
TicketDAO ticketDAO = new TicketDAO(Constants.SQLConnection);
TicketService ticketService = new TicketService(ticketDAO);
AuthorizationService authorizationService = new AuthorizationService();
UserDAO userDAO = new UserDAO(Constants.SQLConnection);
SessionService sessionService = new SessionService(userDAO, authorizationService);
AuthorizationManager authorizationManager = new AuthorizationManager(authorizationService, sessionService);
TicketManager ticketManager = new TicketManager(ticketService, authorizationManager);
Result <List <TicketRecord> > tickets = await ticketManager.GetTicketsAsync(jwtToken, req.filterParams);
return(Ok(tickets));
}
public async Task <IActionResult> SubmitTicket(NewTicketRequest req)
{
TicketDAO ticketDAO = new TicketDAO(Constants.SQLConnection);
TicketService ticketService = new TicketService(ticketDAO);
AuthorizationService authorizationService = new AuthorizationService();
UserDAO userDAO = new UserDAO(Constants.SQLConnection);
SessionService sessionService = new SessionService(userDAO, authorizationService);
AuthorizationManager authorizationManager = new AuthorizationManager(authorizationService, sessionService);
TicketManager ticketManager = new TicketManager(ticketService, authorizationManager);
// Make sure we sent a correct category
Constants.TicketCategories category;
try
{
category = (Constants.TicketCategories)Enum.Parse(typeof(Constants.TicketCategories), req.category);
}
catch
{
return(BadRequest(Constants.TicketImproperCategory));
}
Result <bool> success = await ticketManager.SubmitTicket(category, req.description);
return(Ok(success));
}
public void TestSetUp()
{
var connection = @"Server=DESKTOP-DMYTRO\SQLEXPRESS;Initial Catalog=Academy;Trusted_Connection=True;ConnectRetryCount=0";
DbContextOptionsBuilder <MyContext> t = new DbContextOptionsBuilder <MyContext>();
t.UseSqlServer(connection);
mc = new MyContext(t.Options);
CrewRepository crewRepository = new CrewRepository(mc);
PilotRepository pilotRepository = new PilotRepository(mc);
StewardessRepository stewardessRepository = new StewardessRepository(mc);
FlightRepository flightRepository = new FlightRepository(mc);
TicketRepository ticketRepository = new TicketRepository(mc);
TakeOffRepository takeOffRepository = new TakeOffRepository(mc);
PlaneRepository planeRepository = new PlaneRepository(mc);
PlaneTypeRepository planeTypeRepository = new PlaneTypeRepository(mc);
UnitOfWork unitOfWork = new UnitOfWork(crewRepository, flightRepository, pilotRepository,
planeRepository, planeTypeRepository, stewardessRepository,
takeOffRepository, ticketRepository, mc);
CrewService crewService = new CrewService(unitOfWork);
FlightService flightService = new FlightService(unitOfWork);
StewardessService stewardessService = new StewardessService(unitOfWork);
PilotService pilotService = new PilotService(unitOfWork);
TicketService ticketService = new TicketService(unitOfWork);
TakeOffService takeOffService = new TakeOffService(unitOfWork);
PlaneService planeService = new PlaneService(unitOfWork);
PlaneTypeService planeTypeService = new PlaneTypeService(unitOfWork);
pilotController = new PilotController(pilotService);
flightController = new FlightController(flightService);
}
[Test] // behaviour test
public void Create_When_entity_is_created_Then_it_makes_calls_to_repository_and_unit_of_work()
{
// Arrange
var ticketDTOToCreate = new TicketDTO()
{
Price = 10.23,
FlightId = 1
};
var ticketRepositoryFake = A.Fake <ITicketRepository>();
var unitOfWorkFake = A.Fake <IUnitOfWork>();
A.CallTo(() => unitOfWorkFake.Set <Ticket>()).Returns(ticketRepositoryFake);
var ticketService = new TicketService(unitOfWorkFake, AlwaysValidValidator);
// Act
var result = ticketService.Create(ticketDTOToCreate);
// Assert. Just behaviour
A.CallTo(() => ticketRepositoryFake.Create(A <Ticket> ._)).MustHaveHappenedOnceExactly();
A.CallTo(() => unitOfWorkFake.Set <Ticket>()).MustHaveHappenedOnceExactly();
A.CallTo(() => unitOfWorkFake.SaveChanges()).MustHaveHappenedOnceExactly();
}
public async Task DeleteTicket(int ticketId)
{
var ticket = TicketService.GetTicket(Context, ticketId);
if (ticket == null)
{
await ReplyAsync("No ticket found with that id.");
return;
}
if (!TicketService.IsManager(TicketService.GetTicketGuild(Context.Guild.Id), Context.User as IGuildUser, ticket))
{
await ReplyAsync("You don't have enough permissions to modify that ticket.");
return;
}
if (ticket.AuthorId == Context.User.Id)
{
TicketService.RemoveTicket(Context.Guild.Id, ticketId);
await ReplyAsync("Deleted.");
}
else if (Context.User is SocketGuildUser g && g.GuildPermissions.Administrator)
{
TicketService.RemoveTicket(Context.Guild.Id, ticketId);
await ReplyAsync("Deleted. (as admin)");
}
[Test] // behaviour test
public void Create_When_entity_is_invalid_Then_it_makes_no_calls_to_repository_and_unit_of_work()
{
// Arrange
var ticketDTOToCreate = new TicketDTO()
{
Price = 10.23,
FlightId = 2
};
var ticketRepositoryFake = A.Fake <ITicketRepository>();
var unitOfWorkFake = A.Fake <IUnitOfWork>();
A.CallTo(() => unitOfWorkFake.Set <Ticket>()).Returns(ticketRepositoryFake);
var ticketService = new TicketService(unitOfWorkFake, AlwaysInValidValidator);
// Act + Assert
var exception = Assert.Throws <BadRequestException>(() => ticketService.Create(ticketDTOToCreate));
// Assert. Just behaviour
A.CallTo(() => ticketRepositoryFake.Create(A <Ticket> ._)).MustNotHaveHappened();
A.CallTo(() => unitOfWorkFake.TicketRepository).MustNotHaveHappened();
A.CallTo(() => unitOfWorkFake.Set <Ticket>()).MustNotHaveHappened();
A.CallTo(() => unitOfWorkFake.SaveChanges()).MustNotHaveHappened();
}
public async Task ItCalculatesTheCorrectOwingAmount(DateTimeOffset issuedOn, TimeSpan rateDuration, decimal rateValue, decimal expectedTotal)
{
// arrange
var config = new ParkingLotConfig {
MaxParkingSpaces = 3
};
var ticketService = new TicketService(_context, config);
var rateLevel = new RateLevel
{
Name = rateDuration.ToString(),
Duration = rateDuration,
RateValue = rateValue
};
var ticket = new Ticket
{
Customer = "Test Customer",
RateLevel = rateLevel,
IssuedOn = issuedOn
};
await _context.AddAsync(ticket);
await _context.SaveChangesAsync();
// act
var amountOwing = ticketService.GetAmountOwed(ticket);
// assert
Assert.Equal(expectedTotal, amountOwing);
}
public void TicketCreate()
{
TicketService ticketService = new TicketService(unitOfWork);
TicketDTO ticketDTO = new TicketDTO()
{
Price = 500,
FlightNum = new FlightDTO()
{
DeperturePlace = "testing",
ArrivalPlace = "test",
DepartureTime = new DateTime(1, 4, 3),
ArrivalTime = new DateTime(1, 3, 4)
}
};
ticketService.CreateTicket(ticketDTO);
Ticket ticket = fakeTicketRepository.Get(1);
Assert.AreEqual(ticket.Price, ticketDTO.Price);
Assert.AreEqual(ticket.FlightNum.DepartureTime, ticketDTO.FlightNum.DepartureTime);
Assert.AreEqual(ticket.FlightNum.ArrivalTime, ticketDTO.FlightNum.ArrivalTime);
Assert.AreEqual(ticket.FlightNum.ArrivalPlace, ticketDTO.FlightNum.ArrivalPlace);
Assert.AreEqual(ticket.FlightNum.DeperturePlace, ticketDTO.FlightNum.DeperturePlace);
}
public void Create_When_entity_is_invalid_Then_bad_request_exception_is_thrown()
{
// Arrange
var ticketMock = new Ticket()
{
Id = 2,
Price = 10.23,
FlightId = 2
};
var ticketDTOToCreate = new TicketDTO()
{
Price = 10.23,
FlightId = 2
};
var ticketRepositoryFake = A.Fake <ITicketRepository>();
A.CallTo(() => ticketRepositoryFake.Create(A <Ticket> ._)).Returns(ticketMock);
var unitOfWorkFake = A.Fake <IUnitOfWork>();
A.CallTo(() => unitOfWorkFake.Set <Ticket>()).Returns(ticketRepositoryFake);
var ticketService = new TicketService(unitOfWorkFake, AlwaysInValidValidator);
// Act + Assert
var exception = Assert.Throws <BadRequestException>(() => ticketService.Create(ticketDTOToCreate), "");
Assert.AreEqual(exception.Message, "Is Invalid");
}
public void UpdateEntity_Should_Update_ticket_typeof_Ticket()
{
// Arrange
TicketDTO ticketDTO = new TicketDTO
{
Id = 1,
FlightId = 1,
FlightNumber = 1111,
Price = 120
};
Ticket ticket = new Ticket
{
Id = 1,
FlightId = 1,
FlightNumber = 1111,
Price = 120
};
var ticketRepository = A.Fake <IRepository <Ticket> >();
A.CallTo(() => ticketRepository.Get(A <int> ._)).Returns(new Ticket {
Id = 1
});
var ticketService = new TicketService(ticketRepository);
//Act
ticketService.UpdateEntity(1, ticketDTO);
var result = ticketRepository.Get(1);
// Assert
Assert.AreEqual(ticket, result);
}
public ServerImplement(GameService gameService, TicketService ticketService, SellerService sellerService)
{
this.gameService = gameService;
this.ticketService = ticketService;
this.sellerService = sellerService;
loggedClients = new Dictionary <int, IClient>();
}
public async void Update_ErrorsOccurred_ShouldReturnErrorResponse()
{
var mock = new ServiceMockFacade <ITicketService, ITicketRepository>();
var model = new ApiTicketServerRequestModel();
var validatorMock = new Mock <IApiTicketServerRequestModelValidator>();
validatorMock.Setup(x => x.ValidateUpdateAsync(It.IsAny <int>(), It.IsAny <ApiTicketServerRequestModel>())).Returns(Task.FromResult(new ValidationResult(new List <ValidationFailure>()
{
new ValidationFailure("text", "test")
})));
mock.RepositoryMock.Setup(x => x.Get(It.IsAny <int>())).Returns(Task.FromResult(new Ticket()));
var service = new TicketService(mock.LoggerMock.Object,
mock.MediatorMock.Object,
mock.RepositoryMock.Object,
validatorMock.Object,
mock.DALMapperMockFactory.DALTicketMapperMock,
mock.DALMapperMockFactory.DALSaleTicketsMapperMock);
UpdateResponse <ApiTicketServerResponseModel> response = await service.Update(default(int), model);
response.Should().NotBeNull();
response.Success.Should().BeFalse();
validatorMock.Verify(x => x.ValidateUpdateAsync(It.IsAny <int>(), It.IsAny <ApiTicketServerRequestModel>()));
mock.MediatorMock.Verify(x => x.Publish(It.IsAny <TicketUpdatedNotification>(), It.IsAny <CancellationToken>()), Times.Never());
}
public void CreateEntity_Should_Create_ticket_typeof_Ticket()
{
// Arrange
TicketDTO ticketDTO = new TicketDTO
{
Id = 1,
FlightId = 1,
FlightNumber = 1111,
Price = 120
};
Ticket ticket = new Ticket
{
Id = 1,
FlightId = 1,
FlightNumber = 1111,
Price = 120
};
var ticketRepository = new FakeRepository <Ticket>();
var ticketService = new TicketService(ticketRepository);
// Act
ticketService.CreateEntity(ticketDTO);
var result = ticketRepository.Get(1);
// Assert
Assert.AreEqual(ticket, result);
}
public OrderFacadeService(
OrderService orderService,
TicketService ticketService,
OrderDetailService orderDetailService,
SaleLogService saleLogService,
TicketTestingService ticketTestingService,
SmsService smsService,
AuthorizationService authorizationService,
RefundDetailService refundDetailService,
OtaTicketRelationService otaTicketRelationService,
NoticeOrderConsumedService noticeOrderConsumedService,
OrderTravelNoticeService orderTravelNoticeService)
{
_orderService = orderService;
_ticketService = ticketService;
_orderDetailService = orderDetailService;
_saleLogService = saleLogService;
_ticketTestingService = ticketTestingService;
_smsService = smsService;
_authorizationService = authorizationService;
_refundDetailService = refundDetailService;
_otaTicketRelationService = otaTicketRelationService;
_noticeOrderConsumedService = noticeOrderConsumedService;
_orderTravelNoticeService = orderTravelNoticeService;
}
public RemoveEventViewModel(TicketService serviceT, ConcertService serviceC)
{
tService = serviceT;
cService = serviceC;
Concerts = new ObservableCollection <ConcertDTO>(cService.GetAll());
DeleteConcertCommand = new RelayCommand(x =>
{
int b = 0;
foreach (var i in tService.GetAll())
{
if (i.ConcertId == SelectedConcert.Id)
{
b++;
}
}
if (b == 0)
{
ErrorText = "";
cService.Delete(SelectedConcert);
}
else
{
ErrorText = "Нельзя удалить. Имеются билеты с указанным концертом";
}
Switcher.Switch(new ListEventView());
});
}
public void TestSetup()
{
_ticketId = 1;
_ticket = new Ticket()
{
Id = _ticketId, FlightId = 1, Price = 5000,
Flight = new Flight()
{
Id = 1, DepartureId = 1, Departure = "Kiev", DepartureTime = new DateTime(2018, 7, 15, 19, 35, 00), Destination = "Tbilisi",
ArrivalTime = new DateTime(2018, 7, 15, 21, 52, 00), Tickets = new List <Ticket> {
}
}
};
_ticketDTO = new DTO.Ticket()
{
Id = _ticketId, FlightId = 1, Price = 5000,
Flight = new DTO.Flight()
{
Id = 1, Departure = "Kiev", DepartureTime = new DateTime(2018, 7, 15, 19, 35, 00), Destination = "Tbilisi",
ArrivalTime = new DateTime(2018, 7, 15, 21, 52, 00), Tickets = new List <DTO.Ticket> {
}
}
};
A.CallTo(() => _fakeMapper.Map <Ticket, DTO.Ticket>(_ticket)).Returns(_ticketDTO);
A.CallTo(() => _fakeMapper.Map <DTO.Ticket, Ticket>(_ticketDTO)).Returns(_ticket);
A.CallTo(() => _fakeUnitOfWork.Set <Ticket>()).Returns(_fakeTicketRepository);
_ticketService = new TicketService(_fakeUnitOfWork, _fakeMapper);
}
public void GetMappedCollection_Test()
{
//Arrange
List <Ticket> tickets = new List <Ticket>
{
new Ticket {
Id = 1, Number = "AAABRT", Price = 100
},
new Ticket {
Id = 2, Number = "AABBRT", Price = 120
},
new Ticket {
Id = 3, Number = "AAABR2", Price = 180
},
};
mockUoW.Setup(x => x.Tickets.GetAllAsync()).Returns(Task.FromResult(tickets.AsEnumerable()));
var serviceWithMapper = new TicketService(mockUoW.Object, new MapperConfiguration(cfg =>
{
cfg.CreateMap <TicketDTO, Ticket>()
.ForMember(x => x.Id, opt => opt.Ignore());
cfg.CreateMap <Ticket, TicketDTO>();
}).CreateMapper());
// Act
var result = serviceWithMapper.GetCollectionAsync().Result;
// Assert
Assert.AreEqual(tickets.Count, result.ToList().Count);
}
public void CloseTicket_Can_Close_Ticket()
{
//arrange
var userTicket = new Ticket
{
Id = 1
};
var mockTicketRepo = Substitute.For <ITicketRepo>();
mockTicketRepo.GetTicketById(userTicket.Id).Returns(new Ticket
{
Id = 1,
ClosedAt = null
});
var ticketService = new TicketService(mockTicketRepo);
//act
var expectedTicket = ticketService.CloseTicket(userTicket);
//assert
Assert.IsNotNull(expectedTicket.ClosedAt, "ClosedAt was not set");
mockTicketRepo.Received(1).GetTicketById(userTicket.Id);
mockTicketRepo.ReceivedWithAnyArgs(1).UpdateTicket(expectedTicket);
}
public void CloseTicket_Cannot_Close_Already_Closed_Ticket()
{
//arrange
var ticket = new Ticket
{
Id = 1,
ClosedAt = DateTimeOffset.Now
};
var mockTicketRepo = Substitute.For <ITicketRepo>();
mockTicketRepo.GetTicketById(ticket.Id).Returns(ticket);
var ticketService = new TicketService(mockTicketRepo);
//act
try
{
var expectedTicket = ticketService.CloseTicket(ticket);
}
catch (Exception ex)
{
Assert.AreEqual("Ticket Already Closed", ex.Message);
return;
}
//assert
Assert.Fail("Shouldn't have gotten here");
}
public ServiceList(string url, ResponseToken token)
{
this.eventService = new EventService(url, token);
this.categoryService = new CategoryService(url, token);
this.clubService = new ClubService(url, token);
this.userService = new UserService(url, token);
this.ticketService = new TicketService(url, token);
this.meetingService = new MeetingService(url, token);
this.invoiceService = new InvoiceService(url, token);
this.groupService = new GroupService(url, token);
this.expenseService = new ExpenseService(url, token);
this.emailService = new EmailService(url, token);
this.depositService = new DepositService(url, token);
this.customFieldService = new CustomFieldService(url, token);
this.taskService = new TaskService(url, token);
this.contactService = new ContactService(url, token);
}
/// <summary>
/// Initializes a new instance of the <see cref="TicketController"/> class.
/// </summary>
/// <param name="developerService">The developer service.</param>
/// <param name="lookupService">The lookup service.</param>
/// <param name="ticketService">The ticket service.</param>
public TicketController(DeveloperService developerService, LookupService lookupService, TicketService ticketService)
{
this.lookupService = lookupService;
this.developerService = developerService;
this.ticketService = ticketService;
}
/// <summary>
/// Initializes a new instance of the <see cref="MasterController"/> class.
/// </summary>
/// <param name="holidayService">The holiday service.</param>
/// <param name="lookupService">The lookup service.</param>
/// <param name="ticketService">The ticket service.</param>
public MasterController(HolidayService holidayService, LookupService lookupService, TicketService ticketService)
{
this.holidayService = holidayService;
this.lookupService = lookupService;
this.ticketService = ticketService;
}
/// <summary>
/// Initializes a new instance of the <see cref="TicketSettingsController"/> class.
/// </summary>
/// <param name="ticketService">The ticket service.</param>
public TicketSettingsController(TicketService ticketService)
{
this.ticketService = ticketService;
}
/// <summary>
/// Initializes a new instance of the <see cref="LookupController" /> class.
/// </summary>
/// <param name="lookupService">The lookup service.</param>
/// <param name="timesheetService">The timesheet service.</param>
/// <param name="clientService">the client service</param>
/// <param name="developerService">the developer service</param>
/// <param name="ticketService">The ticket service.</param>
public LookupController(LookupService lookupService, TimesheetService timesheetService, ClientService clientService, DeveloperService developerService, TicketService ticketService)
{
this.lookupService = lookupService;
this.timesheetService = timesheetService;
this.clientService = clientService;
this.developerService = developerService;
this.ticketService = ticketService;
}
