public CustomerController(ICustomerRepository customerRepository, ISequenceRepository sequenceRepository,
ILocationRepository locationRepository)
{
_customerRepository = customerRepository;
_sequenceRepository = sequenceRepository;
_locationRepository = locationRepository;
}
public CosmosUserRepository(
ICosmos db,
ISequenceRepository sequence,
ILogger<CosmosUserRepository> logger)
{
_db = db;
_sequence = sequence;
_logger = logger;
_keys = new PartitionKeyRotation(new string[] { "JumpConsistentSeed1",
"JumpConsistentSeed2",
"JumpConsistentSeed3",
"JumpConsistentSeed4",
"JumpConsistentSeed5",
"JumpConsistentSeed6",
"JumpConsistentSeed7",
"JumpConsistentSeed8",
"JumpConsistentSeed9",
"JumpConsistentSeed10",
"JumpConsistentSeed11",
"JumpConsistentSeed12",
"JumpConsistentSeed13",
"JumpConsistentSeed14",
"JumpConsistentSeed15",
"JumpConsistentSeed16"});
}
protected override void Context()
{
_repository = Resolve<ISequenceRepository>();
_tenantContext = Resolve<ITenantContext>();
_tenantContext.SetTenantId(_tenant);
}
protected override void Context()
{
_repository = Resolve<ISequenceRepository>();
_tenantContext = Resolve<ITenantContext>();
_tenantContext.SetTenantId(_tenant);
_repository.Add(new Sequence { Id = _id, Result = "1", Version = 1 }, 1);
}
public TellerController(ITellerRepository tellerRepository, ISequenceRepository sequenceRepository,
INominalRepository nominalRepository, ITransactionRepository transactionRepository)
{
_tellerRepository = tellerRepository;
_nominalRepository = nominalRepository;
_sequenceRepository = sequenceRepository;
_transactionRepository = transactionRepository;
}
public ISequence SetDbContext(ISequenceRepository repo)
{
if (repo != null)
{
_context.Repo = repo;
}
return(this);
}
public SequenceService(ISequenceRepository repository, IMapper mapper)
{
Require.Objects.NotNull(repository, nameof(repository));
Require.Objects.NotNull(mapper, nameof(mapper));
_sequenceRepository = repository;
_mapper = mapper;
}
public CosmosTemporaryExposureKeyExportRepository(
ICosmos db,
ISequenceRepository sequence,
ILogger <CosmosTemporaryExposureKeyExportRepository> logger)
{
_db = db;
_sequence = sequence;
_logger = logger;
}
public CosmosUserRepository(
ICosmos db,
ISequenceRepository sequence,
ILogger <CosmosUserRepository> logger)
{
_db = db;
_sequence = sequence;
_logger = logger;
}
public AccountsController(IAccountRepository accountRepository, ICustomerRepository customerRepository,
ISequenceRepository sequenceRepository, IAccountTypeRepository accounttypeRepository, ILocationRepository locationRepository)
{
_accountRepository = accountRepository;
_customerRepository = customerRepository;
_sequenceRepository = sequenceRepository;
_locationRepository = locationRepository;
_accounttypeRepository = accounttypeRepository;
}
public CosmosTemporaryExposureKeyExportRepository(
ICosmos db,
ISequenceRepository sequence,
ILogger <CosmosTemporaryExposureKeyExportRepository> logger)
{
_db = db;
_logger = logger;
GetKeysAsyncCache = new QueryCache <TemporaryExposureKeyExportModel[]>(Constants.CacheTimeout);
}
public AccountActions(ICreateAccountParameterValidator createAccountParameterValidator,
IPacketSendService packetSendService,
IHDSerialNumberService hdSerialNumberService,
ISequenceRepository sequenceRepository)
{
_createAccountParameterValidator = createAccountParameterValidator;
_packetSendService = packetSendService;
_hdSerialNumberService = hdSerialNumberService;
_sequenceRepository = sequenceRepository;
}
protected override void Context()
{
_bus = Resolve<IServiceBus>();
_sequenceRepository = Resolve<ISequenceRepository>();
_tenantContext = Resolve<ITenantContext>();
_bus.PublishDomainUpdate(new [] { new SequenceNumberAdded(_id, 1) { Version = 1 }},
Metadata(1));
}
public OrderController(IOrderRepository orderRepository, IOrderListRepository orderlistRepository,
IHubContext <OrderHub> order, ISequenceRepository sequenceRepository, ITransitRepository transitRepository,
ITransactionRepository transactionRepository, ITellerRepository tellerRepository)
{
//_get = get;
_order = order;
_orderRepository = orderRepository;
_sequenceRepository = sequenceRepository;
_tellerRepository = tellerRepository;
_transitRepository = transitRepository;
_transactionRepository = transactionRepository;
_orderlistRepository = orderlistRepository;
}
public PacketProcessActions(ISequenceRepository sequenceNumberRepository,
IPacketEncoderRepository encoderRepository,
IPacketEncoderService encoderService,
IPacketSequenceService sequenceService,
ILoggerProvider loggerProvider)
{
_sequenceRepository = sequenceNumberRepository;
_encoderRepository = encoderRepository;
_encoderService = encoderService;
_sequenceService = sequenceService;
_loggerProvider = loggerProvider;
}
public int Next(int step, ISequenceRepository repository)
{
lock (LockObject)
{
Current = Current + 1;
if (Current < this.Last)
{
return Current;
}
Current = repository.NextWithTransactionScope(this.Id, step);
if(Current < Last)
{
throw new ApplicationException("The next value from SequenceRepository should large than orignal sequence value.");
}
Last = Current + step;
return Current;
}
}
public int Next(int step, ISequenceRepository repository)
{
lock (LockObject)
{
Current = Current + 1;
if (Current < this.Last)
{
return(Current);
}
Current = repository.NextWithTransactionScope(this.Id, step);
if (Current < Last)
{
throw new ApplicationException("The next value from SequenceRepository should large than orignal sequence value.");
}
Last = Current + step;
return(Current);
}
}
public TemporaryExposureKeyExportBatchService(
IConfiguration config,
ISequenceRepository sequence,
ITemporaryExposureKeyRepository tek,
ITemporaryExposureKeyExportRepository tekExport,
ITemporaryExposureKeySignService signService,
ITemporaryExposureKeySignatureInfoService signatureService,
ITemporaryExposureKeyBlobService blobService,
ILogger <TemporaryExposureKeyExportBatchService> logger)
{
Logger = logger;
Logger.LogInformation($"{nameof(TemporaryExposureKeyExportBatchService)} constructor");
Sequence = sequence;
TekRepository = tek;
TekExportRepository = tekExport;
SignService = signService;
SignatureService = signatureService;
BlobService = blobService;
Regions = config.SupportRegions();
}
public NetworkConnectionActions(INetworkClientRepository networkClientRepository,
IConnectionStateRepository connectionStateRepository,
ISequenceRepository sequenceRepository,
IConfigurationProvider configurationProvider,
IHashService hashService,
IHDSerialNumberService hdSerialNumberService,
IPacketTranslator <IInitializationData> initPacketTranslator,
INetworkClientFactory networkClientFactory,
IPacketSendService packetSendService)
{
_networkClientRepository = networkClientRepository;
_connectionStateRepository = connectionStateRepository;
_sequenceRepository = sequenceRepository;
_configurationProvider = configurationProvider;
_hashService = hashService;
_hdSerialNumberService = hdSerialNumberService;
_initPacketTranslator = initPacketTranslator;
_networkClientFactory = networkClientFactory;
_packetSendService = packetSendService;
}
public ProcessController(IAccountRepository accountRepository, ICustomerRepository customerRepository,
ISequenceRepository sequenceRepository, ITellerRepository tellerRepository, ICotRepository cotRepository,
IChequeRepository chequeRepository, INominalRepository nominalRepository, ISmsRepository smsRepository,
IAccountTypeRepository accounttypeRepository, ILocationRepository locationRepository,
ITransactionRepository transactionRepository, IChargeRepository chargeRepository,
ISmsApiRepository smsapiRepository, ITransitRepository transitRepository)
{
_cotRepository = cotRepository;
_smsRepository = smsRepository;
_chequeRepository = chequeRepository;
_chargeRepository = chargeRepository;
_tellerRepository = tellerRepository;
_transitRepository = transitRepository;
_accountRepository = accountRepository;
_nominalRepository = nominalRepository;
_customerRepository = customerRepository;
_locationRepository = locationRepository;
_sequenceRepository = sequenceRepository;
_accounttypeRepository = accounttypeRepository;
_transactionRepository = transactionRepository;
}
public DetailsController(ISequenceRepository sequenceRepository)
{
_sequenceRepository = sequenceRepository;
}
public LocationController(ILocationRepository locationRepository, ISequenceRepository sequenceRepository)
{
_locationRepository = locationRepository;
_sequenceRepository = sequenceRepository;
}
public UzivateleService(IMongoDatabase database, ISequenceRepository sequenceRepository) : base(database)
{
m_sequenceRepository = sequenceRepository;
}
public SequenceService(ISequenceRepository SequenceRepository)
{
this.SequenceRepository = SequenceRepository;
}
/// <summary>
///
/// </summary>
/// <param name="repository"></param>
/// <param name="repositoryRule"></param>
/// <param name="logService"></param>
public SequenceService(ISequenceRepository repository, ISequenceRuleRepository repositoryRule, ILogService logService) : base(repository)
{
_repository = repository;
_logService = logService;
_repositoryRule = repositoryRule;
}
public ContactRepository(ISequenceRepository sequence, IAddedColumnRepository addedColumn, IMongoContext context) : base(context)
{
this.sequence = sequence;
this.addedColumn = addedColumn;
}
public TransitController(ITransitRepository transitRepository, ISequenceRepository sequenceRepository)
{
_transitRepository = transitRepository;
_sequenceRepository = sequenceRepository;
}
protected override void Context()
{
_repository = Resolve<ISequenceRepository>();
_tenantContext = Resolve<ITenantContext>();
_handler = Resolve<SequenceAddNumberHandlers>();
}
// *******************************************************************
// Constructors.
// *******************************************************************
#region Constructors
/// <summary>
/// This constructor creates a new instance of the <see cref="SequenceStore"/>
/// class.
/// </summary>
/// <param name="repository">The repository to use with the store.</param>
public SequenceStore(
ISequenceRepository <TModel, TKey> repository
) : base(repository)
{
}
public JobOrderService()
{
_stringChecker = new StringChecker();
_sequenceRepository = new SequenceRepository(_jobIds, _jobRules);
}
public AddedColumnService(IAddedColumnRepository _addedColumn, ISequenceRepository _sequence)
{
this._addedColumn = _addedColumn;
this._sequence = _sequence;
}
public SequenceService(ISequenceRepository sequenceRepository)
{
this.SequenceRepository = sequenceRepository;
}
public ContactService(IContactRepository _contact, IAddedColumnRepository _addedColumn, ISequenceRepository _sequence)
{
this._contact = _contact;
this._addedColumn = _addedColumn;
this._sequence = _sequence;
}
public EmployeeController(IEmployeeRepository employeeRepository, ISequenceRepository sequenceRepository)
{
_employeeRepository = employeeRepository;
_sequenceRepository = sequenceRepository;
}
public SequenceController(ISequenceRepository sequenceRepository)
{
_sequenceRepository = sequenceRepository;
}
public CompanyRepository(ISequenceRepository sequence, IMongoContext context) : base(context)
{
this.context = context;
this.sequence = sequence;
}