public SubscriptionController(
IOrchardServices orchardServices,
IForumService forumService,
IThreadService threadService,
IPostService postService,
ISiteService siteService,
IShapeFactory shapeFactory,
IAuthorizationService authorizationService,
IAuthenticationService authenticationService,
ISubscriptionService subscriptionService,
IThreadLastReadService threadLastReadService
)
{
_orchardServices = orchardServices;
_forumService = forumService;
_threadService = threadService;
_postService = postService;
_siteService = siteService;
_subscriptionService = subscriptionService;
_authorizationService = authorizationService;
_authenticationService = authenticationService;
_threadLastReadService = threadLastReadService;
T = NullLocalizer.Instance;
Shape = shapeFactory;
}
public ReportPostAdminController(
IOrchardServices orchardServices,
IForumService forumService,
IThreadService threadService,
IPostService postService,
ISiteService siteService,
IShapeFactory shapeFactory,
IAuthorizationService authorizationService,
IAuthenticationService authenticationService,
ISubscriptionService subscriptionService,
IReportPostService reportPostService,
ICountersService countersService
)
{
_orchardServices = orchardServices;
_forumService = forumService;
_threadService = threadService;
_postService = postService;
_siteService = siteService;
_subscriptionService = subscriptionService;
_authorizationService = authorizationService;
_authenticationService = authenticationService;
_reportPostService = reportPostService;
_countersService = countersService;
T = NullLocalizer.Instance;
Shape = shapeFactory;
}
public PostPartHandler(IRepository<PostPartRecord> repository,
IPostService postService,
IClock clock,
IReportPostService reportPostService,
ICountersService countersService,
ISubscriptionService subscriptionService
) {
_postService = postService;
_clock = clock;
_reportPostService = reportPostService;
_countersService = countersService;
_subscriptionService = subscriptionService;
Filters.Add(StorageFilter.For(repository));
OnGetDisplayShape<PostPart>(SetModelProperties);
OnGetEditorShape<PostPart>(SetModelProperties);
OnUpdateEditorShape<PostPart>(SetModelProperties);
OnCreated<PostPart>((context, part) => _countersService.UpdateCounters(part));
OnPublished<PostPart>((context, part) => {
_countersService.UpdateCounters(part);
UpdateThreadVersioningDates(part);
SendNewPostNotification(part);
//for purposes of 'last read' need to know the last valid post to the thread. The last time the user read the thread is tracked
//and is compared to the lastest posts in the thread to determine if the thread has unread posts.
if (!part.IsInappropriate)
{
part.ThreadPart.LastestValidPostDate = part.As<CommonPart>().PublishedUtc.Value;
}
});
OnUnpublished<PostPart>((context, part) => _countersService.UpdateCounters(part));
OnVersioned<PostPart>((context, part, newVersionPart) => _countersService.UpdateCounters(newVersionPart));
OnRemoved<PostPart>((context, part) =>
{
_countersService.UpdateCounters(part);
//going to leave the history record for historic purposes
// RemoveReports(part);
});
OnRemoved<ThreadPart>((context, b) =>
_postService.Delete(context.ContentItem.As<ThreadPart>()));
OnIndexing<PostPart>((context, postPart) => context.DocumentIndex
.Add("body", postPart.Record.Text).RemoveTags().Analyze()
.Add("format", postPart.Record.Format).Store()
.Add("forumsHomeId", postPart.ThreadPart.ForumPart.ForumCategoryPart.ForumsHomePagePart.Id)
.Add("categoryId", postPart.ThreadPart.ForumPart.ForumCategoryPart.Id)
.Add("forumId", postPart.ThreadPart.ForumPart.Id)
.Add("threadId", postPart.ThreadPart.Id)
);
OnIndexing<ThreadPart>((context, threadPart) => context.DocumentIndex.Add("Title", threadPart.As<TitlePart>().Title ));
}
public OrganizationController(IOrganizationService organizationService, IWebSecurityService userService, ISubscriptionService subscriptionService, IWorkflowInstanceService workflowInstanceService, IEmailHelper emailHelper)
{
this.organizationService = organizationService;
this.userService = userService;
this.subscriptionService = subscriptionService;
this.workflowInstanceService = workflowInstanceService;
this.emailHelper = emailHelper;
}
public CustomerController(ISubscriptionService subscriptionService, IOrganizationService organizationService, IWebSecurityService securityService, IEmailHelper emailHelper)
: base(subscriptionService, organizationService, securityService)
{
this.subscriptionService = subscriptionService;
this.organizationService = organizationService;
this.webSecurityService = securityService;
this.emailHelper = emailHelper;
}
public ClientSubscriptionsController(
ICompanyService companyService,
ISubscriptionService subscriptionService,
IMapper mapper)
{
_companyService = companyService;
_subscriptionService = subscriptionService;
_mapper = mapper;
}
public SubscriptionController(
IMembershipService membershipService,
ISubscriptionService subscriptionService,
ISubscriptionMapper subscriptionMapper)
{
this._membershipService = membershipService;
this._subscriptionService = subscriptionService;
this._subscriptionMapper = subscriptionMapper;
}
public CachedSubscriptionService(ISubscriptionService service)
{
if (service == null) throw new ArgumentNullException("service");
this.service = service;
this.cache = new AspCache();
CacheExpiration = TimeSpan.FromMinutes(30);
}
public PersonalPageController(
ISubscriptionService subscriptionService,
IMembershipService membershipService,
IFriendshipService friendshipService)
{
this._subscriptionService = subscriptionService;
this._membershipService = membershipService;
this._friendshipService = friendshipService;
}
public FriendshipController(
IFriendshipService friendshipService,
IMembershipService membershipService,
ISubscriptionService subscriptionService,
IFriendshipMapper friendshipMapper)
{
this._friendshipService = friendshipService;
this._membershipService = membershipService;
this._subscriptionService = subscriptionService;
this._friendshipMapper = friendshipMapper;
}
public OrganizationService(IUnitOfWork unitOfWork, IOrganizationRepository organizationRepository, IPersonService personService, IWebSecurityService userService, IEmailHelper emailHelper, ILocationRepository locationRepository, ISubscriptionService subscriptionService, ICategoryService categoryService)
{
this.unitOfWork = unitOfWork;
this.organizationRepository = organizationRepository;
this.personService = personService;
this.userService = userService;
this.emailHelper = emailHelper;
this.locationRepository = locationRepository;
this.subscriptionService = subscriptionService;
this.categoryService = categoryService;
}
public BillingSynchronizationManager(IBillingSyncConfigurationProvider config,
IUrlTrackingStatService statService,
ICompanyService companyService,
ISubscriptionService subscriptionService,
IBalanceService balanceService)
{
_config = config;
_statService = statService;
_companyService = companyService;
_subscriptionService = subscriptionService;
_balanceService = balanceService;
}
public ImageController(
IImageAlbumService imageAlbumService,
IMembershipService membershipService,
ISubscriptionService subscriptionService,
IFriendshipService friendshipService,
IImageMapper imageMapper)
{
this._membershipService = membershipService;
this._imageAlbumService = imageAlbumService;
this._subscriptionService = subscriptionService;
this._imageMapper = imageMapper;
this._friendshipService = friendshipService;
}
public GamesListController(IGamesDataAccess gamesDataAccess,
ISubscriptionService subscriptionService,
IRedemptionService redemptionService,
IExternalServiceHandler serviceHandler,
IResourceService resourceService,
IPaymentsReportingService paymentsReportingService)
{
_gamesDataAccess = gamesDataAccess;
_subscriptionService = subscriptionService;
_redemptionService = redemptionService;
_serviceHandler = serviceHandler;
_resourceService = resourceService;
_paymentsReportingService = paymentsReportingService;
}
public UrlTrackingService(ISubscriptionService subscriptionService,
ITrackingUrlRepository trackingUrlRepository,
IBalanceService balanceService,
IUrlShortenerService urlShortenerService,
IProjectUriProvider projectUriProvider,
IMappingEngine mappingEngine,
ICompanyService companyService)
{
_subscriptionService = subscriptionService;
_trackingUrlRepository = trackingUrlRepository;
_balanceService = balanceService;
_urlShortenerService = urlShortenerService;
_projectUriProvider = projectUriProvider;
_mappingEngine = mappingEngine;
_companyService = companyService;
}
public OrganizationService(
IServiceProvider serviceProvider,
IStorageService storageService,
ISubscriptionService subscriptionService,
Lazy <IUserInfo> userInfo,
ILogger <OrganizationService> logger,
IBuyerAccountService buyerService) : base(serviceProvider)
{
_logger = logger;
_buyerService = buyerService;
_organizationPersonRepo = UnitOfWork.RepositoryAsync <OrganizationPerson>();
UnitOfWork.RepositoryAsync <Contract>();
_storageService = storageService;
_subscriptionService = subscriptionService;
_userInfo = userInfo;
}
public ShopController(IMapper mapper, IMatchService matchService, ITeamsService teamsService, IMatchStadiumLocationService mslService
, ICompetitionsService competitionsService, ILocationsService locationsService, IOrderService orderService, IOrderLineService orderLineService,
ITicketService ticketService, ITeamCompetitionLocationService tclService, ISubscriptionService subscriptionService, IEmailSender emailSender)
{
_mapper = mapper;
_matchService = matchService;
_teamsService = teamsService;
_mslService = mslService;
_competitionsService = competitionsService;
_locationsService = locationsService;
_orderLineService = orderLineService;
_orderService = orderService;
_ticketService = ticketService;
_tclService = tclService;
_subscriptionService = subscriptionService;
_emailSender = emailSender;
}
internal XDAmazonListener(IIdentityProvider identityProvider, ISerializer serializer,
ITopicRepository topicRepository,
ISubscriberRepository subscriberRepository, ISubscriptionService subscriptionService)
{
identityProvider.Requires("identityProvider").IsNotNull();
serializer.Requires("serializer").IsNotNull();
topicRepository.Requires("topicRepository").IsNotNull();
subscriberRepository.Requires("subscriberRepository").IsNotNull();
subscriptionService.Requires("subscriptionService").IsNotNull();
useLongLiveQueues = identityProvider.Scope == IdentityScope.Machine;
uniqueInstanceId = identityProvider.GetUniqueId();
this.serializer = serializer;
this.topicRepository = topicRepository;
this.subscriberRepository = subscriberRepository;
this.subscriptionService = subscriptionService;
}
internal XDAmazonListener(IIdentityProvider identityProvider, ISerializer serializer,
ITopicRepository topicRepository,
ISubscriberRepository subscriberRepository, ISubscriptionService subscriptionService)
{
Validate.That(identityProvider).IsNotNull();
Validate.That(serializer).IsNotNull();
Validate.That(topicRepository).IsNotNull();
Validate.That(subscriberRepository).IsNotNull();
Validate.That(subscriptionService).IsNotNull();
useLongLiveQueues = (identityProvider.Scope == IdentityScope.Machine);
uniqueInstanceId = identityProvider.GetUniqueId();
this.serializer = serializer;
this.topicRepository = topicRepository;
this.subscriberRepository = subscriberRepository;
this.subscriptionService = subscriptionService;
}
public ThreadPartHandler(IRepository<ThreadPartRecord> repository,
IPostService postService,
IThreadService threadService,
IContentManager contentManager,
ICountersService countersService,
ISubscriptionService subscriptionService,
IOrchardServices orchardServices
) {
_postService = postService;
_threadService = threadService;
_contentManager = contentManager;
_countersService = countersService;
_subscriptionService = subscriptionService;
_orchardServices = orchardServices;
Filters.Add(StorageFilter.For(repository));
OnGetDisplayShape<ThreadPart>(SetModelProperties);
OnGetEditorShape<ThreadPart>(SetModelProperties);
OnUpdateEditorShape<ThreadPart>(SetModelProperties);
OnActivated<ThreadPart>(PropertyHandlers);
OnLoading<ThreadPart>((context, part) => LazyLoadHandlers(part));
OnCreated<ThreadPart>((context, part) => {
_countersService.UpdateForumPartCounters(part);
//bit expensive but doesn't happen frequently
part.ForumsHomepageId = part.ForumPart.ForumCategoryPart.ForumsHomePagePart.Id;
});
OnPublished<ThreadPart>((context, part) => {
_countersService.UpdateForumPartCounters(part);
part.LastestValidPostDate = DateTime.UtcNow;
//bit expensive but doesn't happen frequently
part.ForumsHomepageId = part.ForumPart.ForumCategoryPart.ForumsHomePagePart.Id;
});
OnUnpublished<ThreadPart>((context, part) => _countersService.UpdateForumPartCounters(part));
OnVersioning<ThreadPart>((context, part, newVersionPart) => LazyLoadHandlers(newVersionPart));
OnVersioned<ThreadPart>((context, part, newVersionPart) => _countersService.UpdateForumPartCounters(newVersionPart));
OnRemoved<ThreadPart>((context, part) => OnThreadRemoved(context, part));
OnRemoved<ForumPart>((context, b) =>
_threadService.Delete(context.ContentItem.As<ForumPart>(), true));
}
public new void Setup()
{
base.Setup();
_topUpLogic = GetInst <ITopUpLogic>();
_userManager = GetInst <IUserManager>();
_usageLogic = GetInst <IUsageLogic>();
_userValidationLogic = GetInst <UserValidationLogic>();
_accessRightLogic = GetInst <IAccessRightLogic>();
_subscriptionService = GetInst <ISubscriptionService>();
_subscriptionLogic = GetInst <ISubscriptionLogic>();
_subscriptionVasLogic = GetInst <SubscriptionVasLogic>();
_subscriptionStatusLogic = GetInst <ISubscriptionStatusLogic>();
_changeSubscriptionLogic = GetInst <IChangeSubscriptionLogic>();
_subscriptionOfferingLogic = GetInst <ISubscriptionOfferingLogic>();
_appSettings = GetInst <IApplicationSettings>();
_catalogService = GetInst <ICatalogService>();
_cbmService = GetInst <ICbmService>();
_orderSimLogic = GetInst <IOrderSimLogic>();
_accountLogic = GetInst <IAccountLogic>();
dict = new Dictionary <Params, object>()
{
{ Params.TopUp, _topUpLogic },
{ Params.UserManager, _userManager },
{ Params.Usage, _usageLogic },
{ Params.UserValidation, _userValidationLogic },
{ Params.AccessRights, _accessRightLogic },
{ Params.SubscriptionService, _subscriptionService },
{ Params.Subscription, _subscriptionLogic },
{ Params.SubscriptionVas, _subscriptionVasLogic },
{ Params.SubscriptionStatus, _subscriptionStatusLogic },
{ Params.ChangeSubscription, _changeSubscriptionLogic },
{ Params.SubscriptionOffering, _subscriptionOfferingLogic },
{ Params.AppSettings, _appSettings },
{ Params.CatalogService, _catalogService },
{ Params.CbmService, _cbmService },
{ Params.OrderSim, _orderSimLogic },
{ Params.Account, _accountLogic }
};
}
internal XDAmazonListener(IIdentityProvider identityProvider, ISerializer serializer,
ITopicRepository topicRepository,
ISubscriberRepository subscriberRepository, ISubscriptionService subscriptionService)
{
Validate.That(identityProvider).IsNotNull();
Validate.That(serializer).IsNotNull();
Validate.That(topicRepository).IsNotNull();
Validate.That(subscriberRepository).IsNotNull();
Validate.That(subscriptionService).IsNotNull();
useLongLiveQueues = (identityProvider.Scope == IdentityScope.Machine);
uniqueInstanceId = identityProvider.GetUniqueId();
this.serializer = serializer;
this.topicRepository = topicRepository;
this.subscriberRepository = subscriberRepository;
this.subscriptionService = subscriptionService;
}
public SubscriptionController(
ApiSettings settings,
ILogger <SubscriptionController> logger,
ITransactionCoordinator transactionCoordinator,
ISubscriptionService subscriptionService,
IApiSubscriptionModelMapper subscriptionModelMapper
)
: base(settings,
logger,
transactionCoordinator,
subscriptionService,
subscriptionModelMapper)
{
this.BulkInsertLimit = 250;
this.MaxLimit = 1000;
this.DefaultLimit = 250;
}
public PrometheusMiddleware(
RequestDelegate next,
ILogger <PrometheusMiddleware> logger,
IQueueService queueService,
ITopicService topicService,
ISubscriptionService subscriptionService,
IOptions <AzureServicebusExporterConfig> config,
IServiceBusNamespace serviceBusNamespace = null)
{
_next = next;
_logger = logger;
_queueService = queueService;
_topicService = topicService;
_subscriptionService = subscriptionService;
_config = config;
_serviceBusNamespace = serviceBusNamespace;
}
public ReportApiController(ISubscriptionService subscriptionService,
ILicenceEnvironmentService licenceEnvironmentService,
IReportService reportService,
IUsageReportService usageReportService,
IDeviceOSReportService deviceOSReportService,
ISeatDetailsReportService seatDetailsReportService,
IUserDataService userDataService,
IDeviceManufacturerReportService deviceManufacturerReportService,
IDeviceTypeReportService deviceTypeReportService,
IProductService productService,
ILogger <ReportApiController> logger,
IEnterpriseClientService enterpriseClientService,
IPartnerService partnerService,
IDeviceTypeDictionaryService deviceTypeDictionaryService,
IDeviceModelDictionaryService deviceModelDictionaryService,
IMemoryCache cache,
ISubscriptionAuthService subscriptionAuthService,
IReportProcessorRunService reportProcessorRunService,
IReportProcessor reportProcessor,
ILogger <ReportProvider> reportLogger,
IUserService userService)
{
_subscriptionService = subscriptionService;
_licenceEnvironmentService = licenceEnvironmentService;
_reportService = reportService;
_usageReportService = usageReportService;
_deviceOSReportService = deviceOSReportService;
_seatDetailsReportService = seatDetailsReportService;
_userDataService = userDataService;
_deviceManufacturerReportService = deviceManufacturerReportService;
_deviceTypeReportService = deviceTypeReportService;
_productService = productService;
_logger = logger;
_enterpriseClientService = enterpriseClientService;
_partnerService = partnerService;
_deviceTypeDictionaryService = deviceTypeDictionaryService;
_deviceModelDictionaryService = deviceModelDictionaryService;
_cache = cache;
_subscriptionAuthService = subscriptionAuthService;
_reportProcessorRunService = reportProcessorRunService;
_reportProcessor = reportProcessor;
_reportLogger = reportLogger;
_configuration = CommonHelper.GetConfigurationObject();
_userService = userService;
FillCache();
}
internal XDAmazonListener(IIdentityProvider identityProvider, ISerializer serializer,
ITopicRepository topicRepository,
ISubscriberRepository subscriberRepository, ISubscriptionService subscriptionService)
{
identityProvider.Requires("identityProvider").IsNotNull();
serializer.Requires("serializer").IsNotNull();
topicRepository.Requires("topicRepository").IsNotNull();
subscriberRepository.Requires("subscriberRepository").IsNotNull();
subscriptionService.Requires("subscriptionService").IsNotNull();
useLongLiveQueues = identityProvider.Scope == IdentityScope.Machine;
uniqueInstanceId = identityProvider.GetUniqueId();
this.serializer = serializer;
this.topicRepository = topicRepository;
this.subscriberRepository = subscriberRepository;
this.subscriptionService = subscriptionService;
}
/// <summary>
/// Unsubscribe and disposes internal subscriber resources.
/// </summary>
public void Dispose()
{
bool factoryClosed = false;
bool clientClosed = false;
UnSubscribe();
try
{
if (m_ChannelFactory != null && m_ChannelFactory.State != CommunicationState.Closed && m_ChannelFactory.State != CommunicationState.Faulted)
{
m_ChannelFactory.Close();
m_ChannelFactory.Faulted -= new EventHandler(ChannelFactory_Faulted);
factoryClosed = true;
}
}
catch { } //Dispose should never error
finally
{
if (!factoryClosed && m_ChannelFactory != null)
{
m_ChannelFactory.Abort();
}
m_ChannelFactory = null;
}
try
{
if (m_Client != null)
{
((ICommunicationObject)m_Client).Close();
((ICommunicationObject)m_Client).Faulted -= new EventHandler(ClientChannel_Faulted);
clientClosed = true;
}
}
catch { } //Dispose should never error
finally
{
if (!clientClosed && m_Client != null)
{
((ICommunicationObject)m_Client).Abort();
}
m_Client = null;
}
}
public SubscriptionModelFactory(IAddressModelFactory addressModelFactory,
ISubscriptionService subscriptionService,
IWorkContext workContext,
ICurrencyService currencyService,
IPriceFormatter priceFormatter,
ISubscriptionProcessingService subscriptionProcessingService,
IDateTimeHelper dateTimeHelper,
IPaymentService paymentService,
ILocalizationService localizationService,
ICountryService countryService,
IArticleAttributeParser articleAttributeParser,
IDownloadService downloadService,
IStoreContext storeContext,
ISubscriptionTotalCalculationService subscriptionTotalCalculationService,
IRewardPointService rewardPointService,
CatalogSettings catalogSettings,
SubscriptionSettings subscriptionSettings,
TaxSettings taxSettings,
AddressSettings addressSettings,
RewardPointsSettings rewardPointsSettings,
PdfSettings pdfSettings)
{
this._addressModelFactory = addressModelFactory;
this._subscriptionService = subscriptionService;
this._workContext = workContext;
this._currencyService = currencyService;
this._priceFormatter = priceFormatter;
this._subscriptionProcessingService = subscriptionProcessingService;
this._dateTimeHelper = dateTimeHelper;
this._paymentService = paymentService;
this._localizationService = localizationService;
this._countryService = countryService;
this._articleAttributeParser = articleAttributeParser;
this._downloadService = downloadService;
this._storeContext = storeContext;
this._subscriptionTotalCalculationService = subscriptionTotalCalculationService;
this._rewardPointService = rewardPointService;
this._catalogSettings = catalogSettings;
this._subscriptionSettings = subscriptionSettings;
this._taxSettings = taxSettings;
this._addressSettings = addressSettings;
this._rewardPointsSettings = rewardPointsSettings;
this._pdfSettings = pdfSettings;
}
public SubscriptionController(
ISubscriptionService subscriptionService,
INotificationTypeService notificationTypeService,
INotificationRoleService notificationRoleService,
IMeetingService meetingService,
ILogService logService,
ILoggerFactory logger,
IAuthenticationService authenticationService,
IMeetingAttachmentService meetingAttachmentService)
{
_subscriptionService = subscriptionService;
_notificationTypeService = notificationTypeService;
_meetingService = meetingService;
_logService = logService;
_authenticationService = authenticationService;
_meetingAttachmentService = meetingAttachmentService;
_logger = logger.CreateLogger("SubscriptionController");
}
protected virtual void UpdateSubscriptions(ISubscriptionService subscriptionService)
{
var user = User.Identity as CustomIdentity;
if (user != null)
{
try
{
IList<Subscription> subscriptions =
subscriptionService.GetFilteredSubscriptionsForUser(user.Id);
this.Session[Constants.SessionSubscriptionTargets] =
subscriptions.Select(p => p.Target.Key).ToArray();
}
catch (Exception)
{
this.Session[Constants.SessionSubscriptionTargets] = new int[0];
}
}
}
public CatalogService(IWorkContextAccessor workContextAccessor, ICatalogModuleCategories categoriesApi,
ICatalogModuleProducts productsApi,
ICatalogModuleSearch searchApi, IPricingService pricingService, IMemberService customerService,
ISubscriptionService subscriptionService,
IInventoryService inventoryService, IStorefrontMemoryCache memoryCache, IApiChangesWatcher changesWatcher)
{
_workContextAccessor = workContextAccessor;
_categoriesApi = categoriesApi;
_productsApi = productsApi;
_searchApi = searchApi;
_categoriesApi = categoriesApi;
_pricingService = pricingService;
_inventoryService = inventoryService;
_customerService = customerService;
_subscriptionService = subscriptionService;
_memoryCache = memoryCache;
_apiChangesWatcher = changesWatcher;
}
public NewsletterSubscriptionController(ISubscriptionService subscriptionService,
IUnsubscriptionProvider unsubscriptionProvider,
IContactProvider contactProvider,
IEmailHashValidator emailHashValidator,
ISubscriptionApprovalService subscriptionApprovalService,
IIssueInfoProvider issueInfoProvider,
INewsletterInfoProvider newsletterInfoProvider,
ISiteService siteService)
{
this.subscriptionService = subscriptionService;
this.unsubscriptionProvider = unsubscriptionProvider;
this.contactProvider = contactProvider;
this.emailHashValidator = emailHashValidator;
this.subscriptionApprovalService = subscriptionApprovalService;
this.issueInfoProvider = issueInfoProvider;
this.newsletterInfoProvider = newsletterInfoProvider;
this.siteService = siteService;
}
public SubscriptionController(ISubscriptionModelFactory subscriptionModelFactory,
ISubscriptionService subscriptionService,
IWorkContext workContext,
ISubscriptionProcessingService subscriptionProcessingService,
IPaymentService paymentService,
IPdfService pdfService,
IWebHelper webHelper,
RewardPointsSettings rewardPointsSettings)
{
this._subscriptionModelFactory = subscriptionModelFactory;
this._subscriptionService = subscriptionService;
this._workContext = workContext;
this._subscriptionProcessingService = subscriptionProcessingService;
this._paymentService = paymentService;
this._pdfService = pdfService;
this._webHelper = webHelper;
this._rewardPointsSettings = rewardPointsSettings;
}
public ArticleController(IArticleModelFactory articleModelFactory,
IArticleService articleService,
IWorkContext workContext,
IStoreContext storeContext,
ILocalizationService localizationService,
IWebHelper webHelper,
IRecentlyViewedArticlesService recentlyViewedArticlesService,
ICompareArticlesService compareArticlesService,
IWorkflowMessageService workflowMessageService,
ISubscriptionReportService subscriptionReportService,
ISubscriptionService subscriptionService,
IAclService aclService,
IStoreMappingService storeMappingService,
IPermissionService permissionService,
ICustomerActivityService customerActivityService,
IEventPublisher eventPublisher,
CatalogSettings catalogSettings,
ShoppingCartSettings shoppingCartSettings,
LocalizationSettings localizationSettings,
CaptchaSettings captchaSettings,
ICacheManager cacheManager)
{
this._articleModelFactory = articleModelFactory;
this._articleService = articleService;
this._workContext = workContext;
this._storeContext = storeContext;
this._localizationService = localizationService;
this._webHelper = webHelper;
this._recentlyViewedArticlesService = recentlyViewedArticlesService;
this._compareArticlesService = compareArticlesService;
this._workflowMessageService = workflowMessageService;
this._subscriptionReportService = subscriptionReportService;
this._subscriptionService = subscriptionService;
this._aclService = aclService;
this._storeMappingService = storeMappingService;
this._permissionService = permissionService;
this._customerActivityService = customerActivityService;
this._eventPublisher = eventPublisher;
this._catalogSettings = catalogSettings;
this._shoppingCartSettings = shoppingCartSettings;
this._localizationSettings = localizationSettings;
this._captchaSettings = captchaSettings;
this._cacheManager = cacheManager;
}
public UserApiController(IEnterpriseClientService enterpriseClientService,
IPartnerService partnerService,
ISubscriptionService subscriptionService,
IUserService userService,
UserManager <IdentityUser> userManager,
SignInManager <IdentityUser> signInManager,
RoleManager <IdentityRole> roleManager,
ILogger <UserApiController> logger)
{
_enterpriseClientService = enterpriseClientService;
_partnerService = partnerService;
_subscriptionService = subscriptionService;
_userService = userService;
_userManager = userManager;
_signInManager = signInManager;
_roleManager = roleManager;
_logger = logger;
_configuration = CommonHelper.GetConfigurationObject();
}
public CachedSubscriptionService(ISubscriptionService service)
{
if (service == null)
{
throw new ArgumentNullException("service");
}
this.service = service;
cache = AscCache.Memory;
notify = AscCache.Notify;
CacheExpiration = TimeSpan.FromMinutes(5);
notify.Subscribe <SubscriptionRecord>((s, a) =>
{
var store = GetSubsciptionsStore(s.Tenant, s.SourceId, s.ActionId);
lock (store)
{
if (a == CacheNotifyAction.InsertOrUpdate)
{
store.SaveSubscription(s);
}
else if (a == CacheNotifyAction.Remove)
{
if (s.ObjectId == null)
{
store.RemoveSubscriptions();
}
else
{
store.RemoveSubscriptions(s.ObjectId);
}
}
}
});
notify.Subscribe <SubscriptionMethod>((m, a) =>
{
var store = GetSubsciptionsStore(m.Tenant, m.SourceId, m.ActionId);
lock (store)
{
store.SetSubscriptionMethod(m);
}
});
}
public FluentQueueApi()
{
var unityContainer = new UnityContainer();
unityContainer.RegisterType <IPublisherService, PublisherService>();
unityContainer.RegisterType <ISubscriptionService, SubscriptionService>();
unityContainer.RegisterType <ITopicService, TopicService>();
unityContainer.RegisterSingleton <ISubscriberService, SubscriberService>();
unityContainer.RegisterSingleton <IDeadLetterService, DeadLetterService>();
unityContainer.RegisterSingleton <IExponentialBackOffService, ExponentialBackOffService>();
unityContainer.RegisterSingleton <IIamPolicyRequestService, IamPolicyRequestService>();
_publisherService = unityContainer.Resolve <IPublisherService>();
_subscriptionService = unityContainer.Resolve <ISubscriptionService>();
_topicService = unityContainer.Resolve <ITopicService>();
_subscriberService = unityContainer.Resolve <ISubscriberService>();
_deadLetterService = unityContainer.Resolve <IDeadLetterService>();
_exponentialBackOffService = unityContainer.Resolve <IExponentialBackOffService>();
}
public DemoCatalogService(IWorkContextAccessor workContextAccessor,
ICatalogModuleCategories categoriesApi, ICatalogModuleProducts productsApi,
ICatalogModuleAssociations associationsApi, ICatalogModuleIndexedSearch searchApi,
IPricingService pricingService, IMemberService customerService,
ISubscriptionService subscriptionService, IInventoryService inventoryService,
IStorefrontMemoryCache memoryCache, IApiChangesWatcher changesWatcher,
IStorefrontUrlBuilder storefrontUrlBuilder,
IDemoCatalog demoCatalogApi) :
base(workContextAccessor,
categoriesApi, productsApi, associationsApi, searchApi,
pricingService, customerService, subscriptionService, inventoryService,
memoryCache, changesWatcher,
storefrontUrlBuilder)
{
_memoryCache = memoryCache;
_demoCatalogApi = demoCatalogApi;
_workContextAccessor = workContextAccessor;
_apiChangesWatcher = changesWatcher;
}
public HomeController(
IJobService jobService,
UserManager <ApplicationUser> userManager,
IReportGenerator reportGenerator,
IOutputPersistence persistence,
IOptions <EcosetAppOptions> options,
INotificationService notifyService,
ISubscriptionService subService,
ILogger <HomeController> logger)
{
_jobService = jobService;
_userManager = userManager;
_notifyService = notifyService;
_persistence = persistence;
_reportGenerator = reportGenerator;
_options = options.Value;
_subService = subService;
_logger = logger;
}
private void NotifySubscriberToStopCollaborating(CollaborationRequest request, Subscriber subscriber)
{
//Create a WCF client by indicating A-B-C: Address, Binding, Contract
//Address
var serviceAddress = GetCollaborationServiceAddress(subscriber.Address, unicastPort);
//Binding
NetTcpBinding tcpBinding = new NetTcpBinding();
tcpBinding.Security.Mode = SecurityMode.None;
tcpBinding.Security.Message.ClientCredentialType = MessageCredentialType.None;
//Create the ChannelFactory by indicating the Contract (i.e. the service interface)
ChannelFactory <ISubscriptionService> factory = new ChannelFactory <ISubscriptionService>(tcpBinding, new EndpointAddress(serviceAddress));
//Open the channel and send the request
ISubscriptionService proxy = factory.CreateChannel();
proxy.StopCollaborating(request);
factory.Close();
}
public ContractController(
IGenreService genreService,
IContractService contractService,
IContractResultService contractResultService,
IEditionService editionService,
ICardService cardService,
ISubscriptionService subscriptionService,
IPaymentService paymentService,
IPublisherService publisherService
)
{
_genreService = genreService;
_contractService = contractService;
_contractResultService = contractResultService;
_editionService = editionService;
_cardService = cardService;
_subscriptionService = subscriptionService;
_paymentService = paymentService;
_publisherService = publisherService;
}
public DataPackageApiController(
IJobService jobService,
UserManager <ApplicationUser> userManager,
IOptions <ReportContentOptions> reportOptions,
IOutputPersistence persistence,
INotificationService notifyService,
ILogger <DataPackageApiController> logger,
IDataRegistry dataRegistry,
ISubscriptionService subService,
IOptions <EcosetAppOptions> options)
{
_jobService = jobService;
_userManager = userManager;
_persistence = persistence;
_reportOptions = reportOptions.Value;
_subService = subService;
_logger = logger;
_dataRegistry = dataRegistry;
_options = options.Value;
}
protected virtual void ReleaseUpToDateSubscriptions(
IMembershipService membershipService,
ISubscriptionService subscriptionService)
{
var user = User.Identity as CustomIdentity;
var keyString = RouteData.Values["key"] as string;
int key;
if (int.TryParse(keyString, out key) && user != null && !key.Equals(user.Id))
{
try
{
User subscriber = membershipService.GetUserByKey(user.Id);
User target = membershipService.GetUserByKey(key);
subscriptionService.ResetNewSubscriptions(subscriber, target);
}
catch (Exception)
{
}
}
}
// Sends realtime data
public MainAppVM(ISubscriptionService subscriptionService)
{
_subService = subscriptionService;
_subService.Subscribe(OnData);
Devices = new List <SensorData>();
var DeviceData = new DeviceDataProvider();
var data = DeviceData.GetData();
var devices = data.Documents.GroupBy(e => e.deviceId);
foreach (var device in devices)
{
Devices.Add(device.FirstOrDefault());
}
_timer = new Timer(state =>
{
Changed(nameof(ServerTime));
PushUpdates();
}, null, 0, 1000);
}
public AffiliateController(ILocalizationService localizationService,
IWorkContext workContext, IDateTimeHelper dateTimeHelper, IWebHelper webHelper,
ICountryService countryService, IStateProvinceService stateProvinceService,
IPriceFormatter priceFormatter, IAffiliateService affiliateService,
ICustomerService customerService, ISubscriptionService subscriptionService,
IPermissionService permissionService,
ICustomerActivityService customerActivityService)
{
this._localizationService = localizationService;
this._workContext = workContext;
this._dateTimeHelper = dateTimeHelper;
this._webHelper = webHelper;
this._countryService = countryService;
this._stateProvinceService = stateProvinceService;
this._priceFormatter = priceFormatter;
this._affiliateService = affiliateService;
this._customerService = customerService;
this._subscriptionService = subscriptionService;
this._permissionService = permissionService;
this._customerActivityService = customerActivityService;
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(
IApplicationBuilder app,
IHostingEnvironment env,
ISubscriptionService subscriptionService)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
else
{
app.UseExceptionHandler("/Error");
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseSpaStaticFiles();
app.UseSignalR(routes =>
{
routes.MapHub <AdminNotifyerHub>("/hub");
});
app.UseMvc(routes =>
{
routes.MapRoute(
name: "default",
template: "{controller}/{action=Index}/{id?}");
});
app.UseSpa(spa =>
{
spa.Options.SourcePath = "ClientApp";
if (env.IsDevelopment())
{
spa.UseReactDevelopmentServer(npmScript: "start");
}
});
subscriptionService.Subscribe();
}
static async Task Main(String[] args)
{
Console.Title = "Subscription Service";
IServiceCollection services = new ServiceCollection();
Program.InitialiseConfiguration(services);
Program.ConfigureLogging(services);
IContainer container = Bootstrapper.ConfigureServices(services);
Logger.LogInformation("About to Start Service");
ISubscriptionService SubscriptionService = container.GetInstance <ISubscriptionService>();
SubscriptionService.StartService();
Logger.LogInformation("Service Started");
//Console.Read();
Thread.Sleep(Timeout.Infinite);
}
public ReportProcessor(ISubscriptionService subscriptionService,
ILicenceEnvironmentService licenceEnvironmentService,
IReportService reportService,
IUsageReportService usageReportService,
IDeviceOSReportService deviceOSReportService,
ISeatDetailsReportService seatDetailsReportService,
IUserDataService userDataService,
IDeviceManufacturerReportService deviceManufacturerReportService,
IDeviceTypeReportService deviceTypeReportService,
ILogger <ReportProcessor> logger)
{
_subscriptionService = subscriptionService;
_licenceEnvironmentService = licenceEnvironmentService;
_reportService = reportService;
_usageReportService = usageReportService;
_deviceOSReportService = deviceOSReportService;
_seatDetailsReportService = seatDetailsReportService;
_userDataService = userDataService;
_deviceManufacturerReportService = deviceManufacturerReportService;
_deviceTypeReportService = deviceTypeReportService;
_logger = logger;
}
public ReturnRequestController(IReturnRequestService returnRequestService,
ISubscriptionService subscriptionService,
ICustomerService customerService,
IDateTimeHelper dateTimeHelper,
ILocalizationService localizationService,
IWorkContext workContext,
IWorkflowMessageService workflowMessageService,
ICustomerActivityService customerActivityService,
IPermissionService permissionService,
IDownloadService downloadService)
{
this._returnRequestService = returnRequestService;
this._subscriptionService = subscriptionService;
this._customerService = customerService;
this._dateTimeHelper = dateTimeHelper;
this._localizationService = localizationService;
this._workContext = workContext;
this._workflowMessageService = workflowMessageService;
this._customerActivityService = customerActivityService;
this._permissionService = permissionService;
this._downloadService = downloadService;
}
public HomeController(IStoreContext storeContext,
AdminAreaSettings adminAreaSettings,
ISettingService settingService,
IPermissionService permissionService,
IArticleService articleService,
ISubscriptionService subscriptionService,
ICustomerService customerService,
IReturnRequestService returnRequestService,
IWorkContext workContext,
ICacheManager cacheManager)
{
this._storeContext = storeContext;
this._adminAreaSettings = adminAreaSettings;
this._settingService = settingService;
this._permissionService = permissionService;
this._articleService = articleService;
this._subscriptionService = subscriptionService;
this._customerService = customerService;
this._returnRequestService = returnRequestService;
this._workContext = workContext;
this._cacheManager = cacheManager;
}
public SubscriptionController(ISubscriptionService subscriptionService)
{
this.subscriptionService = subscriptionService;
}
public EventController(IEmailHelper emailHelper, ISubscriptionService subscriptionService, IOrganizationService organizationService)
{
this.emailHelper = emailHelper;
this.subscriptionService = subscriptionService;
this.organizationService = organizationService;
}
public ClientSubscriptionManager(ISubscriptionService service)
{
if (service == null) throw new ArgumentNullException("subscriptionManager");
this.service = service;
}
public PaymentController(IOrganizationService organizationService, ISubscriptionService subscriptionService, IEmailHelper emailHelper)
{
this.organizationService = organizationService;
this.subscriptionService = subscriptionService;
this.emailHelper = emailHelper;
}
public BaseApiController(ISubscriptionService subscriptionService, IOrganizationService organizationService, IWebSecurityService securityService)
{
this.subscriptionService = subscriptionService;
this.organizationService = organizationService;
this.webSecurityService = securityService;
}
public SubscriptionController(IPlanService planService, ISubscriptionService subscriptionService)
{
this.planService = planService;
this.subscriptionService = subscriptionService;
}
public LocationController(IOrganizationService organizationService, IEmailHelper emailHelper, ISubscriptionService subscriptionService, IWebSecurityService securityService):base(subscriptionService, organizationService,securityService)
{
this.organizationService = organizationService;
this.emailHelper = emailHelper;
}
protected override void SetUp()
{
base.SetUp();
IDocumentSerializer serializer = new JsonNetDocumentSerializer();
IDocumentStoreFactory store = new FileDocumentStoreFactory(StorageBaseDir, serializer);
RouteManager = new RouteManager();
Service = new SubscriptionService(store, RouteManager, MyQueueName);
store.Create<Type, SubscriptionRegistration>().Clear();
}
public CachedSubscriptionServiceTest()
{
service = new CachedSubscriptionService(new DbSubscriptionService(ConfigurationManager.ConnectionStrings["core"]));
}
public SupportUsController(IEmailService emailService, ISignatureService signatureService, ISubscriptionService subscriptionService)
{
this.emailService = emailService;
this.signatureService = signatureService;
this.subscriptionService = subscriptionService;
}
