public CommerceTrackingService(
ServiceAccessor <IContentRouteHelper> contentRouteHelperAccessor,
IContextModeResolver contextModeResolver,
IProductService productService,
TrackingDataFactory trackingDataFactory,
ITrackingService trackingService,
IContentLoader contentLoader,
LanguageService languageService,
HttpContextBase httpContextBase,
LanguageResolver languageResolver,
ILineItemCalculator lineItemCalculator,
IRequestTrackingDataService requestTrackingDataService,
ReferenceConverter referenceConverter,
IRelationRepository relationRepository,
ICurrentMarket currentMarket)
{
_contentRouteHelperAccessor = contentRouteHelperAccessor;
_contextModeResolver = contextModeResolver;
_productService = productService;
_trackingDataFactory = trackingDataFactory;
_trackingService = trackingService;
_contentLoader = contentLoader;
_languageService = languageService;
_httpContextBase = httpContextBase;
_languageResolver = languageResolver;
_lineItemCalculator = lineItemCalculator;
_requestTrackingDataService = requestTrackingDataService;
_referenceConverter = referenceConverter;
_relationRepository = relationRepository;
_currentMarket = currentMarket;
}
public ReportViewModel(INavigationService navigationService, ITrackingService trackingService, IUserService userService, ILoadingService loadingService)
{
this.navigationService = navigationService;
this.trackingService = trackingService;
this.userService = userService;
this.loadingService = loadingService;
}
public AddRegistrationHandler(ILogger <AddRegistrationHandler> logger,
IRegistrationService registrationService, ITrackingService trackingService)
{
_logger = logger;
_registrationService = registrationService;
_trackingService = trackingService;
}
public LimitObserver(ITrackingService trackingService,
IRepository repository,
IAppChangedNotifier appChangedNotifier,
IMidnightNotifier midnightNotifier,
ILimitHandler limitHandler,
IAppDurationCalc appDurationCalc,
Mediator mediator,
ISyncContext syncContext)
{
this.trackingService = trackingService;
this.repository = repository;
this.appChangedNotifier = appChangedNotifier;
this.midnightNotifier = midnightNotifier;
this.limitHandler = limitHandler;
this.appDurationCalc = appDurationCalc;
this.mediator = mediator;
limitNotifiers.Add(new LimitNotifier(syncContext, LimitSpan.Day));
limitNotifiers.Add(new LimitNotifier(syncContext, LimitSpan.Week));
foreach (var notifier in limitNotifiers)
{
notifier.LimitReached += OnLimitReached;
}
mediator.Register(MediatorMessages.APP_LIMITS_CHANGIING, LoadAppLimits);
}
public UserIdentitiesUpdater(ulong accountId, IUtxoClientCryptoService clientCryptoService, IAssetsService assetsService, IDataAccessService externalDataAccessService, IHubContext <IdentitiesHub> idenitiesHubContext, IRelationsProofsValidationService relationsProofsValidationService, ITrackingService trackingService)
{
_accountId = accountId;
_clientCryptoService = clientCryptoService;
_assetsService = assetsService;
_dataAccessService = externalDataAccessService;
_idenitiesHubContext = idenitiesHubContext;
_relationsProofsValidationService = relationsProofsValidationService;
_trackingService = trackingService;
PipeIn = new ActionBlock <PacketBase>(p =>
{
try
{
if (p is TransferAssetToUtxo packet)
{
_clientCryptoService.DecodeEcdhTuple(packet.TransferredAsset.EcdhTuple, packet.TransactionPublicKey, out byte[] blindingFactor, out byte[] assetId);
AttributeType attributeType = _assetsService.GetAttributeType(assetId);
_idenitiesHubContext.Clients.Group(_accountId.ToString(CultureInfo.InvariantCulture)).SendAsync("PushAttribute", new UserAttributeDto {
AttributeType = attributeType.ToString(), Source = packet.Signer.ArraySegment.Array.ToHexString(), AssetId = assetId.ToHexString(), OriginalBlindingFactor = blindingFactor.ToHexString(), OriginalCommitment = packet.TransferredAsset.AssetCommitment.ToHexString(), LastBlindingFactor = blindingFactor.ToHexString(), LastCommitment = packet.TransferredAsset.AssetCommitment.ToHexString(), LastTransactionKey = packet.TransactionPublicKey.ToHexString(), LastDestinationKey = packet.DestinationKey.ToHexString(), Validated = false, IsOverriden = false
});
}
else if (p is GroupsRelationsProofs relationsProofs && _clientCryptoService.CheckTarget(relationsProofs.DestinationKey2, relationsProofs.TransactionPublicKey))
{
RelationProofsValidationResults validationResults = _relationsProofsValidationService.VerifyRelationProofs(relationsProofs, _clientCryptoService);
_idenitiesHubContext.Clients.Group(_accountId.ToString(CultureInfo.InvariantCulture)).SendAsync("PushRelationValidation", validationResults);
}
}
catch
{
}
});
}
public WindowTracker(ITrackingService trackingService,
IRepository repository,
IAppChangedNotifier appChangedNotifier,
IScreenshotTracker screenshotTracker,
Mediator mediator)
{
this.trackingService = trackingService;
this.repository = repository;
this.appChangedNotifier = appChangedNotifier;
this.screenshotTracker = screenshotTracker;
this.mediator = mediator;
appChangedSubscription = appChangedNotifier.AppChangedObservable
.Where(a => isTrackingEnabled)
.Select(a => a.LogInfo.AppInfo == AppInfo.Empty ||
string.IsNullOrEmpty(a.LogInfo.AppInfo.GetAppName()) ? LogInfo.Empty : a.LogInfo)
.Do(i => FinishActiveLog())
.Subscribe(CreateActiveLog);
screenshotSubscription = screenshotTracker.ScreenshotObservable
.Where(s => s != null && isTrackingEnabled && activeLog != null)
.ObserveOn(DispatcherScheduler.Current)
.Subscribe(async s =>
{
s.LogID = activeLog.ID;
await repository.SaveNewEntityAsync(s);
mediator.NotifyColleagues(MediatorMessages.SCREENSHOT_TAKEN);
});
}
public HomeController(ILogger <HomeController> logger, BuscarPacoteHandle handler, ITrackingService tracking, AdicionarEmailHandle adicionarEmailHandle, DatabaseContext db)
{
_logger = logger;
_handler = handler;
_tracking = tracking;
_adicionarEmailHandle = adicionarEmailHandle;
_db = db;
}
public TrackingController(
ITrackingService trackingService,
IZoneService zoneService
)
{
_trackingService = trackingService;
_zoneService = zoneService;
}
public TrackingController(ITrackingService trackingService,
IBusPublisher busPublisher,
ILogger <TrackingController> logger)
{
_trackingService = trackingService;
_busPublisher = busPublisher;
_logger = logger;
}
public TrackingController(IAuthenticationService authenticationService,
IDiagnosticService diagnosticService,
ITrackingService trackingService,
IGridConfigService gridConfigService)
: base(authenticationService, diagnosticService, trackingService)
{
_gridConfigService = gridConfigService;
_trackingService = trackingService;
}
public ProductController(ITrackingService trackingService, IProductUiService productUiService, IBackInStockNotificationService backInStockNotificationService, CartModel cart, IDocumentService documentService, IProductReviewUIService productReviewUIService)
{
_trackingService = trackingService;
_productUiService = productUiService;
_backInStockNotificationService = backInStockNotificationService;
_cart = cart;
_documentService = documentService;
_productReviewUIService = productReviewUIService;
}
public AccountController(
IAccountRepository accountRepository,
IVisitorContext visitorContext,
ITrackingService trackingService)
{
this.accountRepository = accountRepository;
this.visitorContext = visitorContext;
this.trackingService = trackingService;
}
public ProfileStoreService(
ITrackingService trackingService,
ISiteDefinitionResolver siteDefinitionResolver,
IContentLoader contentLoader)
{
_trackingService = trackingService;
_siteDefinitionResolver = siteDefinitionResolver;
_contentLoader = contentLoader;
}
public NotificationService(ITrackingService trackingService, IDeviceService deviceService)
{
this.trackingService = trackingService;
this.deviceService = deviceService;
Log.Info("Start sending channels");
RegisterGcmChannel();
RegisterApnsChannel();
RegisterWnsChannel();
}
public PointersViewModel(ITrackingService trackingService)
{
WhenPointerEvent = Observable.FromEvent <TrackerEvents>(
h => trackingService.OnEvents += h,
h => trackingService.OnEvents -= h
)
.Select(events => events.pointerEvents)
.ObserveOn(SynchronizationContext.Current);
}
public ExceptionHandleMiddleware(
RequestDelegate next,
ILoggerService logger,
ITrackingService trackingService)
{
_next = next;
_logger = logger;
_trackingService = trackingService;
}
public CajuService(string outputPath, string zipDeliveryPath,
IStorageService storageService,
ITrackingService trackingService)
{
this.outputPath = outputPath;
this.zipDeliveryPath = zipDeliveryPath;
this.storageService = storageService;
this.trackingService = trackingService;
}
public RecommendationService(TrackingDataFactory trackingDataFactory, ITrackingService trackingService, ReferenceConverter referenceConverter, IContentLoader contentLoader)
{
_trackingDataFactory = trackingDataFactory;
_trackingService = trackingService;
_referenceConverter = referenceConverter;
var homePage = contentLoader.Get <HomePage>(ContentReference.StartPage);
_mode = homePage.Settings.RecommendationsMode.ToEnum(RecommendationsMode.Disabled);
}
public ProductController(ITrackingService trackingService, IProductUiService productUiService,
IBackInStockNotificationService backInStockNotificationService, CartModel cart,
IWebpageAdminService webpageAdminService)
{
_trackingService = trackingService;
_productUiService = productUiService;
_backInStockNotificationService = backInStockNotificationService;
_cart = cart;
_webpageAdminService = webpageAdminService;
}
public HttpClientFactory(ITrackingService trackingService, IConfigService configService,
IOriginSQLUserService originSQLUserService,
IOriginSQLPasswordService originSQLPasswordService)
{
_trackingService = trackingService;
_configService = configService;
_originSQLUserService = originSQLUserService;
_originSQLPasswordService = originSQLPasswordService;
_httpClients = new ConcurrentDictionary <Uri, HttpClient>();
}
public ContactService(ITrackingService trackingService, ILogService <CommonLog> logService, IContactRepository contactRepository)
{
Assert.ArgumentNotNull(trackingService, nameof(trackingService));
Assert.ArgumentNotNull(logService, nameof(logService));
Assert.ArgumentNotNull(contactRepository, nameof(contactRepository));
this.trackingService = trackingService;
this.logService = logService;
this.contactRepository = contactRepository;
}
public RecommendationService(
ITrackingService trackingService,
TrackingDataFactory trackingDataFactory,
IProductService productService,
IContextModeResolver contextModeResolver)
{
_trackingService = trackingService;
_trackingDataFactory = trackingDataFactory;
_productService = productService;
_contextModeResolver = contextModeResolver;
}
public RecommendationService(
ITrackingService trackingService,
TrackingDataFactory trackingDataFactory,
ReferenceConverter referenceConverter,
IContentLoader contentLoader)
{
_trackingService = trackingService;
_trackingDataFactory = trackingDataFactory;
_referenceConverter = referenceConverter;
_contentLoader = contentLoader;
}
public ContactServiceTests()
{
this.fixture = new Fixture();
ILogService <CommonLog> logService = Substitute.For <ILogService <CommonLog> >();
this.trackingService = Substitute.For <ITrackingService>();
this.contactRepository = Substitute.For <IContactRepository>();
this.contactService = Substitute.For <ContactService>(this.trackingService, logService, this.contactRepository);
}
public Tracking(string tableName, DateTime dateTime, int userId, Guid dataGuid, short type)
{
entries = new List <TrackingEntry>();
trackingService = CommonServiceLocator.ServiceLocator.Current.GetInstance <ITrackingService>();
this.tableName = tableName;
this.TrackingTimestamp = dateTime;
this.userId = userId;
this.dataGuid = dataGuid;
this.type = type;
}
public Interactor(
IPublisher bus,
IOutputBoundary <OrderOutput> outputBoundary,
IOutputConverter outputConverter,
ITrackingService trackingService)
{
this.bus = bus;
this.outputBoundary = outputBoundary;
this.outputConverter = outputConverter;
this.trackingService = trackingService;
}
internal DeliveryStatus CheckDeliveryStatus(ITrackingService service)
{
string res = service.GetTracking(this.TrackingTicket);
if (res == "delivered")
{
return(DeliveryStatus.Delivered);
}
return(DeliveryStatus.Dispatching);
}
public UsageTracker(IRepository repository,
ITrackingService trackingService,
Mediator mediator,
IUsageProcessor usageProcessor,
ExportFactory <IIdleNotifier> idleNotifierFactory)
{
this.repository = repository;
this.trackingService = trackingService;
this.mediator = mediator;
this.usageProcessor = usageProcessor;
this.idleNotifierFactory = idleNotifierFactory;
}
public TrackingController(
ITrackingService trackingService,
IUserService userService,
IExcellService excellService,
IWorkContext workContext
)
{
_trackingService = trackingService;
_userService = userService;
_excellService = excellService;
_workContext = workContext;
}
public CmsTrackingService(IContentLoader contentLoader,
ITrackingService trackingService,
IContextModeResolver contextModeResolver,
ISiteDefinitionResolver siteDefinitionResolver,
IRecommendationService personalizationRecommendationService)
{
_contentLoader = contentLoader;
_trackingService = trackingService;
_contextModeResolver = contextModeResolver;
_siteDefinitionResolver = siteDefinitionResolver;
_personalizationRecommendationService = personalizationRecommendationService;
}
/// <summary>
/// Initializes a new instance of the <see cref="Tracker"/> class.
/// </summary>
/// <param name="settings">Settings to be used by the tracker.</param>
/// <param name="trackingService">The tracking service client to be used to communicate
/// with the tracking server.</param>
/// <param name="synchronizationService">The synchronization service to be used for
/// synchronizing data in the project and at the tracking service.</param>
/// <param name="solver">The VRP solver to be used by the tracker.</param>
/// <param name="geocoder">The geocoder to be used by the tracker.</param>
/// <param name="messageReporter">The message reporter to be used for reporting
/// tracking errors.</param>
/// <exception cref="ArgumentNullException"><paramref name="settings"/>,
/// <paramref name="trackingService"/>, <paramref name="synchronizationService"/>,
/// <paramref name="solver"/>, <paramref name="geocoder"/> or
/// <paramref name="messageReporter"/> is a null reference.</exception>
internal Tracker(
TrackingSettings settings,
ITrackingService trackingService,
ISynchronizationService synchronizationService,
IVrpSolver solver,
IGeocoder geocoder,
IMessageReporter messageReporter)
{
CodeContract.RequiresNotNull("settings", settings);
CodeContract.RequiresNotNull("trackingService", trackingService);
CodeContract.RequiresNotNull("synchronizationService", synchronizationService);
CodeContract.RequiresNotNull("solver", solver);
CodeContract.RequiresNotNull("geocoder", geocoder);
CodeContract.RequiresNotNull("messageReporter", messageReporter);
_settings = settings;
_trackingService = trackingService;
_synchronizationService = synchronizationService;
_solver = solver;
_geocoder = geocoder;
_messageReporter = messageReporter;
}
/// <summary>
/// Initializes a new instance of the SynchronizationService class
/// with the tracking service instance and the tracking component instance.
/// </summary>
/// <param name="trackingService">Instance of the tracking service
/// to synchronize with.</param>
public SynchronizationService(ITrackingService trackingService)
{
Debug.Assert(trackingService != null);
_trackingService = trackingService;
}
