public async Task UploadAggregatedJobs(ResponseRoot body)
{
await _s3Service.PutObjectAsync(_iawsConfigurationService.DestinationBucketName,
_iawsConfigurationService.DestinationFileKey, JsonSerializer.Serialize(body));
await _cloudfrontService.CreateInvalidationByPath(_iawsConfigurationService.DestinationCloudfrontDistributionId, $"/{_iawsConfigurationService.DestinationFileKey}");
}
public async Task <IActionResult> Get(string id)
{
var result = new ResponseRoot <Canal>
{
Data = await _canalService.GetCanalByIdAsync(id),
Success = true
};
return(Ok(result));
}
public async Task <IActionResult> GetVideos(string canalId)
{
var result = new ResponseRoot <IList <Video> >
{
Data = await _videoService.GetVideosAsync(w => w.CanalId == canalId),
Success = true
};
return(Ok(result));
}
public async Task <IActionResult> Get(string id)
{
var result = new ResponseRoot <Video>
{
Data = await _videoService.GetVideoByIdAsync(id),
Success = true
};
return(Ok(result));
}
/// <summary>
/// Bulk execute a DbApi with a IList<IDictionary<string, object>> (a collection of input parameters collection)
/// </summary>
/// <typeparam name="T">IDictionary<string, object></typeparam>
/// <param name="apiController">Your ApiController to invoke this extension method</param>
/// <param name="sp">Specifies the fully qualified name of database stored procedure or function</param>
/// <param name="listOfParameters">Specifies a collection of required parameter dictionary for every call in the bulk execution</param>
/// <returns>A complete HttpResponseMessage contains an array of every result data returned by the database</returns>
public static HttpResponseMessage BulkExecuteDbApi <T>(this ApiController apiController, string sp, IList <T> listOfParameters) where T : IDictionary <string, object>
{
if (listOfParameters == null || listOfParameters.Count == 0)
{
return(apiController.Request.CreateResponse(HttpStatusCode.BadRequest));
}
try
{
var negotiationResult = apiController.Request.Negotiate();
if (negotiationResult != null && negotiationResult.Formatter is PseudoMediaTypeFormatter)
{
return(apiController.Request.CreateResponse(HttpStatusCode.UnsupportedMediaType));
}
using (DbContext dbContext = new DbContext())
{
dbContext.SetNamingConvention(apiController.Request.GetQueryStringDictionary());
if (negotiationResult != null)
{
if (negotiationResult.Formatter is RazorMediaTypeFormatter)
{
return(apiController.Request.CreateResponse(HttpStatusCode.UnsupportedMediaType));
}
else if (negotiationResult.Formatter is XmlMediaTypeFormatter)
{
ResponseRoot[] xmlResponses = new ResponseRoot[listOfParameters.Count];
for (int i = 0; i < xmlResponses.Length; i++)
{
xmlResponses[i] = new ResponseRoot(dbContext.ExecuteDbApi(sp, listOfParameters[i]));
}
return(apiController.Request.CreateResponse(HttpStatusCode.OK, xmlResponses.AsQueryable()));
}
}
StoredProcedureResponse[] jsonResponses = new StoredProcedureResponse[listOfParameters.Count];
for (int i = 0; i < jsonResponses.Length; i++)
{
jsonResponses[i] = dbContext.ExecuteDbApi(sp, listOfParameters[i]);
}
return(apiController.Request.CreateResponse(HttpStatusCode.OK, jsonResponses.AsQueryable()));
}
}
finally
{
CleanupCache(apiController.Request.RequestUri);
}
}
public async Task Aggregate()
{
_logger.LogInformation("Aggregating jobs");
var scrapedJobs = await _scraperResultsService.GetAllScrapedJobs();
var res = scrapedJobs.Select(j => new JobByTechnoWithCompany
{
Company = j.Company,
MainTechnologies = _technologiesService.GetTechnologies(j.Title).ToHashSet(),
SecondaryTechnologies = _technologiesService.GetTechnologies(j.Description).ToHashSet(),
Url = j.Url,
Site = j.Site,
Title = j.Title
}).Aggregate(new Dictionary <string, AggregatedCompany>(),
(acc, job) => { return(AggregateCompaniesAndJobs(acc, job)); }, list => list.Select(e => e.Value))
.Where(e => e.SecondaryTechnologies.Count != 0 || e.MainTechnologies.Count != 0).ToHashSet();
var res2 = new ResponseRoot
{
Companies = new CompanyResponse
{
Companies = GetTechnologiesStatistics(res)
},
Technologies = new TechnologiesResponse
{
Technologies = _technologiesAggregatorService.GetTechnologiesStatistics(res)
}
};
if (_awsConfigurationService.WriteResultsToLocal)
{
File.Create("../../../../index.json").Close();
await File.WriteAllTextAsync("../../../../index.json", JsonSerializer.Serialize(res2));
}
if (_awsConfigurationService.UploadResults)
{
await _aggregatorResultsService.UploadAggregatedJobs(res2);
}
;
}
public async Task <IActionResult> Get(int?pageSize, int?pageIndex, string queryString)
{
if (pageSize == null)
{
IList <Canal> list = null;
if (string.IsNullOrEmpty(queryString))
{
list = await _canalService.GetCanaisAsync();
}
else
{
list = await _canalService.GetCanaisAsync(w => w.Title.Contains(queryString));
}
var result = new ResponseRoot <IList <Canal> >
{
Data = list,
Success = true
};
return(Ok(result));
}
else
{
if (pageIndex == null)
{
pageIndex = 0;
}
IMongoQueryable <Canal> query = null;
ResponseRoot <PagedList <Canal> > result = null;
if (string.IsNullOrEmpty(queryString))
{
query = _canalService.GetQuery();
var pagedList = await PagedList <Canal> .Create(query, pageIndex.Value, pageSize.Value);
result = new ResponseRoot <PagedList <Canal> >
{
Data = pagedList,
PageIndex = pagedList.PageIndex,
PageSize = pagedList.PageSize,
TotalCount = pagedList.TotalCount,
TotalPages = pagedList.TotalPages,
Success = true
};
}
else
{
var builder = Builders <Canal> .Filter;
var builderSort = Builders <Canal> .Sort;
var filter = builder.Where(x => x.Title.Contains(queryString));
var sort = builderSort.Ascending(f => f.Title);
var pagedList = await PagedList <Canal> .Create(_canalService.GetCollection(), filter, sort, pageIndex.Value, pageSize.Value);
result = new ResponseRoot <PagedList <Canal> >
{
Data = pagedList,
PageIndex = pagedList.PageIndex,
PageSize = pagedList.PageSize,
TotalCount = pagedList.TotalCount,
TotalPages = pagedList.TotalPages,
Success = true
};
}
return(Ok(result));
}
}
