/// <summary>
/// Views the usage.
/// </summary>
/// <param name="customerId">The customer identifier.</param>
/// <param name="subscriptionId">The subscription identifier.</param>
/// <returns>The HTML template for the view usage page.</returns>
/// <exception cref="ArgumentNullException">
/// <paramref name="customerId"/> is empty or null.
/// or
/// <paramref name="subscriptionId"/> is empty or null.
/// </exception>
public async Task <ActionResult> ViewUsage(string customerId, string subscriptionId)
{
Customer customer;
Subscription subscription;
customerId.AssertNotEmpty(nameof(customerId));
subscriptionId.AssertNotEmpty(nameof(subscriptionId));
try
{
customer = await this.Service.PartnerOperations.GetCustomerAsync(customerId);
subscription = await this.Service.PartnerOperations.GetSubscriptionAsync(customerId, subscriptionId);
UsageModel usageModel = new UsageModel()
{
CompanyName = customer.CompanyProfile.CompanyName,
CustomerId = customerId,
SubscriptionId = subscriptionId,
SubscriptionFriendlyName = subscription.FriendlyName,
Usage = await this.Service.PartnerOperations
.GetSubscriptionUsageAsync(customerId, subscriptionId, DateTime.Now.AddMonths(-1), DateTime.Now)
};
return(this.View(usageModel));
}
finally
{
customer = null;
subscription = null;
}
}
static void ClearCounters(UsageModel usage, bool weekly, bool monthly)
{
usage.NumberOfStartups = 0;
usage.NumberOfClones = 0;
usage.NumberOfReposCreated = 0;
usage.NumberOfReposPublished = 0;
usage.NumberOfGists = 0;
usage.NumberOfOpenInGitHub = 0;
usage.NumberOfLinkToGitHub = 0;
usage.NumberOfLogins = 0;
usage.NumberOfUpstreamPullRequests = 0;
usage.NumberOfPullRequestsOpened = 0;
usage.NumberOfLocalPullRequestsCheckedOut = 0;
usage.NumberOfLocalPullRequestPulls = 0;
usage.NumberOfLocalPullRequestPushes = 0;
usage.NumberOfForkPullRequestsCheckedOut = 0;
usage.NumberOfForkPullRequestPulls = 0;
usage.NumberOfForkPullRequestPushes = 0;
if (weekly)
{
usage.NumberOfStartupsWeek = 0;
}
if (monthly)
{
usage.NumberOfStartupsMonth = 0;
}
}
async Task <UsageModel> GetCurrentReport(UsageData data)
{
var current = data.Reports.FirstOrDefault(x => x.Dimensions.Date.Date == DateTimeOffset.Now.Date);
if (current == null)
{
var guid = await service.GetUserGuid();
current = UsageModel.Create(guid);
data.Reports.Add(current);
}
current.Dimensions.Lang = CultureInfo.InstalledUICulture.IetfLanguageTag;
current.Dimensions.CurrentLang = CultureInfo.CurrentCulture.IetfLanguageTag;
current.Dimensions.AppVersion = AssemblyVersionInformation.Version;
current.Dimensions.VSVersion = vsservices.VSVersion;
if (connectionManager.Connections.Any(x => x.HostAddress.IsGitHubDotCom()))
{
current.Dimensions.IsGitHubUser = true;
}
if (connectionManager.Connections.Any(x => !x.HostAddress.IsGitHubDotCom()))
{
current.Dimensions.IsEnterpriseUser = true;
}
return(current);
}
/// <summary>
/// Views the usage.
/// </summary>
/// <param name="customerId">The customer identifier.</param>
/// <param name="subscriptionId">The subscription identifier.</param>
/// <returns>The HTML template for the view usage page.</returns>
/// <exception cref="ArgumentNullException">
/// <paramref name="customerId"/> is empty or null.
/// or
/// <paramref name="subscriptionId"/> is empty or null.
/// </exception>
public async Task <ActionResult> ViewUsage(string customerId, string subscriptionId)
{
Customer customer;
Subscription subscription;
customerId.AssertNotEmpty(nameof(customerId));
subscriptionId.AssertNotEmpty(nameof(subscriptionId));
try
{
customer = await Provider.PartnerOperations.GetCustomerAsync(customerId).ConfigureAwait(false);
subscription = await Provider.PartnerOperations.GetSubscriptionAsync(customerId, subscriptionId).ConfigureAwait(false);
UsageModel usageModel = new UsageModel()
{
CompanyName = customer.CompanyProfile.CompanyName,
CustomerId = customerId,
SubscriptionId = subscriptionId,
SubscriptionFriendlyName = subscription.FriendlyName,
};
usageModel.Usage.AddRange(await Provider.PartnerOperations
.GetSubscriptionUsageAsync(customerId, subscriptionId, DateTime.Now.AddMonths(-1), DateTime.Now)
.ConfigureAwait(false));
return(View(usageModel));
}
finally
{
customer = null;
subscription = null;
}
}
static StringContent SerializeRequest(UsageModel model)
{
var serializer = new SimpleJsonSerializer();
var dictionary = ToModelDictionary(model);
return(new StringContent(serializer.Serialize(dictionary), Encoding.UTF8, "application/json"));
}
public async Task IncrementsLoginCount()
{
var apiClient = Substitute.For <IApiClient>();
apiClient.HostAddress.Returns(HostAddress.GitHubDotComHostAddress);
apiClient.GetOrCreateApplicationAuthenticationCode(
Args.TwoFactorChallengCallback, Args.String, Args.Boolean)
.Returns(Observable.Return(new ApplicationAuthorization("S3CR3TS")));
apiClient.GetUser().Returns(Observable.Return(CreateOctokitUser("baymax")));
var hostCache = new InMemoryBlobCache();
var modelService = Substitute.For <IModelService>();
var loginManager = Substitute.For <ILoginManager>();
loginManager.Login(HostAddress.GitHubDotComHostAddress, Arg.Any <IGitHubClient>(), "baymax", "aPassword").Returns(CreateOctokitUser("baymax"));
var loginCache = new TestLoginCache();
var usage = Substitute.For <IUsageTracker>();
var host = new RepositoryHost(apiClient, modelService, loginManager, loginCache, usage);
var result = await host.LogIn("baymax", "aPassword");
var model = new UsageModel();
await usage.Received().IncrementCounter(
Arg.Is <Expression <Func <UsageModel, int> > >(x =>
((MemberExpression)x.Body).Member.Name == nameof(model.NumberOfLogins)));
}
public async Task ShouldWriteUpdatedData()
{
var model = UsageModel.Create(Guid.NewGuid());
//model.Dimensions.AppVersion = AssemblyVersionInformation.Version;
model.Dimensions.Lang = CultureInfo.InstalledUICulture.IetfLanguageTag;
model.Dimensions.CurrentLang = CultureInfo.CurrentCulture.IetfLanguageTag;
model.Measures.NumberOfClones = 1;
var service = CreateUsageService(model);
var target = new UsageTracker(
CreateServiceProvider(),
service,
CreatePackageSettings(),
new JoinableTaskContext(),
vsTelemetry: false);
await target.IncrementCounter(x => x.NumberOfClones);
await service.Received(1).WriteLocalData(Arg.Is <UsageData>(data =>
data.Reports.Count == 1 &&
data.Reports[0].Dimensions.Date.Date == DateTimeOffset.Now.Date &&
//data.Reports[0].Dimensions.AppVersion == AssemblyVersionInformation.Version &&
data.Reports[0].Dimensions.Lang == CultureInfo.InstalledUICulture.IetfLanguageTag &&
data.Reports[0].Dimensions.CurrentLang == CultureInfo.CurrentCulture.IetfLanguageTag &&
data.Reports[0].Measures.NumberOfClones == 2
));
}
public async Task FirstTickShouldIncrementLaunchCount()
{
var service = CreateUsageService(UsageModel.Create(Guid.NewGuid()));
var targetAndTick = CreateTargetAndGetTick(CreateServiceProvider(), service);
await targetAndTick.Item2();
await service.Received(1).WriteLocalData(Arg.Any <UsageData>());
}
/// <summary>
/// Initializes a new instance of the <see cref="PSHpcCacheUsageModels"/> class.
/// PSHpcCacheUsageModels.
/// </summary>
/// <param name="usagemodel"> usagemodel.</param>
public PSHpcCacheUsageModels(UsageModel usagemodel)
{
if (usagemodel != null)
{
this.Name = usagemodel.ModelName;
this.TargetType = usagemodel.TargetType;
this.Display = usagemodel.Display.Description;
}
}
async Task SendUsage(UsageModel usage, bool includeWeekly, bool includeMonthly)
{
if (client == null)
{
throw new GitHubLogicException("SendUsage should not be called when there is no IMetricsService");
}
var model = usage.Clone(includeWeekly, includeMonthly);
await client.PostUsage(model);
}
static IUsageService CreateUsageService(
UsageModel model = null)
{
return(CreateUsageService(new UsageData
{
Reports = model != null ? new List <UsageModel> {
model
} : new List <UsageModel>()
}));
}
//Insert and Update new record
public Task <int> SaveItemAsync(UsageModel obj)
{
if (obj.UsageID != 0)
{
return(db.UpdateAsync(obj));
}
else
{
return(db.InsertAsync(obj));
}
}
public static StringContent SerializeRequest(UsageModel model)
{
var serializer = new SimpleJsonSerializer();
var dictionary = new Dictionary <string, object>
{
{ ToJsonPropertyName("Dimensions"), ToModelDictionary(model.Dimensions) },
{ ToJsonPropertyName("Measures"), ToModelDictionary(model.Measures) }
};
return(new StringContent(serializer.Serialize(dictionary), Encoding.UTF8, "application/json"));
}
static IUsageService CreateUsageService(
UsageModel model,
bool sameDay = true,
bool sameWeek = true,
bool sameMonth = true)
{
return(CreateUsageService(new UsageData
{
LastUpdated = DateTimeOffset.Now,
Model = model
}, sameDay, sameWeek, sameMonth));
}
public async Task TickShouldNotSendDataIfSameDay()
{
var serviceProvider = CreateServiceProvider();
var targetAndTick = CreateTargetAndGetTick(
serviceProvider,
CreateUsageService(UsageModel.Create(Guid.NewGuid())));
await targetAndTick.Item2();
var metricsService = serviceProvider.TryGetService <IMetricsService>();
await metricsService.DidNotReceive().PostUsage(Arg.Any <UsageModel>());
}
public async Task SubsequentTickShouldNotIncrementLaunchCount()
{
var service = CreateUsageService(UsageModel.Create(Guid.NewGuid()));
var targetAndTick = CreateTargetAndGetTick(CreateServiceProvider(), service);
await targetAndTick.Item2();
service.ClearReceivedCalls();
await targetAndTick.Item2();
await service.DidNotReceiveWithAnyArgs().WriteLocalData(null);
}
public async Task <bool> SaveUsage()
{
DateTime dateTime = DateTime.Now;
var timeApp = "";
DateTime timeOfDayGreeting = DateTime.Now;
if (timeOfDayGreeting.Hour >= 5 && timeOfDayGreeting.Hour < 12)
{
timeApp = "Morning Application";
}
else if (timeOfDayGreeting.Hour >= 12 && timeOfDayGreeting.Hour < 18)
{
timeApp = "Afternoon Application";
}
else if (timeOfDayGreeting.Hour >= 19 && timeOfDayGreeting.Hour < 23)
{
timeApp = "Night Time Application";
}
else
{
timeApp = "Midnight Application";
}
if (!string.IsNullOrEmpty(_applicationType) || !string.IsNullOrEmpty(_note))
{
UsageModel usage = new UsageModel()
{
Title = _applicationType,
Description = _note,
Date = DateTime.Now,
Image = "header",
Duration = dateTime.ToString("hh:mm tt"),
Venue = timeApp
};
//Add New Usage
await App.SQLiteDb.SaveItemAsync(usage);
ApplicationType = string.Empty;
Note = string.Empty;
await PopupNavigation.Instance.PushAsync(new MessageModal("Added Record"), true);
//RecordViewModel recordViewModel = new RecordViewModel();
//recordViewModel.GetDbUses();
return(true);
}
else
{
await PopupNavigation.Instance.PushAsync(new MessageModal("Whoops!! Please try again"), true);
return(false);
}
}
UsageModel UpdateModelUserData(UsageModel model)
{
if (connectionManager.Connections.Any(x => x.HostAddress.IsGitHubDotCom()))
{
model.IsGitHubUser = true;
}
if (connectionManager.Connections.Any(x => !x.HostAddress.IsGitHubDotCom()))
{
model.IsEnterpriseUser = true;
}
return(model);
}
public async Task ShouldIncrementCounter()
{
var model = new UsageModel {
NumberOfClones = 4
};
var target = new UsageTracker(
CreateServiceProvider(),
CreateUsageService(model));
await target.IncrementCounter(x => x.NumberOfClones);
Assert.That(5, Is.EqualTo(model.NumberOfClones));
}
public async Task UpdatesMetricsWhenRepositoryClonedAsync(string cloneUrl, int numberOfCalls, string counterName)
{
var vsGitServices = Substitute.For <IVSGitServices>();
var usageTracker = Substitute.For <IUsageTracker>();
var cloneService = CreateRepositoryCloneService(vsGitServices: vsGitServices, usageTracker: usageTracker);
await cloneService.CloneRepository(cloneUrl, @"c:\dev\bar");
var model = UsageModel.Create(Guid.NewGuid());
await usageTracker.Received(numberOfCalls).IncrementCounter(
Arg.Is <Expression <Func <UsageModel.MeasuresModel, int> > >(x =>
((MemberExpression)x.Body).Member.Name == counterName));
}
public JsonResult DecreaseQty(UsageModel model)
{
// Update model to your db
// foreach (var item in model) {
// model.ID = item.ID;
// model.Description = item.Description;
// model.QtyAvailable = item.QtyAvailable;
// model.UserQty = item.UserQty * -1;
// }
string message = "Success - Decrease Quantity - Usage";
return(Json(message, JsonRequestBehavior.AllowGet));
}
public async Task UpdatesMetricsWhenDefaultClonePath(string targetPath, string defaultPath, int numberOfCalls, string counterName)
{
var vsGitServices = Substitute.For <IVSGitServices>();
vsGitServices.GetLocalClonePathFromGitProvider().Returns(defaultPath);
var usageTracker = Substitute.For <IUsageTracker>();
var cloneService = CreateRepositoryCloneService(usageTracker: usageTracker, vsGitServices: vsGitServices);
await cloneService.CloneRepository("https://github.com/foo/bar", targetPath);
var model = UsageModel.Create(Guid.NewGuid());
await usageTracker.Received(numberOfCalls).IncrementCounter(
Arg.Is <Expression <Func <UsageModel.MeasuresModel, int> > >(x =>
((MemberExpression)x.Body).Member.Name == counterName));
}
public async Task PostUsage(UsageModel model)
{
var request = new Request
{
Method = HttpMethod.Post,
BaseAddress = centralUri,
Endpoint = new Uri("api/usage/visualstudio", UriKind.Relative),
};
request.Headers.Add("User-Agent", productHeader.ToString());
request.Body = SerializeRequest(model);
request.ContentType = "application/json";
await httpClient.Value.Send(request);
}
async Task <UsageModel> UpdateModelUserData(UsageModel model)
{
model.Guid = await service.GetUserGuid();
if (connectionManager.Connections.Any(x => x.HostAddress.IsGitHubDotCom()))
{
model.IsGitHubUser = true;
}
if (connectionManager.Connections.Any(x => !x.HostAddress.IsGitHubDotCom()))
{
model.IsEnterpriseUser = true;
}
return(model);
}
public async Task UpdatesMetricsWhenRepositoryCloned()
{
var serviceProvider = Substitutes.ServiceProvider;
var operatingSystem = serviceProvider.GetOperatingSystem();
var vsGitServices = serviceProvider.GetVSGitServices();
var usageTracker = Substitute.For <IUsageTracker>();
var cloneService = new RepositoryCloneService(operatingSystem, vsGitServices, usageTracker);
await cloneService.CloneRepository("https://github.com/foo/bar", "bar", @"c:\dev");
var model = new UsageModel();
await usageTracker.Received().IncrementCounter(
Arg.Is <Expression <Func <UsageModel, int> > >(x =>
((MemberExpression)x.Body).Member.Name == nameof(model.NumberOfClones)));
}
public async Task TickShouldSendDataIfDifferentDay()
{
var model = UsageModel.Create(Guid.NewGuid());
model.Dimensions.Date = DateTimeOffset.Now.AddDays(-2);
var serviceProvider = CreateServiceProvider();
var targetAndTick = CreateTargetAndGetTick(
serviceProvider,
CreateUsageService(model));
await targetAndTick.Item2();
var metricsService = serviceProvider.TryGetService <IMetricsService>();
await metricsService.Received(1).PostUsage(Arg.Any <UsageModel>());
}
public async Task ShouldDisposeTimerIfMetricsServiceNotFound()
{
var service = CreateUsageService(UsageModel.Create(Guid.NewGuid()));
var disposed = false;
var disposable = Disposable.Create(() => disposed = true);
service.StartTimer(null, new TimeSpan(), new TimeSpan()).ReturnsForAnyArgs(disposable);
var targetAndTick = CreateTargetAndGetTick(
CreateServiceProvider(hasMetricsService: false),
service);
await targetAndTick.Item2();
Assert.True(disposed);
}
public async Task ShouldIncrementCounter()
{
var model = new UsageModel {
NumberOfClones = 4
};
var usageService = CreateUsageService(model);
var target = new UsageTracker(
CreateServiceProvider(),
usageService);
await target.IncrementCounter(x => x.NumberOfClones);
UsageData result = usageService.ReceivedCalls().First(x => x.GetMethodInfo().Name == "WriteLocalData").GetArguments()[0] as UsageData;
Assert.AreEqual(5, result.Model.NumberOfClones);
}
public async Task UpdatesMetricsWhenRepositoryClonedAsync(string cloneUrl, int numberOfCalls, string counterName)
{
var serviceProvider = Substitutes.ServiceProvider;
var operatingSystem = serviceProvider.GetOperatingSystem();
var vsGitServices = serviceProvider.GetVSGitServices();
var graphqlFactory = Substitute.For <IGraphQLClientFactory>();
var usageTracker = Substitute.For <IUsageTracker>();
var cloneService = new RepositoryCloneService(operatingSystem, vsGitServices, graphqlFactory, usageTracker);
await cloneService.CloneRepository(cloneUrl, @"c:\dev\bar");
var model = UsageModel.Create(Guid.NewGuid());
await usageTracker.Received(numberOfCalls).IncrementCounter(
Arg.Is <Expression <Func <UsageModel.MeasuresModel, int> > >(x =>
((MemberExpression)x.Body).Member.Name == counterName));
}
async Task SendUsage(UsageModel usage, bool weekly, bool monthly)
{
Debug.Assert(client != null, "SendUsage should not be called when there is no IMetricsService");
if (connectionManager.Connections.Any(x => x.HostAddress.IsGitHubDotCom()))
{
usage.IsGitHubUser = true;
}
if (connectionManager.Connections.Any(x => !x.HostAddress.IsGitHubDotCom()))
{
usage.IsEnterpriseUser = true;
}
var model = usage.Clone(weekly, monthly);
await client.PostUsage(model);
}
