public BookingValidator(IClientsRepository clientsRepository, IRoomsRepository roomsRepository, IBookingsRepository bookingsRepository)
{
_clientsRepository = clientsRepository;
_roomsRepository = roomsRepository;
_bookingsRepository = bookingsRepository;
RuleFor(booking => booking.ClientId)
.Cascade(CascadeMode.Stop)
.NotEmpty()
.MustAsync(async(clientId, cancellation) => { return(await _clientsRepository.IsClientExistsAsync(clientId)); })
.WithMessage("Client with this id doesn't exists.");
RuleFor(booking => booking.RoomId)
.Cascade(CascadeMode.Stop)
.NotEmpty()
.MustAsync(async(roomId, cancellation) => { return(await _roomsRepository.IsRoomExistsAsync(roomId)); })
.WithMessage("Room with this id doesn't exists.");
RuleFor(booking => booking.BookingDates)
.NotNull()
.Must(BeAValidDates)
.WithMessage("Dates are incorrect");
RuleFor(booking => booking.NumberOfPerson)
.NotEmpty()
.LessThanOrEqualTo(booking => GetMaxNumberOfPersonInRoom(booking.RoomId))
.GreaterThan(0);
}
public OrdersController(IOrdersRepository repo, IClientsRepository clientRepo, ILogger <OrdersController> logger, IMapper mapper)
{
_repo = repo;
_logger = logger;
_mapper = mapper;
_clientsRepo = clientRepo;
}
public OAuth2TokenController(IUserRepository userRepository, IConfigurationRepository configurationRepository, IClientsRepository clientsRepository, ICodeTokenRepository refreshTokenRepository)
{
UserRepository = userRepository;
ConfigurationRepository = configurationRepository;
ClientsRepository = clientsRepository;
RefreshTokenRepository = refreshTokenRepository;
}
public async Task PutClient_ShouldNotWork()
{
using var factory = new SQLiteDbContextFactory();
await using var dbContext = factory.CreateContext();
clientsRepository = new ClientService(dbContext, mapper);
//Arrange
var clientDto = new ClientDTO
{
Id = 19,
Name = "Updated Client",
PhoneNumber = "999-929-391",
Type = ClientType.Business,
Mail = "*****@*****.**",
AddressId = 2
};
//Actual
//Assert
var exception = Assert.Throws <Exception>
(() => clientsRepository.PutClient(clientDto.Id, clientDto));
Assert.Equal("Client not found", exception.Message);
}
public async Task SaveClient_ShouldWork()
{
using var factory = new SQLiteDbContextFactory();
await using var dbContext = factory.CreateContext();
clientsRepository = new ClientService(dbContext, mapper);
//Arrange
var expectedCount = await dbContext.Clients.CountAsync() + 1;
var clientDto = new ClientDTO
{
Name = "New Client",
PhoneNumber = "111-111-111",
Type = ClientType.Residential,
Mail = "*****@*****.**",
AddressId = 1
};
//Actual
var actual = clientsRepository.SaveClient(clientDto);
var actualCount = await dbContext.Clients.CountAsync();
//Assert
Assert.NotNull(actual);
Assert.Equal(expectedCount, actualCount);
Assert.Equal(clientDto.Name, actual.Name);
Assert.Equal(clientDto.PhoneNumber, actual.PhoneNumber);
Assert.Equal(clientDto.Type, actual.Type);
Assert.Equal(clientDto.Mail, actual.Mail);
Assert.Equal(clientDto.AddressId, actual.AddressId);
}
public async Task PutClient_ShouldWork()
{
using var factory = new SQLiteDbContextFactory();
await using var dbContext = factory.CreateContext();
clientsRepository = new ClientService(dbContext, mapper);
//Arrange
var clientDto = new ClientDTO
{
Id = 1,
Name = "Updated Client",
PhoneNumber = "999-929-391",
Type = ClientType.Business,
Mail = "*****@*****.**",
AddressId = 2
};
//Actual
var actual = clientsRepository.PutClient(clientDto.Id, clientDto);
//Assert
Assert.Equal(clientDto.Name, actual.Name);
Assert.Equal(clientDto.PhoneNumber, actual.PhoneNumber);
Assert.Equal(clientDto.Type, actual.Type);
Assert.Equal(clientDto.Mail, actual.Mail);
Assert.Equal(clientDto.AddressId, actual.AddressId);
}
public MainAccounatantForm(int userId, FileManager fileManager)
{
_currentUserId = userId;
_documentsRepository = (IDocumentsRepository)Program.ServiceProvider.GetService(typeof(IDocumentsRepository));
_ordersRepository = (IOrdersRepository)Program.ServiceProvider.GetService(typeof(IOrdersRepository));
_clientsRepository = (IClientsRepository)Program.ServiceProvider.GetService(typeof(IClientsRepository));
_workerRepository = (IWorkerRepository)Program.ServiceProvider.GetService(typeof(IWorkerRepository));
localFileManager = fileManager;
InitializeComponent();
dataGridViewOrders.RowHeadersVisible = false;
dataGridViewOrders.ColumnCount = 5;
dataGridViewOrders.Columns[0].HeaderText = "Код";
dataGridViewOrders.Columns[1].HeaderText = "Сумма";
dataGridViewOrders.Columns[2].HeaderText = "Оплачено";
dataGridViewOrders.Columns[3].HeaderText = "Дата создания";
dataGridViewOrders.Columns[4].HeaderText = "Дата выполнения";
dataGridViewDocuments.RowHeadersVisible = false;
dataGridViewDocuments.ColumnCount = 3;
dataGridViewDocuments.Columns[0].HeaderText = "Код";
dataGridViewDocuments.Columns[1].HeaderText = "Название фаила";
dataGridViewDocuments.Columns[2].HeaderText = "Ссылка на фаил";
dataGridViewDocuments.Columns[0].Visible = false;
dataGridViewDocuments.Columns[1].ReadOnly = true;
refreshGridWidth();
UpdateDataGridViewOrders(dateTimePickerFrom.Value, dateTimePickerTo.Value);
}
public void SetUp()
{
DetachAllEntities();
_clientsRepository = ServiceProvider.GetService <IClientsRepository>();
_dbContext = ServiceProvider.GetService <ApplicationDbContext>();
}
public async Task ShouldBeAbleToAddClientAsync()
{
// Arrange
using var factory = new SQLiteDbContextFactory();
await using var dbContext = factory.CreateContext();
_clientService = new BankApplication.Service.Service.ClientService(dbContext, _mapper);
ClientDTO client = new ClientDTO()
{
Name = "Client",
PhoneNumber = "073666777",
Mail = "*****@*****.**",
Type = ClientType.Business,
AddressId = 4
};
//Act
var response = _clientService.SaveClient(client);
var item = dbContext.Clients.Find(response.Id);
// Assert
Assert.AreEqual(item.Name, response.Name);
Assert.AreEqual(item.PhoneNumber, response.PhoneNumber);
Assert.AreEqual(item.Email, response.Mail);
Assert.AreEqual(item.Type, response.Type);
Assert.AreEqual(item.AddressId, response.AddressId);
}
public OAuth2TokenController(IUserRepository userRepository, IConfigurationRepository configurationRepository, IClientsRepository clientsRepository, ICodeTokenRepository codeTokenRepository)
{
UserRepository = userRepository;
ConfigurationRepository = configurationRepository;
ClientsRepository = clientsRepository;
CodeTokenRepository = codeTokenRepository;
}
public OrdersService(IOrdersRepository ordersRepository, IStorageItemsRepository storageItemsRepository, IClientsRepository clientsRepository, IMailService mailService)
{
_ordersRepository = ordersRepository;
_storageItemsRepository = storageItemsRepository;
_clientsRepository = clientsRepository;
_mailService = mailService;
}
public async Task ShouldBeAbleToAddClientAsync()
{
// Arrange
using var factory = new SQLiteDbContextFactory();
await using var dbContext = factory.CreateContext();
_service = new Service.Service.ClientService(dbContext, _mapper);
ClientDTO client = new ClientDTO()
{
Name = "Client",
PhoneNumber = "543890530",
Mail = "*****@*****.**",
// Type =
AddressId = 1
};
//Act
var response = _service.SaveClient(client);
var item = dbContext.Clients.Find(response.Id);
// Assert
Assert.AreEqual(item.Name, response.Name);
Assert.AreEqual(item.PhoneNumber, response.PhoneNumber);
// Assert.AreEqual(item.Mail, response.Mail);
// Assert.AreEqual(item.Type, response.Type);
Assert.AreEqual(item.AddressId, response.AddressId);
}
public async Task ShouldBeAbleToUpdateStudentAsync()
{
// Arrange
using var factory = new SQLiteDbContextFactory();
await using var dbContext = factory.CreateContext();
_service = new Service.Service.ClientService(dbContext, _mapper);
Client clientEntity = new Client()
{
Name = "Client",
PhoneNumber = "Test",
Email = "*****@*****.**",
Type = ClientType.Business,
AddressId = 1,
};
dbContext.Clients.Add(clientEntity);
dbContext.SaveChanges();
ClientDTO clientDto = new ClientDTO()
{
Name = "Client",
PhoneNumber = "Test",
Mail = "*****@*****.**",
// Type = ClientType
AddressId = 1,
};
//Act
var response = _service.PutClient(clientEntity.Id, clientDto);
// Assert
Assert.AreEqual(clientDto.Name, response.Name);
Assert.AreEqual(clientDto.Mail, response.Mail);
}
public OAuth2AuthorizeController(IConfigurationRepository configuration, IClientsRepository client, IRelyingPartyRepository rpRepository, ICodeTokenRepository codeTokenRepository)
{
Configuration = configuration;
Clients = client;
RPRepository = rpRepository;
CodeTokenRepository = codeTokenRepository;
}
public OAuth2AuthorizeController(IConfigurationRepository configuration, IClientsRepository client, IRelyingPartyRepository rpRepository, ICodeTokenRepository codeTokenRepository)
{
Configuration = configuration;
Clients = client;
RPRepository = rpRepository;
CodeTokenRepository = codeTokenRepository;
}
public OAuthRefreshTokenIndexViewModel(
TokenSearchCriteria searchCriteria,
IClientsRepository clientRepository,
ICodeTokenRepository codeTokenRepository,
bool doSearch = false)
{
this.SearchCriteria = searchCriteria;
var clients =
from item in clientRepository.GetAll()
select new
{
item.Name, item.ID
};
var list =
(from item in clients.ToArray()
select new SelectListItem
{
Text = item.Name, Value=item.ID
}).ToList();
list.Insert(0, new SelectListItem { Text = @"-none selected-", Value="" });
this.Clients = list;
if (searchCriteria.HasValues || doSearch)
{
var results = codeTokenRepository.Search(searchCriteria.ClientID, searchCriteria.Username, searchCriteria.Scope, CodeTokenType.RefreshTokenIdentifier);
this.SearchResults = results.OrderBy(x=>x.TimeStamp);
}
}
/// <summary>
/// constructor: se le deben inyectar los repositorios con los que va interactuar
/// </summary>
public ClientsController(
IClientsRepository clientsRepository,
IPoliciesRepository policiesRepository)
{
this.clientsRepository = clientsRepository;
this.policiesRepository = policiesRepository;
}
public OAuthRefreshTokenIndexViewModel(
TokenSearchCriteria searchCriteria,
IClientsRepository clientRepository,
ICodeTokenRepository codeTokenRepository,
bool doSearch = false)
{
this.SearchCriteria = searchCriteria;
var clients =
from item in clientRepository.GetAll()
select new
{
item.Name, item.ID
};
var list =
(from item in clients.ToArray()
select new SelectListItem
{
Text = item.Name, Value = item.ID.ToString()
}).ToList();
list.Insert(0, new SelectListItem {
Text = "-none selected-", Value = ""
});
this.Clients = list;
if (searchCriteria.HasValues || doSearch)
{
var results = codeTokenRepository.Search(searchCriteria.ClientID, searchCriteria.Username, searchCriteria.Scope, CodeTokenType.RefreshTokenIdentifier);
this.SearchResults = results.OrderBy(x => x.TimeStamp);
}
}
public OrdersService(IOrdersRepository ordersRepository, IStorageItemsRepository storageItemsRepository, IClientsRepository clientsRepository, IMailService mailService)
{
_ordersRepository = ordersRepository;
_storageItemsRepository = storageItemsRepository;
_clientsRepository = clientsRepository;
_mailService = mailService;
}
public SendEmailWhenUpdatedServiceRequest(IClientsRepository clientsRepository, IMailTemplate mailTemplate,
IMailService mailService)
{
_clientsRepository = clientsRepository;
_mailTemplate = mailTemplate;
_mailService = mailService;
}
public BookingsController(IBookingsRepository bookingsRepository, IClientsRepository clientsRepository, IDbRepository dbRepository, IMapper mapper)
{
_bookingsRepository = bookingsRepository;
_clientsRepository = clientsRepository;
_dbRepository = dbRepository;
_mapper = mapper;
}
public UploadsController(ISitesRepository sitesRepository, IClientsRepository clientsRepository, IJobsRepository jobsRepository, IMapper mapper)
{
_sitesRepository = sitesRepository;
_clientsRepository = clientsRepository;
_jobsRepository = jobsRepository;
_mapper = mapper;
}
public ClientsController(IClientsRepository clientsRepository, IRentsRepository rentsRepository, ICarsRepository carsRepository, IInvoicesRepository invoicesRepository, IIncomesRepository incomesRepository)
{
_clientsRepository = clientsRepository;
_rentsRepository = rentsRepository;
_carsRepository = carsRepository;
_invoicesRepository = invoicesRepository;
_incomesRepository = incomesRepository;
}
public UnitOfWork(ICheckInRepository CheckInRepository, IClientsRepository ClientsRepository, ICommentsRepository CommentsRepository, IRoomsRepository RoomsRepository, IRoomImagesRepository RoomImagesRepository)
{
_CheckInRepository = CheckInRepository;
_ClientsRepository = ClientsRepository;
_CommentsRepository = CommentsRepository;
_RoomsRepository = RoomsRepository;
_RoomImagesRepository = RoomImagesRepository;
}
public ActivitiesController(IActivitiesRepository activitiesRepository, IClientsRepository clientsRepository,
IUnitWork unitWork, IMapper mapper)
{
_activitiesRepository = activitiesRepository;
_clientsRepository = clientsRepository;
_unitWork = unitWork;
_mapper = mapper;
}
public QuickJobTimeReportQuery(IConfiguration configuration, ISessionAdapter sessionAdapter, IJobsRepository jobsRepository, ISitesRepository sitesRepository, IClientsRepository clientsRepository)
{
this.configuration = configuration;
_sessionAdapter = sessionAdapter;
_jobsRepository = jobsRepository;
_sitesRepository = sitesRepository;
_clientsRepository = clientsRepository;
}
public void ReInitializeTest()
{
_clients = ClientsInitializer.GetAllClients();
_sessionFactory = NHibernateSessionFactory.CreateSessionFactory(DBTypes.SQLite);
_unitOfWork = new Mock <IUnitOfWork>(MockBehavior.Default).Object;
_clientsMockRepository = SetUpClientsRepository();
_clientsService = new ClientsService(_clientsMockRepository);
}
public ClientsController(IClientsRepository clientsRepository,
IApplicationUserRepository applicationUserRepository, IUnitWork unitWork, IMapper mapper)
{
_clientsRepository = clientsRepository;
_applicationUserRepository = applicationUserRepository;
_unitWork = unitWork;
_mapper = mapper;
}
public OAuthClientIndexViewModel(IClientsRepository clientsRepository)
{
// TODO: Complete member initialization
this.clientsRepository = clientsRepository;
this.Clients = this.clientsRepository.GetAll().Select(x => new OAuthClientIndexInputModel {
Name = x.Name, ID = x.ID
}).ToArray();
}
protected internal AppointmentsPage(IAppointmentsRepository a, IClientsRepository c, ITreatmentsRepository tr, ITechniciansRepository te)
: base(a)
{
PageTitle = "Broneeringud";
Clients = CreateSelectList <Domain.Client.Client, ClientData>(c);
Treatments = CreateSelectList <Domain.Treatment.Treatment, TreatmentData>(tr);
Technicians = CreateSelectList <Domain.Technician.Technician, TechnicianData>(te);
}
public GangsterBankUnitOfWork(
IRepository <Account> accountsRepository,
IRepository <Address> addressesRepository,
ICitiesRepository citiesRepository,
IClientsRepository clientsRepository,
IContactsRepository contactsRepository,
ICountriesRepository countryRepository,
IEmploymentDataRepository employmentDataRepository,
ILoanProductsRepository loanProductsRepository,
IObligationRepository obligationsRepository,
IPassportDataRepository passportDataRepository,
IPropertyRepository propertiesRepository,
IPersonalDetailsRepository personalDetailsRepository,
ILoanRequestsRepository loanRequestsRepository,
IRolesRepository roles,
IRepository <LoanProductRequirements> loanProductsRequirmentsRepository,
IRepository <TakenLoan> takenLoansRepository,
IRepository <Payment> paymentsRepository,
ILoanPaymentsRepository loanPaymentsRepository)
{
Contract.Requires <ArgumentNullException>(accountsRepository.IsNotNull());
Contract.Requires <ArgumentNullException>(addressesRepository.IsNotNull());
Contract.Requires <ArgumentNullException>(citiesRepository.IsNotNull());
Contract.Requires <ArgumentNullException>(clientsRepository.IsNotNull());
Contract.Requires <ArgumentNullException>(contactsRepository.IsNotNull());
Contract.Requires <ArgumentNullException>(countryRepository.IsNotNull());
Contract.Requires <ArgumentNullException>(employmentDataRepository.IsNotNull());
Contract.Requires <ArgumentNullException>(loanProductsRepository.IsNotNull());
Contract.Requires <ArgumentNullException>(obligationsRepository.IsNotNull());
Contract.Requires <ArgumentNullException>(passportDataRepository.IsNotNull());
Contract.Requires <ArgumentNullException>(propertiesRepository.IsNotNull());
Contract.Requires <ArgumentNullException>(personalDetailsRepository.IsNotNull());
Contract.Requires <ArgumentNullException>(loanRequestsRepository.IsNotNull());
Contract.Requires <ArgumentNullException>(roles.IsNotNull());
Contract.Requires <ArgumentNullException>(loanProductsRequirmentsRepository.IsNotNull());
Contract.Requires <ArgumentNullException>(takenLoansRepository.IsNotNull());
Contract.Requires <ArgumentNullException>(paymentsRepository.IsNotNull());
Contract.Requires <ArgumentNullException>(loanPaymentsRepository.IsNotNull());
this.AccountsRepository = accountsRepository;
this.AddressesRepository = addressesRepository;
this.CitiesRepository = citiesRepository;
this.ClientsRepository = clientsRepository;
this.ContactsRepository = contactsRepository;
this.CountryRepository = countryRepository;
this.EmploymentDataRepository = employmentDataRepository;
this.LoanProductsRepository = loanProductsRepository;
this.ObligationsRepository = obligationsRepository;
this.PassportDataRepository = passportDataRepository;
this.PropertiesRepository = propertiesRepository;
this.PersonalDetailsRepository = personalDetailsRepository;
this.LoanRequestsRepository = loanRequestsRepository;
this.RolesRepository = roles;
this.LoanProductsRequirmentsRepository = loanProductsRequirmentsRepository;
this.TakenLoansRepository = takenLoansRepository;
this.PaymentsRepository = paymentsRepository;
this.LoanPaymentsRepository = loanPaymentsRepository;
}
public GangsterBankUnitOfWork(
IRepository<Account> accountsRepository,
IRepository<Address> addressesRepository,
ICitiesRepository citiesRepository,
IClientsRepository clientsRepository,
IContactsRepository contactsRepository,
ICountriesRepository countryRepository,
IEmploymentDataRepository employmentDataRepository,
ILoanProductsRepository loanProductsRepository,
IObligationRepository obligationsRepository,
IPassportDataRepository passportDataRepository,
IPropertyRepository propertiesRepository,
IPersonalDetailsRepository personalDetailsRepository,
ILoanRequestsRepository loanRequestsRepository,
IRolesRepository roles,
IRepository<LoanProductRequirements> loanProductsRequirmentsRepository,
IRepository<TakenLoan> takenLoansRepository,
IRepository<Payment> paymentsRepository,
ILoanPaymentsRepository loanPaymentsRepository)
{
Contract.Requires<ArgumentNullException>(accountsRepository.IsNotNull());
Contract.Requires<ArgumentNullException>(addressesRepository.IsNotNull());
Contract.Requires<ArgumentNullException>(citiesRepository.IsNotNull());
Contract.Requires<ArgumentNullException>(clientsRepository.IsNotNull());
Contract.Requires<ArgumentNullException>(contactsRepository.IsNotNull());
Contract.Requires<ArgumentNullException>(countryRepository.IsNotNull());
Contract.Requires<ArgumentNullException>(employmentDataRepository.IsNotNull());
Contract.Requires<ArgumentNullException>(loanProductsRepository.IsNotNull());
Contract.Requires<ArgumentNullException>(obligationsRepository.IsNotNull());
Contract.Requires<ArgumentNullException>(passportDataRepository.IsNotNull());
Contract.Requires<ArgumentNullException>(propertiesRepository.IsNotNull());
Contract.Requires<ArgumentNullException>(personalDetailsRepository.IsNotNull());
Contract.Requires<ArgumentNullException>(loanRequestsRepository.IsNotNull());
Contract.Requires<ArgumentNullException>(roles.IsNotNull());
Contract.Requires<ArgumentNullException>(loanProductsRequirmentsRepository.IsNotNull());
Contract.Requires<ArgumentNullException>(takenLoansRepository.IsNotNull());
Contract.Requires<ArgumentNullException>(paymentsRepository.IsNotNull());
Contract.Requires<ArgumentNullException>(loanPaymentsRepository.IsNotNull());
this.AccountsRepository = accountsRepository;
this.AddressesRepository = addressesRepository;
this.CitiesRepository = citiesRepository;
this.ClientsRepository = clientsRepository;
this.ContactsRepository = contactsRepository;
this.CountryRepository = countryRepository;
this.EmploymentDataRepository = employmentDataRepository;
this.LoanProductsRepository = loanProductsRepository;
this.ObligationsRepository = obligationsRepository;
this.PassportDataRepository = passportDataRepository;
this.PropertiesRepository = propertiesRepository;
this.PersonalDetailsRepository = personalDetailsRepository;
this.LoanRequestsRepository = loanRequestsRepository;
this.RolesRepository = roles;
this.LoanProductsRequirmentsRepository = loanProductsRequirmentsRepository;
this.TakenLoansRepository = takenLoansRepository;
this.PaymentsRepository = paymentsRepository;
this.LoanPaymentsRepository = loanPaymentsRepository;
}
public ClientsController(IClientsRepository clientsRepository)
{
if (clientsRepository == null)
{
throw new ArgumentNullException(nameof(clientsRepository));
}
this.clientsRepository = clientsRepository;
}
public ClientsController(IClientsRepository clientsRepository)
{
if (clientsRepository == null)
{
throw new ArgumentNullException(nameof(clientsRepository));
}
this.clientsRepository = clientsRepository;
}
public BasketCheckoutApiController(
IBasketRepository basketRepository,
IClientsRepository clientsRepository,
IStringLocalizer <OrderResources> orderLocalizer)
{
this.basketRepository = basketRepository;
this.orderLocalizer = orderLocalizer;
this.clientsRepository = clientsRepository;
}
public ClientsApiController(
IOrganisationsRepository organisationsRepository,
IClientsRepository clientsRepository,
IStringLocalizer <ClientResources> clientLocalizer)
{
this.organisationsRepository = organisationsRepository;
this.clientsRepository = clientsRepository;
this.clientLocalizer = clientLocalizer;
}
public DataManager(IPricesRepository pricesRepository, IAdresRepository adresRepository, IContaktnoeLicoRepository contaktnoeLicoRepository, IClientsRepository clientsRepository, IDogovorRepository dogovoraRepository, IZakazyRepository zakazyRepository, IZakazyAdresyRepository zakazyAdresyRepository, IUsersRepository usersRepository, IRazrabotkiRepository razrabotkiRepository)
{
this.pricesRepository = pricesRepository;
this.adresRepository = adresRepository;
this.clientsRepository = clientsRepository;
this.contaktnoeLicoRepository = contaktnoeLicoRepository;
this.dogovoraRepository = dogovoraRepository;
this.zakazyRepository = zakazyRepository;
this.zakazyAdresyRepository = zakazyAdresyRepository;
this.usersRepository = usersRepository;
this.razrabotkiRepository = razrabotkiRepository;
}
public OAuthClientIndexViewModel(IClientsRepository clientsRepository)
{
// TODO: Complete member initialization
this.clientsRepository = clientsRepository;
this.Clients = this.clientsRepository.GetAll().Select(x=>new OAuthClientIndexInputModel{Name=x.Name, ID=x.ID}).ToArray();
}
public OAuthRefreshTokenController(
IClientsRepository clientRepository, ICodeTokenRepository codeTokenRepository)
{
this.clientRepository = clientRepository;
this.codeTokenRepository = codeTokenRepository;
}
public ParkingHouseRepository(IClientsRepository clientsRepo)
{
_clientsRepo = clientsRepo;
_parkingSpaces = new ParkingSpaces();
CreateParkingSpots();
}
public OAuthClientController(IClientsRepository clientRepository)
{
this.clientRepository = clientRepository;
}
public TokenRequestValidator(IClientsRepository clients, IStoredGrantRepository grants)
{
Clients = clients;
Grants = grants;
}
public OidcAuthorizeController(IClientsRepository clients, IStoredGrantRepository grants)
{
Clients = clients;
Grants = grants;
}
public OAuth2FacctsAuthorizeController(IConfigurationRepository configuration, IClientsRepository client, IRelyingPartyRepository rpRepository)
{
this.Configuration = configuration;
this.Clients = client;
this.RPRepository = rpRepository;
}
