public async Task <HttpResponseMessage> PutPackage([FromBody] IPackage package)
{
if (package == null || string.IsNullOrWhiteSpace(package.Id) || package.Version == null)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Must provide package with valid id and version."));
}
if (package.HasSourceAndSymbols())
{
var response = Request.CreateResponse(HttpStatusCode.RedirectKeepVerb);
response.Headers.Location = new Uri(Url.Link(RouteNames.Symbols.Upload, null), UriKind.RelativeOrAbsolute);
return(response);
}
try
{
Audit("Add package {0} version {1}", package.Id, package.Version);
await LuceneRepository.AddPackageAsync(package, CancellationToken.None);
}
catch (PackageOverwriteDeniedException ex)
{
return(Request.CreateErrorResponse(HttpStatusCode.Conflict, ex.Message));
}
var location = Url.Link(RouteNames.Packages.Info, new { id = package.Id, version = package.Version });
var result = Request.CreateResponse(HttpStatusCode.Created);
result.Headers.Location = new Uri(location);
return(result);
}
private static async Task GenerateSampleData(int recordsNumber)
{
var httpClient = new HttpClient();
var htmlResult = new HtmlDocument();
var random = new Random();
for (int i = 0; i < recordsNumber; i++)
{
var htmlStringResult = await httpClient.GetStringAsync("http://randomtextgenerator.com/");
htmlResult.LoadHtml(htmlStringResult);
var randomText = htmlResult.GetElementbyId("generatedtext").InnerText;
var randomNumber = random.Next(150);
var newModel = new SampleModel
{
Id = Guid.NewGuid(),
Description = randomText,
CreatedDate = DateTime.Now.AddDays(randomNumber),
ViewCount = randomNumber
};
Db.SampleModels.Add(newModel);
LuceneRepository <SampleModel> .AddUpdateLuceneIndex(newModel);
}
Db.SaveChanges();
}
private LucenePackage FindNewestReleasePackage(string packageId)
{
return((LucenePackage)LuceneRepository
.FindPackagesById(packageId)
.Where(p => p.IsReleaseVersion())
.OrderByDescending(p => p.Version)
.FirstOrDefault());
}
private static void ClearIndexAndDb()
{
LuceneRepository <SampleModel> .ClearLuceneIndex();
foreach (var sampleModel in Db.SampleModels)
{
Db.SampleModels.Remove(sampleModel);
}
Db.SaveChanges();
}
private LucenePackage FindPackage(PackageSpec packageSpec)
{
if (packageSpec.Version == null)
{
return(FindNewestReleasePackage(packageSpec.Id));
}
var package = MirroringRepository.FindPackage(packageSpec.Id, packageSpec.Version);
return(package != null?LuceneRepository.Convert(package) : null);
}
public HttpResponseMessage DownloadPackage(string id, string version = "")
{
var packageSpec = new PackageSpec(id, version);
var package = FindPackage(packageSpec);
var result = EvaluateCacheHeaders(packageSpec, package);
if (result != null)
{
return(result);
}
if (Request.Headers.Range != null)
{
try
{
HttpResponseMessage partialResponse = Request.CreateResponse(HttpStatusCode.PartialContent);
partialResponse.Content = new ByteRangeStreamContent(package.GetStream(), Request.Headers.Range, new MediaTypeWithQualityHeaderValue("application/zip"));
return(partialResponse);
}
catch (InvalidByteRangeException e)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, e));
}
}
result = Request.CreateResponse(HttpStatusCode.OK);
if (Request.Method == HttpMethod.Get)
{
result.Content = new StreamContent(package.GetStream());
TaskRunner.QueueBackgroundWorkItem(cancellationToken => LuceneRepository.IncrementDownloadCountAsync(package, cancellationToken));
}
else
{
result.Content = new StringContent(string.Empty);
}
result.Headers.ETag = new EntityTagHeaderValue('"' + package.PackageHash + '"');
result.Content.Headers.ContentType = new MediaTypeWithQualityHeaderValue("application/zip");
result.Content.Headers.LastModified = package.LastUpdated;
result.Content.Headers.ContentDisposition = new ContentDispositionHeaderValue(DispositionTypeNames.Attachment)
{
FileName = string.Format("{0}.{1}{2}", package.Id, package.Version, Constants.PackageExtension),
Size = package.PackageSize,
CreationDate = package.Created,
ModificationDate = package.LastUpdated,
};
return(result);
}
private static void Main(string[] args)
{
//ClearIndexAndDb();
//GenerateSampleData(100000).Wait();
var startTime = DateTime.Now;
var dbSearchResult = Db.SampleModels.Find(new Guid("26A033D4-EA33-4CF5-A24A-FFF684BD16C5"));
Console.WriteLine("Databse process");
Console.WriteLine("result: " + dbSearchResult);
Console.WriteLine("Time:" + (DateTime.Now - startTime));
Console.WriteLine();
startTime = DateTime.Now;
var luceneSearchResult = LuceneRepository <SampleModel> .SearchById("26A033D4-EA33-4CF5-A24A-FFF684BD16C5");
Console.WriteLine("Lucene process");
Console.WriteLine("result: " + luceneSearchResult.Count());
Console.WriteLine("Time:" + (DateTime.Now - startTime));
}
public async Task <HttpResponseMessage> DeletePackage(string id, string version = "")
{
if (string.IsNullOrWhiteSpace(id) || string.IsNullOrWhiteSpace(version))
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Must specify package id and version."));
}
var package = LuceneRepository.FindPackage(id, new SemanticVersion(version));
if (package == null)
{
var message = string.Format("Package '{0}' version '{1}' not found.", id, version);
return(Request.CreateErrorResponse(HttpStatusCode.NotFound, message));
}
Audit("Delete package {0} version {1}", id, version);
var task1 = LuceneRepository.RemovePackageAsync(package, CancellationToken.None);
var task2 = SymbolSource.RemoveSymbolsAsync(package);
await Task.WhenAll(task1, task2);
return(Request.CreateResponse(HttpStatusCode.OK));
}
public IList <string> GetAvailableSearchFieldNames()
{
return(LuceneRepository.GetAvailableSearchFieldNames().ToList());
}
public dynamic Search(
string query = "",
bool includePrerelease = false,
bool latestOnly = true,
int offset = 0,
int count = 20,
PackageOriginFilter originFilter = PackageOriginFilter.Any,
SearchSortField sort = SearchSortField.Score,
SearchSortDirection order = SearchSortDirection.Ascending)
{
var criteria = new SearchCriteria(query)
{
AllowPrereleaseVersions = includePrerelease,
PackageOriginFilter = originFilter,
SortField = sort,
SortDirection = order
};
LuceneQueryStatistics stats = null;
List <IPackage> hits;
try
{
var queryable = LuceneRepository.Search(criteria).CaptureStatistics(s => stats = s);
if (latestOnly)
{
queryable = queryable.LatestOnly(includePrerelease);
}
hits = queryable.Skip(offset).Take(count).ToList();
}
catch (InvalidSearchCriteriaException ex)
{
var message = ex.InnerException != null ? ex.InnerException.Message : ex.Message;
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, message));
}
dynamic result = new ExpandoObject();
// criteria
result.Query = query;
result.IncludePrerelease = includePrerelease;
result.TotalHits = stats.TotalHits;
result.OriginFilter = originFilter;
result.Sort = sort;
result.Order = order;
// statistics
result.Offset = stats.SkippedHits;
result.Count = stats.RetrievedDocuments;
result.ElapsedPreparationTime = stats.ElapsedPreparationTime;
result.ElapsedSearchTime = stats.ElapsedSearchTime;
result.ElapsedRetrievalTime = stats.ElapsedRetrievalTime;
var chars = stats.Query.ToString().Normalize(NormalizationForm.FormD);
result.ComputedQuery = new string(chars.Where(c => c < 0x7f && !char.IsControl(c)).ToArray());
// hits
result.Hits = hits;
return(result);
}
