public MessageService(IMessagePrinterService messagePrinterService, IUserService userService, IMessageRepository messageRepository, ISubscriptionRepository subscriptionRepository)
{
_userService = userService;
_messageRepository = messageRepository;
_subscriptionRepository = subscriptionRepository;
_messagePrinterService = messagePrinterService;
}
public SubscriptionService(
IEmailService emailService,
ISubscriptionRepository subscriptionRepository)
{
_subscriptionRepository = subscriptionRepository;
_emailService = emailService;
}
public SubscriptionController(ISubscriptionRepository subscriptions, ILogger log, InstagramConfig config)
{
_log = log;
_config = config;
_subscriptionEndpoint = new Subscription(_config);
_subscriptions = subscriptions;
}
public EventChecker(IEventRepository eventRepository, IViagogoConnector viagogoConnector, ISubscriptionRepository subscriptionRepository, IMailerService mailerService)
{
_eventRepository = eventRepository;
_viagogoConnector = viagogoConnector;
_subscriptionRepository = subscriptionRepository;
_mailerService = mailerService;
}
private IEnumerable <SubscriptionFeed> ConvertToSubscription()
{
feedRepository = new FeedRepository(new FeedContext());
subscriptionRepository = new SubscriptionRepository(new FeedContext());
var feeds = feedRepository.All();
var subscribedFeeds = subscriptionRepository.All().ToList();
foreach (FeedEntity feed in feeds)
{
var a = subscribedFeeds.Any(x => x.feedId == feed.Id && x.IsActive == true);
yield return(new SubscriptionFeed()
{
Id = feed.Id,
description = feed.description,
IsActive = feed.IsActive,
source = feed.source,
title = feed.title,
url = feed.url,
isSubscribed = subscribedFeeds.Any(x => x.feedId == feed.Id && x.IsActive == true)
});
}
;
}
public SubscriptionService(
ISubscriptionRepository subscriptionRepository,
UnitOfWork unitOfWork)
{
_subscriptionRepository = subscriptionRepository;
_unitOfWork = unitOfWork;
}
public TaskMonitoringSource(HealthMonitoringSettings settings, ILogger logger, IServiceBus serviceBus, ISubscriptionRepository repository)
{
_settings = settings;
_logger = logger;
_serviceBus = serviceBus;
_repository = repository;
}
public void OneTimeSetUp()
{
userRepository = new InMemoryUserRepository();
subscriptionRepository = new InMemorySubscriptionRepository();
loginRepository = new InMemoryLoginRepository();
subscriptionType = new SubscriptionType(1, "s", 8, 1, 1, 1, 1, 1, 1, "s");
var user = new User(-1, "1", "1", false, UserType.User);
var userId = userRepository.Create(user);
var sub = new Subscription(-1, 1, userId, DateTime.Now.AddMonths(-8).AddDays(-1), 1, true)
{
Type = subscriptionType
};
subscriptionRepository.Create(sub);
PasswordHashing.CreatePasswordHash("test", out var hash, out var salt);
var login = new Login(-1, hash, salt, "*****@*****.**", userId);
loginRepository.Create(login);
user = new User(-1, "1", "1", false, UserType.Staff);
userId = userRepository.Create(user);
login = new Login(-1, hash, salt, "*****@*****.**", userId);
loginRepository.Create(login);
user = new User(-1, "1", "1", false, UserType.User);
userId = userRepository.Create(user);
sub = new Subscription(-1, 1, userId, DateTime.Now.AddMonths(-7).AddDays(-10), 1, true)
{
Type = subscriptionType
};
subscriptionRepository.Create(sub);
login = new Login(-1, hash, salt, "*****@*****.**", userId);
loginRepository.Create(login);
}
public CreateSubscriptionPresenter(
ICreateSubscriptionView view,
ISubscriptionRepository subscriptions)
{
_view = view;
_subscriptions = subscriptions;
}
public SubscribersController(
ILogger <SubscribersController> logger,
ISubscriptionRepository subscriptionRepository)
{
_logger = logger;
this.subscriptionRepository = subscriptionRepository;
}
private IEnumerable <CustomerSubscription> GetCustomerSubscriptionsByNumber(ISubscriptionRepository repository, string subscriptionNumber)
{
foreach (var customer in repository.FindBySubscription(subscriptionNumber).Customers)
{
yield return(ConvertToCustomerSubscription(customer));
}
}
public SubscriptionService()
{
_subscriptionRepository=new SubscriptionRepository();
Mapper.CreateMap<DataSubscription, Subscription>();
Mapper.CreateMap<Subscription, DataSubscription>();
}
public PersistentTaskAgent(IPersistentTask task, HealthMonitoringSettings settings, ILogger logger, ISubscriptionRepository repository)
{
_task = task;
_settings = settings;
_logger = logger;
_repository = repository;
}
public AddSubscriptionCommandHandler(
ISubscriptionRepository subscriptionRepository,
ICustomerRepository customerRepository)
{
this._subscriptionRepository = subscriptionRepository;
this._customerRepository = customerRepository;
}
public IoTHubController(ILogger <IoTHubController> logger, ISubscriptionRepository subscriptionRepository, IAccessTokenRepository accessTokenRepository, IIoTHubRepository ioTHubRepository)
{
_logger = logger;
this.subscriptionRepository = subscriptionRepository;
this.accessTokenRepository = accessTokenRepository;
this.ioTHubRepository = ioTHubRepository;
}
public NewsLetterService(INewsLetterRepository newsLetterRepository, IUnitOfWork unitOfWork,
ISubscriptionRepository subscriptionRepository)
{
this._subscriptionRepository = subscriptionRepository;
this._newsLetterRepository = newsLetterRepository;
this._unitOfWork = unitOfWork;
}
public PersistentTaskAgent(IPersistentTask task, HealthMonitoringSettings settings, ILogger logger, ISubscriptionRepository repository)
{
_task = task;
_settings = settings;
_logger = logger;
_repository = repository;
}
public SubscriptionAppService(ISubscriptionRepository subscriptionRepository,
IRepository <SubscriptionCycle, Guid> subscriptionCycleRepository,
IRepository <SubscriptionCycleOrder, Guid> subscriptionCycleOrderRepository,
IRepository <Plan, Guid> planRepository,
IPlanPriceRepository planPriceRepository,
IRepository <Order, Guid> orderRepository,
IRepository <Invoice, Guid> invoiceRepository,
IRepository <InvoicePaymentProvider, Guid> invoicePaymentProviderRepository,
IOrderDomainService orderDomainService,
ISubscriptionDomainService subscriptionDomainService,
ISubscriptionCycleDomainService subscriptionCycleDomainService,
ISubscriptionCycleOrderDomainService subscriptionCycleOrderDomainService,
IInvoiceDomainService invoiceDomainService,
IObjectMapper mapper,
IPaypalService paypalService,
IMobbexService mobbexService)
{
_subscriptionRepository = subscriptionRepository ?? throw new ArgumentNullException(nameof(subscriptionRepository));
_subscriptionCycleRepository = subscriptionCycleRepository ?? throw new ArgumentNullException(nameof(subscriptionCycleRepository));
_subscriptionCycleOrderRepository = subscriptionCycleOrderRepository ?? throw new ArgumentNullException(nameof(subscriptionCycleOrderRepository));
_planRepository = planRepository ?? throw new ArgumentNullException(nameof(planRepository));
_planPriceRepository = planPriceRepository ?? throw new ArgumentNullException(nameof(planPriceRepository));
_orderRepository = orderRepository ?? throw new ArgumentNullException(nameof(orderRepository));
_invoiceRepository = invoiceRepository ?? throw new ArgumentNullException(nameof(invoiceRepository));
_invoicePaymentProviderRepository = invoicePaymentProviderRepository ?? throw new ArgumentNullException(nameof(invoicePaymentProviderRepository));
_orderDomainService = orderDomainService ?? throw new ArgumentNullException(nameof(orderDomainService));
_subscriptionDomainService = subscriptionDomainService ?? throw new ArgumentNullException(nameof(subscriptionDomainService));
_subscriptionCycleDomainService = subscriptionCycleDomainService ?? throw new ArgumentNullException(nameof(subscriptionCycleDomainService));
_subscriptionCycleOrderDomainService = subscriptionCycleOrderDomainService ?? throw new ArgumentNullException(nameof(subscriptionCycleOrderDomainService));
_invoiceDomainService = invoiceDomainService ?? throw new ArgumentNullException(nameof(invoiceDomainService));
_mapper = mapper ?? throw new ArgumentNullException(nameof(mapper));
_paypalService = paypalService ?? throw new ArgumentNullException(nameof(paypalService));
_mobbexService = mobbexService ?? throw new ArgumentNullException(nameof(mobbexService));
}
public FeedContainerVM SyncroniceFeeds()
{
FeedContainerVM feedContainerVM = new FeedContainerVM();
feedRepository = new FeedRepository(new FeedContext());
subscriptionRepository = new SubscriptionRepository(new FeedContext());
feedContainerVM.feeds = ConvertToSubscription().Where(x => x.isSubscribed == true);
feedContainerVM.hasSubscriptions = hasSubscriptions();
List <FeedItemEntity> downloadFeeds = new List <FeedItemEntity>();
temporalFeedRepository = new TemporalFeedRepository(new FeedContext());
var userId = 1; //harcoded userId for demo purposes
var currentFeeds = temporalFeedRepository.FindBy(x => x.userId == userId).ToList();
//Wipeout table before syncronization
foreach (TemporalFeed tmpFeed in currentFeeds)
{
temporalFeedRepository.Erase(tmpFeed);
}
foreach (FeedEntity subscribedFeed in feedContainerVM.feeds)
{
downloadFeeds.AddRange(WriteFeedsToTemporalDatabase(GetFeeds(subscribedFeed.url), subscribedFeed.Id));
}
feedContainerVM.feedItems = downloadFeeds;
return(feedContainerVM);
}
public SubscriptionManager(ISubscriptionRepository subscriptionRepository, ICompanyManager companyManager)
: base(subscriptionRepository)
{
_subscriptionRepository = subscriptionRepository;
_companyManager = companyManager;
StripeConfiguration.SetApiKey(ConfigUtil.StripeApiKey);
}
public CustomerController(
ICustomerRepository customerRepository,
ISubscriptionRepository subscriptionRepository)
{
_customerRepository = customerRepository;
_subscriptionRepository = subscriptionRepository;
}
public SubscriptionService(IUserRepository userRepository, IPlanRepository planRepository, ISubscriptionRepository subscriptionRepository, IUnitOfWork unitOfWork)
{
_userRepository = userRepository;
_planRepository = planRepository;
_subscriptionRepository = subscriptionRepository;
_unitOfWork = unitOfWork;
}
public SubscriptionMiddleware(ISubscriptionRepository repo, SubscriptionOptions options = null)
{
Repo = repo;
QueueNameFunc = options?.QueueNameFunc ?? (context => context.GetConsumerConfiguration()?.Consume.QueueName);
ConsumerFunc = options?.ConsumeFunc ?? (context => context.GetConsumer());
SaveInContext = options?.SaveInContext ?? ((ctx, subscription) => ctx.Properties.Add(PipeKey.Subscription, subscription));
}
public MessageService(IMessagePrinterService messagePrinterService, IUserService userService, IMessageRepository messageRepository, ISubscriptionRepository subscriptionRepository)
{
_userService = userService;
_messageRepository = messageRepository;
_subscriptionRepository = subscriptionRepository;
_messagePrinterService = messagePrinterService;
}
public AccountsController(UserManager <User> userManager, SignInManager <User> signInManager, IJWTTokenGenerator jwtToken, ISubscriptionRepository subscriberRepository)
{
_userManager = userManager;
_signInManager = signInManager;
_jwtToken = jwtToken;
_subscriberRepository = subscriberRepository;
}
public SubscriptionService(
IEmailService mailService,
ISubscriptionRepository subRepo)
{
_subRepo = subRepo;
_mailService = mailService;
}
public SubscriptionActivator(ISubscriptionRepository repository, IEnvelopeSender sender, ISubscriptionCache cache, IEnumerable<ISubscriptionRequirement> requirements)
{
_repository = repository;
_sender = sender;
_cache = cache;
_requirements = requirements;
}
public ActivityController(ISubscriptionRepository subscriptionRepository, IWorkflowController workflowController, IDateTimeProvider dateTimeProvider, IDistributedLockProvider lockProvider)
{
_subscriptionRepository = subscriptionRepository;
_dateTimeProvider = dateTimeProvider;
_lockProvider = lockProvider;
_workflowController = workflowController;
}
public SubscriptionManager(
ISubscriptionRepository subscriptionRepository,
ILoggerWrapper logger)
{
_subscriptionRepository = subscriptionRepository;
_logger = logger;
}
public GetSubscriptionOfUser(ISubscriptionRepository subscriptionRepository,
ITimeSlotRepository timeSlotRepository, long userId)
{
this.subscriptionRepository = subscriptionRepository;
UserId = userId;
this.timeSlotRepository = timeSlotRepository;
}
public TaskMonitoringSource(HealthMonitoringSettings settings, ILogger logger, IServiceBus serviceBus, ISubscriptionRepository repository)
{
_settings = settings;
_logger = logger;
_serviceBus = serviceBus;
_repository = repository;
}
public MonthlyEmailNotficationBalanceService(IMonthlyEmailNotficationBalanceRepository repository, IEmailNotificationLogRepository emailNotificationLogRepository, ISubscriptionRepository subscriptionRepository, IFeatureService featureService) : base(repository)
{
_repository = repository;
_emailNotificationLogRepository = emailNotificationLogRepository;
_subscriptionRepository = subscriptionRepository;
_featureService = featureService;
}
public static void PreWarm(this IApplicationBuilder applicationBuilder)
{
Startup.LoadTypes();
var internalSubscriptionService = bool.Parse(ConfigurationReader.GetValue("InternalSubscriptionService"));
if (internalSubscriptionService)
{
String eventStoreConnectionString = ConfigurationReader.GetValue("EventStoreSettings", "ConnectionString");
Int32 inflightMessages = int.Parse(ConfigurationReader.GetValue("AppSettings", "InflightMessages"));
Int32 persistentSubscriptionPollingInSeconds = int.Parse(ConfigurationReader.GetValue("AppSettings", "PersistentSubscriptionPollingInSeconds"));
String filter = ConfigurationReader.GetValue("AppSettings", "InternalSubscriptionServiceFilter");
String ignore = ConfigurationReader.GetValue("AppSettings", "InternalSubscriptionServiceIgnore");
String streamName = ConfigurationReader.GetValue("AppSettings", "InternalSubscriptionFilterOnStreamName");
Int32 cacheDuration = int.Parse(ConfigurationReader.GetValue("AppSettings", "InternalSubscriptionServiceCacheDuration"));
ISubscriptionRepository subscriptionRepository = SubscriptionRepository.Create(eventStoreConnectionString, cacheDuration);
((SubscriptionRepository)subscriptionRepository).Trace += (sender,
s) => Extensions.log(TraceEventType.Information, "REPOSITORY", s);
// init our SubscriptionRepository
subscriptionRepository.PreWarm(CancellationToken.None).Wait();
var eventHandlerResolver = Startup.ServiceProvider.GetService <IDomainEventHandlerResolver>();
SubscriptionWorker concurrentSubscriptions =
SubscriptionWorker.CreateConcurrentSubscriptionWorker(eventStoreConnectionString,
eventHandlerResolver,
subscriptionRepository,
inflightMessages,
persistentSubscriptionPollingInSeconds);
concurrentSubscriptions.Trace += (_,
args) => Extensions.concurrentLog(TraceEventType.Information, args.Message);
concurrentSubscriptions.Warning += (_,
args) => Extensions.concurrentLog(TraceEventType.Warning, args.Message);
concurrentSubscriptions.Error += (_,
args) => Extensions.concurrentLog(TraceEventType.Error, args.Message);
if (!string.IsNullOrEmpty(ignore))
{
concurrentSubscriptions = concurrentSubscriptions.IgnoreSubscriptions(ignore);
}
if (!string.IsNullOrEmpty(filter))
{
//NOTE: Not overly happy with this design, but
//the idea is if we supply a filter, this overrides ignore
concurrentSubscriptions = concurrentSubscriptions.FilterSubscriptions(filter).IgnoreSubscriptions(null);
}
if (!string.IsNullOrEmpty(streamName))
{
concurrentSubscriptions = concurrentSubscriptions.FilterByStreamName(streamName);
}
concurrentSubscriptions.StartAsync(CancellationToken.None).Wait();
}
}
public SubscriptionStore(ISubscriptionRepository repository,
IServiceProvider serviceProvider, IUserStore userStore)
{
this.repository = repository;
this.serviceProvider = serviceProvider;
this.userStore = userStore;
}
public OrderRenewSubscriptionPayedEventHandler(IOrderRepository orderRepository,
ISubscriptionRepository subscriptionRepository,
IRepository <SubscriptionCycle, Guid> subscriptionCycleRepository,
IRepository <SubscriptionCycleOrder, Guid> subscriptionCycleOrderRepository,
IPlanPriceRepository planPriceRepository,
ISubscriptionDomainService subscriptionDomainService,
ISubscriptionCycleDomainService subscriptionCycleDomainService,
IOrderDomainService orderDomainService,
IRepository <Notification, Guid> noticationRepository,
IMapper mapper,
IClientOptions clientOptions,
IHttpClientFactory httpClientFactory,
IBackgroundJobManager backgroundJobManager,
IRepository <Invoice, Guid> invoiceRepository,
IInvoiceDomainService invoiceDomainService,
INotificationDomainService notificationDomainService)
{
_orderRepository = orderRepository ?? throw new ArgumentNullException(nameof(orderRepository));
_subscriptionRepository = subscriptionRepository ?? throw new ArgumentNullException(nameof(subscriptionRepository));
_subscriptionCycleRepository = subscriptionCycleRepository ?? throw new ArgumentNullException(nameof(subscriptionCycleRepository));
_subscriptionCycleOrderRepository = subscriptionCycleOrderRepository ?? throw new ArgumentNullException(nameof(subscriptionCycleOrderRepository));
_planPriceRepository = planPriceRepository ?? throw new ArgumentNullException(nameof(planPriceRepository));
_subscriptionDomainService = subscriptionDomainService ?? throw new ArgumentNullException(nameof(subscriptionDomainService));
_subscriptionCycleDomainService = subscriptionCycleDomainService ?? throw new ArgumentNullException(nameof(subscriptionCycleDomainService));
_orderDomainService = orderDomainService ?? throw new ArgumentNullException(nameof(orderDomainService));
_notificationDomainService = notificationDomainService ?? throw new ArgumentNullException(nameof(notificationDomainService));
_noticationRepository = noticationRepository ?? throw new ArgumentNullException(nameof(noticationRepository));
_clientOptions = clientOptions ?? throw new ArgumentNullException(nameof(clientOptions));
_httpClient = httpClientFactory?.CreateClient() ?? throw new ArgumentNullException(nameof(httpClientFactory));
_backgroundJobManager = backgroundJobManager ?? throw new ArgumentNullException(nameof(backgroundJobManager));
_invoiceRepository = invoiceRepository ?? throw new ArgumentNullException(nameof(invoiceRepository));
_invoiceDomainService = invoiceDomainService ?? throw new ArgumentNullException(nameof(invoiceDomainService));
_eventBus = EventBus.Default;
_mapper = mapper ?? throw new ArgumentNullException(nameof(mapper));
}
protected virtual IQueryable <SubscriptionEntity> BuildQuery(ISubscriptionRepository repository, SubscriptionSearchCriteria criteria)
{
var query = repository.Subscriptions;
if (!string.IsNullOrEmpty(criteria.Number))
{
query = query.Where(x => x.Number == criteria.Number);
}
else if (criteria.Keyword != null)
{
query = query.Where(x => x.Number.Contains(criteria.Keyword));
}
if (criteria.CustomerId != null)
{
query = query.Where(x => x.CustomerId == criteria.CustomerId);
}
if (criteria.Statuses != null && criteria.Statuses.Any())
{
query = query.Where(x => criteria.Statuses.Contains(x.Status));
}
if (criteria.StoreId != null)
{
query = query.Where(x => criteria.StoreId == x.StoreId);
}
if (criteria.StartDate != null)
{
query = query.Where(x => x.CreatedDate >= criteria.StartDate);
}
if (criteria.EndDate != null)
{
query = query.Where(x => x.CreatedDate <= criteria.EndDate);
}
if (criteria.ModifiedSinceDate != null)
{
query = query.Where(x => x.ModifiedDate >= criteria.ModifiedSinceDate);
}
if (!string.IsNullOrEmpty(criteria.CustomerOrderId))
{
var order = _customerOrderService.GetByIdsAsync(new[] { criteria.CustomerOrderId }).GetAwaiter().GetResult().FirstOrDefault();
if (order != null && !string.IsNullOrEmpty(order.SubscriptionId))
{
query = query.Where(x => x.Id == order.SubscriptionId);
}
else
{
query = query.Where(x => false);
}
}
if (criteria.OuterId != null)
{
query = query.Where(x => x.OuterId == criteria.OuterId);
}
return(query);
}
public RecentMediaController(ILogger log, InstagramConfig config, ISubscriptionRepository subscriptions)
{
_geoEndpoint = new Geographies(config);
_tagEndpoint = new Tags(config);
_config = config;
_log = log;
_subscriptions = subscriptions;
}
public SubscriptionService( IServiceRepository serviceRepository,
IServiceChargeRepository serviceChargeRepository,
ISubscriptionRepository subscriptionRepository)
{
_serviceRepository = serviceRepository;
_serviceChargeRepository = serviceChargeRepository;
_subscriptionRepository = subscriptionRepository;
}
public ReleaseClassBookAppl(ITypeAdapter adapter, IProfessionalClassRepository classRepo, ISubscriptionRepository subscriptionRepo, IInventoryRepository inventoryRepo, IStorageRepository storageRepo)
{
_adapter = adapter;
_classRepo = classRepo;
_subscriptionRepo = subscriptionRepo;
_inventoryRepo = inventoryRepo;
_storageRepo = storageRepo;
}
public SubscriptionActivator(ISubscriptionRepository repository, IEnvelopeSender sender, ISubscriptionCache cache, IEnumerable<ISubscriptionRequirement> requirements, ChannelGraph graph,
TransportSettings settings)
{
_repository = repository;
_sender = sender;
_cache = cache;
_requirements = requirements;
_graph = graph;
_settings = settings;
}
public void Initialize()
{
_Clock = new Mock<IClock>();
_Console = new Mock<Console> ();
_MessagePrinter = new MessagePrinter(_Console.Object, _Clock.Object);
_UserRepository = new UserRepository();
_MessageRepository = new MessageRepository(_Clock.Object);
_SubscriptionRepository = new SubscriptionRepository();
_CommandParser = new CommandParser(GetAllCommands(), _UserRepository, _MessageRepository, _SubscriptionRepository, _MessagePrinter);
}
public ICommand CreateCommand(string[] inputParts, IUserRepository userRepository, IMessageRepository messageRepository,
ISubscriptionRepository subscriptionRepository, IMessagePrinter messagePrinter)
{
return new CreateSubscriptionCommand
{
FollowerName = inputParts[0],
FolloweeName = inputParts[2],
SubscriptionRepository = subscriptionRepository,
UserRepository = userRepository
};
}
public ICommand CreateCommand(string[] inputParts, IUserRepository userRepository, IMessageRepository messageRepository,
ISubscriptionRepository subscriptionRepository, IMessagePrinter messagePrinter)
{
return new ShowWallCommand
{
MessagePrinter = messagePrinter,
UserName = inputParts[0],
MessageRepository = messageRepository,
UserRepository = userRepository,
SubscriptionRepository = subscriptionRepository
};
}
public void CreateAndStoreASubscription()
{
_SubscriptionRepository = new SubscriptionRepository();
var follower = new User { Name = "Charlie" };
var followee = new User { Name = "Alice" };
_SubscriptionRepository.AddSubscriptionIfNoneParticipantIsNull(follower, followee);
var allSubscription = _SubscriptionRepository.AllSubscription();
Assert.AreEqual(allSubscription.Count, 1);
Assert.AreEqual(allSubscription[0], new Subscription { Followee = followee, Follower = follower });
}
public void NotCreateAndStoreASubscriptionIfAnyParticipantIsNull()
{
_SubscriptionRepository = new SubscriptionRepository();
var user = new User { Name = "Alice" };
_SubscriptionRepository.AddSubscriptionIfNoneParticipantIsNull(user, null);
_SubscriptionRepository.AddSubscriptionIfNoneParticipantIsNull(null, user);
_SubscriptionRepository.AddSubscriptionIfNoneParticipantIsNull(null, null);
var allSubscription = _SubscriptionRepository.AllSubscription();
Assert.AreEqual(allSubscription.Count, 0);
}
public void SetUp()
{
theServiceBus = new RiggedServiceBus();
theSubscriptions = MockRepository.GenerateMock<ISubscriptionRepository>();
theLogger = new RecordingLogger();
thePeer = new TransportPeer(new HealthMonitoringSettings(), theNode, theSubscriptions, theServiceBus, theLogger);
theSubscriptions.Stub(x => x.FindPeer(theNode.Id))
.Return(theNode);
theContextIs();
}
public TransportPeer(HealthMonitoringSettings settings, TransportNode node, ISubscriptionRepository subscriptions, IServiceBus serviceBus, ILogger logger)
{
_settings = settings;
_node = node;
_subscriptions = subscriptions;
_serviceBus = serviceBus;
_logger = logger;
if (!_node.Addresses.Any())
{
throw new ArgumentOutOfRangeException("node", "The TransportNode must have at least one reply Uri");
}
}
public CommandParser(
IEnumerable<ICommandFactory> allCommands,
IUserRepository userRepository,
IMessageRepository messageRepository,
ISubscriptionRepository subscriptionRepository,
IMessagePrinter messagePrinter)
{
_AllCommands = allCommands;
_UserRepository = userRepository;
_MessageRepository = messageRepository;
_SubscriptionRepository = subscriptionRepository;
_MessagePrinter = messagePrinter;
}
public ICommand CreateCommand(
string[] inputParts,
IUserRepository userRepository,
IMessageRepository messageRepository,
ISubscriptionRepository subscriptionRepository,
IMessagePrinter messagePrinter)
{
return new PostMessageCommand
{
UserName = inputParts[0],
MessageText = inputParts[2],
UserRepository = userRepository,
MessageRepository = messageRepository
};
}
public void RetrieveSubscribedUsers()
{
_SubscriptionRepository = new SubscriptionRepository();
var charlie = new User { Name = "Charlie" };
var alice = new User { Name = "Alice" };
var bob = new User { Name = "Bob" };
_SubscriptionRepository.AddSubscriptionIfNoneParticipantIsNull(charlie, alice);
_SubscriptionRepository.AddSubscriptionIfNoneParticipantIsNull(charlie, bob);
_SubscriptionRepository.AddSubscriptionIfNoneParticipantIsNull(bob, charlie);
IList<User> followeesOfCharlie = _SubscriptionRepository.GetSubscribedUsersOf(charlie);
Assert.AreEqual(followeesOfCharlie.Count, 2);
IList<User> followeesOfBob = _SubscriptionRepository.GetSubscribedUsersOf(bob);
Assert.AreEqual(followeesOfBob.Count, 1);
}
private readonly ITeacherDeclarationRepository _teaDeclRepo; // = ServiceLocator.Current.GetInstance<ITeacherDeclarationRepository>();
#endregion Fields
#region Constructors
public SubscriptionAppl(ITypeAdapter adapter,
IStudentDeclarationJiaoWuRepository stuDeclJiaoWuRepo,
ITeacherDeclarationJiaoWuRepository teaDeclJiaoWuRepo,
IStudentDeclarationRepository stuDeclRepo,
ITeacherDeclarationRepository teaDeclRepo,
ISubscriptionRepository subscriptionRepo,
IRepositoryContext context
)
{
_adapter = adapter;
_stuDeclRepo = stuDeclRepo;
_teaDeclRepo = teaDeclRepo;
_stuDeclJiaoWuRepo = stuDeclJiaoWuRepo;
_teaDeclJiaoWuRepo = teaDeclJiaoWuRepo;
_subscriptionRepo = subscriptionRepo;
_contextForUpdate = context;
}
public void Initialize()
{
_context = new EntityFrameworkRepositoryContext();
_trans = new TransactionScope();
_adapter = new AutoMapperTypeAdapter();
_stuDeclJiaoWuRepo = new StudentDeclarationJiaoWuRepository(_context);
_teaDeclJiaoWuRepo = new TeacherDeclarationJiaoWuRepository(_context);
_stuDeclRepo = new StudentDeclarationRepository(_context);
_teaDeclRepo = new TeacherDeclarationRepository(_context);
_subscriptionRepo = new SubscriptionRepository(_context);
_appl = new SubscriptionAppl(
_adapter,
_stuDeclJiaoWuRepo,
_teaDeclJiaoWuRepo,
_stuDeclRepo,
_teaDeclRepo,
_subscriptionRepo
);
}
public SubscriptionController(ISubscriptionRepository subscriptionRepository)
{
_subscriptionRepository = subscriptionRepository;
}
public SubscriptionRegistration(ISubscriptionRepository subscriptionRepository)
{
_subscriptionRepository = subscriptionRepository;
}
public SignInController(ISubscriptionRepository subscriptionRepository, IFormsAuthenticator formsAuthenticator)
{
_subscriptionRepository = subscriptionRepository;
_formsAuthenticator = formsAuthenticator;
}
public RepositoriesFactory(IDbContext context)
{
GroupRepository = new GroupRepository(context);
PersonRepository = new PersonRepository(context);
SubscriptionRepository = new SubscriptionRepository(context);
}
public SubscriptionsHandler(ISubscriptionRepository repository, ISubscriptionCache cache, IEnvelopeSender sender)
{
_repository = repository;
_cache = cache;
_sender = sender;
}
public SignInController()
{
_subscriptionRepository = new SubscriptionRepository(MongoServer.Create().GetDatabase("blog"));
_formsAuthenticator = new FormsAuthenticator();
}
public SubscriptionSearch(ISubscriptionRepository subscriptionRepository)
{
_subscriptionRepository = subscriptionRepository;
}
private readonly ISubscriptionRepository _subscriptionRepo; //= ServiceLocator.Current.GetInstance<ISubscriptionRepository>();
#endregion Fields
#region Constructors
public FeedbackAppl(ITypeAdapter adapter, ISubscriptionRepository subscriptionRepo)
{
_adapter = adapter;
_subscriptionRepo = subscriptionRepo;
}
