public async Task <IHttpActionResult> Get(Guid id)
{
ProgramUpdatePackageInfo packageInfo = await this.work.UpdatePackages.GetUpdatePackageInfo(id).ConfigureAwait(false);
if (packageInfo == null)
{
return(this.BadRequest($"Program Update Package [{id}] does not exist!"));
}
try
{
byte[] bytes = await this.work.UpdatePackages.GetPackage(id, this.FileRetriever).ConfigureAwait(false);
HttpResponseMessage result =
new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new ByteArrayContent(bytes)
};
result.Content.Headers.ContentDisposition =
new ContentDispositionHeaderValue("attachment")
{
FileName = packageInfo.FileName
};
result.Content.Headers.ContentType = new MediaTypeHeaderValue("application/zip");
return(this.ResponseMessage(result));
}
catch (Exception ex)
{
Trace.TraceError($"Error while trying to download update package {packageInfo.GetPropertyInfoString()}.\r\n\r\n{ex}");
return(this.InternalServerError(new InvalidOperationException("Error while trying to download update package")));
}
}
public async Task <IEnumerable <ProgramSummary> > GetProgramSummary(List <Program> programs)
{
List <ProgramSummary> returnData = new List <ProgramSummary>();
foreach (Program program in programs)
{
ProgramSummary summary;
try
{
List <Event> events = await this.Events.FindAsync(x => x.ProgramId == program.Id).ConfigureAwait(false);
List <EventTelemetrySummary> eventSummaries = events.SelectMany(x => x.TelemetrySummaries).ToList();
summary = new ProgramSummary
{
ProgramName = program.Name
, DeveloperName = program.DeveloperTeam?.Name ?? "N/A"
, TelemetryKey = program.TelemetryKey
, RegisteredDate = program.RegisteredDate
, UsersCount = eventSummaries.DistinctBy(x => x.ClientAppUserId).Count()
};
ProgramUpdatePackageInfo latestPkg = await this.UpdatePackages.GetLatestPackage(program.Id).ConfigureAwait(false);
if (latestPkg != null)
{
summary.LastUpdateDate = latestPkg.UploadedDate;
summary.LatestVersion = latestPkg.SupportedToolkitVersion ?? "?";
summary.ToolkitVersion = latestPkg.SupportedToolkitVersion ?? "?";
}
else
{
ProgramPackageInfo programPkg = await this.ProgramPackages.GetLatestProgramPackageInfo(program.Id).ConfigureAwait(false);
if (programPkg != null)
{
summary.LastUpdateDate = programPkg.UploadedDate;
summary.LatestVersion = programPkg.Version;
summary.ToolkitVersion = programPkg.SupportedToolkitVersion;
}
else
{
summary.LatestVersion = "N/A";
summary.ToolkitVersion = "N/A";
}
}
summary.NumberOfUpdatePackages = await this.UpdatePackages.CountPackages(program.Id).ConfigureAwait(false);
}
catch (Exception)
{
summary = new ProgramSummary();
summary.ProgramName = program?.Name ?? "Error while loading summary";
summary.DeveloperName = "Error while loading summary";
}
returnData.Add(summary);
}
return(returnData);
}
public async Task <IHttpActionResult> Upload()
{
try
{
Trace.TraceInformation(LoggerHelper.FormatMessage(this.RequestContext, "Starting update package upload"));
string reqString = HttpContext.Current.Request.Form["Model"];
CreateUpdatePackageRequest request = JsonConvert.DeserializeObject <CreateUpdatePackageRequest>(reqString);
HttpPostedFile uploadedFile = HttpContext.Current.Request.Files.Count > 0 ? HttpContext.Current.Request.Files[0] : null;
if (uploadedFile != null && uploadedFile.ContentLength > 0)
{
Program program = await this.work.Programs.GetByTelemetryKey(request.TelemetryKey).ConfigureAwait(false);
ProgramUpdatePackageInfo pkg = await this.work.UpdatePackages.StorePackageAsync(program, uploadedFile.FileName, uploadedFile.InputStream
, request.ToolkitVersionUsed, request.IsBeta, request.ReleaseNotes, this.fileSaver).ConfigureAwait(false);
await this.work.CompleteAsync().ConfigureAwait(false);
#pragma warning disable 618
return(this.Ok(pkg.Id));
#pragma warning restore 618
}
return(this.BadRequest("Empty attachment"));
}
catch (Exception ex)
{
return(this.BadRequest(ex.Message));
}
}
public async Task <bool> ToggleBetaSetting(Guid packageId, bool isBeta)
{
ProgramUpdatePackageInfo pkg = await this.work.UpdatePackages.FirstOrDefaultAsync(x => x.PublicId == packageId).ConfigureAwait(false);
pkg.IsBeta = isBeta;
await this.work.CompleteAsync().ConfigureAwait(false);
return(pkg.IsBeta);
}
public async Task <IHttpActionResult> SetReleaseNotes(Guid packageId, ReleaseNotesRequest request)
{
ProgramUpdatePackageInfo pkg = await this.work.UpdatePackages.FirstOrDefaultAsync(x => x.PublicId == packageId).ConfigureAwait(false);
pkg.ReleaseNotes = request.Notes;
await this.work.CompleteAsync().ConfigureAwait(false);
return(this.Ok(""));
}
public async Task <IHttpActionResult> SetReleaseNotes(Guid packageId, ReleaseNotesRequest request)
{
ProgramUpdatePackageInfo pkg = await this.work.UpdatePackages.FirstOrDefaultAsync(x => x.PublicId == packageId).ConfigureAwait(false);
Trace.TraceInformation(LoggerHelper.FormatMessage(this.RequestContext, $"Setting release notes on package {pkg.Id}"));
pkg.ReleaseNotes = request.Notes;
await this.work.CompleteAsync().ConfigureAwait(false);
return(this.Ok(""));
}
private async Task AssignAppNameToAuditRecord(AuditViewModel viewModel)
{
Guid?guid = GetTelemetryKeyFromUrl(viewModel.AreaAccessed);
if (guid.HasValue)
{
string cacheKey = "AppName:" + guid.ToString();
string name = (string)MemoryCache.Default.Get(cacheKey);
if (string.IsNullOrEmpty(name))
{
Program app = await this.unitOfWork.Programs.GetByTelemetryKey(guid.Value).ConfigureAwait(false);
name = app.Name;
MemoryCache.Default.Add(cacheKey, name, new CacheItemPolicy()
{
AbsoluteExpiration = DateTimeOffset.UtcNow.AddDays(1)
});
}
viewModel.Application = name;
return;
}
guid = GetUpdatePackageGuidFromUrl(viewModel.AreaAccessed);
if (guid.HasValue)
{
string cacheKey = "AppName:" + guid.ToString();
string name = (string)MemoryCache.Default.Get(cacheKey);
if (string.IsNullOrEmpty(name))
{
ProgramUpdatePackageInfo packageInfo = await this.unitOfWork.UpdatePackages.GetUpdatePackageInfo(guid.Value).ConfigureAwait(false);
if (packageInfo != null)
{
Program app = await this.unitOfWork.Programs.GetByProgramId(packageInfo.ProgramId).ConfigureAwait(false);
if (app != null)
{
name = app.Name;
MemoryCache.Default.Add(cacheKey, name, new CacheItemPolicy()
{
AbsoluteExpiration = DateTimeOffset.UtcNow.AddDays(1)
});
}
}
}
viewModel.Application = name;
}
}
public async Task <IHttpActionResult> Delete(Guid id)
{
ProgramUpdatePackageInfo packageInfo = await this.work.UpdatePackages.GetUpdatePackageInfo(id).ConfigureAwait(false);
if (packageInfo == null)
{
return(this.BadRequest($"Program Update Package [{id}] does not exist!"));
}
await this.work.UpdatePackages.DeletePackage(packageInfo, this.fileRemover).ConfigureAwait(false);
await this.work.CompleteAsync().ConfigureAwait(false);
return(this.Ok());
}
public async Task <IEnumerable <ProgramSummary> > GetProgramSummary(List <Program> programs)
{
List <ProgramSummary> returnData = new List <ProgramSummary>();
foreach (Program program in programs)
{
ProgramSummary summary;
try
{
List <View> views = await this.Views.FindAsync(x => x.ProgramId == program.Id).ConfigureAwait(false);
List <ViewTelemetrySummary> viewSummaries = views.SelectMany(x => x.TelemetrySummaries).ToList();
List <Event> events = await this.Events.FindAsync(x => x.ProgramId == program.Id).ConfigureAwait(false);
List <EventTelemetrySummary> eventSummaries = events.SelectMany(x => x.TelemetrySummaries).ToList();
List <TelemetrySummary> allSummaries = viewSummaries.Cast <TelemetrySummary>().Concat(eventSummaries).ToList();
ProgramUpdatePackageInfo latestPkg = await this.UpdatePackages.GetLatestPackage(program.Id).ConfigureAwait(false);
summary = new ProgramSummary
{
ProgramName = program.Name
, DeveloperName = program.DeveloperTeam?.Name ?? "N/A"
, TelemetryKey = program.TelemetryKey
, RegisteredDate = program.RegisteredDate
, UsersCount = allSummaries.DistinctBy(x => x.ClientAppUserId).Count()
, LastUpdateDate = latestPkg?.UploadedDate
, LatestVersion = latestPkg?.SupportedToolkitVersion ?? "?"
, ToolkitVersion = latestPkg?.SupportedToolkitVersion ?? "?"
};
}
catch (Exception)
{
summary = new ProgramSummary();
summary.ProgramName = program?.Name ?? "Error while loading summary";
summary.DeveloperName = "Error while loading summary";
}
returnData.Add(summary);
}
return(returnData);
}
public async Task <bool> ToggleBetaSetting(Guid packageId, bool isBeta)
{
ProgramUpdatePackageInfo pkg = await this.work.UpdatePackages.FirstOrDefaultAsync(x => x.PublicId == packageId).ConfigureAwait(false);
Trace.TraceInformation(LoggerHelper.FormatMessage(this.RequestContext, $"Setting IsBeta on package {packageId} to {isBeta}"));
pkg.IsBeta = isBeta;
await this.work.CompleteAsync().ConfigureAwait(false);
pkg = await this.work.UpdatePackages.FirstOrDefaultAsync(x => x.PublicId == packageId).ConfigureAwait(false);
if (pkg.IsBeta != isBeta)
{
throw new InvalidOperationException($"Error occurred while setting package 'beta' status to {isBeta}. Value was not saved correctly.");
}
Trace.TraceInformation(LoggerHelper.FormatMessage(this.RequestContext, $"Successfully set IsBeta on package {packageId} to {pkg.IsBeta}"));
return(pkg.IsBeta);
}
public static async Task <string> GetMaximumSupportedToolkitVersion(IProgramsUnitOfWork unitOfWork, List <ProgramUpdatePackageInfo> updatePackages, Program program
, UpdateRequest updateRequest)
{
string maxVersionInPackages = null;
#pragma warning disable 618
ProgramUpdatePackageInfo newestPackage = updatePackages.OrderByDescending(x => x.Id).FirstOrDefault();
#pragma warning restore 618
if (newestPackage != null)
{
maxVersionInPackages = newestPackage.SupportedToolkitVersion;
}
else
{
//no updates now, so figure out what version is supported by the client already
var version = program.DetermineProgramVersion(updateRequest.VersionData);
ProgramUpdatePackageInfo previousPackage =
await unitOfWork.UpdatePackages.FirstOrDefaultAsync(x => x.ProgramId == program.Id && x.Version == version).ConfigureAwait(false);
if (previousPackage != null)
{
maxVersionInPackages = previousPackage.SupportedToolkitVersion;
}
else
{
var pkg = (await unitOfWork.ProgramPackages.FirstOrDefaultAsync(x => x.ProgramId == program.Id)
.ConfigureAwait(false));
maxVersionInPackages = pkg?.SupportedToolkitVersion ?? "0.0.0.0";
}
}
if (updateRequest.ToolkitVersion.IsNewerOrEqualVersion(maxVersionInPackages))
{
return(updateRequest.ToolkitVersion);
}
return(maxVersionInPackages);
}
public static List <ProgramUpdatePackageInfo> FilterPackagesSet(List <ProgramUpdatePackageInfo> updatePackages, UpdateRequest request)
{
if (updatePackages.IsNullOrEmpty())
{
return(new List <ProgramUpdatePackageInfo>());
}
if (!request.AcceptBeta)
{
updatePackages.RemoveAll(x => x.IsBeta);
if (updatePackages.IsNullOrEmpty())
{
return(new List <ProgramUpdatePackageInfo>());
}
}
ProgramUpdatePackageInfo newestPackage = updatePackages.First();
if (newestPackage.IsStandalone)
{
return(new List <ProgramUpdatePackageInfo> {
newestPackage
});
}
List <ProgramUpdatePackageInfo> list = new List <ProgramUpdatePackageInfo>();
foreach (ProgramUpdatePackageInfo updatePackageInfo in updatePackages)
{
list.Add(updatePackageInfo);
if (updatePackageInfo.IsStandalone)
{
break;
}
}
return(list);
}
public async Task <IHttpActionResult> Get(Guid id)
{
ProgramUpdatePackageInfo packageInfo = await this.work.UpdatePackages.GetUpdatePackageInfo(id).ConfigureAwait(false);
if (packageInfo == null)
{
return(this.BadRequest($"Program Update Package [{id}] does not exist!"));
}
byte[] bytes = await this.work.UpdatePackages.GetPackage(id, this.FileRetriever).ConfigureAwait(false);
HttpResponseMessage result = new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new ByteArrayContent(bytes)
};
result.Content.Headers.ContentDisposition = new ContentDispositionHeaderValue("attachment")
{
FileName = packageInfo.FileName
};
result.Content.Headers.ContentType = new MediaTypeHeaderValue("application/zip");
return(this.ResponseMessage(result));
}
public async Task <string> GetReleaseNotes(Guid packageId)
{
ProgramUpdatePackageInfo pkg = await this.work.UpdatePackages.FirstOrDefaultAsync(x => x.PublicId == packageId).ConfigureAwait(false);
return(pkg.ReleaseNotes);
}
public static List <ProgramUpdatePackageInfo> FilterPackagesSet(List <ProgramUpdatePackageInfo> updatePackages, UpdateRequest request)
{
if (updatePackages.IsNullOrEmpty())
{
return(new List <ProgramUpdatePackageInfo>());
}
if (!request.AcceptBeta)
{
updatePackages.RemoveAll(x => x.IsBeta);
if (updatePackages.IsNullOrEmpty())
{
return(new List <ProgramUpdatePackageInfo>());
}
}
ProgramUpdatePackageInfo newestPackage = updatePackages.First();
if (newestPackage.IsStandalone && !newestPackage.IsBeta) //in case newest is beta, return a latest stable as well - because the end user might choose to not install beta
{
return(new List <ProgramUpdatePackageInfo> {
newestPackage
});
}
List <ProgramUpdatePackageInfo> list = new List <ProgramUpdatePackageInfo>();
foreach (ProgramUpdatePackageInfo updatePackageInfo in updatePackages)
{
list.Add(updatePackageInfo);
if (updatePackageInfo.IsStandalone && !updatePackageInfo.IsBeta)
{
break;
}
}
//now skip all the potential beta standalone except for the latest one
var finalFiltered = new List <ProgramUpdatePackageInfo>();
bool latestStandaloneBetaAdded = false;
foreach (ProgramUpdatePackageInfo programUpdatePackageInfo in list)
{
if (programUpdatePackageInfo.IsBeta)
{
if (latestStandaloneBetaAdded)
{
continue;
}
if (programUpdatePackageInfo.IsStandalone)
{
latestStandaloneBetaAdded = true;
}
finalFiltered.Add(programUpdatePackageInfo);
}
else
{
finalFiltered.Add(programUpdatePackageInfo);
}
}
return(finalFiltered);
}
public static string DownloadProgramUpdate(ProgramUpdatePackageInfo pkg)
{
return($"{DownloadProgramUpdatePackage}/{pkg.PublicId}");
}
