private async Task <RootObject> GetRealEstatesAsync(string type, string searchOptions, int nextPage, int numberOfItems)
{
HttpClient client = _httpClientService.GetHttpClient();
var apiKey = _serviceConfiguration.GetConfigSection(RealEstateConstants.FundaApiKey);
var response = client.GetAsync(string.Format($"{client.BaseAddress.AbsoluteUri}/json/{apiKey}/?type={type}&zo={searchOptions}&page={nextPage}&pagesize={numberOfItems}")).Result;
if (response.IsSuccessStatusCode)
{
var json = await response.Content.ReadAsStringAsync();
if (JsonConvert.DeserializeObject(json) == null)
{
return(null);
}
var rootObject = JsonConvert.DeserializeObject <RootObject>(JsonConvert.DeserializeObject(json,
new JsonSerializerSettings()
{
TypeNameHandling = TypeNameHandling.Auto,
ReferenceLoopHandling = ReferenceLoopHandling.Ignore
}).ToString());
return(rootObject);
}
return(new RootObject
{
TotaalAantalObjecten = 0,
Objects = new List <RealEstate>()
{
}
});
}
private async Task GetCertificateAsync()
{
if (certificateBuff == null)
{
if (certificateBlobConfig == null)
{
certificateBlobConfig = _serviceConfiguration.GetConfigSection("CertBlobConfig");
}
if (!certificateBlobConfig.ContainsKey("ConnectionString"))
{
throw new Exception("Please add ConnectionString parameter to CertBlobConfig section");
}
if (!certificateBlobConfig.ContainsKey("ContainerName"))
{
throw new Exception("Please add ContainerName parameter to CertBlobConfig section");
}
if (!certificateBlobConfig.ContainsKey("Filename"))
{
throw new Exception("Please add Filename parameter to CertBlobConfig section");
}
var connectionString = certificateBlobConfig["ConnectionString"];
var containerName = certificateBlobConfig["ContainerName"];
var filename = certificateBlobConfig["Filename"];
var fileContent = await _blobStorageConfiguration.GetContentFromConfigurationFile(connectionString, containerName, filename);
certificateBuff = Encoding.Unicode.GetBytes(fileContent);
}
}
protected override async Task RunAsync(CancellationToken cancellationToken)
{
// need to call base run async to prepare for the state or else actor state will throw errors ReminderLoadInProgressException
await base.RunAsync(cancellationToken);
var config = ServiceConfig.GetConfigSection(SectionKeyName);
//read the blob and init scheduler actor
if (ConfigMode == ConfigMode.BlobConfig)
{
var configList = await BlobStorageConfiguration.GetConfigsFromBlobFile <ServiceBusOption>(
config[CONNECTION_STRING_KEY],
config[CONTAINER_NAME_KEY],
config[FILE_NAME_KEY],
$"{SectionKeyName}");
foreach (var option in configList)
{
Logger.LogInformation($"[{SectionKeyName}] Initialize Listener Actor", option);
await InitScalingListenersAsync(option, cancellationToken);
}
}
else if (ConfigMode == ConfigMode.ServiceFabricConfig)
{
var serviceBusOption = new ServiceBusOption()
{
ConnectionString = config[CONNECTION_STRING_KEY],
ClientMode = ClientMode.Receiving,
SubscriptionRequireSession = false,
SubscriptionName = $"{SectionKeyName}_sub_no_sessionId"
};
await InitScalingListenersAsync(serviceBusOption, cancellationToken);
}
}
private async Task HandleActorBlob(CancellationToken cancellationToken)
{
try
{
var _config = ServiceConfiguration.GetConfigSection("BlobStorageForFtp");
_blobClient = new BlobClient(_config["StorageAccountKey"], _config["StorageAccountName"]);
var ftpActorListStream = await _blobClient.ReadBlobAsync(_config["ContainerName"], _config["FileName"]);
using (var reader = new StreamReader(ftpActorListStream))
{
string content = reader.ReadToEnd();
if (!string.IsNullOrEmpty(content))
{
var actorObject = JObject.Parse(content);
var arrayActor = actorObject[SectionKeyName].Values <JObject>();
foreach (var ftpObject in arrayActor)
{
var ftpOption = ftpObject.ToObject <FtpOption>();
InitSchedulerActor(ftpOption, cancellationToken);
}
}
}
}
catch (Exception ex)
{
Logger.LogError(ex, $"[HandleActorBlob] {GetType().Name} Failed to handler blob : {ex.Message} ");
throw;
}
}
/// <summary>
/// Gets the HTTP client.
/// </summary>
/// <returns></returns>
public HttpClient GetHttpClient()
{
var productApi = _serviceConfiguration.GetConfigSection(RealEstateConstants.FundaApi);
return(new HttpClient {
BaseAddress = new Uri(productApi)
});
}
private async Task <IEnumerable <FtpOption> > GetFtpConfigsAsync()
{
var config = _serviceConfiguration.GetConfigSection(SectionKeyName);
var configList = await _blobStorageConfiguration.GetConfigsFromBlobFile <FtpOption>(
config[CONNECTION_STRING_KEY],
config[CONTAINER_NAME_KEY],
config[FILE_NAME_KEY],
$"{SectionKeyName}");
return(configList);
}
public override async Task StartJobAsync(DateTime timeExecuted, CancellationToken cancellationToken)
{
try
{
Logger.LogInformation($"ScalerActor startjobasync");
var ftpOptions =
await StateManager.TryGetStateAsync <List <FtpOption> >(FTP_LIST_STATE_NAME, cancellationToken);
var configs = ServiceConfiguration.GetConfigSection("BlobStorageForFtp");
var blobFtpList = await ReadFtpConfigAsync(configs);
if (ftpOptions.HasValue)
{
var stateFtpList = ftpOptions.Value;
bool listChanged = false;
if (stateFtpList.Count == blobFtpList.Count)
{
foreach (var ftpOption in stateFtpList)
{
listChanged = blobFtpList.Any(item =>
{
string id = item.FtpConfig.Ftp.Host + item.FtpConfig.Ftp.Path;
if (id == ftpOption.FtpConfig.Ftp.Host + ftpOption.FtpConfig.Ftp.Path)
{
string ftpOptionString = ftpOption.Serialize();
string itemString = item.Serialize();
return(!ftpOptionString.Equals(itemString));
}
return(true);
});
if (listChanged)
{
break;
}
}
}
else
{
listChanged = true;
}
if (listChanged)
{
var intersectList = blobFtpList.Intersect(stateFtpList, new FtpOptionComparer()).ToList();
var remainingList = stateFtpList.Except(intersectList, new FtpOptionComparer()).ToList();
foreach (var ftpOption in remainingList)
{
string actorId = ftpOption.FtpConfig.Ftp.Host + ftpOption.FtpConfig.Ftp.Path + ftpOption.FtpConfig.Freq;
DisposeActor(new ActorId(actorId), new Uri($"{ApplicationName}/{SchedulerActorService}"), cancellationToken);
}
await StateManager.AddOrUpdateStateAsync(FTP_LIST_STATE_NAME, blobFtpList, (s, key) => blobFtpList,
cancellationToken);
foreach (var ftpOption in blobFtpList)
{
await InitSchedulerActor(ftpOption, cancellationToken);
}
}
}
else
{
await StateManager.AddOrUpdateStateAsync(FTP_LIST_STATE_NAME, blobFtpList, (s, key) => blobFtpList,
cancellationToken);
foreach (var ftpOption in blobFtpList)
{
await InitSchedulerActor(ftpOption, cancellationToken);
}
}
}
catch (Exception ex)
{
Logger.LogError(ex, $"{CurrentActor} failed to start job. Message: {ex.Message}");
}
}
