public ICodeDescriptor Generate(IModelGeneratorContext context, EnumType enumType)
{
var values = new List <EnumValueDescriptor>();
foreach (EnumValue value in enumType.Values)
{
IDirective directive = value.Directives.FirstOrDefault(t =>
t.Name.Equals(GeneratorDirectives.Name) &&
t.GetArgument <string>(GeneratorDirectives.ValueArgument) != null);
string name = directive is null
? GetPropertyName(value.Name.ToLowerInvariant())
: directive.GetArgument <string>(GeneratorDirectives.ValueArgument);
values.Add(new EnumValueDescriptor(name, value.Name));
}
NameString typeName = context.GetOrCreateName(
enumType.SyntaxNode,
GetClassName(enumType.Name));
var descriptor = new EnumDescriptor(
typeName,
context.Namespace,
values);
context.Register(descriptor);
return(descriptor);
}
private async Task <bool> ProcessDefinedDirectives(ICliContext context)
{
bool isInteractiveMode = context.IsInteractiveMode;
IReadOnlyList <DirectiveInput> directives = context.Input.Directives;
foreach (DirectiveInput directiveInput in directives)
{
// Try to get the directive matching the input or fallback to default
DirectiveSchema directive = context.RootSchema.TryFindDirective(directiveInput.Name) ?? throw EndUserTypinExceptions.UnknownDirectiveName(directiveInput);
if (!isInteractiveMode && directive.InteractiveModeOnly)
{
throw EndUserTypinExceptions.InteractiveModeDirectiveNotAvailable(directiveInput.Name);
}
// Get directive instance
IDirective instance = (IDirective)_serviceProvider.GetRequiredService(directive.Type);
await instance.HandleAsync(context.Console);
if (!instance.ContinueExecution)
{
return(false);
}
}
return(true);
}
private static void AddDirective(IDirective directive)
{
foreach (string name in directive.DirectiveNames)
{
AllDirectives.TryAdd(name, directive);
}
}
public void AnnotateCostToObjectFieldCodeFirstTwoMultiplier()
{
// arrange
// act
var schema = Schema.Create(
t =>
{
t.RegisterQueryType(new ObjectType(
o => o.Name("Query")
.Field("field")
.Argument("a", a => a.Type <StringType>())
.Type <StringType>()
.Cost(5, "a", "b")));
t.RegisterDirective <CostDirectiveType>();
t.Use(next => context => Task.CompletedTask);
});
ObjectType query = schema.GetType <ObjectType>("Query");
IDirective directive = query.Fields["field"].Directives
.Single(t => t.Name == "cost");
CostDirective obj = directive.ToObject <CostDirective>();
Assert.Equal(5, obj.Complexity);
Assert.Collection(obj.Multipliers,
t => Assert.Equal("a", t),
t => Assert.Equal("b", t));
}
private void InvokeDirectiveAdded(IDirective directive)
{
if (DirectiveAdded != null)
{
DirectiveAdded(this, new DirectiveEventArgs(directive));
}
}
public static Tuple <bool, object> Render(IDirective directive, string rawValue)
{
Property objectProperty =
new Property(directive, rawValue);
return(objectProperty.Render());
}
public void Attach(HostManifest host, IDirective directive)
{
_host = host;
_directive = (T)directive;
_diagnostics.LogDirective(host, directive);
}
public void AnnotateCostToInterfaceFieldSchemaFirst()
{
// arrange
// act
var schema = SchemaBuilder.New()
.AddDocumentFromString(
@"
type Query {
field(a: Int): String
@cost(complexity: 5 multipliers: [""a""])
}
interface IQuery {
field(a: Int): String
@cost(complexity: 5 multipliers: [""a""])
}
")
.AddDirectiveType <CostDirectiveType>()
.Use(next => context => Task.CompletedTask)
.Create();
InterfaceType queryInterface = schema.GetType <InterfaceType>("IQuery");
IDirective directive =
queryInterface.Fields["field"].Directives.Single(t => t.Name == "cost");
CostDirective obj = directive.ToObject <CostDirective>();
Assert.Equal(5, obj.Complexity);
Assert.Collection(obj.Multipliers, t => Assert.Equal("a", t));
}
private static FieldDelegate BuildComponent(
IDirective directive,
FieldDelegate first)
{
FieldDelegate next = first;
IReadOnlyList <DirectiveMiddleware> components =
directive.MiddlewareComponents;
for (int i = components.Count - 1; i >= 0; i--)
{
DirectiveDelegate component = components[i].Invoke(next);
next = context =>
{
if (HasErrors(context.Result))
{
return(Task.CompletedTask);
}
return(component.Invoke(
new DirectiveContext(context, directive)));
};
}
return(next);
}
/// <summary>
///
/// </summary>
private void GetRecordInstance(WorkPackageClosingDataGridViewRow row,
Audit wp,
NextPerformance nextPerformance = null,
AuditRecord workPackageRecord = null)
{
if (row.ClosingItem == null)
{
return;
}
IDirective currentClosingItem = row.ClosingItem;
if (currentClosingItem is Procedure)
{
row.Record = new DirectiveRecord();
}
if (nextPerformance != null)
{
row.Record.PerformanceNum = nextPerformance.PerformanceNum;
}
if (workPackageRecord != null)
{
row.Record.PerformanceNum = workPackageRecord.PerformanceNumFromStart;
}
row.Record.Parent = currentClosingItem;
row.Record.ParentId = currentClosingItem.ItemId;
row.Record.DirectivePackageId = wp.ItemId;
}
public override MaxComplexityVisitorContext AddField(
IOutputField fieldDefinition,
FieldNode fieldSelection)
{
IDirective directive = fieldDefinition.Directives
.FirstOrDefault(t => t.Type is CostDirectiveType);
int complexity;
CostDirective cost = directive == null
? DefaultCost
: directive.ToObject <CostDirective>();
complexity = Complexity + CalculateComplexity(
new ComplexityContext(
fieldDefinition, fieldSelection,
FieldPath, _variables, cost));
if (complexity > MaxComplexity)
{
MaxComplexity = complexity;
}
return(new MaxComplexityWithMultipliersVisitorContext(
FragmentPath,
FieldPath.Add(fieldDefinition),
this));
}
/// <summary>
/// Создает несохраненного клона (Itemid которого =-1) переданного элемента
/// </summary>
/// <param name="toCopy">Элемент для клонирования (иожет быть равен null)</param>
/// <returns>Склонированный элемент или элемент по умолчанию</returns>
public DirectiveRecord(DirectiveRecord toCopy) : this()
{
if (toCopy == null)
{
return;
}
Completed = toCopy.Completed;
Dispatched = toCopy.Dispatched;
MaintenanceOrganization = toCopy.MaintenanceOrganization;
ODR = toCopy.ODR;
_onLifelength = toCopy.OnLifelength;
_parent = toCopy.Parent;
_parentId = toCopy.ParentId;
_parentType = toCopy.ParentType;
_performanceNum = toCopy.PerformanceNum;
_recordDate = toCopy.RecordDate;
RecordTypeId = toCopy.RecordTypeId;
Reference = toCopy.Reference;
_remarks = toCopy.Remarks;
_directivePackage = toCopy.DirectivePackage;
_directivePackageId = toCopy.DirectivePackageId;
_attachedFile = toCopy.AttachedFile;
}
public override void VisitDirectiveNode(IDirective directiveParam, IHighlightingConsumer context)
{
context.AddHighlighting(new CgHighlighting(CgHighlightingAttributeIds.KEYWORD, directiveParam.HeaderNode.GetDocumentRange()));
context.AddHighlighting(new CgHighlighting(CgHighlightingAttributeIds.PREPPROCESSOR_LINE_CONTENT, directiveParam.ContentNode.GetDocumentRange()));
base.VisitDirectiveNode(directiveParam, context);
}
/// <summary>
/// Определяет значение средней утилизации для выполнения задачи
/// </summary>
/// <param name="source">Задача, для которой нужно определить утилизацию</param>
/// <param name="forecastData">прогнозируемый ресурс выполнения задачи</param>
/// <returns>Значение средней утилизации или null</returns>
public AverageUtilization GetAverageUtillization(IDirective source, ForecastData forecastData = null)
{
if (source == null)
{
return(null);
}
if (forecastData == null)
{
if (source is BaseComponent)
{
return(((BaseComponent)source).AverageUtilization);
}
var a = _aircraftsCore.GetParentAircraft(source);
if (a != null)
{
var aircraftFrame = _componentCore.GetBaseComponentById(a.AircraftFrameId);
return(aircraftFrame.AverageUtilization);
}
var s = _storeCore.GetParentStore(source);
return(s != null ? new AverageUtilization(0, 0) : null);
}
return(forecastData.AverageUtilization);
}
private static void CollectComputeDependencies(
Context context,
IComplexOutputType type,
IOutputField field)
{
IDirective directive = field.Directives[DirectiveNames.Computed]
.FirstOrDefault();
if (directive != null)
{
NameString[] dependantOn = directive
.ToObject <ComputedDirective>()
.DependantOn;
if (dependantOn != null)
{
foreach (string fieldName in dependantOn)
{
if (type.Fields.TryGetField(
fieldName,
out IOutputField dependency))
{
context.Dependencies.Add(new FieldDependency(
type.Name, dependency.Name));
}
}
}
}
}
private static DirectiveNode SerializeDirective(
IDirective directiveType,
ReferencedTypes referenced)
{
referenced.DirectiveNames.Add(directiveType.Name);
return(directiveType.ToNode(true));
}
public void AnnotateCostToInterfaceFieldCodeFirst()
{
// arrange
// act
ISchema schema = SchemaBuilder.New()
.AddQueryType(d => d
.Name("Query")
.Field("field")
.Argument("a", a => a.Type <StringType>())
.Type <StringType>())
.AddInterfaceType(d => d
.Name("IQuery")
.Field("field")
.Argument("a", a => a.Type <StringType>())
.Type <StringType>()
.Cost(5))
.AddDirectiveType <CostDirectiveType>()
.Use(_ => _)
.Create();
InterfaceType queryInterface = schema.GetType <InterfaceType>("IQuery");
IDirective directive = queryInterface.Fields["field"].Directives
.Single(t => t.Name == "cost");
CostDirective obj = directive.ToObject <CostDirective>();
Assert.Equal(5, obj.Complexity);
}
public void AnnotateCostToObjectFieldCodeFirstTwoMultiplier()
{
// arrange
// act
ISchema schema = SchemaBuilder.New()
.AddQueryType(d => d
.Name("Query")
.Field("field")
.Argument("a", a => a.Type <StringType>())
.Type <StringType>()
.Cost(5, "a", "b"))
.AddDirectiveType <CostDirectiveType>()
.Use(_ => _)
.Create();
ObjectType query = schema.GetType <ObjectType>("Query");
IDirective directive = query.Fields["field"].Directives
.Single(t => t.Name == "cost");
CostDirective obj = directive.ToObject <CostDirective>();
Assert.Equal(5, obj.Complexity);
Assert.Collection(obj.Multipliers,
t => Assert.Equal("a", t),
t => Assert.Equal("b", t));
}
public void AnnotateCostToInterfaceFieldCodeFirst()
{
// arrange
// act
var schema = Schema.Create(
t =>
{
t.RegisterQueryType(new ObjectType(
o => o.Name("Query")
.Field("field")
.Argument("a", a => a.Type <StringType>())
.Type <StringType>()));
t.RegisterType(new InterfaceType(
o => o.Name("IQuery")
.Field("field")
.Argument("a", a => a.Type <StringType>())
.Type <StringType>()
.Cost(5)));
t.RegisterDirective <CostDirectiveType>();
t.Use(next => context => Task.CompletedTask);
});
InterfaceType queryInterface = schema.GetType <InterfaceType>("IQuery");
IDirective directive = queryInterface.Fields["field"].Directives
.Single(t => t.Name == "cost");
CostDirective obj = directive.ToObject <CostDirective>();
Assert.Equal(5, obj.Complexity);
}
public async Task <AverageUtilization> GetAverageUtillization(IDirective source)
{
if (source == null)
{
return(null);
}
if (source is BaseComponentView)
{
return(((BaseComponentView)source).AverageUtilization);
}
var a = await _aircraftRepository.GetParentAircraftAsync(source);
if (a != null)
{
var aircraftFrame = await _componentRepository.GetBaseComponentByIdAsync(a.AircraftFrameId);
return(aircraftFrame.AverageUtilization);
}
//var s = await _storeCore.GetParentStoreAsync(source);
//return s != null ? new AverageUtilization(0, 0) : null;
return(new AverageUtilization(0, 0));
}
public void AddDirective(IDirective directive)
{
if (Directives == null)
{
Directives = new List <IDirective>();
}
Directives.Add(directive);
}
public void Add_Directive_ShouldThrowArgumentNullExceptionWhenDirectiveIsNull()
{
const IDirective directive = null;
var actualException = Assert.Throws <ArgumentNullException>(() => _plan.Add(directive));
Assert.Equal(nameof(directive), actualException.ParamName);
}
public void ConcludeDirective(IDirective directive)
{
if (directive.GetType () == typeof(MoveDirective)) {
CreatePauseDirective ();
} else {
CreateMoveDirective ();
}
}
public ValidationDirectiveVisitor(IDirective directive,
IServiceProvider services, object value, FieldValidationContext ctx)
{
this.directive = directive;
this.services = services;
this.value = value;
this.ctx = ctx;
}
public DirectiveContext(
IMiddlewareContext middlewareContext,
IDirective directive)
{
_middlewareContext = middlewareContext
?? throw new ArgumentNullException(nameof(middlewareContext));
Directive = directive
?? throw new ArgumentNullException(nameof(directive));
}
///<summary>
///</summary>
///<param name="currentDirective"></param>
///<param name="currentRecord"></param>
public DirectiveComplianceDialog(IDirective currentDirective, DirectiveRecord currentRecord)
: this()
{
_currentDirective = currentDirective;
_currentDirectiveRecord = currentRecord;
_animatedThreadWorker.DoWork += AnimatedThreadWorkerDoLoad;
_animatedThreadWorker.RunWorkerCompleted += BackgroundWorkerRunWorkerLoadCompleted;
}
public void Enqueue(Player player, IDirective directive)
{
if (!_playerQueues.ContainsKey(player))
{
_playerQueues.Add(player, new Queue <IDirective>());
}
_playerQueues[player].Enqueue(directive);
}
public void SetDirective(bool clear, IDirective directive)
{
if (clear)
{
ClearDirective();
}
response.Response.Directives.Add(directive);
}
private void Check(IDirective directive, AbstractPerformanceRecord performance)
{
if (directive.PerformanceRecords.GetLast() != null)
{
if (directive.IsClosed && directive.PerformanceRecords.GetLast().RecordDate > performance.RecordDate)
{
throw new Exception("1629: Can not register performance after directive closing");
}
}
}
///<summary>
///</summary>
///<param name="currentDirective"></param>
///<param name="nextPerformance"></param>
public DirectiveComplianceDialog(IDirective currentDirective, NextPerformance nextPerformance)
: this()
{
_currentDirective = currentDirective;
_currentDirectiveRecord = DirectiveRecord.CreateInstance(nextPerformance);
_nextPerformance = nextPerformance;
_animatedThreadWorker.DoWork += AnimatedThreadWorkerDoLoad;
_animatedThreadWorker.RunWorkerCompleted += BackgroundWorkerRunWorkerLoadCompleted;
}
private bool ExecuteBind()
{
int level = this.Leveling.Level;
IDirective leveledDirective = this;
while (level > 0)
{
leveledDirective = leveledDirective.Parent;
level--;
if (leveledDirective != null)
{
continue;
}
leveledDirective = this;
break;
}
// Execution preparation should be done at the same level with it's parent. Because of that, send parent as parameters
this.Bind.Parameters.Prepare(
parameter =>
{
Tuple <bool, object> result =
Directives.Property.Render(leveledDirective, parameter.Query);
return(result.Item2);
});
Basics.Execution.InvokeResult <object> invokeResult =
Manager.Executer.InvokeBind <object>(Helpers.Context.Request.Header.Method, this.Bind, Manager.ExecuterTypes.Other);
if (invokeResult.Exception != null)
{
throw new Exceptions.ExecutionException(invokeResult.Exception);
}
if (invokeResult.Result is Basics.ControlResult.RedirectOrder redirectOrder)
{
Helpers.Context.AddOrUpdate("RedirectLocation", redirectOrder.Location);
// this.Children.Add(
// new Static(string.Empty));
return(true);
}
string result =
Manager.Executer.GetPrimitiveValue(invokeResult.Result);
if (!string.IsNullOrEmpty(result))
{
this.Children.Add(new Static(result));
}
return(true);
}
void Update()
{
if (directives.Count > 0) {
if (current_directive == null) {
current_directive = directives.OrderBy (i => i.Priority).First ();
current_directive.Execute (this);
} else if (current_directive.IsComplete (this)) {
current_directive.Behavior.ConcludeDirective (current_directive);
directives.Remove (current_directive);
current_directive = null;
}
}
}
private static void AddDirective(IDirective directive)
{
if (string.IsNullOrEmpty(directive.Name))
{
throw new ArgumentException($"The directive {directive.GetType().Name} must have a name");
}
if (string.IsNullOrEmpty(directive.Description))
{
throw new ArgumentException($"The directive {directive.GetType().Name} must have a description");
}
AllDirectives.TryAdd(directive.Name, directive);
if (!string.IsNullOrEmpty(directive.ShortName))
{
AllDirectives.TryAdd(directive.ShortName, directive);
}
}
public void LogDirective(HostManifest host, IDirective directive)
{
LogObject(directive, "Found in '{0}'".ToFormat(host));
LogFor(host).AddChild(directive);
}
public void WriteDirective(IDirective directive)
{
var directiveWriter = new DirectiveWriter(_writer, _types);
directiveWriter.Write(directive);
}
// Take this out of the public interface
public IDirectiveRunner Build(IDirective directive)
{
return _container.ForObject(directive)
.GetClosedTypeOf(typeof (DirectiveRunner<>))
.As<IDirectiveRunner>();
}
public void ConcludeDirective(IDirective directive)
{
throw new NotImplementedException ();
}
public void AddDirective(IDirective directive)
{
//Debug.Log ("Adding new directive");
directives.Add (directive);
}
public IPackageLog LogAction(HostManifest host, IDirective directive, object action, string description)
{
throw new NotImplementedException();
}
public void LogDirective(HostManifest host, IDirective directive)
{
}
