private void ExecuteBulkInsertAI(OrderingSettings settings, ILogger <OrderingContextSeed> logger)
{
const string insertBuyers = @"BULK INSERT [Microsoft.eShopOnContainers.Services.OrderingDb].ordering.buyers
FROM '\var\opt\bulk\orderBuyers.csv' WITH (FORMAT='CSV', FIRSTROW=2)";
const string insertOrders = @"BULK INSERT [Microsoft.eShopOnContainers.Services.OrderingDb].ordering.orders
FROM '\var\opt\bulk\orders.csv' WITH (FORMAT='CSV', FIRSTROW=2)";
const string insertOrderItems = @"BULK INSERT [Microsoft.eShopOnContainers.Services.OrderingDb].ordering.orderItems
FROM '\var\opt\bulk\orderItems.csv' WITH (FORMAT='CSV', FIRSTROW=2)";
using (var conn = new SqlConnection(settings.ConnectionString))
{
try
{
conn.Open();
conn.Execute(insertBuyers);
conn.Execute(insertOrders);
conn.Execute(insertOrderItems);
}
catch (SqlException exception)
{
logger.LogCritical($"FATAL ERROR: Database connections could not be opened: {exception.Message}");
}
}
}
private static void ProcessUsings(SyntaxNodeAnalysisContext context, OrderingSettings orderingSettings, SyntaxList <UsingDirectiveSyntax> usings)
{
var usingDirectives = new List <UsingDirectiveSyntax>();
var systemUsingDirectives = new List <UsingDirectiveSyntax>();
foreach (var usingDirective in usings)
{
if (usingDirective.IsPrecededByPreprocessorDirective())
{
CheckIncorrectlyOrderedUsingsAndReportDiagnostic(context, usingDirectives);
CheckIncorrectlyOrderedUsingsAndReportDiagnostic(context, systemUsingDirectives);
usingDirectives.Clear();
systemUsingDirectives.Clear();
}
if (IsAliasOrStaticUsingDirective(usingDirective))
{
continue;
}
if (usingDirective.HasNamespaceAliasQualifier() ||
!usingDirective.IsSystemUsingDirective() ||
!orderingSettings.SystemUsingDirectivesFirst)
{
usingDirectives.Add(usingDirective);
}
else
{
systemUsingDirectives.Add(usingDirective);
}
}
CheckIncorrectlyOrderedUsingsAndReportDiagnostic(context, usingDirectives);
CheckIncorrectlyOrderedUsingsAndReportDiagnostic(context, systemUsingDirectives);
}
public GracePeriodManagerService(IOptions <OrderingSettings> settings,
IEventBus eventBus,
ILogger <GracePeriodManagerService> logger)
{
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_eventBus = eventBus ?? throw new ArgumentNullException(nameof(eventBus));
_settings = settings?.Value ?? throw new ArgumentNullException(nameof(settings));
}
public GracePeriodManagerService(IOptions <OrderingSettings> settings,
IEndpointInstance endpoint,
ILogger <GracePeriodManagerService> logger)
{
_endpoint = endpoint;
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_settings = settings?.Value ?? throw new ArgumentNullException(nameof(settings));
}
public OrderStatusChangedToStockConfirmedDomainEventHandler(
IOrderRepository orderRepository, ILoggerFactory logger,
IOrderingIntegrationEventService orderingIntegrationEventService,
IOptionsSnapshot <OrderingSettings> settings)
{
_orderRepository = orderRepository ?? throw new ArgumentNullException(nameof(orderRepository));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_orderingIntegrationEventService = orderingIntegrationEventService;
_settings = settings.Value;
}
public GracePeriod(IOptions <OrderingSettings> settings)
{
this.settings = settings?.Value ?? throw new ArgumentNullException(nameof(settings));
}
private static void CheckUsingDeclarations(SyntaxNodeAnalysisContext context, OrderingSettings orderingSettings, SyntaxList <UsingDirectiveSyntax> usingDirectives)
{
UsingDirectiveSyntax lastStaticUsingDirective = null;
UsingDirectiveSyntax lastSystemStaticUsingDirective = null;
UsingDirectiveSyntax firstNonSystemUsing = null;
foreach (var usingDirective in usingDirectives)
{
if (usingDirective.IsPrecededByPreprocessorDirective())
{
lastStaticUsingDirective = null;
lastSystemStaticUsingDirective = null;
firstNonSystemUsing = null;
}
if (usingDirective.StaticKeyword.IsKind(SyntaxKind.StaticKeyword))
{
if (orderingSettings.SystemUsingDirectivesFirst && usingDirective.IsSystemUsingDirective())
{
if (firstNonSystemUsing != null)
{
context.ReportDiagnostic(Diagnostic.Create(
Descriptor,
firstNonSystemUsing.GetLocation(),
new[] { firstNonSystemUsing.Name.ToNormalizedString(), usingDirective.Name.ToNormalizedString() }));
return;
}
if (lastSystemStaticUsingDirective != null)
{
var firstName = lastSystemStaticUsingDirective.Name;
var secondName = usingDirective.Name;
if (NameSyntaxHelpers.Compare(firstName, secondName) > 0)
{
context.ReportDiagnostic(Diagnostic.Create(
Descriptor,
lastSystemStaticUsingDirective.GetLocation(),
new[] { firstName.ToNormalizedString(), secondName.ToNormalizedString() }));
return;
}
}
lastSystemStaticUsingDirective = usingDirective;
}
else
{
if (lastStaticUsingDirective != null)
{
var firstName = lastStaticUsingDirective.Name;
var secondName = usingDirective.Name;
if (NameSyntaxHelpers.Compare(firstName, secondName) > 0)
{
context.ReportDiagnostic(Diagnostic.Create(
Descriptor,
lastStaticUsingDirective.GetLocation(),
new[] { firstName.ToNormalizedString(), secondName.ToNormalizedString() }));
return;
}
}
lastStaticUsingDirective = usingDirective;
firstNonSystemUsing = firstNonSystemUsing ?? usingDirective;
}
}
}
}
private static async Task <Document> GetTransformedDocumentAsync(Document document, SyntaxNode syntaxRoot, CancellationToken cancellationToken)
{
var compilationUnit = (CompilationUnitSyntax)syntaxRoot;
var settings = SettingsHelper.GetStyleCopSettings(document.Project.AnalyzerOptions, cancellationToken);
var semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
var indentationOptions = IndentationOptions.FromDocument(document);
var usingsHelper = new UsingsHelper(settings, semanticModel, document, compilationUnit);
var namespaceCount = CountNamespaces(compilationUnit.Members);
// Only move using declarations inside the namespace when
// - There are no global attributes
// - There is only a single namespace declared at the top level
// - OrderingSettings.UsingDirectivesPlacement is set to InsideNamespace
UsingDirectivesPlacement usingDirectivesPlacement;
OrderingSettings orderingSettings = SettingsHelper.GetStyleCopSettings(document.Project.AnalyzerOptions, cancellationToken).OrderingRules;
switch (orderingSettings.UsingDirectivesPlacement)
{
case UsingDirectivesPlacement.InsideNamespace:
if (compilationUnit.AttributeLists.Any() ||
compilationUnit.Members.Count > 1 ||
namespaceCount > 1)
{
// Override the user's setting with a more conservative one
usingDirectivesPlacement = UsingDirectivesPlacement.Preserve;
}
else if (namespaceCount == 0)
{
usingDirectivesPlacement = UsingDirectivesPlacement.OutsideNamespace;
}
else
{
usingDirectivesPlacement = UsingDirectivesPlacement.InsideNamespace;
}
break;
case UsingDirectivesPlacement.OutsideNamespace:
usingDirectivesPlacement = UsingDirectivesPlacement.OutsideNamespace;
break;
case UsingDirectivesPlacement.Preserve:
default:
usingDirectivesPlacement = UsingDirectivesPlacement.Preserve;
break;
}
string usingsIndentation;
if (usingDirectivesPlacement == UsingDirectivesPlacement.InsideNamespace)
{
var rootNamespace = compilationUnit.Members.OfType <NamespaceDeclarationSyntax>().First();
var indentationLevel = IndentationHelper.GetIndentationSteps(indentationOptions, rootNamespace);
usingsIndentation = IndentationHelper.GenerateIndentationString(indentationOptions, indentationLevel + 1);
}
else
{
usingsIndentation = string.Empty;
}
// - The strategy is to strip all using directive that are not inside a conditional directive and replace them later with a sorted list at the correct spot
// - The using directives that are inside a conditional directive are replaced (in sorted order) on the spot.
// - Conditional directives are not moved, as correctly parsing them is too tricky
// - No using directives will be stripped when there are multiple namespaces. In that case everything is replaced on the spot.
List <UsingDirectiveSyntax> stripList;
var replaceMap = new Dictionary <UsingDirectiveSyntax, UsingDirectiveSyntax>();
// When there are multiple namespaces, do not move using statements outside of them, only sort.
if (usingDirectivesPlacement == UsingDirectivesPlacement.Preserve)
{
BuildReplaceMapForNamespaces(usingsHelper, replaceMap, indentationOptions, false);
stripList = new List <UsingDirectiveSyntax>();
}
else
{
stripList = usingsHelper.GetContainedUsings(usingsHelper.RootSpan);
}
BuildReplaceMapForConditionalDirectives(usingsHelper, replaceMap, indentationOptions, usingsHelper.RootSpan);
var usingSyntaxRewriter = new UsingSyntaxRewriter(stripList, replaceMap);
var newSyntaxRoot = usingSyntaxRewriter.Visit(syntaxRoot);
if (usingDirectivesPlacement == UsingDirectivesPlacement.InsideNamespace)
{
newSyntaxRoot = AddUsingsToNamespace(newSyntaxRoot, usingsHelper, usingsIndentation, replaceMap.Any());
}
else if (usingDirectivesPlacement == UsingDirectivesPlacement.OutsideNamespace)
{
newSyntaxRoot = AddUsingsToCompilationRoot(newSyntaxRoot, usingsHelper, usingsIndentation, replaceMap.Any());
}
// Final cleanup
newSyntaxRoot = StripMultipleBlankLines(newSyntaxRoot);
newSyntaxRoot = ReAddFileHeader(syntaxRoot, newSyntaxRoot);
var newDocument = document.WithSyntaxRoot(newSyntaxRoot.WithoutFormatting());
return(newDocument);
}
