public TicketForm() //new ticket constructor
{
InitializeComponent();
TicketsRepo = new TicketRepository(new AppDbContext());
LoadForNewTicket();
}
public DataService(ITicketRepository ticketRepository, IUserRepository userRepository, ICountriesRepository countriesRepository, IDepartureTRepository departureTRepository)
{
this._ticketRepository = ticketRepository;
this._userRepository = userRepository;
this._countriesRepository = countriesRepository;
this._departureTRepository = departureTRepository;
}
public void AddTicketResponseToUnknownTicketThrowsArgumentException()
{
_repository = Substitute.For <ITicketRepository>();
_mgr = new TicketManager(_repository);
Assert.Throws <KeyNotFoundException>(() => _mgr.AddTicketResponse(0, "Some response", false));
}
public void ChangeTicketWithNullAsParameterThrowsArgumentNullException()
{
_repository = Substitute.For <ITicketRepository>();
_mgr = new TicketManager(_repository);
Assert.Throws <ArgumentNullException>(() => _mgr.ChangeTicket(null));
}
public MasterController(ITicketService ticketService, IUserRepository userRepo, IProjectRepository projectRepo, ITicketRepository ticketRepo)
{
_ticketService = ticketService;
_userRepo = userRepo;
_projectRepo = projectRepo;
_ticketRepo = ticketRepo;
}
public void GetTicketsCallsRepositoryReadTicketsExactlyOnce()
{
_repository = Substitute.For <ITicketRepository>();
_mgr = new TicketManager(_repository);
_mgr.GetTickets();
_repository.Received(1).ReadTickets();
}
public void AddTicketWithInvalidQuestionThrowsValidationException(string question)
{
_repository = Substitute.For <ITicketRepository>();
_mgr = new TicketManager(_repository);
Assert.Throws <ValidationException>(() => _mgr.AddTicket(1, question));
}
//private readonly IUserRepository _userRepository;
public TicketController(ITicketRepository ticketRepository, IProjectRepository projectRepository, ITicketRecordRepository ticketRecordRepository)
{
_projectRepository = projectRepository;
_ticketRepository = ticketRepository;
_ticketRecordRepository = ticketRecordRepository;
//_userRepository = userRepository;
}
public TicketController(ITicketRepository ticketRepository, IProjectionRepository projectionResosiory,
IReservationRepository reservationRepository)
{
this.projectionResosiory = projectionResosiory;
this.ticketRepository = ticketRepository;
this.reservationRepository = reservationRepository;
}
public HomeController(ILogger <HomeController> logger, ITicketRepository repository, UserManager <IdentityUserModel> userManager, INoteRepository noteRepository)
{
_logger = logger;
_ticketRepository = repository;
_userManager = userManager;
_noteRepository = noteRepository;
}
public TicketsController(ITicketRepository objIrepository, IPassengersRepository objIrepository_p
, IToursRepository objIRepository_t)
{
repository = objIrepository;
repository_p = objIrepository_p;
repository_t = objIRepository_t;
}
public Consumer(
ILogger <Consumer> logger,
ITicketRepository ticketRepository)
{
_logger = logger;
_ticketRepository = ticketRepository;
}
public OptimizationAlgorithm(IDeveloperRepository developerRepository, ITicketRepository ticketRepository)
{
Developers = developerRepository.GetDevelopers();
Tickets = ticketRepository.GetTickets();
CostCalculator = new Cost(Developers, Tickets);
Domain = GetDomain();
}
public HistoricController()
{
db = new DBHF();
pageRepository = new PageRepository(db);
activityRepository = new ActivityRepository(db);
ticketRepository = new TicketRepository(db);
}
public void GetTicketWithNegativeNumberAsTicketNumberThrowsArgumentException()
{
_repository = Substitute.For <ITicketRepository>();
_mgr = new TicketManager(_repository);
Assert.Throws <ArgumentException>(() => _mgr.GetTicket(-1));
}
public TicketsController(ITicketRepository ticketRepository, IDBRepository <Client> clientRepository, IInventoryService inventoryService, IHRService hrService)
{
_ticketRepository = ticketRepository;
_clientRepository = clientRepository;
_inventoryService = inventoryService;
_hrService = hrService;
}
public Unit(ITourRepository tourRepository, IUserRepository userRepository, ITicketRepository ticketRepository, IMediaRepository mediaRepository)
{
_tourRepository = tourRepository;
_userRepository = userRepository;
_ticketRepository = ticketRepository;
_mediaRepository = mediaRepository;
}
public void Initialize()
{
_mediatorFactory = A.Fake <IMediatorFactory>();
_repository = A.Fake <ITicketRepository>();
_sut = new RegisterTicketMediatorCommandHandler(_mediatorFactory, _repository);
}
public void Setup()
{
var ticket = new Ticket()
{
TipoSolicitudId = 108,
Observacion = "Test1"
};
var list = new List <TicketDTO>();
list.Add(new TicketDTO
{
TipoSolicitudId = 1,
Observacion = "Test"
});
var listTicket = new List <Ticket>();
listTicket.Add(new Ticket
{
TipoSolicitudId = 1,
Observacion = "Test"
});
Mock <ITicketRepository> _mock = new Mock <ITicketRepository>();
_mock.Setup(mr => mr.GetAll()).Returns(listTicket);
_mock.Setup(mr => mr.GetTickets()).Returns(list);
_mock.Setup(t => t.Add(It.IsAny <Ticket>())).Returns(ticket);
TicketRepository = _mock.Object;
}
public HallMovieController(IHallMovieRepository HallMovieRepo, IMovieRepository MovieRepo, ITicketRepository TicketRepo, IHallLayoutRepository HallLayoutRepo)
{
this.HallMovieRepo = HallMovieRepo;
this.MovieRepo = MovieRepo;
this.TicketRepo = TicketRepo;
this.HallLayoutRepo = HallLayoutRepo;
}
public ReceiptService(IReceiptRepository receiptRepo, ITicketRepository ticketRepo,
ITicketStatusRepository ticketStatusRepo)
{
ReceiptRepo = receiptRepo;
TicketRepo = ticketRepo;
TicketStatusRepo = ticketStatusRepo;
}
public TicketService(ITicketRepository ticketRepository, IUserRepository userRepository, IMessageRepository messageRepository, ICommonOperationsService commonOperationsService)
{
_ticketRepository = ticketRepository;
_userRepository = userRepository;
_messageRepository = messageRepository;
_commonOperationsService = commonOperationsService;
}
public Cast(string n, int ind)
{
actorRepo = new SqlActorRepository(connectionString);
movieRepo = new SqlMovieRepository(connectionString);
reviewRepo = new SqlReviewRepository(connectionString);
showtimeRepo = new SqlShowTimeRepository(connectionString);
ticketRepo = new SqlTicketRepository(connectionString);
viewerRepo = new SqlViewerRepository(connectionString);
InitializeComponent();
index = ind;
name = n;
index = ind;
name = movieRepo.FetchMovie(ind).Name;
label1.Text = name;
IReadOnlyList <Actor> actors = actorRepo.FetchActorOnMovie(ind);
foreach (Actor a in actors)
{
listBox1.Items.Add(a.Name);
}
}
public PrintController(IOrderRepository OrderRepo, ITicketRepository TicketRepo, IMovieRepository MovieRepo, IHallMovieRepository HallMovieRepo)
{
this.OrderRepo = OrderRepo;
this.TicketRepo = TicketRepo;
this.MovieRepo = MovieRepo;
this.HallMovieRepo = HallMovieRepo;
}
public void Setup()
{
_ticketRepository = new MockTicketRepository();
_connectionString = "User ID=developer;Password=password;Connect Timeout=0;Application Name=EntityFramework";
_tenantId = 1368421345;
_ticketsSold = 1;
}
public Service(IUserRepository userRepo, ITicketRepository ticketRepo, IShowRepository showRepo)
{
userRepository = userRepo;
ticketRepository = ticketRepo;
showRepository = showRepo;
loggedClients = new Dictionary <string, IObserver>();
}
public ProjectionService(IProjectionsRepository projectionsRepository,
ITicketRepository ticketRepository, ISeatsRepository seatsRepository)
{
_projectionsRepository = projectionsRepository;
_ticketRepository = ticketRepository;
_seatsRepository = seatsRepository;
}
public DbIntializer(UserManager <User> userManager, ITicketRepository ticketRepo, IMovieRepository movieRepo, RoleManager <IdentityRole> roleManager)
{
_userManager = userManager;
_ticketRepo = ticketRepo;
_movieRepo = movieRepo;
_roleManager = roleManager;
}
public AdminController(ITicketRepository trepo, IGroupRepository grepo, UserManager <AppUser> usr, RoleManager <IdentityRole> roleMngr)
{
ticketRepository = trepo;
groupRepository = grepo;
userManager = usr;
roleManager = roleMngr;
}
public Reviews(MovieList ml, int i)
{
actorRepo = new SqlActorRepository(connectionString);
movieRepo = new SqlMovieRepository(connectionString);
reviewRepo = new SqlReviewRepository(connectionString);
showtimeRepo = new SqlShowTimeRepository(connectionString);
ticketRepo = new SqlTicketRepository(connectionString);
viewerRepo = new SqlViewerRepository(connectionString);
InitializeComponent();
movieList = ml;
rUserLabel.Text = movieList.getCurrentUserLabel();
cu = movieList.getCurrentUser();
index = i;
movieName = movieRepo.FetchMovie(i).Name;
IReadOnlyList <Review> reviews = reviewRepo.FetchMovieReviews(i);
foreach (Review r in reviews)
{
listBox1.Items.Add(r.ToString());
}
movieNameLabel.Text = movieName;
}
/// <summary>
/// Initializes a new instance of the <see cref="AdminstratorLogic"/> class.
/// </summary>
/// <param name="ticketRepo">Ticket Repo.</param>
/// <param name="eventRepository">Event Repo.</param>
/// <param name="guestRepository">Guest Repo.</param>
/// <param name="adminRepository">Admin Repo.</param>
public AdminstratorLogic(ITicketRepository ticketRepo, IEventRepository eventRepository, IGuestRepository guestRepository, IAdminUserRepository adminRepository)
{
this.ticketRepo = ticketRepo;
this.eventRepository = eventRepository;
this.guestRepository = guestRepository;
this.adminRepository = adminRepository;
}
public EventController(IEventRepository eventRepository, ICategoryRepository categoryRepository, IArtistRepository artistRepository, ITicketRepository ticketRepository)
{
this._repository = eventRepository;
this._categoryRep = categoryRepository;
this._artistRep = artistRepository;
this._ticketRep = ticketRepository;
}
public Bll()
{
_departmentRepository = new DepartmentRepository();
_doctorRepository = new DoctorRepository();
_patientRepository = new PatientRepository();
_ticketRepository = new TicketRepository();
_rangeRepository = new RangeRepository();
}
public ReportingTicketsController(IEventRepository eventRepo,
IEventSeriesRepository seriesRepo,
ITicketRepository ticketsRepo)
{
eventRepository = eventRepo;
seriesRepository = seriesRepo;
ticketsRepository = ticketsRepo;
}
public AddTicketViewModel (IUserRepository userRepository, ITicketRepository ticketsRepository, IWindowManager windowManager)
{
this.windowManager = windowManager;
this.userRepository = userRepository;
this.ticketsRepository = ticketsRepository;
Users = new ObservableCollection<string> ();
UpdateUsersList ();
}
public MainPageViewModel (ITicketRepository ticketsRepostiry, IUserRepository userRepository)
{
this.userRepository = userRepository;
this.ticketsRepostiry = ticketsRepostiry;
TicketsList = new ObservableCollection<TicketInfo> ();
UpdateUsersList ();
UpdateTicketsList ();
}
public TicketService
(
ISecurityService securityService,
ITicketRepository ticketRepository,
INotificationQueuingService notificationService,
TicketSearchService search
)
{
Security = securityService;
Repository = ticketRepository;
Notification = notificationService;
Search = search;
Repository.Saving += new EventHandler<TicketEventArgs>(TicketSaving);
}
public FindSeatsController(IVenueMetaDataRepository venueMetaDataRepository, IConcertRepository concertRepository, ITicketRepository ticketRepository, IVenueRepository venueRepository, IFindSeatsRepository findSeatsRepository)
{
// Setup Fields
_venueMetaDataRepository = venueMetaDataRepository;
_concertRepository = concertRepository;
_ticketRepository = ticketRepository;
_venueRepository = venueRepository;
_findSeatsRepository = findSeatsRepository;
// Setup Callbacks
_venueMetaDataRepository.StatusCallback = DisplayMessage;
_concertRepository.StatusCallback = DisplayMessage;
_ticketRepository.StatusCallback = DisplayMessage;
_venueRepository.StatusCallback = DisplayMessage;
}
public TicketsController(ITicketRepository repository)
{
if (repository == null) throw new ArgumentNullException("repository");
_repository = repository;
}
public TicketManager()
{
repo = new TicketRepositoryHC();
}
public ActivityStream(IUserRepository userRepo, ITicketRepository ticketRepo)
{
_userRepo = userRepo;
_ticketRepo = ticketRepo;
}
/// <summary>
/// Generates a series of random solutions and finds the one with the lowest cost.
/// </summary>
/// <param name="developerRepository"></param>
/// <param name="ticketRepository"></param>
public RandomOptimize(IDeveloperRepository developerRepository, ITicketRepository ticketRepository)
: base(developerRepository, ticketRepository)
{
}
public TicketsController(ITicketRepository ticketRepository, ITagRepository tagRepository)
{
_ticketRepository = ticketRepository;
_tagRepository = tagRepository;
}
public ProjectController(ITicketService ticketService, IUserRepository userRepo, IProjectRepository projectRepo, ITicketRepository ticketRepo)
: base(ticketService, userRepo, projectRepo, ticketRepo)
{
}
public TicketManager()
{
this.repo = new SC.DAL.EF.TicketRepository();
}
public DeveloperService(IDeveloperRepository developerRepository, ITicketRepository ticketRepository, OptimizationAlgorithm optimization)
{
_developerRepository = developerRepository;
_ticketRepository = ticketRepository;
_optimization = optimization;
}
public TicketLogic(ITicketRepository ticketRepository)
{
_ticketRepository = ticketRepository;
}
public TicketManager()
{
//repo = new TicketRepository(); //Was originally the HC (HardCoded) version, change that here!
repo = new SC.DAL.EF.TicketRepository();
}
public ManagementController(IProjectService projectService, ITicketService ticketService, IUserRepository userRepo, IProjectRepository projectRepo, ITicketRepository ticketRepo)
: base(ticketService, userRepo, projectRepo, ticketRepo)
{
_projectService = projectService;
}
public TicketHoldersController(IOrderRepository orderRepo, ITicketRepository ticketRepo)
{
orderRepository = orderRepo;
ticketRepository = ticketRepo;
}
public TicketService(ITicketRepository ticketRepo)
{
_ticketRepository = ticketRepo;
}
private Booking UpdateNewBooking(Booking booking, ITicketRepository ticketRepository)
{
try
{
var ticketResult = ticketRepository.Update(booking);
return ticketResult;
}
catch (NullReferenceException ex)
{
System.Console.WriteLine("Processor Usage" + ex.Message);
}
return null;
}
public TicketActivityStream(IUserRepository userRepo, ITicketRepository ticketRepo)
: base(userRepo, ticketRepo)
{
}
public TicketManager()
{
//repo = new TicketRepositoryHC();
//repo = new SC.DAL.SqlClient.TicketRepository();
repo = new SC.DAL.EF.TicketRepository();
}
public TicketService(IUnitOfWork uow, ITicketRepository ticketRepository, IProjectRepository projectRepository)
{
_ticketRepository = ticketRepository;
_projectRepository = projectRepository;
_uow = uow;
}
public TicketsController(ITicketRepository ticketRepository)
{
_ticketRepository = ticketRepository;
}
