public LoggingPermissions(IApplicationConstants appConstants, ITelemetryService telemetryService, IRegistry registry) {
_appConstants = appConstants;
_telemetryService = telemetryService;
_registry = registry;
_registryVerbosity = GetLogLevelFromRegistry();
_registryFeedbackSetting = GetFeedbackFromRegistry();
}
public ApplicationController([NotNull] IEventAggregator eventAggregator, [NotNull] ILiveTileManager liveTileManager, [NotNull] IDispatcherService dispatcherService, [NotNull] ITelemetryService telemetry)
{
Guard.NotNull(eventAggregator, nameof(eventAggregator));
Guard.NotNull(liveTileManager, nameof(liveTileManager));
Guard.NotNull(dispatcherService, nameof(dispatcherService));
Guard.NotNull(telemetry, nameof(telemetry));
this.eventAggregator = eventAggregator;
this.liveTileManager = liveTileManager;
this.dispatcherService = dispatcherService;
this.telemetry = telemetry;
}
public CoreServices(IApplicationConstants appConstants
, ITelemetryService telemetry
, ITaskService tasks
, IMainThread mainThread
, ISecurityService security) {
Telemetry = telemetry;
Registry = new RegistryImpl();
Security = security;
LoggingServices = new LoggingServices(new LoggingPermissions(appConstants, telemetry, Registry), appConstants);
Tasks = tasks;
ProcessServices = new ProcessServices();
FileSystem = new FileSystem();
MainThread = mainThread;
Log = LoggingServices.GetOrCreateLog(appConstants.ApplicationName);
}
private async void Init()
{
_commClient = new NamedPipeService();
try
{
_dataBroker = new ServiceBusTelemetryService();
await _dataBroker.OpenAsync();
_cloudConnectionFailure = false;
}
catch
{
_cloudConnectionFailure = true;
}
}
public EntryOperations(
ICompositionFactory compositionFactory,
IBackendServiceClient storage,
IEventAggregator eventAggregator,
IStatusBusyService statusBusyService,
Lazy<ITranslationService> translator,
ILocalSettingsService settingsService,
ITelemetryService telemetry)
{
this.compositionFactory = compositionFactory;
this.storage = storage;
this.eventAggregator = eventAggregator;
this.statusBusyService = statusBusyService;
this.translator = translator;
this.settingsService = settingsService;
this.telemetry = telemetry;
}
public CoreServices(IApplicationConstants appConstants
, ITelemetryService telemetry
, ILoggingPermissions permissions
, ISecurityService security
, ITaskService tasks
, IMainThread mainThread
, IActionLog log
, IFileSystem fs
, IRegistry registry
, IProcessServices ps) {
LoggingServices = new LoggingServices(permissions, appConstants);
Log = log;
Telemetry = telemetry;
Security = security;
Tasks = tasks;
ProcessServices = ps;
Registry = registry;
FileSystem = fs;
MainThread = mainThread;
}
public LogTelemetryEventEditedPolicy([NotNull] ITelemetryService telemetryService)
{
this.telemetryService = telemetryService ?? throw new ArgumentNullException(nameof(telemetryService));
}
public MainViewModel(IMissionPlanner planner, IHeartBeatManager heartBeatManager, ITelemetryService telemetryService, IConnectedUasManager connectedUasManager)
{
_telemetryService = telemetryService;
_heartBeatManager = heartBeatManager;
Connections = connectedUasManager;
Connections.ActiveDroneChanged += Connections_ActiveDroneChanged;
var transport = new SerialPortTransport(DispatcherServices);
//Connections.Active = new ConnectedUas(new APM(null), transport);
//Connections.All.Add(Connections.Active);
//Connections.Active.Transport.OnMessageReceived += _telemeteryLink_MessageParsed;
//TelemetryLink.MessageParsed += _telemeteryLink_MessageParsed;
OpenSerialPortCommand = new RelayCommand(HandleConnectClick, CanPressConnect);
ShowMissionPlannerCommand = new RelayCommand(() => ViewModelNavigation.NavigateAsync <Missions.MissionPlannerViewModel>(this), CanDoConnectedStuff);
StartDataStreamsCommand = new RelayCommand(() => _telemetryService.Start(Connections.Active.Uas, Connections.Active.Transport), CanDoConnectedStuff);
StopDataStreamsCommand = new RelayCommand(() => _telemetryService.Stop(Connections.Active.Transport), CanDoConnectedStuff);
BeginCalibrationCommand = new RelayCommand(() => ViewModelNavigation.NavigateAsync <Calibration.AccCalibrationViewModel>(this), CanDoConnectedStuff);
FlyNowCommand = new RelayCommand(() => ViewModelNavigation.NavigateAsync <HudViewModel>(this), CanDoConnectedStuff);
MotorTestCommand = new RelayCommand(() => ViewModelNavigation.NavigateAsync <Testing.MotorsTestViewModel>(this), CanDoConnectedStuff);
Title = "UAS NuvIoT Connector";
_planner = planner;
MenuItems = new List <MenuItem>()
{
new MenuItem()
{
Command = new RelayCommand(() => ViewModelNavigation.NavigateAsync <UasTypeManagerViewModel>(this)),
Name = "Settings",
FontIconKey = "fa-users"
},
new MenuItem()
{
Command = new RelayCommand(() => ViewModelNavigation.NavigateAsync <UserOrgsViewModel>(this)),
Name = ClientResources.MainMenu_SwitchOrgs,
FontIconKey = "fa-users"
},
new MenuItem()
{
Command = new RelayCommand(() => ViewModelNavigation.NavigateAsync <ChangePasswordViewModel>(this)),
Name = ClientResources.MainMenu_ChangePassword,
FontIconKey = "fa-key"
},
new MenuItem()
{
Command = new RelayCommand(() => ViewModelNavigation.NavigateAsync <InviteUserViewModel>(this)),
Name = ClientResources.MainMenu_InviteUser,
FontIconKey = "fa-user"
},
new MenuItem()
{
Command = new RelayCommand(() => ViewModelNavigation.NavigateAsync <AboutViewModel>(this)),
Name = "About",
FontIconKey = "fa-info"
},
new MenuItem()
{
Command = new RelayCommand(() => Logout()),
Name = ClientResources.Common_Logout,
FontIconKey = "fa-sign-out"
}
};
this.RefreshUI();
}
public ConfiguredProjectPackageRestoreTelemetryService(ConfiguredProject project, ITelemetryService telemetryService)
{
_project = project;
_telemetryService = telemetryService;
}
public TelemetriesController(ITelemetryService telemetryService)
{
_telemetryService = telemetryService;
}
public Timer(string method, ITelemetryService telemetryService)
{
_method = method;
_telemetryService = telemetryService;
_stopwatch = Stopwatch.StartNew();
}
public RtvsTelemetry(ITelemetryService service = null) {
_telemetryService = service ?? VsTelemetryService.Current;
}
public RtvsTelemetry(IPackageIndex packageIndex, IRSettings settings, IREditorSettings editorSettings, ITelemetryService telemetryService = null, ToolWindowTracker toolWindowTracker = null)
{
_packageIndex = packageIndex;
_settings = settings;
_editorSettings = editorSettings;
TelemetryService = telemetryService;
_toolWindowTracker = toolWindowTracker;
}
public Catalog2MonitoringJob(ITelemetryService telemetryService, ILoggerFactory loggerFactory)
: base(telemetryService, loggerFactory)
{
_collectorFactory = new ValidationCollectorFactory(LoggerFactory);
}
public ConfiguredProjectPackageRestoreTelemetryService(ConfiguredProject project, ITelemetryService telemetryService, IProjectThreadingService projectThreadingService)
{
_project = project;
_telemetryService = telemetryService;
_projectGuidLazy = new AsyncLazy <Guid>(async() =>
{
return(await _project.UnconfiguredProject.GetProjectGuidAsync());
}, projectThreadingService.JoinableTaskFactory);
}
public CheckRunController(ILogger <CheckRunController> logger, ITempFileService tempFileService, ICheckRunSubmissionService checkRunSubmissionService, ITelemetryService telemetryService)
: base(logger, tempFileService)
{
_checkRunSubmissionService = checkRunSubmissionService;
_telemetryService = telemetryService;
}
public Catalog2DnxJob(ITelemetryService telemetryService, ILoggerFactory loggerFactory)
: base(telemetryService, loggerFactory)
{
}
/// <summary>
/// Initializes a new instance of the class.
/// </summary>
/// <param name="deviceCommunicationAdapter"></param>
/// <param name="fileService"></param>
/// <param name="logger"></param>
/// <param name="telemetryService"></param>
public DeviceService(IDeviceCommunicationAdapter deviceCommunicationAdapter, IFileService fileService, ILogger <DeviceService> logger, ITelemetryService telemetryService)
{
m_DeviceCommunicationAdapter = deviceCommunicationAdapter;
m_FileService = fileService;
m_Logger = logger;
m_TelemetryService = telemetryService;
}
public Catalog2RegistrationJob(ITelemetryService telemetryService, ILoggerFactory loggerFactory)
: base(telemetryService, loggerFactory)
{
}
public MainViewModel(IGitterApiService gitterApiService,
ILocalNotificationService localNotificationService,
IApplicationStorageService applicationStorageService,
IProgressIndicatorService progressIndicatorService,
IPasswordStorageService passwordStorageService,
IEventService eventService,
ITelemetryService telemetryService,
INavigationService navigationService)
{
// Services
_gitterApiService = gitterApiService;
_localNotificationService = localNotificationService;
_applicationStorageService = applicationStorageService;
_progressIndicatorService = progressIndicatorService;
_passwordStorageService = passwordStorageService;
_eventService = eventService;
_navigationService = navigationService;
_telemetryService = telemetryService;
// Commands
SelectRoomCommand = new RelayCommand<IRoomViewModel>(SelectRoom);
ChatWithUsCommand = new RelayCommand(ChatWithUs, CanChatWithUs);
GoToAboutPageCommand = new RelayCommand(GoToAboutPage);
RefreshCommand = new RelayCommand(Refresh, () => !IsRefreshing);
ToggleSearchCommand = new RelayCommand<bool>(ToggleSearch);
// Properties
CurrentDateTime = DateTime.Now;
if (IsInDesignMode)
{
// Code runs in Blend --> create design time data.
CurrentUser = new User
{
Id = "53307734c3599d1de448e192",
Username = "******",
DisplayName = "Mauro Pompilio",
Url = "/malditogeek",
SmallAvatarUrl = "https://avatars.githubusercontent.com/u/14751?",
MediumAvatarUrl = "https://avatars.githubusercontent.com/u/14751?"
};
var suprememoocow = new User
{
Id = "53307831c3599d1de448e19a",
Username = "******",
DisplayName = "Andrew Newdigate",
Url = "/suprememoocow,",
SmallAvatarUrl = "https://avatars.githubusercontent.com/u/594566?",
MediumAvatarUrl = "https://avatars.githubusercontent.com/u/594566?"
};
Rooms.Add(new RoomViewModel(new Room
{
Id = "53307860c3599d1de448e19d",
Name = "Andrew Newdigate",
Topic = string.Empty,
OneToOne = true,
Users = new[] { suprememoocow },
UnreadItems = 52,
UnreadMentions = 0,
DisabledNotifications = false,
Type = "ONETOONE"
}, gitterApiService, localNotificationService, progressIndicatorService, eventService, telemetryService, this));
Rooms.Add(new RoomViewModel(new Room
{
Id = "5330777dc3599d1de448e194",
Name = "gitterHQ",
Topic = "Gitter",
Url = "gitterHQ",
OneToOne = false,
UserCount = 2,
UnreadItems = 0,
UnreadMentions = 0,
LastAccessTime = new DateTime(2014, 3, 24, 18, 22, 28),
DisabledNotifications = false,
Type = "ORG",
Version = 1
}, gitterApiService, localNotificationService, progressIndicatorService, eventService, telemetryService, this));
Rooms.Add(new RoomViewModel(new Room
{
Id = "5330780dc3599d1de448e198",
Name = "gitterHQ/devops",
Topic = string.Empty,
Url = "gitterHQ/devops",
OneToOne = false,
UserCount = 2,
UnreadItems = 3,
UnreadMentions = 0,
LastAccessTime = new DateTime(2014, 3, 24, 18, 23, 10),
DisabledNotifications = false,
Type = "ORG_CHANNEL",
Version = 1
}, gitterApiService, localNotificationService, progressIndicatorService, eventService, telemetryService, this));
Rooms.Add(new RoomViewModel(new Room
{
Id = "53307793c3599d1de448e196",
Name = "malditogeek/vmux",
Topic = "VMUX - Plugin-free video calls in your browser using WebRTC",
Url = "gitterHQ/devops",
OneToOne = false,
UserCount = 2,
UnreadItems = 42,
UnreadMentions = 0,
LastAccessTime = new DateTime(2014, 3, 24, 18, 21, 08),
DisabledNotifications = false,
Type = "REPO",
Version = 1
}, gitterApiService, localNotificationService, progressIndicatorService, eventService, telemetryService, this));
SelectedRoom = Rooms.FirstOrDefault();
foreach (var room in Rooms)
SearchedRooms.Add(room);
}
else
{
// Code runs "for real"
// Events
_eventService.ReadRoom
.Subscribe(room =>
{
HtmlToXaml.HtmlToXaml.RoomName = room.Room.Name;
});
HtmlToXaml.HtmlToXaml.ImageTapped += (sender, args) =>
{
var image = sender as Image;
var bitmapImage = image.Source as BitmapImage;
ViewModelLocator.FullImage.Source = bitmapImage.UriSource.OriginalString;
_navigationService.NavigateTo("FullImage");
};
// Retrieve access token to use in the app
string token = _passwordStorageService.Retrieve("token");
_gitterApiService.SetToken(token);
// Add event that will update READ new messages
_currentSelectedRoomUnreadMessages = _eventService.NotifyUnreadMessages
.Subscribe(async unreadMessages => await NotifyReadMessages(unreadMessages));
}
}
public SortingIdVersionCollector(Uri index, ITelemetryService telemetryService, Func <HttpMessageHandler> handlerFunc = null)
: base(index, telemetryService, handlerFunc)
{
}
public CookiecutterTelemetry(ITelemetryService service = null) {
TelemetryService = service ?? VsTelemetryService.Current;
}
public PasswordClipboardService(ITelemetryService telemetry)
{
_telemetry = telemetry;
}
public TelemetryRpcTraceListener(ITelemetryService telemetryService)
{
_telemetryService = telemetryService;
}
private ServiceCollection ConfigureServices(ITestOutputHelper output)
{
Mock <ITelemetryService> mockITelemetryService = new Mock <ITelemetryService>();
ITelemetryService telemetryServiceResolver = mockITelemetryService.Object;
ServiceCollection services = new ServiceCollection();
_logger = new LoggerFor_TestSearchHttpClient(output);
services.AddSingleton <ILogger>(_logger);
AddTestHttpClient(
services,
_longInvalidAddress,
_nameFor_InvalidTestSearchHttpClientWithLongCircuitBreakDelay,
_retryCount,
_waitBetweenRetriesInMilliseconds,
_circuitBreakerTimeoutLongInMilliseconds,
_circuitBreakerFailAfter,
_circuitBreakerShortDelaySeconds,
telemetryServiceResolver);
AddTestHttpClient(
services,
_shortInvalidAddress,
_nameFor_InvalidTestSearchHttpClientWithShortCircuitBreakDelay,
_retryCount,
_waitBetweenRetriesInMilliseconds,
_circuitBreakerTimeoutLongInMilliseconds,
_circuitBreakerFailAfter,
_circuitBreakerShortDelaySeconds,
telemetryServiceResolver);
AddTestHttpClient(
services,
_validAddress,
_nameFor_ValidTestSearchHttpClient,
_retryCount,
_waitBetweenRetriesInMilliseconds,
_circuitBreakerTimeoutLongInMilliseconds,
_circuitBreakerFailAfter,
_circuitBreakerShortDelaySeconds,
telemetryServiceResolver);
AddTestHttpClient(
services,
_shortInvalidAddress_2,
_nameFor_InvalidTestSearchHttpClientRetryCountExpires,
_retryCount_2,
_waitBetweenRetriesInMilliseconds,
_circuitBreakerTimeoutLongInMilliseconds,
_circuitBreakerFailAfter_2,
_circuitBreakerShortDelaySeconds,
telemetryServiceResolver);
AddTestHttpClient(
services,
_403Address,
_nameFor_SearchHttpClientReturning403,
_retryCount,
_waitBetweenRetriesInMilliseconds,
_circuitBreakerTimeoutLongInMilliseconds,
_circuitBreakerFailAfter,
_circuitBreakerLongDelaySeconds,
telemetryServiceResolver);
AddTestHttpClient(
services,
_timeoutAddress,
_nameFor_SearchHttpClientTimingOut,
_retryCount,
_waitBetweenRetriesInMilliseconds,
_circuitBreakerTimeoutShortInMilliseconds,
_circuitBreakerFailAfter,
_circuitBreakerShortDelaySeconds,
telemetryServiceResolver);
return(services);
}
public CookiecutterTelemetry(ITelemetryService service = null)
{
TelemetryService = service ?? VsTelemetryService.Current;
}
public WorkItemQueryStepViewModel(WorkItemQueryModel model, IVstsService vstsService, ITelemetryService telemetryService)
{
_vstsService = vstsService ?? throw new ArgumentNullException(nameof(vstsService));
_telemetryService = telemetryService ?? throw new ArgumentNullException(nameof(telemetryService));
Model = model ?? throw new ArgumentNullException(nameof(model));
}
public OverviewModule(ICurrentOwner currentOwner, IOverviewService overviewService, ITelemetryService telemetryService, IItemRepository itemRepository)
{
_currentOwner = currentOwner;
_overviewService = overviewService;
_telemetryService = telemetryService;
_itemRepository = itemRepository;
}
public HomeController(ITelemetryService telemetryService)
{
_telemetryService = telemetryService;
}
public DataController(ITelemetryService telemetryService)
{
_telemetryService = telemetryService;
}
public BackgroundMessageService(IMailSender mailSender, IAppConfiguration config, ITelemetryService telemetryService, ErrorLog errorLog, Func <BackgroundMessageService> messageServiceFactory)
: base(mailSender, config, telemetryService)
{
_errorLog = errorLog ?? throw new ArgumentNullException(nameof(errorLog));
_messageServiceFactory = messageServiceFactory ?? throw new ArgumentNullException(nameof(messageServiceFactory));
_sentMessage = false;
}
public RtvsTelemetry(ITelemetryService service = null)
{
_telemetryService = service ?? VsTelemetryService.Current;
}
public UserDataService(ILogger logger, ITelemetryService telemetryService)
: base(telemetryService)
{
_logger = logger.ForContext <UserDataService>();
}
public AuthenticationService(
IEntitiesContext entities, IAppConfiguration config, IDiagnosticsService diagnostics,
IAuditingService auditing, IEnumerable <Authenticator> providers, ICredentialBuilder credentialBuilder,
ICredentialValidator credentialValidator, IDateTimeProvider dateTimeProvider, ITelemetryService telemetryService,
IContentObjectService contentObjectService)
{
InitCredentialFormatters();
Entities = entities ?? throw new ArgumentNullException(nameof(entities));
_config = config ?? throw new ArgumentNullException(nameof(config));
_trace = diagnostics?.SafeGetSource("AuthenticationService") ?? throw new ArgumentNullException(nameof(diagnostics));
Auditing = auditing ?? throw new ArgumentNullException(nameof(auditing));;
Authenticators = providers?.ToDictionary(p => p.Name, StringComparer.OrdinalIgnoreCase) ?? throw new ArgumentNullException(nameof(providers));
_credentialBuilder = credentialBuilder ?? throw new ArgumentNullException(nameof(credentialBuilder));
_credentialValidator = credentialValidator ?? throw new ArgumentNullException(nameof(credentialValidator));
_dateTimeProvider = dateTimeProvider ?? throw new ArgumentNullException(nameof(dateTimeProvider));
_telemetryService = telemetryService ?? throw new ArgumentNullException(nameof(telemetryService));
_contentObjectService = contentObjectService ?? throw new ArgumentNullException(nameof(contentObjectService));
}
public DailyStockSummary(IMediator mediator, ITelemetryService telemetry)
{
_mediator = mediator;
_telemetry = telemetry;
}
public RoomViewModel(Room room,
IGitterApiService gitterApiService,
ILocalNotificationService localNotificationService,
IProgressIndicatorService progressIndicatorService,
IEventService eventService,
ITelemetryService telemetryService,
IMainViewModel mainViewModel)
{
// Properties
Room = room;
// View Models
_mainViewModel = mainViewModel;
// Commands
SendMessageCommand = new RelayCommand(SendMessage, CanSendMessage);
SendMessageWithParamCommand = new RelayCommand<bool>(SendMessageWithParam);
RemoveMessageCommand = new RelayCommand<IMessageViewModel>(RemoveMessage, CanRemoveMessage);
CopyMessageCommand = new RelayCommand<IMessageViewModel>(CopyMessage);
RespondToCommand = new RelayCommand<User>(RespondTo);
ViewProfileCommand = new RelayCommand<User>(ViewProfile);
TalkCommand = new RelayCommand(Talk);
RefreshCommand = new RelayCommand(Refresh);
// Inject Services
_gitterApiService = gitterApiService;
_localNotificationService = localNotificationService;
_progressIndicatorService = progressIndicatorService;
_eventService = eventService;
_telemetryService = telemetryService;
if (IsInDesignMode)
{
// Code runs in Blend --> create design time data.
var malditogeek = new User
{
Id = "53307734c3599d1de448e192",
Username = "******",
DisplayName = "Mauro Pompilio",
Url = "/malditogeek",
SmallAvatarUrl = "https://avatars.githubusercontent.com/u/14751?",
MediumAvatarUrl = "https://avatars.githubusercontent.com/u/14751?"
};
var suprememoocow = new User
{
Id = "53307831c3599d1de448e19a",
Username = "******",
DisplayName = "Andrew Newdigate",
Url = "/suprememoocow,",
SmallAvatarUrl = "https://avatars.githubusercontent.com/u/594566?",
MediumAvatarUrl = "https://avatars.githubusercontent.com/u/594566?"
};
Messages = new MessagesIncrementalLoadingCollection("123456", gitterApiService, eventService, mainViewModel)
{
new MessageViewModel(new Message
{
Id = "53316dc47bfc1a000000000f",
Text = "Hi @suprememoocow !",
Html =
"Hi <span data-link-type=\"mention\" data-screen-name=\"suprememoocow\" class=\"mention\">@suprememoocow</span> !",
SentDate = new DateTime(2014, 3, 25, 11, 51, 32),
EditedDate = null,
User = malditogeek,
UnreadByCurrent = false,
ReadCount = 0,
Urls = new List<MessageUrl>(),
Mentions = new List<Mention>
{
new Mention
{
ScreenName = "suprememoocow",
UserId = "53307831c3599d1de448e19a"
}
},
Issues = new List<Issue>(),
Version = 1
}),
new MessageViewModel(new Message
{
Id = "53316ec37bfc1a0000000011",
Text = "I've been working on #11, it'll be ready to ship soon",
Html =
"I've been working on <span data-link-type=\"issue\" data-issue=\"11\" class=\"issue\">#11</span>, it'll be ready to ship soon",
SentDate = new DateTime(2014, 3, 25, 11, 55, 47),
EditedDate = null,
User = malditogeek,
UnreadByCurrent = false,
ReadCount = 0,
Urls = new List<MessageUrl>(),
Mentions = new List<Mention>(),
Issues = new List<Issue>
{
new Issue {Number = "11"}
},
Version = 1
}),
new MessageViewModel(new Message
{
Id = "53316ec37bfc1a0000000012",
Text = "This is a test message",
Html = "This is a test message",
SentDate = new DateTime(2014, 3, 25, 11, 55, 47),
EditedDate = null,
User = suprememoocow,
UnreadByCurrent = false,
ReadCount = 0,
Urls = new List<MessageUrl>(),
Mentions = new List<Mention>(),
Issues = new List<Issue>(),
Version = 1
}),
new MessageViewModel(new Message
{
Id = "53316ec37bfc1a0000000013",
Text = "Another long long ............... message",
Html = "Another long long ............... message",
SentDate = new DateTime(2014, 3, 25, 11, 55, 47),
EditedDate = null,
User = malditogeek,
UnreadByCurrent = false,
ReadCount = 0,
Urls = new List<MessageUrl>(),
Mentions = new List<Mention>(),
Issues = new List<Issue>(),
Version = 1
})
};
}
else
{
// Code runs "for real"
Messages = new MessagesIncrementalLoadingCollection(Room.Id, gitterApiService, eventService, mainViewModel);
OpenRealtimeStream();
}
// Update count of unread messages
UnreadMessagesCount = Room.UnreadItems;
}
public static PackageValidatorContextEnqueuer CreatePackageValidatorContextEnqueuer(
IStorageQueue <PackageValidatorContext> queue,
string catalogIndexUrl,
Persistence.IStorageFactory monitoringStorageFactory,
EndpointConfiguration endpointConfig,
ITelemetryService telemetryService,
Func <HttpMessageHandler> messageHandlerFactory,
ILoggerFactory loggerFactory)
{
if (queue == null)
{
throw new ArgumentNullException(nameof(queue));
}
if (string.IsNullOrEmpty(catalogIndexUrl))
{
throw new ArgumentException(nameof(catalogIndexUrl));
}
if (monitoringStorageFactory == null)
{
throw new ArgumentNullException(nameof(monitoringStorageFactory));
}
if (telemetryService == null)
{
throw new ArgumentNullException(nameof(telemetryService));
}
var collection = new ServiceCollection();
collection.AddSingleton(loggerFactory);
collection.AddSingleton(typeof(ILogger <>), typeof(Logger <>));
var builder = new ContainerBuilder();
builder.Populate(collection);
builder.RegisterEndpointConfiguration(endpointConfig);
builder.RegisterEndpoints(endpointConfig);
builder.RegisterMessageHandlerFactory(messageHandlerFactory);
builder
.RegisterInstance(queue)
.As <IStorageQueue <PackageValidatorContext> >();
builder
.RegisterInstance(new Uri(catalogIndexUrl))
.As <Uri>();
builder
.RegisterInstance(telemetryService)
.As <ITelemetryService>();
builder
.RegisterType <ValidationCollector>()
.As <ValidationCollector>();
builder
.RegisterInstance(GetFront(monitoringStorageFactory))
.As <ReadWriteCursor>();
builder
.RegisterType <AggregateEndpointCursor>()
.As <ReadCursor>();
builder
.RegisterType <PackageValidatorContextEnqueuer>()
.As <PackageValidatorContextEnqueuer>();
var container = builder.Build();
return(container.Resolve <PackageValidatorContextEnqueuer>());
}
public static void Initialize(ITelemetryService service = null) {
if (Current == null) {
Current = new RtvsTelemetry(service);
}
}
public RtvsTelemetry(IPackageIndex packageIndex, IRSettings settings, ITelemetryService service = null) {
_packageIndex = packageIndex;
_settings = settings;
TelemetryService = service ?? VsAppShell.Current.ExportProvider.GetExportedValue<ITelemetryService>();
}
public static void Initialize(ITelemetryService service = null) {
if (Current == null) {
Current = new CookiecutterTelemetry(service);
}
}
public TelemetryController(ILogger logger, ITelemetryService telemetryService)
: base(logger)
{
this.telemetryService = telemetryService;
}
public void SetTelemetryService(ITelemetryService telemetryService)
{
_telemetryService = telemetryService;
}
public RequestTimer(ITelemetryService telemetryService)
{
_telemetryService = telemetryService;
}
public DesignTimeTelemetryLogger(ITelemetryService telemetryService)
{
_telemetryService = telemetryService;
}
public static void Initialize(IPackageIndex packageIndex, IRSettings settings, ITelemetryService service = null) {
if (Current == null) {
Current = new RtvsTelemetry(packageIndex, settings, service);
}
}
