/// <summary>
/// Constructor for the <see cref="OperationConfigurationsFacade"/>.
/// </summary>
/// <param name="context">Database context containing dashboard type entities.</param>
/// <param name="blobManager">Manager for Azure Blob Storage.</param>
/// <param name="queueManager">Manager for Azure Queue Storage.</param>
/// <param name="documentDb">Azure DocumentDB repository</param>
public OperationConfigurationsFacade(DataContext context, IBlobManager blobManager, IQueueManager queueManager,
IDocumentDbRepository <UploadTransaction> documentDb)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (blobManager == null)
{
throw new ArgumentNullException(nameof(blobManager));
}
if (queueManager == null)
{
throw new ArgumentNullException(nameof(queueManager));
}
if (documentDb == null)
{
throw new ArgumentNullException(nameof(documentDb));
}
_blobStorageConnectionString = ConfigurationManager.ConnectionStrings["BlobProcessorStorageConnectionString"].ConnectionString;
_blobStorageContainerName = ConfigurationManager.AppSettings["BlobProcessorBlobStorageContainerName"];
_queueStorageContainerName = ConfigurationManager.AppSettings["BlobProcessorQueueStorageContainerName"];
_context = context;
_blobManager = blobManager;
_queueManager = queueManager;
_documentDb = documentDb;
}
public RegisterDeviceCommand(Guid deviceId, IDocumentDbRepository <DeviceRegistration> database,
IDeviceHub deviceHub)
{
_database = database;
_deviceHub = deviceHub;
DeviceId = deviceId;
}
public DocumentDbBackgroundTaskStore(IDocumentDbRepository <BackgroundTaskDocument> repository,
IServerTimestampService timestamps, ISafeLogger <DocumentDbBackgroundTaskStore> logger)
{
_repository = repository;
_timestamps = timestamps;
_logger = logger;
}
public SaveUserPreferences(
IDocumentDbRepository <User> userRepository,
IDocumentDbRepository <Hashtag> hashTagRepository,
IOptions <AppSettingsConfiguration> configurations)
{
_userRepository = userRepository;
_hashTagRepository = hashTagRepository;
_configurations = configurations;
}
public GetLatestTweets(
IDocumentDbRepository <User> userRepository,
IDocumentDbRepository <Tweet> tweetRepository,
IOptions <AppSettingsConfiguration> configurations)
{
_userRepository = userRepository;
_tweetRepository = tweetRepository;
_configurations = configurations;
}
public TweetSchedulerFunction(
IServiceBusOperations serviceBusOperations,
IDocumentDbRepository <Hashtag> hashTagRepository,
IOptions <AppSettingsConfiguration> configurations)
{
_serviceBusOperations = serviceBusOperations;
_hashTagRepository = hashTagRepository;
_configurations = configurations;
}
public InvoiceRepository(
IDocumentDbRepository <DataModels.InvoiceManagement.Invoice> genericRepo,
IMapper <Domain.InvoiceManagement.Invoice, DataModels.InvoiceManagement.Invoice> dataModelInvoiceMapper,
IMapper <DataModels.InvoiceManagement.Invoice, Domain.InvoiceManagement.Invoice> domainInvoiceMapper
)
{
_genericRepo = genericRepo;
_dataModelInvoiceMapper = dataModelInvoiceMapper;
_domainInvoiceMapper = domainInvoiceMapper;
}
public EventStore(IDocumentDbRepository <AggregateDocument> aggregateRepository,
IDocumentDbRepository <EventDocument> eventRepository,
IAggregateDocumentFactory aggregateDocumentFactory,
IEventDocumentFactory eventDocumentFactory)
{
_aggregateRepository = aggregateRepository;
_eventRepository = eventRepository;
_aggregateDocumentFactory = aggregateDocumentFactory;
_eventDocumentFactory = eventDocumentFactory;
}
public CustomerRepository(
IDocumentDbRepository <DataModels.CustomerManagement.Customer> genericRepo,
IMapper <Domain.CustomerManagement.Customer, DataModels.CustomerManagement.Customer> dataModelCustomerMapper,
IMapper <DataModels.CustomerManagement.Customer, Domain.CustomerManagement.Customer> domainCustomerMapper
)
{
_genericRepo = genericRepo;
_dataModelCustomerMapper = dataModelCustomerMapper;
_domainCustomerMapper = domainCustomerMapper;
}
public TweetBotFunction(
ITweetOperations tweetOperations,
IServiceBusOperations serviceBusOperations,
IDocumentDbRepository <Tweet> tweetDbRepository,
IDocumentDbRepository <Hashtag> hashtagDbRepository)
{
_tweetOperations = tweetOperations;
_serviceBusOperations = serviceBusOperations;
_tweetDbRepository = tweetDbRepository;
_hashtagDbRepository = hashtagDbRepository;
}
public Logic(string docDBEndpoint, string docDBKey, string docDbName, string partitionKeyName, string docDbCollectionName)
{
_partitionKeyName = partitionKeyName;
var initializer = new DocumentDbInitializer();
//TODO check out connection policy
var client = initializer.GetClient(docDBEndpoint, docDBKey);
_repository = new DocumentDbRepository <WordsData>(client, docDbName, _partitionKeyName, () => docDbCollectionName);
}
public DeviceActivationCommand(string registrationCode, string teamId, string teamDomain, string channelId,
string channelName, string userId, string userName, IDocumentDbRepository <DeviceRegistration> database)
{
TeamId = teamId;
TeamDomain = teamDomain;
ChannelId = channelId;
ChannelName = channelName;
UserId = userId;
UserName = userName;
_database = database;
RegistrationCode = registrationCode;
}
public override RegisterDeviceCommand GetStandardRegisterDeviceCommand(Guid?deviceIdIs = null,
IDocumentDbRepository <DeviceRegistration> databaseIs = null, IDeviceHub deviceHubIs = null,
bool useStandardValues = true)
{
if (useStandardValues && databaseIs == null)
{
databaseIs = DeviceRegistrationDb;
}
return(base.GetStandardRegisterDeviceCommand(deviceIdIs, databaseIs, deviceHubIs, useStandardValues));
}
public virtual DeviceActivationCommand GetStandardActivationCommand(string registrationCodeIs = null,
string teamIdIs = null, string teamDomainIs = null, string channelIdIs = null, string channelNameIs = null,
string userIdIs = null, string userNameIs = null,
IDocumentDbRepository <DeviceRegistration> databaseIs = null,
bool useDefaults = true)
{
if (useDefaults && registrationCodeIs == null)
{
registrationCodeIs = StandardDeviceRegistrationCode;
}
if (useDefaults && teamIdIs == null)
{
teamIdIs = StandardTeamId;
}
if (useDefaults && teamDomainIs == null)
{
teamDomainIs = StandardTeamDomain;
}
if (useDefaults && channelIdIs == null)
{
channelIdIs = StandardChannelId;
}
if (useDefaults && channelNameIs == null)
{
channelNameIs = StandardChannelName;
}
if (useDefaults && userIdIs == null)
{
userIdIs = StandardUserId;
}
if (useDefaults && userNameIs == null)
{
userNameIs = StandardUserName;
}
if (useDefaults && databaseIs == null)
{
databaseIs = GetStandardMockDatabase <DeviceRegistration>().Object;
}
return(new DeviceActivationCommand(registrationCodeIs, teamIdIs, teamDomainIs, channelIdIs, channelNameIs,
userIdIs, userNameIs, databaseIs));
}
public override DeviceActivationCommand GetStandardActivationCommand(string registrationCodeIs = null,
string teamIdIs = null, string teamDomainIs = null, string channelIdIs = null, string channelNameIs = null,
string userIdIs = null, string userNameIs = null,
IDocumentDbRepository <DeviceRegistration> databaseIs = null,
bool useDefaults = true)
{
if (useDefaults && databaseIs == null)
{
databaseIs = DeviceRegistrationDb;
}
return(base.GetStandardActivationCommand(registrationCodeIs, teamIdIs, teamDomainIs, channelIdIs,
channelNameIs,
userIdIs, userNameIs, databaseIs, useDefaults));
}
public GivenCustomerRepository()
{
_genericRepo = Substitute.For <IDocumentDbRepository <DataModels.CustomerManagement.Customer> >();
var fixture = new Fixture();
var autoMapper = new AutoMapperFactory();
IMapper <Domain.CustomerManagement.Customer, DataModels.CustomerManagement.Customer> dataModelCustomerMapper
= autoMapper.CreateMapper <Domain.CustomerManagement.Customer, DataModels.CustomerManagement.Customer>();
IMapper <DataModels.CustomerManagement.Customer, Domain.CustomerManagement.Customer> domainCustomerMapper
= autoMapper.CreateMapper <DataModels.CustomerManagement.Customer, Domain.CustomerManagement.Customer>();
fixture.Inject(_genericRepo);
fixture.Inject(dataModelCustomerMapper);
fixture.Inject(domainCustomerMapper);
_sut = fixture.Create <CustomerRepository>();
}
public GivenInvoiceRepository()
{
_genericRepo = Substitute.For <IDocumentDbRepository <DataModels.InvoiceManagement.Invoice> >();
var fixture = new Fixture();
var autoMapper = new AutoMapperFactory();
IMapper <Domain.InvoiceManagement.Invoice, DataModels.InvoiceManagement.Invoice> dataModelInvoiceMapper
= autoMapper.CreateMapper <Domain.InvoiceManagement.Invoice, DataModels.InvoiceManagement.Invoice>();
IMapper <DataModels.InvoiceManagement.Invoice, Domain.InvoiceManagement.Invoice> domainInvoiceMapper
= autoMapper.CreateMapper <DataModels.InvoiceManagement.Invoice, Domain.InvoiceManagement.Invoice>();
fixture.Inject(_genericRepo);
fixture.Inject(dataModelInvoiceMapper);
fixture.Inject(domainInvoiceMapper);
_sut = fixture.Create <InvoiceRepository>();
}
/// <summary>
/// Constructor for the <see cref="FileFacade"/> class taking datbase context, DocumentDb repository,
/// and blob manager arguments.
/// </summary>
/// <param name="context">Database context used to access user and tenant information.</param>
/// <param name="documentDb">Azure DocumentDB repository containing file metadata.</param>
/// <param name="blobManager">Manager used to access Azure Blob Storage.</param>
public FileFacade(DataContext context, IDocumentDbRepository <UploadTransaction> documentDb, IBlobManager blobManager)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (documentDb == null)
{
throw new ArgumentNullException(nameof(documentDb));
}
if (blobManager == null)
{
throw new ArgumentNullException(nameof(blobManager));
}
_context = context;
_blobManager = blobManager;
_documentDb = documentDb;
_blobStorageConnectionString = ConfigurationManager.ConnectionStrings["BlobProcessorStorageConnectionString"].ConnectionString;
}
public virtual RegisterDeviceCommand GetStandardRegisterDeviceCommand(Guid?deviceIdIs = null,
IDocumentDbRepository <DeviceRegistration> databaseIs = null, IDeviceHub deviceHubIs = null,
bool useStandardValues = true)
{
if (useStandardValues && !deviceIdIs.HasValue)
{
deviceIdIs = StandardDeviceId;
}
if (useStandardValues && databaseIs == null)
{
databaseIs = GetStandardMockDatabase <DeviceRegistration>().Object;
}
if (useStandardValues && deviceHubIs == null)
{
deviceHubIs = GetStandardMockDeviceHub().Object;
}
Debug.Assert(deviceIdIs != null, nameof(deviceIdIs) + " != null");
return(new RegisterDeviceCommand(deviceIdIs.Value, databaseIs, deviceHubIs));
}
public TeamsScoreLogic(IDocumentDbRepository <KarmaModel> db)
{
_db = db;
}
public ItemsController(IDocumentDbRepository db)
{
this.db = db;
}
public TeamsScoreboardLogic(IDocumentDbRepository <ScoreboardModel> db)
{
_db = db;
}
public OrderFulfillmentSuccessfulHandler(IDocumentDbRepository <OrderRequest> repository) => _repository = repository;
public Handler(IDocumentDbRepository <OrderRequest> orderRepository)
{
_orderRepository = orderRepository;
}
public HeatMapController(IDocumentDbRepository documentDbRepository)
{
_documentDbRepository = documentDbRepository;
}
public UnitOfWork(DocumentDbRepository <Person> repository)
{
_personRepo = repository;
}
public AttendeeService(IDocumentDbRepository<Attendee> repository)
{
_repository = repository;
}
public ResortsController(IDocumentDbRepository <ResortInfo> documentRepository,
IBlobStorageRepository blobStorageRepository)
{
_documentRepository = documentRepository;
_blobStorageRepository = blobStorageRepository;
}
public StockRequestHandler(IDocumentDbRepository <Stock> repository) => _repository = repository;
public DeviceController(IDocumentDbRepository documentDbRepository)
{
_documentDbRepository = documentDbRepository;
}
/// <inheritdoc />
public OrderService(
IDocumentDbRepository <Order> repositoryOrders
)
{
this.repositoryOrders = repositoryOrders;
}
