private void Reason(RuleRecord record)
{
foreach (var item in record.Reason)
{
_Logger.WriteObject(string.Concat("##vso[task.logissue type=error]- ", item), false);
}
}
protected override void FailWithError(RuleRecord record)
{
BreakIfUnbrokenInfo();
WriteLine(string.Concat(" [-] ", record.RuleName));
ErrorDetail(record);
UnbrokenContent();
}
public Task CreateOrUpdateRuleRecordAsync(RuleRecord record, CancellationToken cancellationToken = default)
=> CreateOrUpdateItemAsync(
record,
pk: CONNECTION_PREFIX + record.ConnectionId,
sk: RULE_PREFIX + record.Rule,
cancellationToken
);
private void Reason(RuleRecord record)
{
foreach (var item in record.Reason)
{
_Logger.WriteObject(string.Concat("::error:: - ", item), false);
}
}
protected override void FailWithError(RuleRecord record)
{
BreakIfUnbrokenInfo();
WriteLine(string.Format(FormatterStrings.Client_Error, record.RuleName), forgroundColor: ConsoleColor.Red);
ErrorDetail(record);
UnbrokenContent();
}
protected override void FailWithError(RuleRecord record)
{
BreakIfUnbrokenInfo();
WriteLine(string.Format(FormatterStrings.Plain_Fail, record.RuleName));
ErrorDetail(record);
UnbrokenContent();
}
public RuleRecord CreateRule(string name)
{
var ruleRecord = new RuleRecord {
Name = name
};
_ruleRepository.Create(ruleRecord);
return(ruleRecord);
}
protected override void ErrorDetail(RuleRecord record)
{
if (record.Error == null)
{
return;
}
Error(string.Format(FormatterStrings.AzurePipelines_Error, record.TargetName, record.RuleName, record.Error.Message));
LineBreak();
WriteLine(record.Error.ScriptStackTrace);
}
private void GetError(RuleRecord record)
{
if (record.Error == null)
{
return;
}
Error(string.Format(FormatterStrings.AzurePipelines_Error, record.TargetName, record.RuleName, record.Error.Message));
Write();
Write(record.Error.ScriptStackTrace);
}
public static RuleRecord ParseRules(string input)
{
var rules = new Dictionary <string, Rule>();
foreach (var line in input.Split(Environment.NewLine))
{
var split = line.Split(":");
rules.Add(split[0], RuleRecord.ParseRule(split[0], split[1]));
}
return(new RuleRecord(rules));
}
/// <summary>
/// Initializes a new instance of the <see cref="CreateRuleInput" /> class.
/// </summary>
/// <param name="Rule">Rule (required).</param>
public CreateRuleInput(RuleRecord Rule = null)
{
// to ensure "Rule" is required (not null)
if (Rule == null)
{
throw new InvalidDataException("Rule is a required property for CreateRuleInput and cannot be null");
}
else
{
this.Rule = Rule;
}
}
protected void WriteErrorInfo(RuleRecord record)
{
if (record == null || record.Error == null)
{
return;
}
WriteError(new ErrorRecord(
record.Error.Exception,
record.Error.ErrorId,
record.Error.Category,
record.TargetName
));
}
protected override void FailDetail(RuleRecord record)
{
LineBreak();
WriteLine(FormatterStrings.Recommend, forgroundColor: ConsoleColor.Cyan);
WriteLines(record.Recommendation, prefix: FormatterStrings.RecommendPrefix, forgroundColor: ConsoleColor.Cyan);
if (record.Reason != null && record.Reason.Length > 0)
{
LineBreak();
WriteLine(FormatterStrings.Reason, forgroundColor: ConsoleColor.Cyan);
for (var i = 0; i < record.Reason.Length; i++)
{
WriteLines(record.Reason[i], prefix: FormatterStrings.ReasonPrefix, forgroundColor: ConsoleColor.Cyan);
}
}
LineBreak();
}
/// <summary>
/// Add a record to the result.
/// </summary>
/// <param name="ruleRecord">The record after processing a rule.</param>
internal void Add(RuleRecord ruleRecord)
{
_Outcome = GetWorstCase(ruleRecord.Outcome);
_Time += ruleRecord.Time;
_Total++;
if (ruleRecord.Outcome == RuleOutcome.Error)
{
_Error++;
}
if (ruleRecord.Outcome == RuleOutcome.Fail)
{
_Fail++;
}
_Record.Add(ruleRecord);
}
protected virtual void FailDetail(RuleRecord record)
{
if (!string.IsNullOrEmpty(record.Recommendation))
{
LineBreak();
WriteLine(FormatterStrings.Recommend);
WriteLines(record.Recommendation, prefix: FormatterStrings.RecommendPrefix);
}
if (record.Reason != null && record.Reason.Length > 0)
{
LineBreak();
WriteLine(FormatterStrings.Reason);
for (var i = 0; i < record.Reason.Length; i++)
{
WriteLines(record.Reason[i], prefix: FormatterStrings.ReasonPrefix);
}
}
LineBreak();
}
/// <summary>
/// Initializes a new instance of the <see cref="UpdateRuleResult" /> class.
/// </summary>
/// <param name="Hdr">Hdr (required).</param>
/// <param name="UpdatedRule">UpdatedRule (required).</param>
public UpdateRuleResult(ResponseHeaderRecord Hdr = null, RuleRecord UpdatedRule = null)
{
// to ensure "Hdr" is required (not null)
if (Hdr == null)
{
throw new InvalidDataException("Hdr is a required property for UpdateRuleResult and cannot be null");
}
else
{
this.Hdr = Hdr;
}
// to ensure "UpdatedRule" is required (not null)
if (UpdatedRule == null)
{
throw new InvalidDataException("UpdatedRule is a required property for UpdateRuleResult and cannot be null");
}
else
{
this.UpdatedRule = UpdatedRule;
}
}
/// <summary>
/// Exit the rule block scope.
/// </summary>
public void ExitRuleBlock()
{
// Stop rule execution time
_RuleTimer.Stop();
RuleRecord.Time = _RuleTimer.ElapsedMilliseconds;
if (!RuleRecord.IsSuccess())
{
RuleRecord.Reason = _Reason.ToArray();
}
if (_Logger != null)
{
_Logger.ExitScope();
}
_LogPrefix = null;
RuleRecord = null;
RuleBlock = null;
_Reason.Clear();
}
/// <summary>
/// Initializes a new instance of the <see cref="CreateRuleResult" /> class.
/// </summary>
/// <param name="SavedRule">SavedRule (required).</param>
/// <param name="Hdr">Hdr (required).</param>
public CreateRuleResult(RuleRecord SavedRule = null, ResponseHeaderRecord Hdr = null)
{
// to ensure "SavedRule" is required (not null)
if (SavedRule == null)
{
throw new InvalidDataException("SavedRule is a required property for CreateRuleResult and cannot be null");
}
else
{
this.SavedRule = SavedRule;
}
// to ensure "Hdr" is required (not null)
if (Hdr == null)
{
throw new InvalidDataException("Hdr is a required property for CreateRuleResult and cannot be null");
}
else
{
this.Hdr = Hdr;
}
}
private void VisitRecord(RuleRecord record)
{
if (record == null)
{
return;
}
WriteColumn(record.RuleName);
_Builder.Append(COMMA);
WriteColumn(record.TargetName);
_Builder.Append(COMMA);
WriteColumn(record.TargetType);
_Builder.Append(COMMA);
WriteColumn(record.Outcome.ToString());
_Builder.Append(COMMA);
WriteColumn(record.OutcomeReason.ToString());
_Builder.Append(COMMA);
WriteColumn(record.Info.Synopsis);
_Builder.Append(COMMA);
WriteColumn(record.Info.Recommendation);
_Builder.Append(Environment.NewLine);
}
/// <summary>
/// Enter the rule block scope.
/// </summary>
public RuleRecord EnterRuleBlock(RuleBlock ruleBlock)
{
_Binder.Bind(Baseline, TargetObject);
RuleBlock = ruleBlock;
RuleRecord = new RuleRecord(
ruleId: ruleBlock.RuleId,
ruleName: ruleBlock.RuleName,
targetObject: TargetObject,
targetName: _Binder.TargetName,
targetType: _Binder.TargetType,
tag: ruleBlock.Tag,
info: ruleBlock.Info,
field: _Binder.Field
);
if (_Logger != null)
{
_Logger.EnterScope(ruleBlock.RuleName);
}
// Starts rule execution timer
_RuleTimer.Restart();
return(RuleRecord);
}
protected override void Fail(RuleRecord record)
{
BreakIfUnbrokenInfo();
WriteLine(string.Format(FormatterStrings.Client_Fail, record.RuleName), forgroundColor: ConsoleColor.Red);
FailDetail(record);
}
protected override void Pass(RuleRecord record)
{
BreakIfUnbrokenInfo();
WriteLine(string.Format(FormatterStrings.Plain_Pass, record.RuleName));
UnbrokenContent();
}
public static int SaveRuleRecord(RuleRecord item)
{
return(DukappRepository.SaveRuleRecord(item));
}
protected override void FailDetail(RuleRecord record)
{
base.FailDetail(record);
Error(string.Format(FormatterStrings.GitHubActions_Fail, record.TargetName, record.RuleName, record.Info.Synopsis));
LineBreak();
}
protected override void Fail(RuleRecord record)
{
BreakIfUnbrokenInfo();
WriteLine(string.Format(FormatterStrings.Plain_Fail, record.RuleName));
FailDetail(record);
}
protected override void Pass(RuleRecord record)
{
BreakIfUnbrokenInfo();
WriteLine(string.Format(FormatterStrings.Client_Pass, record.RuleName), forgroundColor: ConsoleColor.Green);
UnbrokenContent();
}
protected override void Fail(RuleRecord record)
{
BreakIfUnbrokenInfo();
WriteLine(string.Concat(" [-] ", record.RuleName));
FailDetail(record);
}
protected override void Pass(RuleRecord record)
{
BreakIfUnbrokenInfo();
WriteLine(string.Concat(" [+] ", record.RuleName));
UnbrokenContent();
}
private string GetReason(RuleRecord record)
{
return(string.Join(" ", record.Reason));
}
protected virtual void ErrorDetail(RuleRecord record)
{
}
