public override async Task <DBSubscription> CreateSubscriptionAsync(Uri uri)
{
var username = uri.Segments[1];
await UpdateToken();
var user = await PollyHelper.WebFallbackAsync(() => _client.UserByScreenName(username));
if (user != null)
{
_lastRequest = DateTimeOffset.Now;
}
if (user?.Data.User == null)
{
return(null);
}
return(new DBSubscription
{
SourceId = user.Data.User.RestId.ToString(),
Username = user.Data.User.Legacy.ScreenName,
IsProtected = user.Data.User.Legacy.Protected,
Source = ESource.Twitter
});
}
public override async Task <List <DBCard> > GetCardsAsync(DBSubscription subscription)
{
await UpdateToken();
var timeline = await PollyHelper.WebFallbackAsync(() => _client.UserTweetsAsync(long.Parse(subscription.SourceId), Settings.Default.TwitterMaxLoadPerUser));
if (timeline != null)
{
_lastRequest = DateTimeOffset.Now;
}
return(timeline?.GlobalObjects.Tweets.Values
.Where(w => w.UserId.ToString() == subscription.SourceId).Select(s =>
{
var media = s.ExtendedEntities?.Media?.FirstOrDefault();
return new DBCard
{
Timestamp = s.CreatedAt,
Text = TrimText(s.Text),
CardId = s.Id.ToString(),
Header = $"@{subscription.Username}",
HasImage = media?.Type == ETwitterMediaType.Photo || media?.Type == ETwitterMediaType.Gif,
HasVideo = media?.Type == ETwitterMediaType.Video,
HasRepost = s.QuotedId != null,
OriginalUrl = $"https://twitter.com/{subscription.Username}/status/{s.Id}",
};
}).ToList());
}
public IActionResult Polly(string text)
{
var filename = Guid.NewGuid().ToString();
PollyHelper.TextToMp3Async(text, filename);
ViewBag.audio = filename + ".mp3";
return(View());
}
/// <summary>
/// Gets the most recent stack event.
/// </summary>
/// <param name="stackId">The stack identifier.</param>
/// <returns>Timestamp of most recent event</returns>
private async Task <DateTime> GetMostRecentStackEvent(string stackId)
{
// CF returns events in descending chronological order
var response = await PollyHelper.ExecuteWithPolly(
() => this.client.DescribeStackEventsAsync(
new DescribeStackEventsRequest {
StackName = stackId
}));
return(response.StackEvents.Any()
? response.StackEvents.First().Timestamp
: DateTime.MinValue);
}
public override async Task <DBSubscription> CreateSubscriptionAsync(Uri uri)
{
var id = uri.Segments.ElementAtOrDefault(2);
if (id == null)
{
return(null);
}
if (uri.Segments.ElementAt(1) == "c/" || uri.Segments.ElementAt(1) == "user/")
{
var channelId = await PollyHelper.WebFallbackAsync(() => _client.ChannelId(uri.AbsoluteUri));
if (channelId == null)
{
return(null);
}
id = channelId;
}
using (var xmlReader = XmlReader.Create($"https://www.youtube.com/feeds/videos.xml?channel_id={id}", new XmlReaderSettings {
Async = true
}))
{
var feedReader = new AtomFeedReader(xmlReader);
while (await feedReader.Read())
{
switch (feedReader.ElementType)
{
case SyndicationElementType.Content:
var content = await feedReader.ReadContent();
if (string.Equals(content.Name, "title", StringComparison.OrdinalIgnoreCase))
{
return(new DBSubscription
{
Source = ESource.Youtube,
IsProtected = false,
SourceId = id,
Username = content.Value
});
}
break;
}
}
}
return(null);
}
public void HandleUploadFiles(HttpFileCollectionBase files, Int64 id)
{
foreach (string file in Request.Files)
{
var fileDataContent = Request.Files[file];
var stream = fileDataContent.InputStream;
var fileName = Path.GetFileName(fileDataContent.FileName);
var uploadPath = Server.MapPath("~/App_Data/uploads");
if (!FileHelper.ExistDirectory(uploadPath))
{
FileHelper.CreateDirectory(uploadPath);
}
var path = Path.Combine(uploadPath, fileName);
//使用瞬态故障处理库Polly处理异常，采用等待重试策略
PollyHelper.WaitAndRetry <IOException>(() =>
{
if (FileHelper.Exist(path))
{
FileHelper.Delete(path);
}
using (var fileStream = System.IO.File.Create(path))
{
stream.CopyTo(fileStream);
}
// 当上传中断，已上传部分是否能合并？（待优化）
var ut = new Utils();
var storeFileName = string.Empty;
var result = false;
//Merge file
ut.MergeFile(path, out result, out storeFileName);
if (result)
{
var model = bookRepository.GetById(id);
model.Url = storeFileName;
bookRepository.Update(model);
unitOfWork.Commit();
}
});
}
}
/// <summary>
/// Initializes a new instance of the <see cref="AiSpeakerBot" /> class.
/// </summary>
/// <seealso
/// cref="https://docs.microsoft.com/en-us/aspnet/core/fundamentals/logging/?view=aspnetcore-2.1#windows-eventlog-provider" />
public AiSpeakerBot(AiSpeakerBotAccessors accessors, ILoggerFactory loggerFactory,
SpeechHelper speechHelper, BlobHelper blobHelper, PollyHelper pollyHelper)
{
if (loggerFactory == null)
{
throw new ArgumentNullException(nameof(loggerFactory));
}
_logger = loggerFactory.CreateLogger <AiSpeakerBot>();
_logger.LogTrace("EchoBot turn start.");
_accessors = accessors ?? throw new ArgumentNullException(nameof(accessors));
_speechHelper = speechHelper ?? throw new ArgumentNullException(nameof(speechHelper));
_blobHelper = blobHelper ?? throw new ArgumentNullException(nameof(blobHelper));
_pollyHelper = pollyHelper ?? throw new ArgumentNullException(nameof(pollyHelper));
}
/// <summary>
/// 交换机发送消息
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="exchangeName"></param>
/// <param name="msg"></param>
/// <param name="routingKey"></param>
/// <param name="exchangeType"></param>
/// <param name="isTask"></param>
/// <param name="durable"></param>
public void SendMessageByExchange <T>(string exchangeName, T msg, string routingKey = "", string exchangeType = "direct", bool isTask = true, bool?durable = null) where T : class
{
var message = SerializeObject(msg);
PollyHelper.GetRetryTimesPolicy(2, ex =>
{
if (isTask)
{
var task = new Task(() => { SendMsgByExchange(exchangeName, message, exchangeType, routingKey, durable); });
TasksCache.Enqueue(task);
}
else
{
throw ex;
}
}).Execute(() => { SendMsgByExchange(exchangeName, message, exchangeType, routingKey, durable); });
}
private static readonly ConcurrentQueue <Task> TasksCache = new ConcurrentQueue <Task>(); //缓存队列
#region 公有函数
/// <summary>
/// 发送消息
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="qName"></param>
/// <param name="msg"></param>
/// <param name="isTask"></param>
/// <param name="durable"></param>
public void SendMessage <T>(string qName, T msg, bool isTask = true, bool?durable = null) where T : class
{
var message = SerializeObject(msg);
PollyHelper.GetRetryTimesPolicy(2, ex =>
{
if (isTask)
{
var task = new Task(() => { SendMsg(qName, message, durable); });
TasksCache.Enqueue(task);
}
else
{
throw ex;
}
}).Execute(() => { SendMsg(qName, message, durable); });
}
public JsonResult Polly(string text)
{
try
{
var mp3Link = PollyHelper.GetSentenceMp3(text);
return(new JsonResult(new JsonDTO
{
result = "ok",
mp3Link = mp3Link
}));
}
catch (Exception ex)
{
return(new JsonResult(new JsonDTO
{
result = "error",
mp3Link = ex.Message
}));
}
}
private async Task <bool> UpdateToken(bool force = false)
{
if (force || _lastRequest.AddMinutes(20) <= DateTimeOffset.Now)
{
_client.GuestToken = null;
var token = await PollyHelper.WebFallbackAsync(() => _client.GetGuestTokenAsync());
if (token != null)
{
_client.GuestToken = token.Value;
return(true);
}
else
{
return(false);
}
}
else
{
return(false);
}
}
public async Task <List <CompanyDto> > GetAsync(ApiDto apiDto)
{
var httpClient = HttpClientHelper.Get(apiDto);
var policeResponse = await PollyHelper.GetHttpResponseMessage(httpClient, ConfigurationManager.AppSettings["RetryPolicy:Http:RetryTimeoutMinutes"], "/api/skillviews/search?viewName=SkillsWorkflowIntegrationHrLinkCompanies");
if (!policeResponse.IsSuccessStatusCode)
{
throw new Exception("Error searching view named SkillsWorkflowIntegrationHrLinkCompanies. " + Environment.NewLine + policeResponse.Content.ReadAsStringAsync().Result);
}
var searchedViews = await policeResponse.Content.ReadAsJsonAsync <List <string> >();
if (searchedViews.Count == 0)
{
return(new List <CompanyDto>());
}
policeResponse = await PollyHelper.GetHttpResponseMessage(httpClient, ConfigurationManager.AppSettings["RetryPolicy:Http:RetryTimeoutMinutes"], "/api/skillviews/SkillsWorkflowIntegrationHrLinkCompanies");
if (!policeResponse.IsSuccessStatusCode)
{
throw new Exception("Error executing view named SkillsWorkflowIntegrationHrLinkCompanies. " + Environment.NewLine + policeResponse.Content.ReadAsStringAsync().Result);
}
return(await policeResponse.Content.ReadAsJsonAsync <List <CompanyDto> >());
}
/// <summary>Waits for a stack operation. to compete, sending stack event messages to the log.</summary>
/// <param name="stackArn"> ARN or name of stack to wait on.</param>
/// <param name="throwOnFailure">if set to <c>true</c> [throw on failure].</param>
/// <returns>The stack being waited on.</returns>
private async Task <Stack> WaitStackOperationAsync(string stackArn, bool throwOnFailure)
{
var describeStacksRequest = new DescribeStacksRequest {
StackName = stackArn
};
while (true)
{
Thread.Sleep(this.waitPollTime);
var stack = (await PollyHelper.ExecuteWithPolly(
() => this.client.DescribeStacksAsync(describeStacksRequest))).Stacks.First();
// Have we finished?
var isComplete = stack.StackStatus.Value.EndsWith("COMPLETE") ||
stack.StackStatus.Value.EndsWith("FAILED");
// Get events and render them
var events = (await GetEventsAsync(stackArn)).OrderBy(e => e.Timestamp).ToList();
if (events.Any())
{
// Most recent event is last
this.lastEventTime = events.Last().Timestamp;
// Now output them oldest first
foreach (var evt in events.OrderBy(e => e.Timestamp))
{
this.context.Logger.LogStackEvent(evt);
}
}
if (isComplete)
{
// Operation finished
if (Regex.IsMatch(stack.StackStatus.Value, "(ROLLBACK|FAILED)") && throwOnFailure)
{
throw new StackOperationException(stack);
}
// We done
return(stack);
}
}
// Local recursive function to collect events from nested stacks
async Task <IEnumerable <StackEvent> > GetEventsAsync(string stackArnLocal)
{
string nextToken = null;
var allEvents = new List <StackEvent>();
// Get events for this stack
do
{
var response = await PollyHelper.ExecuteWithPolly(
() => this.client.DescribeStackEventsAsync(
new DescribeStackEventsRequest
{
// ReSharper disable once AccessToModifiedClosure
StackName = stackArnLocal, NextToken = nextToken
}));
nextToken = response.NextToken;
allEvents.AddRange(response.StackEvents.Where(e => e.Timestamp > this.lastEventTime));
if (response.StackEvents.Any() && response.StackEvents.Last().Timestamp <= this.lastEventTime)
{
// Break here as remaining events will be older.
nextToken = null;
}
}while (nextToken != null);
// Enumerate any nested stack resources and recurse into each
foreach (var nested in (await PollyHelper.ExecuteWithPolly(
() => this.client.DescribeStackResourcesAsync(
new DescribeStackResourcesRequest {
StackName = stackArnLocal
})))
.StackResources.Where(
r => r.ResourceType == "AWS::CloudFormation::Stack" &&
!string.IsNullOrEmpty(r.PhysicalResourceId)))
{
allEvents.AddRange(await GetEventsAsync(nested.PhysicalResourceId));
}
return(allEvents);
}
}
// This method gets called by the runtime. Use this method to add services to the container.
// For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940
public void ConfigureServices(IServiceCollection services)
{
var azureAdOptions = Configuration.GetSection(nameof(AzureAd)).Get <AzureAd>();
var keyVaultConfig = Configuration.GetSection(nameof(KeyVaultConfig)).Get <KeyVaultConfig>();
var adoConfig = Configuration.GetSection(nameof(AdoConfig)).Get <AdoConfig>();
_logger.LogInformation($"{nameof(KeyVaultConfig.UseKeyVault)} = {keyVaultConfig.UseKeyVault}");
if (keyVaultConfig.UseKeyVault)
{
try
{
//_logger.LogInformation($"Delay to wait for AUTH api to start");
//Task.Delay(10 * 1000).Wait();
_logger.LogInformation($"{nameof(KeyVaultConfig.KeyVaultName)} = {keyVaultConfig.KeyVaultName}");
var azureServiceTokenProvider = new AzureServiceTokenProvider();
var keyVaultClient = new KeyVaultClient(new KeyVaultClient.AuthenticationCallback(azureServiceTokenProvider.KeyVaultTokenCallback));
//clien secret
if (keyVaultConfig.ClientSecretVaultKey != null)
{
azureAdOptions.ClientSecret = keyVaultClient.GetSecretAsync(keyVaultConfig.KeyVaultName, keyVaultConfig.ClientSecretVaultKey).Result.Value;
Configuration[KeyVaultConfig.Constants.AzureAdClientSecret] = azureAdOptions.ClientSecret;
}
_logger.LogSecretVariableValueStartValue(KeyVaultConfig.Constants.AzureAdClientSecret, azureAdOptions.ClientSecret);
//SPN clien secret
var spnAd = Configuration.GetSection(nameof(SpnAd)).Get <SpnAd>();
if (keyVaultConfig.SpnClientSecretVaultKey != null)
{
spnAd.ClientSecret = keyVaultClient.GetSecretAsync(keyVaultConfig.KeyVaultName, keyVaultConfig.SpnClientSecretVaultKey).Result.Value;
Configuration[KeyVaultConfig.Constants.SpnClientSecret] = spnAd.ClientSecret;
}
_logger?.LogSecretVariableValueStartValue(KeyVaultConfig.Constants.SpnClientSecret, spnAd.ClientSecret);
//ConnectionStrings
if (keyVaultConfig.TokenCacheDbCsVaultKey != null)
{
if (!keyVaultConfig.UseLocalDb)
{
Configuration["ConnectionStrings:" + KeyVaultConfig.ConnectionStrings.TokenCacheDb] = keyVaultClient.GetSecretAsync(keyVaultConfig.KeyVaultName, keyVaultConfig.TokenCacheDbCsVaultKey).Result.Value;
}
}
_logger.LogSecretVariableValueStartValue(KeyVaultConfig.ConnectionStrings.TokenCacheDb, Configuration["ConnectionStrings:" + KeyVaultConfig.ConnectionStrings.TokenCacheDb]);
//ado
if (keyVaultConfig.AdoPersonalAccessTokenVaultKey != null)
{
adoConfig.AdoPersonalAccessToken = keyVaultClient.GetSecretAsync(keyVaultConfig.KeyVaultName, keyVaultConfig.AdoPersonalAccessTokenVaultKey).Result.Value;
Configuration["AdoConfig:" + nameof(adoConfig.AdoPersonalAccessToken)] = adoConfig.AdoPersonalAccessToken;
}
_logger.LogSecretVariableValueStartValue(nameof(adoConfig.AdoPersonalAccessToken), adoConfig.AdoPersonalAccessToken);
}
catch (Exception ex)
{
_logger?.LogError("Error reading Keyvalut", ex);
}
}
services.AddAutoMapper(AppDomain.CurrentDomain.GetAssemblies());
services.AddTransient <ITimeZoneService, TimeZoneService>();
//services.AddAutoMapperBuilder(builder =>
//{
// builder.Profiles.Add(new VersionProfile(services.BuildServiceProvider().GetRequiredService<ITimeZoneService>()));
//});
#region Add HttpClient
string ApiEndpoint = Configuration.GetValue <string>(ConstatCsro.EndPoints.ApiEndpoint);
services.AddHttpClient(ConstatCsro.EndPoints.ApiEndpoint, (client) =>
{
client.Timeout = TimeSpan.FromMinutes(ConstatCsro.ClientNames.API_TimeOut_Mins);
client.BaseAddress = new Uri(ApiEndpoint);
client.DefaultRequestHeaders.Add("Accept", "application/json");
}).ConfigurePrimaryHttpMessageHandler(() =>
{
return(new HttpClientHandler()
{
AutomaticDecompression = DecompressionMethods.Deflate | DecompressionMethods.GZip | DecompressionMethods.Brotli,
UseCookies = false
});
})
.SetHandlerLifetime(TimeSpan.FromMinutes(5))
.AddPolicyHandler(PollyHelper.GetRetryPolicy())
.AddPolicyHandler(PollyHelper.GetRetryPolicy());
;
string ApiEndpointAdo = Configuration.GetValue <string>(ConstatCsro.EndPoints.ApiEndpointAdo);
services.AddHttpClient(ConstatCsro.EndPoints.ApiEndpointAdo, (client) =>
{
client.Timeout = TimeSpan.FromMinutes(ConstatCsro.ClientNames.API_TimeOut_Mins);
client.BaseAddress = new Uri(ApiEndpointAdo);
client.DefaultRequestHeaders.Add("Accept", "application/json");
}).ConfigurePrimaryHttpMessageHandler(() =>
{
return(new HttpClientHandler()
{
AutomaticDecompression = DecompressionMethods.Deflate | DecompressionMethods.GZip | DecompressionMethods.Brotli,
UseCookies = false
});
})
.SetHandlerLifetime(TimeSpan.FromMinutes(5))
.AddPolicyHandler(PollyHelper.GetRetryPolicy())
.AddPolicyHandler(PollyHelper.GetRetryPolicy());
;
const int REPORT_TIME_OUT = 55;
string ApiEndpointReport = Configuration.GetValue <string>(ConstatCsro.EndPoints.ApiEndpointReport);
services.AddHttpClient(ConstatCsro.EndPoints.ApiEndpointReport, (client) =>
{
client.Timeout = TimeSpan.FromMinutes(REPORT_TIME_OUT);
client.BaseAddress = new Uri(ApiEndpointReport);
client.DefaultRequestHeaders.Add("Accept", "application/json");
}).ConfigurePrimaryHttpMessageHandler(() =>
{
return(new HttpClientHandler()
{
AutomaticDecompression = DecompressionMethods.Deflate | DecompressionMethods.GZip | DecompressionMethods.Brotli,
UseCookies = false
});
})
.SetHandlerLifetime(TimeSpan.FromMinutes(REPORT_TIME_OUT))
.AddPolicyHandler(PollyHelper.GetRetryPolicy())
.AddPolicyHandler(PollyHelper.GetRetryPolicy());
;
string ApiEndpointAuth = Configuration.GetValue <string>(ConstatCsro.EndPoints.ApiEndpointAuth);
services.AddHttpClient(ConstatCsro.EndPoints.ApiEndpointAuth, (client) =>
{
client.Timeout = TimeSpan.FromMinutes(ConstatCsro.ClientNames.API_TimeOut_Mins);
client.BaseAddress = new Uri(ApiEndpointAuth);
client.DefaultRequestHeaders.Add("Accept", "application/json");
}).ConfigurePrimaryHttpMessageHandler(() =>
{
return(new HttpClientHandler()
{
AutomaticDecompression = DecompressionMethods.Deflate | DecompressionMethods.GZip | DecompressionMethods.Brotli,
UseCookies = false
});
})
.SetHandlerLifetime(TimeSpan.FromMinutes(5))
.AddPolicyHandler(PollyHelper.GetRetryPolicy())
.AddPolicyHandler(PollyHelper.GetRetryPolicy());
;
services.AddHttpClient(ConstatCsro.ClientNames.MANAGEMENT_AZURE_EndPoint, (client) =>
{
client.Timeout = TimeSpan.FromMinutes(ConstatCsro.ClientNames.MANAGEMENT_TimeOut_Mins);
client.BaseAddress = new Uri(ConstatCsro.ClientNames.MANAGEMENT_AZURE_EndPoint);
client.DefaultRequestHeaders.Add("Accept", "application/json");
}).ConfigurePrimaryHttpMessageHandler(() =>
{
return(new HttpClientHandler()
{
AutomaticDecompression = DecompressionMethods.Deflate | DecompressionMethods.GZip | DecompressionMethods.Brotli,
UseCookies = false
});
})
.SetHandlerLifetime(TimeSpan.FromMinutes(5))
.AddPolicyHandler(PollyHelper.GetRetryPolicy())
.AddPolicyHandler(PollyHelper.GetRetryPolicy());
;
services.AddHttpClient(ConstatAdo.ClientNames.DEVOPS_EndPoint, (client) =>
{
client.Timeout = TimeSpan.FromMinutes(ConstatAdo.ClientNames.MANAGEMENT_TimeOut_Mins);
client.BaseAddress = new Uri(ConstatAdo.ClientNames.DEVOPS_EndPoint);
client.DefaultRequestHeaders.Add("Accept", "application/json");
}).ConfigurePrimaryHttpMessageHandler(() =>
{
return(new HttpClientHandler()
{
AutomaticDecompression = DecompressionMethods.Deflate | DecompressionMethods.GZip | DecompressionMethods.Brotli,
UseCookies = false
});
})
.SetHandlerLifetime(TimeSpan.FromMinutes(5))
.AddPolicyHandler(PollyHelper.GetRetryPolicy())
.AddPolicyHandler(PollyHelper.GetRetryPolicy());
;
#endregion
var distributedTokenCachesConfig = Configuration.GetSection(nameof(DistributedTokenCachesConfig)).Get <DistributedTokenCachesConfig>();
if (distributedTokenCachesConfig != null && distributedTokenCachesConfig.IsEnabled)
{
services.AddAuthentication(OpenIdConnectDefaults.AuthenticationScheme)
.AddMicrosoftIdentityWebApp(Configuration.GetSection("AzureAd"))
//.EnableTokenAcquisitionToCallDownstreamApi() //v1
.EnableTokenAcquisitionToCallDownstreamApi(new List <string> {
"user.read", "openid", "email", "profile", "offline_access", Configuration.GetValue <string>(Core.ConstatCsro.Scopes.Scope_Auth_Api)
})
.AddDistributedTokenCaches();
}
else
{
services.AddAuthentication(OpenIdConnectDefaults.AuthenticationScheme)
.AddMicrosoftIdentityWebApp(Configuration.GetSection("AzureAd"))
//.EnableTokenAcquisitionToCallDownstreamApi() //v1
.EnableTokenAcquisitionToCallDownstreamApi(new List <string> {
"user.read", "openid", "email", "profile", "offline_access", Configuration.GetValue <string>(Core.ConstatCsro.Scopes.Scope_Auth_Api)
})
.AddInMemoryTokenCaches();
}
#region Distributed Token Caches
//services.AddDistributedSqlServerCache(options =>
//{
// options.ConnectionString = Configuration.GetConnectionString(KeyVaultConfig.ConnectionStrings.TokenCacheDb);
// options.SchemaName = "dbo";
// options.TableName = "TokenCache";
// //def is 20 minutes
// if (distributedTokenCachesConfig?.DefaultSlidingExpirationMinutes > 0)
// options.DefaultSlidingExpiration = TimeSpan.FromMinutes(distributedTokenCachesConfig.DefaultSlidingExpirationMinutes);
//});
#endregion
services.Configure <MicrosoftIdentityOptions>(options =>
{
options.ResponseType = OpenIdConnectResponseType.Code;
if (keyVaultConfig.UseKeyVault && !string.IsNullOrWhiteSpace(azureAdOptions.ClientSecret))
{
options.ClientSecret = azureAdOptions.ClientSecret;
}
if (keyVaultConfig.UseKeyVault)
{
_logger.LogSecretVariableValueStartValue(keyVaultConfig.ClientSecretVaultKey, azureAdOptions.ClientSecret);
}
});
services.AddControllersWithViews()
.AddMicrosoftIdentityUI()
.AddFluentValidation(fv =>
{
fv.ImplicitlyValidateChildProperties = true;
fv.RegisterValidatorsFromAssemblyContaining <Services.Validation.BaseAbstractValidator>();
});
services.AddAuthorization(options =>
{
// By default, all incoming requests will be authorized according to the default policy
//Will automatical sign in user
options.FallbackPolicy = options.DefaultPolicy;
//options.AddPolicy(PoliciesCsro.CanApproveAdoRequest, policy => policy.RequireClaim(ClaimTypesCsro.CanApproveAdoRequest, true.ToString()));
foreach (var pol in PoliciesCsro.PolicyClaimsDictionary)
{
options.AddPolicy(pol.Key, policy => policy.RequireClaim(pol.Value.Type, pol.Value.Value));
}
});
services.AddRazorPages();
services.AddServerSideBlazor()
.AddMicrosoftIdentityConsentHandler();
services.AddTransient <IGraphClientService, GraphClientService>();
services.AddTransient <IAuthCsroService, AuthCsroService>();
services.AddTransient <IUserDataService, UserDataService>();
services.AddTransient <IUserClaimDataService, UserClaimDataService>();
services.AddTransient <ICsvExporter, CsvExporter>();
services.AddTransient <IVersionService, VersionService>();
services.AddTransient <IBaseDataService <Ticket>, TicketDataService>();
services.AddTransient <IBaseDataService <VmTicketHistory>, VmTicketHistoryDataService>();
services.AddTransient <IAdoProjectHistoryDataService, AdoProjectHistoryDataService>();
services.AddTransient <IVmTicketDataService, VmTicketDataService>();
services.AddTransient <ISubcriptionDataService, SubcriptionDataService>();
services.AddTransient <ICustomerDataService, CustomerDataService>();
services.AddTransient <IServiceIssueDataService, ServiceIssueDataService>();
services.AddTransient <ISupportAzureService, SupportAzureService>();
services.AddTransient <IRefundSupportTicketDataService, RefundSupportTicketDataService>();
services.AddTransient <IServiceOutageDataService, ServiceOutageDataService>();
services.AddTransient <IServiceOutageSummaryDataService, ServiceOutageSummaryDataService>();
services.AddTransient <IEmailDataService, EmailDataService>();
services.AddTransient <IVmService, VmService>();
services.AddTransient <ISubcriptionService, SubcriptionService>(); //TODO remove
services.AddTransient <IResourceGroupService, ResourceGroupService>();
services.AddTransient <INetworkService, NetworkService>();
services.AddSingleton <ILocationsService, LocationsService>();
services.AddTransient <IAdoProjectDataService, AdoProjectDataService>();
services.AddTransient <IAdoProjectAccessDataService, AdoProjectAccessDataService>();
#region SDK services
services.AddTransient <IVmSdkService, VmSdkService>();
services.AddTransient <ISubscriptionSdkService, SubscriptionSdkService>();
services.AddTransient <IAdService, AdService>();
bool UseChainTokenCredential = Configuration.GetValue <bool>("UseChainTokenCredential");
if (UseChainTokenCredential)
{
services.AddTransient <ICsroTokenCredentialProvider, ChainnedCsroTokenCredentialProvider>(); //for personal
//services.AddTransient<ICsroTokenCredentialProvider, ChainnedCsroTokenCredentialProvider>((op) =>
//{
// var pr = new ChainnedCsroTokenCredentialProvider(azureAdOptions);
// return pr;
//}); //for personal
}
else
{
services.AddTransient <ICsroTokenCredentialProvider, CsroTokenCredentialProvider>(); //for work
}
#endregion
services.AddTransient <IProjectAdoServices, ProjectAdoServices>();
services.AddTransient <IProcessAdoServices, ProcessAdoServices>();
services.AddTransient <ISupportedRegionsService, SupportedRegionsService>();
services.AddSingleton <ICacheProvider, CacheProvider>(); //testing
//UI component for dialods
services.AddTransient <ICsroDialogService, CsroDialogService>();
services.AddMudServices();
//services.AddApplicationInsightsTelemetry(Configuration["APPINSIGHTS_CONNECTIONSTRING"]);
services.AddApplicationInsightsTelemetry();
services.AddHealthChecksUI().AddInMemoryStorage();
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddAutoMapper(AppDomain.CurrentDomain.GetAssemblies());
services.AddMediatR(Assembly.GetExecutingAssembly());
services.AddApplicationServices(Configuration, _env, _logger);
string ApiEndpointAuth = Configuration.GetValue <string>(ConstatCsro.EndPoints.ApiEndpointAuth);
services.AddHttpClient(Core.ConstatCsro.EndPoints.ApiEndpointAuth, (client) =>
{
client.Timeout = TimeSpan.FromMinutes(ConstatCsro.ClientNames.API_TimeOut_Mins);
client.BaseAddress = new Uri(ApiEndpointAuth);
client.DefaultRequestHeaders.Add("Accept", "application/json");
}).ConfigurePrimaryHttpMessageHandler(() =>
{
return(new HttpClientHandler()
{
AutomaticDecompression = DecompressionMethods.Deflate | DecompressionMethods.GZip | DecompressionMethods.Brotli,
UseCookies = false
});
})
.SetHandlerLifetime(TimeSpan.FromMinutes(5))
.AddPolicyHandler(PollyHelper.GetRetryPolicy())
.AddPolicyHandler(PollyHelper.GetRetryPolicy());
;
#region Auth
services.AddAuthorization(options =>
{
// By default, all incoming requests will be authorized according to the default policy
//Will automatical sign in user
//options.FallbackPolicy = options.DefaultPolicy;
options.AddPolicy(PoliciesCsro.CanApproveAdoRequestPolicy, policy => policy.RequireClaim(ClaimTypesCsro.CanApproveAdoRequestClaim, true.ToString()));
});
//TODO replace with rest or GRPC service
services.AddScoped <IRestUserService, RestUserService>();
services.AddScoped <IClaimsTransformation, ClaimsTransformation>();
#endregion
services.AddApplicationInsightsTelemetry();
services.AddControllers();
services.AddMvc(options =>
{
options.Filters.Add(new CsroValidationFilter());
})
.AddFluentValidation(options =>
{
//options.RegisterValidatorsFromAssemblyContaining<Startup>();
options.RegisterValidatorsFromAssemblyContaining <Validation.BaseAdoAbstractValidator>();
});
services.AddScoped <IApiIdentity, ApiIdentity>();
services.AddScoped <IEmailService, EmailService>();
services.AddSingleton <IMessageBus, AzServiceBusMessageBus>();
services.AddTransient <IProjectAdoServices, ProjectAdoServices>();
services.AddTransient <IProcessAdoServices, ProcessAdoServices>();
services.AddSingleton <ICacheProvider, CacheProvider>(); //testing
services.AddTransient <IPropertyMappingService, AdoPropertyMappingService>();
//services.AddSingleton<IServiceBusConsumer, AzServiceBusConsumer>();
services.AddScoped <IAdoProjectApproverService, AdoProjectApproverService>();
services.AddScoped <IGenerateEmailForApprovalService, GenerateEmailForApprovalService>();
services.AddScoped <IAdoProjectAccessRepository, AdoProjectAccessRepository>();
//services.AddControllers(options => options.Filters.Add(new AutoValidateAntiforgeryTokenAttribute()));
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new OpenApiInfo {
Title = _namespace, Version = "v1"
});
});
#region DbContext
DbTypeEnum DbTypeEnum = DbTypeEnum.Unknown;
try
{
DbTypeEnum = Configuration.GetValue <DbTypeEnum>(nameof(DbTypeEnum));
}
catch { }
services.AddDbContext <AdoContext>(options =>
{
if (DbTypeEnum == DbTypeEnum.SqlLite)
{
options.UseSqlite(Configuration.GetConnectionString(KeyVaultConfig.ConnectionStrings.AdoDb), x => x.MigrationsAssembly(_namespace));
}
else if (DbTypeEnum == DbTypeEnum.InMemory)
{
options.UseInMemoryDatabase(databaseName: KeyVaultConfig.ConnectionStrings.AdoDb);
}
else
{
options.UseSqlServer(Configuration.GetConnectionString(KeyVaultConfig.ConnectionStrings.AdoDb), x => x.MigrationsAssembly(_namespace));
}
});
//services.AddDbContext<TokenCacheContext>(options =>
//{
// if (UseSqlLiteDb)
// options.UseSqlite(Configuration.GetConnectionString(KeyVaultConfig.ConnectionStrings.TokenCacheDb));
// else
// options.UseSqlServer(Configuration.GetConnectionString(KeyVaultConfig.ConnectionStrings.TokenCacheDb));
//});
#endregion
#region Repositories
services.AddScoped(typeof(IRepository <>), typeof(AdoRepository <>));
services.AddScoped <IAdoProjectHistoryRepository, AdoProjectHistoryRepository>();
services.AddScoped <IAdoProjectRepository, AdoProjectRepository>();
#endregion
var busConfig = Configuration.GetSection(nameof(BusConfig)).Get <BusConfig>();
if (busConfig == null)
{
_logger.LogWarning($"No {nameof(BusConfig)} found.");
}
else
{
_logger.LogInformation($"{nameof(BusConfig)} is {busConfig} ", busConfig);
//_logger.LogInformation("BusConfig is {busConfig} ", busConfig);
if (busConfig.IsBusEnabled && busConfig.BusTypeEnum == BusTypeEnum.AzureServiceBus)
{
//should be last to hav all dependencies
services.AddHostedService <ProjectApprovalHostedService>(sp =>
{
var serviceProvider = services.BuildServiceProvider();
var apiIdentity = serviceProvider.GetService <IApiIdentity>();
var ctx = serviceProvider.GetService <AdoContext>();
IRepository <AdoProject> obj = new Repository <AdoProject>(ctx, apiIdentity);
var logger = sp.GetService <ILogger <ProjectApprovalHostedService> >();
IGenerateEmailForApprovalService generateEmailForApprovalService = serviceProvider.GetService <IGenerateEmailForApprovalService>();
return(new ProjectApprovalHostedService(generateEmailForApprovalService, logger));
});
services.AddHostedService <AzServiceBusConsumer>(sp =>
{
var serviceProvider = services.BuildServiceProvider();
//var serviceProvider = sp;
var apiIdentity = serviceProvider.GetService <IApiIdentity>();
var ctx = serviceProvider.GetService <AdoContext>();
IRepository <AdoProject> obj = new Repository <AdoProject>(ctx, apiIdentity);
IConfiguration configuration = serviceProvider.GetService <IConfiguration>();
IMessageBus messageBus = serviceProvider.GetService <IMessageBus>();
IMediator mediator = serviceProvider.GetService <IMediator>();
IProjectAdoServices projectAdoServices = serviceProvider.GetService <IProjectAdoServices>();
IAdoProjectRepository adoProjectRepository = serviceProvider.GetService <IAdoProjectRepository>();
IAdoProjectHistoryRepository adoProjectHistoryRepository = serviceProvider.GetService <IAdoProjectHistoryRepository>();
IMapper mapper = serviceProvider.GetService <IMapper>();
ILogger <AzServiceBusConsumer> logger = serviceProvider.GetService <ILogger <AzServiceBusConsumer> >();
return(new AzServiceBusConsumer(configuration, messageBus, mediator, projectAdoServices, adoProjectRepository, adoProjectHistoryRepository, mapper, logger));
});
}
}
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
if (_env.IsDevelopment())
{
;
}
else if (_env.IsStaging())
{
;
}
services.AddAutoMapper(AppDomain.CurrentDomain.GetAssemblies());
services.AddMediatR(Assembly.GetExecutingAssembly());
services.AddApplicationServices(Configuration, _env, _logger);
#region Add HttpClient
services.AddHttpClient(Core.ConstatCsro.ClientNames.MANAGEMENT_AZURE_EndPoint, (client) =>
{
client.Timeout = TimeSpan.FromMinutes(Core.ConstatCsro.ClientNames.MANAGEMENT_TimeOut_Mins);
client.BaseAddress = new Uri(Core.ConstatCsro.ClientNames.MANAGEMENT_AZURE_EndPoint);
client.DefaultRequestHeaders.Add("Accept", "application/json");
}).ConfigurePrimaryHttpMessageHandler(() =>
{
return(new HttpClientHandler()
{
AutomaticDecompression = DecompressionMethods.Deflate | DecompressionMethods.GZip | DecompressionMethods.Brotli,
UseCookies = false
});
})
.SetHandlerLifetime(TimeSpan.FromMinutes(5))
.AddPolicyHandler(PollyHelper.GetRetryPolicy())
.AddPolicyHandler(PollyHelper.GetRetryPolicy());
;
string ApiEndpointAuth = Configuration.GetValue <string>(ConstatCsro.EndPoints.ApiEndpointAuth);
services.AddHttpClient(Core.ConstatCsro.EndPoints.ApiEndpointAuth, (client) =>
{
client.Timeout = TimeSpan.FromMinutes(ConstatCsro.ClientNames.API_TimeOut_Mins);
client.BaseAddress = new Uri(ApiEndpointAuth);
client.DefaultRequestHeaders.Add("Accept", "application/json");
}).ConfigurePrimaryHttpMessageHandler(() =>
{
return(new HttpClientHandler()
{
AutomaticDecompression = DecompressionMethods.Deflate | DecompressionMethods.GZip | DecompressionMethods.Brotli,
UseCookies = false
});
})
.SetHandlerLifetime(TimeSpan.FromMinutes(5))
.AddPolicyHandler(PollyHelper.GetRetryPolicy())
.AddPolicyHandler(PollyHelper.GetRetryPolicy());
;
#endregion
//services.Configure<MicrosoftIdentityOptions>(options =>
//{
// options.ResponseType = OpenIdConnectResponseType.Code;
// if (UseKeyVault && !string.IsNullOrWhiteSpace(azureAdOptions.ClientSecret))
// options.ClientSecret = azureAdOptions.ClientSecret;
// if (UseKeyVault)
// LogSecretVariableValueStartValue(ClientSecretVaultName, azureAdOptions.ClientSecret);
//});
#region Auth
services.AddAuthorization(options =>
{
// By default, all incoming requests will be authorized according to the default policy
//Will automatical sign in user
//options.FallbackPolicy = options.DefaultPolicy;
options.AddPolicy(PoliciesCsro.IsAdminPolicy, policy => policy.RequireClaim(ClaimTypes.Role, RolesCsro.Admin));
});
//TODO replace with rest or GRPC service
services.AddScoped <IRestUserService, RestUserService>();
services.AddScoped <IClaimsTransformation, ClaimsTransformation>();
#endregion
services.AddApplicationInsightsTelemetry();
services.AddControllers();
services.AddMvc(options =>
{
options.Filters.Add(new CsroValidationFilter());
})
.AddFluentValidation(options =>
{
//options.RegisterValidatorsFromAssemblyContaining<Startup>();
options.RegisterValidatorsFromAssemblyContaining <Server.Services.Validation.BaseAbstractValidator>();
});
services.AddScoped <IApiIdentity, ApiIdentity>();
services.AddScoped <IEmailService, EmailService>();
services.AddSingleton <IMessageBus, AzServiceBusMessageBus>();
services.AddTransient <IAzureVmManagementService, AzureVmManagementService>();
services.AddTransient <ISubcriptionService, SubcriptionService>();
services.AddTransient <ISubcriptionSPNService, SubcriptionSPNService>();
services.AddTransient <IResourceGroupervice, ResourceGroupervice>();
services.AddTransient <ISubcriptionRepository, SubcriptionRepository>();
services.AddSingleton <ICacheProvider, CacheProvider>(); //testing
//services.AddApplicationInsightsTelemetry(Configuration["APPINSIGHTS_CONNECTIONSTRING"]);
//services.AddControllers(options => options.Filters.Add(new AutoValidateAntiforgeryTokenAttribute()));
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new OpenApiInfo {
Title = _namespace, Version = "v1"
});
});
#region SDK services
services.AddTransient <IVmSdkService, VmSdkService>();
services.AddTransient <ISubscriptionSdkService, SubscriptionSdkService>();
services.AddTransient <IAdService, AdService>();
services.AddTransient <IGsnowService, FakeGsnowService>();
bool UseChainTokenCredential = Configuration.GetValue <bool>("UseChainTokenCredential");
if (UseChainTokenCredential)
{
services.AddTransient <ICsroTokenCredentialProvider, ChainnedCsroTokenCredentialProvider>(); //for personal
//services.AddTransient<ICsroTokenCredentialProvider, ChainnedCsroTokenCredentialProvider>((op) =>
//{
// var pr = new ChainnedCsroTokenCredentialProvider(azureAdOptions);
// return pr;
//}); //for personal
}
else
{
services.AddTransient <ICsroTokenCredentialProvider, CsroTokenCredentialProvider>(); //for work
}
#endregion
#region DbContext
DbTypeEnum DbTypeEnum = DbTypeEnum.Unknown;
try
{
DbTypeEnum = Configuration.GetValue <DbTypeEnum>(nameof(DbTypeEnum));
}
catch { }
if (DbTypeEnum == DbTypeEnum.Unknown)
{
throw new Exception($"Unable to read {nameof(DbTypeEnum)} from config. Please set value to SqlServer, InMemory for testing or.....");
}
services.AddDbContext <AppVersionContext>(options =>
{
if (DbTypeEnum == DbTypeEnum.SqlLite)
{
options.UseSqlite(Configuration.GetConnectionString(KeyVaultConfig.ConnectionStrings.ApiDb), x => x.MigrationsAssembly(_namespace));
}
else if (DbTypeEnum == DbTypeEnum.InMemory)
{
options.UseInMemoryDatabase(databaseName: KeyVaultConfig.ConnectionStrings.ApiDb);
}
else
{
options.UseSqlServer(Configuration.GetConnectionString(KeyVaultConfig.ConnectionStrings.ApiDb), x => x.MigrationsAssembly(_namespace));
}
});
services.AddDbContext <CustomersDbContext>(options =>
{
var cs = Configuration.GetConnectionString(KeyVaultConfig.ConnectionStrings.CustomerDb);
if (DbTypeEnum == DbTypeEnum.SqlLite)
{
options.UseSqlite(Configuration.GetConnectionString(KeyVaultConfig.ConnectionStrings.CustomerDb), x => x.MigrationsAssembly(_namespace));
}
else if (DbTypeEnum == DbTypeEnum.InMemory)
{
options.UseInMemoryDatabase(databaseName: KeyVaultConfig.ConnectionStrings.CustomerDb);
}
else //SqlServer
{
options.UseSqlServer(Configuration.GetConnectionString(KeyVaultConfig.ConnectionStrings.CustomerDb), x => x.MigrationsAssembly(_namespace));
}
});
//services.AddDbContext<TokenCacheContext>(options =>
//{
// if (DbTypeEnum == DbTypeEnum.SqlLite)
// options.UseSqlite(Configuration.GetConnectionString(KeyVaultConfig.ConnectionStrings.TokenCacheDb));
// else
// options.UseSqlServer(Configuration.GetConnectionString(KeyVaultConfig.ConnectionStrings.TokenCacheDb));
//});
#endregion
#region Repositories
services.AddScoped(typeof(IRepository <>), typeof(AppRepository <>));
services.AddScoped <ITicketRepository, TicketRepository>();
services.AddScoped <IVersionRepository, VersionRepository>();
services.AddScoped <IVmTicketRepository, VmTicketRepository>();
services.AddScoped <ICustomerRepository, CustomerRepository>();
services.AddScoped <IVmTicketHistoryRepository, VmTicketHistoryRepository>();
#endregion
var busConfig = Configuration.GetSection(nameof(BusConfig)).Get <BusConfig>();
if (busConfig == null)
{
_logger.LogWarning($"No {nameof(BusConfig)} found.");
}
else
{
_logger.LogInformation($"{nameof(BusConfig)} is {busConfig} ", busConfig);
if (busConfig.IsBusEnabled && busConfig.BusTypeEnum == BusTypeEnum.AzureServiceBus)
{
services.AddHostedService <AzServiceBusConsumer>(sp =>
{
//var serviceProvider = sp;
var serviceProvider = _serviceProvider;
//var apiIdentity = serviceProvider.GetService<IApiIdentity>();
//var ctx = serviceProvider.GetService<AdoContext>();
//IRepository<AdoProject> obj = new Repository<AdoProject>(ctx, apiIdentity);
IConfiguration configuration = serviceProvider.GetService <IConfiguration>();
IMessageBus messageBus = serviceProvider.GetService <IMessageBus>();
IMediator mediator = serviceProvider.GetService <IMediator>();
IMapper mapper = serviceProvider.GetService <IMapper>();
ILogger <AzServiceBusConsumer> logger = serviceProvider.GetService <ILogger <AzServiceBusConsumer> >();
return(new AzServiceBusConsumer(configuration, messageBus, mediator, mapper, logger));
});
}
}
services.AddHealthChecks().AddDbContextCheck <CustomersDbContext>("Customers DB");
services.AddHealthChecks().AddDbContextCheck <AppVersionContext>("Api DB");
if (busConfig != null && busConfig.IsBusEnabled && busConfig.BusTypeEnum == BusTypeEnum.AzureServiceBus)
{
services.AddHealthChecks()
.AddAzureServiceBusTopicHealthCheck(Configuration["ConnectionStrings:AzureServiceBus"],
Configuration["ServiceBusConfig:VmOperationRequesTopic"], "ServiceBus: Vm Operation Topic", HealthStatus.Unhealthy);
}
_serviceProvider = services.BuildServiceProvider();
}
public bool MergeFile(string fileName, out bool result, out string storeFileName)
{
result = false;
storeFileName = string.Empty;
var fileNamePartToken = fileName.IndexOf(PARTTOKEN);
var baseFileName = fileName.Substring(0, fileNamePartToken);
var trailingTokens = fileName.Substring(fileNamePartToken + PARTTOKEN.Length);
var fileIndex = 0;
var fileCount = 0;
int.TryParse(trailingTokens.Substring(0, trailingTokens.IndexOf(".")), out fileIndex);
int.TryParse(trailingTokens.Substring(0, trailingTokens.IndexOf(".")), out fileCount);
var searchPattern = Path.GetFileName(baseFileName) + PARTTOKEN + "*";
var filesList = FileHelper.GetFiles(Path.GetDirectoryName(fileName), searchPattern);
if (filesList.Count() == fileCount)
{
var extensionName = FileHelper.GetExtensionName(baseFileName);
storeFileName = FileHelper.GetFileNameWithoutExtension(baseFileName) + extensionName;
}
if (!MergeFileSingleton.Instance.InUse(baseFileName))
{
MergeFileSingleton.Instance.AddFile(baseFileName);
if (FileHelper.Exist(baseFileName))
{
FileHelper.Delete(baseFileName);
}
var mergeList = new List <SortedFile>();
foreach (var file in filesList)
{
var sortedFile = new SortedFile
{
FileName = file
};
baseFileName = file.Substring(0, file.IndexOf(PARTTOKEN));
trailingTokens = file.Substring(file.IndexOf(PARTTOKEN) + PARTTOKEN.Length);
int.TryParse(trailingTokens.Substring(0, trailingTokens.IndexOf(".")), out fileIndex);
sortedFile.FileOrder = fileIndex;
mergeList.Add(sortedFile);
}
var mergeOrder = mergeList.OrderBy(s => s.FileOrder).ToList();
using (var fileStream = new FileStream(baseFileName, FileMode.Create))
{
try
{
foreach (var chunk in mergeOrder)
{
PollyHelper.WaitAndRetry <IOException>(() =>
{
using (var fileChunk = new FileStream(chunk.FileName, FileMode.Open))
{
fileChunk.CopyTo(fileStream);
}
});
}
}
catch (IOException e)
{
return(false);
throw e;
}
}
result = true;
MergeFileSingleton.Instance.RemoveFile(baseFileName);
Parallel.ForEach(mergeList, (d) => { FileHelper.Delete(d.FileName); });
}
return(result);
}
