private static void ApplyMetadataAwareAttributes(IEnumerable<Attribute> attributes, ModelMetadata result)
{
foreach (IMetadataAware awareAttribute in attributes.OfType<IMetadataAware>())
{
awareAttribute.OnMetadataCreated(result);
}
}
public IEnumerable<IConceptInfo> CreateNewConcepts(IEnumerable<IConceptInfo> existingConcepts)
{
var newConcepts = new List<IConceptInfo>();
var changesOnChangesItems = existingConcepts.OfType<ChangesOnChangedItemsInfo>()
.Where(change => change.Computation == EntityComputedFrom.Source)
.ToArray();
newConcepts.AddRange(changesOnChangesItems.Select(change =>
new KeepSynchronizedOnChangedItemsInfo { EntityComputedFrom = EntityComputedFrom, UpdateOnChange = change, FilterSaveExpression = FilterSaveExpression }));
// If the computed data source is an extension, but its value does not depend on changes in its base data structure,
// it should still be computed every time the base data structure data is inserted.
var dataSourceExtension = existingConcepts.OfType<DataStructureExtendsInfo>()
.Where(ex => ex.Extension == EntityComputedFrom.Source)
.SingleOrDefault();
if (dataSourceExtension != null
&& dataSourceExtension.Base is IWritableOrmDataStructure
&& !changesOnChangesItems.Any(c => c.DependsOn == dataSourceExtension.Base)
&& !existingConcepts.OfType<ChangesOnBaseItemInfo>().Where(c => c.Computation == EntityComputedFrom.Source).Any())
newConcepts.Add(new ComputeForNewBaseItemsInfo { EntityComputedFrom = EntityComputedFrom, FilterSaveExpression = FilterSaveExpression });
return newConcepts;
}
protected override ModelMetadata CreateMetadata(IEnumerable<Attribute> attributes, Type containerType, Func<object> modelAccessor, Type modelType, string propertyName)
{
ModelMetadata metadata = base.CreateMetadata(attributes, containerType, modelAccessor, modelType,
propertyName);
RegularExpressionAttribute regularExpressionAttribute =
attributes.OfType<RegularExpressionAttribute>().FirstOrDefault();
RangeAttribute rangeAttribute = attributes.OfType<RangeAttribute>().FirstOrDefault();
CurrencyAttribute currencyAttribute = attributes.OfType<CurrencyAttribute>().FirstOrDefault();
StringLengthAttribute stringLengthAttribute = attributes.OfType<StringLengthAttribute>().FirstOrDefault();
MaxLengthAttribute maxLengthAttribute = attributes.OfType<MaxLengthAttribute>().FirstOrDefault();
if (regularExpressionAttribute != null)
metadata.AdditionalValues["RegularExpression"] = regularExpressionAttribute;
if (rangeAttribute != null)
metadata.AdditionalValues["Range"] = rangeAttribute;
if (currencyAttribute != null)
metadata.AdditionalValues["Currency"] = currencyAttribute;
if (stringLengthAttribute != null && maxLengthAttribute == null && stringLengthAttribute.MaximumLength > 0)
metadata.AdditionalValues["MaxLength"] = stringLengthAttribute.MaximumLength;
if (maxLengthAttribute != null)
metadata.AdditionalValues["MaxLength"] = maxLengthAttribute.Length;
return metadata;
}
private void InitializeVariables(IEnumerable<IVariable> variables)
{
ValidateInputProperties();
Index1Variable = variables.OfType<IVariable>().First(v => v.Name == Index1VariableName);
Index2Variable = variables.OfType<IVariable>().First(v => v.Name == Index2VariableName);
XVariable = variables.OfType<IVariable<double>>().First(v => v.Name == XVariableName);
YVariable = variables.OfType<IVariable<double>>().First(v => v.Name == YVariableName);
ValuesVariable = variables.First(v => v.Name == ValuesVariableName);
if(!string.IsNullOrEmpty(TimeVariableName))
{
TimeVariable = variables.First(v => v.Name == TimeVariableName);
}
/*
if(!XVariable.Arguments.SequenceEqual(YVariable.Arguments))
{
throw new NotSupportedException("Arguments used in X variable must be the same as in Y variable");
}
if (!XVariable.Arguments.SequenceEqual(ValuesVariable.Arguments))
{
throw new NotSupportedException("Arguments used in Values variable must be the same as in X and Y variables");
}
*/
}
/// <summary>
/// Populate asynchronously.
/// </summary>
/// <param name="done">The callback.</param>
public void Populate(Action<ISeries> done) {
_series.Populate(() => {
_children = _series.Children.Select(x => new Chapter(x) as IChapter).ToArray();
foreach (var source in _children.OfType<Chapter>()) {
if (source.Number != -1) continue;
var differential = new Dictionary<double, int>();
var origin = null as Chapter;
foreach (var candidate in _children.OfType<Chapter>()) {
if (candidate != source && candidate.Number != -1 && candidate.Volume == source.Volume) {
if (origin != null) {
var difference = Math.Round(candidate.Number - origin.Number, 4);
if (differential.ContainsKey(difference)) {
differential[difference]++;
} else {
differential[difference] = 1;
}
}
origin = candidate;
}
}
if (differential.Count == 0) {
source.Number = origin == null ? 0.5 : origin.Number + origin.Number / 2;
} else {
var shift = differential.OrderByDescending(x => x.Value).FirstOrDefault().Key;
source.Number = Math.Round(origin.Number + (shift <= 0 || shift >= 1 ? 1 : shift) / 2, 4);
}
}
done(this);
});
}
protected override ModelMetadata CreateMetadata(
IEnumerable<Attribute> attributes,
Type containerType,
Func<object> modelAccessor,
Type modelType,
string propertyName)
{
var modelMetadata = base.CreateMetadata(attributes, containerType, modelAccessor, modelType, propertyName);
//attributes.OfType<DataTypeAttribute>().ToList().ForEach(m => { if (m.DataType.Equals(DataType.Date) || (m.DataType.Equals(DataType.Custom) && m.CustomDataType == "DateTimeDto")) modelMetadata.TemplateHint = "DatePicker"; });
attributes.OfType<DataTypeAttribute>().ToList().ForEach(m =>
{
if (m.DataType.Equals(DataType.Custom) &&
(m.CustomDataType == "TimesheetDto"))
modelMetadata.TemplateHint = "TimesheetEditor";
});
attributes.OfType<DataTypeAttribute>().ToList().ForEach(m =>
{
if (m.DataType.Equals(DataType.Custom) &&
(m.CustomDataType == "TimesheetDtoList"))
modelMetadata.TemplateHint = "TimesheetList";
if (m.DataType.Equals(DataType.Custom) &&
(m.CustomDataType == "TerraGraphicDtoList"))
modelMetadata.TemplateHint = "TerraGraphicsList";
});
//attributes.OfType<DataTypeAttribute>().ToList().ForEach(m =>
//{
// if (m.DataType.Equals(DataType.Custom) && (m.CustomDataType == "DropdownDto"))
// modelMetadata.TemplateHint = "Dropdown";
//});
attributes.OfType<MetadataAttribute>().ToList().ForEach(x => x.Process(modelMetadata));
return modelMetadata;
}
protected override ModelMetadata CreateMetadata(IEnumerable<Attribute> attributes, Type containerType,
Func<object> modelAccessor, Type modelType, string propertyName) {
ModelMetadata metadata = base.CreateMetadata(attributes, containerType, modelAccessor, modelType, propertyName);
DisplayAttribute display = attributes.OfType<DisplayAttribute>().FirstOrDefault();
if (display != null) {
string name = display.GetName();
if (name != null) {
metadata.DisplayName = name;
}
metadata.Description = display.GetDescription();
metadata.ShortDisplayName = display.GetShortName();
metadata.Watermark = display.GetPrompt();
}
EditableAttribute editable = attributes.OfType<EditableAttribute>().FirstOrDefault();
if (editable != null) {
metadata.IsReadOnly = !editable.AllowEdit;
}
DisplayFormatAttribute displayFormat = attributes.OfType<DisplayFormatAttribute>().FirstOrDefault();
if (displayFormat != null && !displayFormat.HtmlEncode && String.IsNullOrWhiteSpace(metadata.DataTypeName)) {
metadata.DataTypeName = DataType.Html.ToString();
}
foreach (IMetadataAware awareAttribute in attributes.OfType<IMetadataAware>()) {
awareAttribute.OnMetadataCreated(metadata);
}
return metadata;
}
private static bool IsHiddenBy(IEntity entity, IEnumerable<IEntity> members)
{
var m = entity as IMethod;
if (m != null)
return members.OfType<IMethod>().Any(existing => SameNameAndSignature(m, existing));
return members.OfType<IEntity>().Any(existing => existing.Name == entity.Name);
}
public IEnumerable<IConceptInfo> CreateNewConcepts(IEnumerable<IConceptInfo> existingConcepts)
{
var newConcepts = new List<IConceptInfo>();
var cloneMethod = typeof(object).GetMethod("MemberwiseClone", BindingFlags.NonPublic | BindingFlags.Instance);
var property = (PropertyInfo)cloneMethod.Invoke(Source, null);
property.DataStructure = Destination;
newConcepts.Add(property);
//var destinationEntity = Destination as EntityInfo;
//if (destinationEntity != null)
//{
var required = existingConcepts.OfType<RequiredPropertyInfo>().Where(ci => ci.Property == Source)
.Select(ci => new RequiredPropertyInfo { Property = property })
.SingleOrDefault();
if (required != null)
newConcepts.Add(required);
var destinationProperties = new HashSet<string>(
existingConcepts.OfType<PropertyInfo>()
.Where(ci => ci.DataStructure == Destination)
.Select(ci => ci.Name));
if (SqlIndexMultipleInfo.IsSupported(Destination))
foreach (var sourceIndex in existingConcepts.OfType<SqlIndexMultipleInfo>().Where(ci => ci.Entity == Source.DataStructure))
{
var indexProperties = sourceIndex.PropertyNames.Split(' ');
if (property.Name == indexProperties.FirstOrDefault()
&& indexProperties.Skip(1).All(indexProperty => destinationProperties.Contains(indexProperty)))
newConcepts.Add(new SqlIndexMultipleInfo { Entity = Destination, PropertyNames = sourceIndex.PropertyNames });
}
return newConcepts;
}
private void CacheAttributes(IEnumerable<Attribute> attributes)
{
Display = attributes.OfType<DisplayAttribute>().FirstOrDefault();
DisplayFormat = attributes.OfType<DisplayFormatAttribute>().FirstOrDefault();
Editable = attributes.OfType<EditableAttribute>().FirstOrDefault();
ReadOnly = attributes.OfType<ReadOnlyAttribute>().FirstOrDefault();
}
protected Broker(IEnumerable <IBrokerBehavior> behaviors, ILoggerFactory loggerFactory)
{
_producerBehaviors = behaviors?.OfType <IProducerBehavior>() ?? Enumerable.Empty <IProducerBehavior>();
_consumerBehaviors = behaviors?.OfType <IConsumerBehavior>() ?? Enumerable.Empty <IConsumerBehavior>();
LoggerFactory = loggerFactory;
_logger = loggerFactory.CreateLogger(GetType());
}
public CachedDataAnnotationsMetadataAttributes(IEnumerable<Attribute> attributes)
{
Display = attributes.OfType<DisplayAttribute>().FirstOrDefault();
DisplayFormat = attributes.OfType<DisplayFormatAttribute>().FirstOrDefault();
DisplayName = attributes.OfType<DisplayNameAttribute>().FirstOrDefault();
Editable = attributes.OfType<EditableAttribute>().FirstOrDefault();
ReadOnly = attributes.OfType<ReadOnlyAttribute>().FirstOrDefault();
}
PackagingProject GetPackagingProject (IEnumerable<IWorkspaceFileObject> items)
{
Solution solution = items.OfType<Solution> ().FirstOrDefault ();
if (solution != null) {
return GetPackagingProject (solution.GetAllProjects ());
}
return items.OfType<PackagingProject> ().FirstOrDefault ();
}
public static PropertyValidator FromAttributes(IEnumerable attributes, string propertyName) {
try {
var validationAttributes = attributes != null ? attributes.OfType<ValidationAttribute>().ToArray() : new ValidationAttribute[0];
var dxValidationAttributes = attributes != null ? attributes.OfType<DXValidationAttribute>().ToArray() : new DXValidationAttribute[0];
return validationAttributes.Any() || dxValidationAttributes.Any() ? new PropertyValidator(validationAttributes, dxValidationAttributes, propertyName) : null;
} catch(TypeAccessException) {
return null;
}
}
internal override bool IsContradicting(IEnumerable<BinaryRelationship> relationships)
{
// a < b and a <= b contradicts b < a
var isLessOpContradicting = relationships
.OfType<ComparisonRelationship>()
.Where(c => c.ComparisonKind == ComparisonKind.Less)
.Any(rel => AreOperandsSwapped(rel));
if (isLessOpContradicting)
{
return true;
}
if (ComparisonKind == ComparisonKind.Less)
{
// a < b contradicts b <= a
var isLessEqualOpContradicting = relationships
.OfType<ComparisonRelationship>()
.Where(c => c.ComparisonKind == ComparisonKind.LessOrEqual)
.Any(rel => AreOperandsSwapped(rel));
if (isLessEqualOpContradicting)
{
return true;
}
// a < b contradicts a == b and b == a
var isEqualOpContradicting = relationships
.OfType<EqualsRelationship>()
.Any(rel => AreOperandsMatching(rel));
if (isEqualOpContradicting)
{
return true;
}
}
if (ComparisonKind == ComparisonKind.LessOrEqual)
{
// a <= b contradicts a >= b && a != b
var isLessEqualOp = relationships
.OfType<ComparisonRelationship>()
.Where(c => c.ComparisonKind == ComparisonKind.LessOrEqual)
.Any(rel => AreOperandsSwapped(rel));
var isNotEqualOpContradicting = relationships
.OfType<ValueNotEqualsRelationship>()
.Any(rel => AreOperandsMatching(rel));
if (isLessEqualOp && isNotEqualOpContradicting)
{
return true;
}
}
return false;
}
IEnumerable<DotNetProject> GetLibraryProjects (IEnumerable<IWorkspaceFileObject> items)
{
Solution solution = items.OfType<Solution> ().FirstOrDefault ();
if (solution != null) {
return GetLibraryProjects (solution.GetAllProjects ());
}
return items.OfType<DotNetProject> ().Where (p => !(p is PackagingProject));
}
public IEnumerable<IConceptInfo> CreateNewConcepts(IEnumerable<IConceptInfo> existingConcepts)
{
var newConcepts = new List<IConceptInfo>();
var sourceProperties = existingConcepts.OfType<PropertyInfo>().Where(p => p.DataStructure == EntityComputedFrom.Source);
// Some computed properties might be customized, so ignore existing ones:
var existingComputedPropertiesSource = new HashSet<string>(
existingConcepts.OfType<PropertyComputedFromInfo>()
.Where(comp => comp.EntityComputedFrom == EntityComputedFrom)
.Select(comp => comp.Source.Name));
var newSourceProperties = sourceProperties
.Where(sp => !existingComputedPropertiesSource.Contains(sp.Name)).ToArray();
// Clone source properties, including their cascade delete and extension concepts (only for automatically created propeties):
newConcepts.AddRange(newSourceProperties.Select(sp => new PropertyFromInfo { Source = sp, Destination = EntityComputedFrom.Target }));
AllPropertiesFromInfo.CloneExtension(EntityComputedFrom.Source, EntityComputedFrom.Target, existingConcepts, newConcepts);
newConcepts.AddRange(existingConcepts.OfType<ReferenceCascadeDeleteInfo>()
.Where(ci => ci.Reference.DataStructure == EntityComputedFrom.Source)
.Where(ci => newSourceProperties.Contains(ci.Reference))
.Select(ci => new ReferenceCascadeDeleteInfo
{
Reference = new ReferencePropertyInfo
{
DataStructure = EntityComputedFrom.Target,
Name = ci.Reference.Name,
Referenced = ci.Reference.Referenced
}
}));
// Assign ComputedFrom to the target properties and extension:
newConcepts.AddRange(newSourceProperties.Select(sp =>
new PropertyComputedFromInfo
{
Target = new PropertyInfo { DataStructure = EntityComputedFrom.Target, Name = sp.Name },
Source = sp,
EntityComputedFrom = EntityComputedFrom
}));
IConceptInfo extensionComputedFrom = existingConcepts.OfType<DataStructureExtendsInfo>()
.Where(extension => extension.Extension == EntityComputedFrom.Source)
.Select(extension => new ExtensionComputedFromInfo { EntityComputedFrom = EntityComputedFrom })
.SingleOrDefault();
if (extensionComputedFrom != null)
newConcepts.Add(extensionComputedFrom);
return newConcepts;
}
public static ModelMetadataItem CreateModelMetadataItem(ModelMetadata modelMetadata, IEnumerable<Attribute> attributes)
{
Throw.IfNullArgument(modelMetadata, "modelMetadata");
var item = new ModelMetadataItem();
item.ShowForDisplay = modelMetadata.ShowForDisplay;
item.IsReadOnly = modelMetadata.IsReadOnly;
item.ShowForEdit = modelMetadata.ShowForEdit && !modelMetadata.IsReadOnly;
DisplayAttribute displayAttribute = attributes.OfType<DisplayAttribute>().FirstOrDefault();
RequiredAttribute requiredAttribute = attributes.OfType<RequiredAttribute>().FirstOrDefault();
DisplayFormatAttribute displayFormatAttribute = attributes.OfType<DisplayFormatAttribute>().FirstOrDefault();
if (displayAttribute != null)
item.DisplayName = () => displayAttribute.GetName();
else
item.DisplayName = () => modelMetadata.GetDisplayName();
if (displayAttribute != null)
item.ShortDisplayName = () => displayAttribute.GetShortName();
else
item.ShortDisplayName = () => modelMetadata.ShortDisplayName;
item.TemplateName = modelMetadata.TemplateHint ?? modelMetadata.DataTypeName;
if (displayAttribute != null)
item.Description = () => displayAttribute.GetDescription();
else
item.Description = () => modelMetadata.Description;
if (modelMetadata.NullDisplayText != null)
item.NullDisplayText = () => modelMetadata.NullDisplayText;
if (modelMetadata.Watermark != null)
item.Watermark = () => modelMetadata.Watermark;
item.HideSurroundingHtml = modelMetadata.HideSurroundingHtml;
item.RequestValidationEnabled = modelMetadata.RequestValidationEnabled;
item.IsRequired = modelMetadata.IsRequired;
item.Order = modelMetadata.Order;
item.ConvertEmptyStringToNull = modelMetadata.ConvertEmptyStringToNull;
if (displayFormatAttribute != null)
item.DisplayFormat = () => displayFormatAttribute.DataFormatString;
else if (modelMetadata.DisplayFormatString != null)
item.DisplayFormat = () => modelMetadata.DisplayFormatString;
if (displayFormatAttribute != null && displayFormatAttribute.ApplyFormatInEditMode)
item.EditFormat = () => modelMetadata.DisplayFormatString;
else if (modelMetadata.EditFormatString != null)
item.EditFormat = () => modelMetadata.EditFormatString;
item.ApplyFormatInEditMode = item.EditFormat != null;
return item;
}
public IUserGroup ResolveReference(string reference, IEnumerable<IUserGroup> userGroups)
{
if (!reference.StartsWith("u:"))
return userGroups.OfType<UserGroup>().SingleOrDefault(g => g.Name == reference);
reference = reference.SubstringAfter("u:");
using (var md5 = MD5.Create()) {
return userGroups.OfType<KnownUser>().SingleOrDefault(
u => md5.ComputeHashAsString(Encoding.UTF8.GetBytes(u.Email)) == reference
);
}
}
/// <summary>
/// Constructs a new instance of <see cref="BindingInfo"/> from the given <paramref name="attributes"/>.
/// </summary>
/// <param name="attributes">A collection of attributes which are used to construct <see cref="BindingInfo"/>
/// </param>
/// <returns>A new instance of <see cref="BindingInfo"/>.</returns>
public static BindingInfo GetBindingInfo(IEnumerable<object> attributes)
{
var bindingInfo = new BindingInfo();
var isBindingInfoPresent = false;
// BinderModelName
foreach (var binderModelNameAttribute in attributes.OfType<IModelNameProvider>())
{
isBindingInfoPresent = true;
if (binderModelNameAttribute?.Name != null)
{
bindingInfo.BinderModelName = binderModelNameAttribute.Name;
break;
}
}
// BinderType
foreach (var binderTypeAttribute in attributes.OfType<IBinderTypeProviderMetadata>())
{
isBindingInfoPresent = true;
if (binderTypeAttribute.BinderType != null)
{
bindingInfo.BinderType = binderTypeAttribute.BinderType;
break;
}
}
// BindingSource
foreach (var bindingSourceAttribute in attributes.OfType<IBindingSourceMetadata>())
{
isBindingInfoPresent = true;
if (bindingSourceAttribute.BindingSource != null)
{
bindingInfo.BindingSource = bindingSourceAttribute.BindingSource;
break;
}
}
// PropertyFilterProvider
var propertyFilterProviders = attributes.OfType<IPropertyFilterProvider>().ToArray();
if (propertyFilterProviders.Length == 1)
{
isBindingInfoPresent = true;
bindingInfo.PropertyFilterProvider = propertyFilterProviders[0];
}
else if (propertyFilterProviders.Length > 1)
{
isBindingInfoPresent = true;
bindingInfo.PropertyFilterProvider = new CompositePropertyFilterProvider(propertyFilterProviders);
}
return isBindingInfoPresent ? bindingInfo : null;
}
/// <summary>Gets the metadata for the specified property.</summary>
/// <param name="attributes"></param>
/// <param name="containerType"></param>
/// <param name="modelAccessor"></param>
/// <param name="modelType"></param>
/// <param name="propertyName"></param>
/// <created author="laurentiu.macovei" date="Sun, 27 Mar 2011 00:07:08 GMT"/>
protected override ModelMetadata CreateMetadata(IEnumerable<Attribute> attributes, Type containerType, Func<object> modelAccessor, Type modelType, string propertyName)
{
var displayAttribute = attributes.OfType<global::DisplayNameAttribute>().FirstOrDefault();
var attrs = attributes;
var defaultValueAttribute = attributes.OfType<DefaultValueAttribute>().FirstOrDefault();
//var eitherAttribute = attributes.OfType<EitherAttribute>().FirstOrDefault();
var htmlEncodeAttribute = attributes.OfType<HtmlEncodeAttribute>().FirstOrDefault();
//var pageAttribute = attributes.OfType<PageAttribute>().FirstOrDefault();
var htmlPropertiesAttribute = attributes.OfType<HtmlPropertiesAttribute>().FirstOrDefault();
if (displayAttribute != null)
{
if (!attrs.OfType<System.ComponentModel.DataAnnotations.DisplayAttribute>().Any())
attrs = attrs.Concat(new System.ComponentModel.DataAnnotations.DisplayAttribute
{
Description = GetString(displayAttribute.GetDescription()),
AutoGenerateField = displayAttribute.GetAutoGenerateField() ?? true,
AutoGenerateFilter = displayAttribute.GetAutoGenerateFilter() ?? true,
GroupName = GetString(displayAttribute.GetGroupName()),
Name = GetString(displayAttribute.GetName()),
Order = displayAttribute.GetOrder() ?? 0,
Prompt = GetString(displayAttribute.GetPrompt()),
ShortName = GetString(displayAttribute.GetShortName()),
}.ToEnumerable());
}
var modelData = base.CreateMetadata(attrs, containerType, modelAccessor, modelType, propertyName);
if (htmlPropertiesAttribute != null)
modelData.AdditionalValues.Add("HtmlAttributes", htmlPropertiesAttribute);
if (htmlEncodeAttribute != null)
modelData.AdditionalValues["HtmlEncodeAttribute"] = htmlEncodeAttribute;
if (displayAttribute != null)
modelData.AdditionalValues["DisplayAttribute"] = displayAttribute;
if (defaultValueAttribute != null)
modelData.AdditionalValues["DefaultValue"] = defaultValueAttribute.Value;
//if (pageAttribute != null)
// modelData.AdditionalValues["PageAttribute"] = pageAttribute;
//if (eitherAttribute != null)
//{
// Dictionary<string, ModelMetadata> other;
// object otherValue;
// if (!modelData.AdditionalValues.TryGetValue("EitherAttribute", out otherValue) || (other = otherValue as Dictionary<string, ModelMetadata>) == null)
// modelData.AdditionalValues["EitherAttribute"] = other = new Dictionary<string, ModelMetadata>();
// var otherProperty = containerType.GetProperty(eitherAttribute.OtherProperty, Reflection.BindingFlags.Instance | Reflection.BindingFlags.Public | Reflection.BindingFlags.NonPublic);
// var eitherAttributes = otherProperty.GetCustomAttributes(true).OfType<Attribute>().ToArray();
// var otherPropertyModel = this.CreateMetadata(eitherAttributes, containerType, () => null, modelType, eitherAttribute.OtherProperty);
// other[eitherAttribute.OtherProperty] = otherPropertyModel;
// if (eitherAttribute.OtherPropertyName == null)
// eitherAttribute.OtherPropertyName = otherPropertyModel.GetDisplayName();
//}
return modelData;
}
protected override ModelMetadata CreateMetadata(IEnumerable<System.Attribute> attributes, Type containerType, Func<object> modelAccessor, Type modelType, string propertyName)
{
if (attributes.OfType<MetadataLocationAttribute>().Any())
{
var metadataType = attributes.OfType<MetadataLocationAttribute>().First().Type;
if (attributes != null)
return base.CreateMetadata(attributes, metadataType, modelAccessor, modelType, propertyName);
}
return base.CreateMetadata(attributes, containerType, modelAccessor, modelType, propertyName);
}
public override void Update(IEnumerable<Entity> entities)
{
if (!IsAvailable)
return;
UpdateGamePadStates();
foreach (var button in entities.OfType<GamePadButtonTrigger>())
if (GetButtonState(button.Button) == button.State)
button.Invoke();
foreach (var stick in entities.OfType<GamePadAnalogTrigger>())
if (IsGamePadStickTriggered(stick))
stick.Invoke();
}
public void TransformMetadata(System.Web.Mvc.ModelMetadata metadata, IEnumerable<Attribute> attributes)
{
if (attributes.OfType<RenderModeAttribute>().Any())
{
switch (attributes.OfType<RenderModeAttribute>().First().RenderMode)
{
case RenderMode.None:
metadata.ShowForDisplay = false;
metadata.ShowForEdit = false;
break;
}
}
}
public override ScaffoldedMigration Generate(string migrationId, IEnumerable<MigrationOperation> operations, string sourceModel, string targetModel, string @namespace, string className)
{
_foreignKeys = (from tbl in operations.OfType<CreateTableOperation>()
from fk in operations.OfType<AddForeignKeyOperation>()
where tbl.Name.Equals(fk.DependentTable, StringComparison.InvariantCultureIgnoreCase)
select new KeyValuePair<CreateTableOperation, AddForeignKeyOperation>(tbl, fk)).ToList();
_tableIndexes = (from tbl in operations.OfType<CreateTableOperation>()
from idx in operations.OfType<CreateIndexOperation>()
where tbl.Name.Equals(idx.Table, StringComparison.InvariantCultureIgnoreCase)
select new KeyValuePair<CreateTableOperation, CreateIndexOperation>(tbl, idx)).ToList();
return base.Generate(migrationId, operations, sourceModel, targetModel, @namespace, className);
}
/// <summary>
/// For each property that does not have it's LegacyProperty defined, this function creates a default LegacyProperty
/// assuming that corresponding legacy tables's column has the same name as the property.
/// </summary>
public IEnumerable<IConceptInfo> CreateNewConcepts(IEnumerable<IConceptInfo> existingConcepts)
{
var properties = existingConcepts.OfType<PropertyInfo>().Where(prop => prop.DataStructure == this).ToArray();
var propertiesWithLegacyProperty = existingConcepts.OfType<LegacyPropertyInfo>().Where(lp => lp.Property.DataStructure == this).Select(lp => lp.Property).ToArray();
var legacyIndex = new HashSet<PropertyInfo>(propertiesWithLegacyProperty);
var propertiesWithoutLegacyPropertyInfo = properties.Where(p => !legacyIndex.Contains(p)).ToArray();
var errorReference = propertiesWithoutLegacyPropertyInfo.OfType<ReferencePropertyInfo>().FirstOrDefault();
if (errorReference != null)
throw new DslSyntaxException("Legacy reference property '" + errorReference.GetKeyProperties() +"' must have explicitly defined LegacyProperty with source columns (comma separated), referenced table and referenced columns.");
return propertiesWithoutLegacyPropertyInfo.Select(p => new LegacyPropertySimpleInfo { Property = p, Column = p.Name }).ToList();
}
public IEnumerable<IConceptInfo> CreateNewConcepts(IEnumerable<IConceptInfo> existingConcepts)
{
return existingConcepts.OfType<PropertyInfo>()
.Where(p => p.DataStructure == EntityHistory.Entity)
.Select(p => new EntityHistoryPropertyInfo { Property = p })
.ToList();
}
public IEnumerable<IConceptInfo> CreateNewConcepts(IEnumerable<IConceptInfo> existingConcepts)
{
var extendsConcept = existingConcepts.OfType<DataStructureExtendsInfo>().Where(extends => extends.Extension == Computation).FirstOrDefault();
if (extendsConcept == null)
return null;
// TODO: Implement and use gobal ConceptInfoMetadata to check if this concept is handled or not after evaluating all other concepts.
//throw new DslSyntaxException("ChangesOnBaseItem is used on '" + Computation.GetUserDescription()
// + "' which does not extend another base data structure. Consider adding 'Extends' concept.");
if (!typeof(EntityInfo).IsAssignableFrom(extendsConcept.Base.GetType()))
throw new DslSyntaxException("ChangesOnBaseItem is used on '" + Computation.GetUserDescription()
+ "', but the base data structure '" + extendsConcept.Base.GetUserDescription()
+ "' is not Entity. Currently only entities are supported in automatic handling of dependencies.");
return new[]
{
new ChangesOnChangedItemsInfo
{
Computation = Computation,
DependsOn = (EntityInfo)extendsConcept.Base,
FilterType = "Guid[]",
FilterFormula = "changedItems => changedItems.Select(item => item.ID).ToArray()"
}
};
}
public void AddEqualToDataAttr(IEnumerable<ValidationAttribute> propertyValidators, HtmlTag htmlTag, RequestData request)
{
var equal = propertyValidators.OfType<CompareAttribute>().FirstOrDefault();
if (equal != null)
{
var formatErrorMessage = equal.FormatErrorMessage(request.Accessor.Name);
if (_msUnobtrusive)
{
htmlTag.Data("val", true);
htmlTag.Data("val-equalto", formatErrorMessage);
if (request.Accessor.PropertyNames.Length > 1)
{
htmlTag.Data("val-equalto-other", request.Id.Replace("_" + request.Accessor.Name, "") + "_" + equal.OtherProperty);
}
else
{
htmlTag.Data("val-equalto-other", "*." + equal.OtherProperty);
}
}
else
{
htmlTag.Data("msg-equalto", formatErrorMessage);
if (request.Accessor.PropertyNames.Length > 1)
htmlTag.Data("rule-equalto", "#" + request.Id.Replace("_" + request.Accessor.Name, "") + "_" + equal.OtherProperty);
else
htmlTag.Data("rule-equalto", "#" + equal.OtherProperty);
}
}
}
static object GetMaxId(IEnumerable <dynamic> data,
string columnName)
{
var kvps = data?.OfType <IDictionary <string, object> >();
return(kvps.Max(e => e[columnName]));
}
protected override IEnumerable<ModelValidator> GetValidators(ModelMetadata metadata, ControllerContext context, IEnumerable<Attribute> attributes) {
_adaptersLock.EnterReadLock();
try {
List<ModelValidator> results = new List<ModelValidator>();
if (AddImplicitRequiredAttributeForValueTypes &&
metadata.IsRequired &&
!attributes.Any(a => a is RequiredAttribute)) {
attributes = attributes.Concat(new[] { new RequiredAttribute() });
}
foreach (ValidationAttribute attribute in attributes.OfType<ValidationAttribute>()) {
DataAnnotationsModelValidationFactory factory;
if (!AttributeFactories.TryGetValue(attribute.GetType(), out factory)) {
factory = DefaultAttributeFactory;
}
results.Add(factory(metadata, context, attribute));
}
return results;
}
finally {
_adaptersLock.ExitReadLock();
}
}
public IEnumerable<IConceptInfo> CreateNewConcepts(IEnumerable<IConceptInfo> existingConcepts)
{
var extendsConcept = existingConcepts.OfType<DataStructureExtendsInfo>().Where(extends => extends.Extension == Computation).FirstOrDefault();
if (extendsConcept == null)
throw new DslSyntaxException("ChangesOnLinkedItems is used on '" + Computation.GetUserDescription()
+ "' which does not extend another base data structure. Consider adding 'Extends' concept.");
if (LinkedItemsReference.Referenced != extendsConcept.Base)
throw new DslSyntaxException("ChangesOnLinkedItems used on '" + Computation.GetUserDescription()
+ "' declares reference '" + LinkedItemsReference.GetKeyProperties()
+ "'. The reference should point to computation's base data structure '" + extendsConcept.Base.GetUserDescription()
+ "'. Instead it points to '" + LinkedItemsReference.Referenced.GetUserDescription() + "'.");
if (!typeof(EntityInfo).IsAssignableFrom(LinkedItemsReference.DataStructure.GetType()))
throw new DslSyntaxException("ChangesOnLinkedItems is used on '" + Computation.GetUserDescription()
+ "', but the data structure it depends on '" + LinkedItemsReference.DataStructure.GetUserDescription()
+ "' is not Entity. Currently only entities are supported in automatic handling of dependencies.");
return new[]
{
new ChangesOnChangedItemsInfo
{
Computation = Computation,
DependsOn = (EntityInfo)LinkedItemsReference.DataStructure,
FilterType = "Guid[]",
FilterFormula = @"changedItems => changedItems.Where(item => item." + LinkedItemsReference.Name + " != null).Select(item => item." + LinkedItemsReference.Name + ".ID).Distinct().ToArray()"
}
};
}
/// <summary>Checks whether a type is nullable.</summary>
/// <param name="type">The type.</param>
/// <param name="parentAttributes">The parent attributes (e.g. property or parameter attributes).</param>
/// <param name="defaultReferenceTypeNullHandling">The default reference type null handling used when no nullability information is available.</param>
/// <returns>true if the type can be null.</returns>
public virtual bool IsNullable(Type type, IEnumerable <Attribute> parentAttributes, ReferenceTypeNullHandling defaultReferenceTypeNullHandling)
{
var jsonPropertyAttribute = parentAttributes?.OfType <JsonPropertyAttribute>().SingleOrDefault();
if (jsonPropertyAttribute != null && jsonPropertyAttribute.Required == Required.DisallowNull)
{
return(false);
}
if (parentAttributes.TryGetIfAssignableTo("NotNullAttribute", TypeNameStyle.Name) != null)
{
return(false);
}
if (parentAttributes.TryGetIfAssignableTo("CanBeNullAttribute", TypeNameStyle.Name) != null)
{
return(true);
}
if (type.Name == "Nullable`1")
{
return(true);
}
var isValueType = type != typeof(string) && type.GetTypeInfo().IsValueType;
return(isValueType == false && defaultReferenceTypeNullHandling == ReferenceTypeNullHandling.Null);
}
public static void AddRange(this IList <SelectListItem> listItems, IEnumerable items, IEnumerable selectedItems)
{
var selected = selectedItems?.OfType <object>();
foreach (var item in items)
{
if (item == null)
{
continue;
}
else if (item is IEntity)
{
listItems.Add((IEntity)item);
}
else if (item is SelectListItem)
{
listItems.Add((SelectListItem)item);
}
else
{
listItems.Add(new SelectListItem {
Text = item.ToStringOrEmpty(), Value = item.ToStringOrEmpty()
});
}
if (selected != null && selected.Contains(item))
{
listItems[listItems.Count - 1].Selected = true;
}
}
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="message">Required.</param>
/// <param name="innerExceptions">Optional</param>
public AggregateComposerException(string message, IEnumerable <ComposerException> innerExceptions)
: base(
message,
innerExceptions?.OfType <Exception>()
?? new Exception[0])
{
}
/// <summary>
/// Initializes a new instance of the <see cref="TypeData"/> class.
/// </summary>
/// <param name="declaration"><see cref="BaseTypeDeclarationSyntax"/> this <see cref="TypeData"/> represents.</param>
/// <param name="compilation">Parent <see cref="ICompilationData"/> of this <see cref="TypeData"/>.</param>
/// <param name="symbol"><see cref="INamedTypeSymbol"/> this <see cref="TypeData"/> represents.</param>
/// <param name="semanticModel"><see cref="SemanticModel"/> of the <paramref name="declaration"/>.</param>
/// <param name="partialDeclarations">A collection of <see cref="TypeDeclarationSyntax"/> that represent the partial declarations of the target <paramref name="symbol"/>.</param>
/// <param name="modifiers">A collection of all modifiers applied to the <paramref name="symbol"/>.</param>
/// <param name="containingTypes">A collection of <see cref="ITypeData"/>s the <paramref name="symbol"/> is contained within.</param>
/// <param name="containingNamespaces">A collection of <see cref="INamespaceSymbol"/>s the <paramref name="symbol"/> is contained within.</param>
/// <param name="attributes">A collection of <see cref="AttributeData"/>s representing the <paramref name="symbol"/> attributes.</param>
protected internal TypeData(
BaseTypeDeclarationSyntax declaration,
ICompilationData compilation,
INamedTypeSymbol symbol,
SemanticModel semanticModel,
IEnumerable <BaseTypeDeclarationSyntax>?partialDeclarations = null,
IEnumerable <SyntaxToken>?modifiers = null,
IEnumerable <ITypeData>?containingTypes = null,
IEnumerable <INamespaceSymbol>?containingNamespaces = null,
IEnumerable <AttributeData>?attributes = null
) : base(
declaration,
compilation,
symbol,
semanticModel,
containingTypes,
containingNamespaces,
attributes
)
{
_partialDeclarations = partialDeclarations?.OfType <TypeDeclarationSyntax>().ToArray();
if (modifiers is not null)
{
_modifiers = modifiers.ToArray();
}
}
/// <summary>
/// 現在のパラメータ一覧を取得する。
/// </summary>
/// <param name="targetParameterIds">
/// 取得対象のパラメータID列挙。 null ならば存在する全パラメータを対象とする。
/// </param>
/// <returns>
/// パラメータIDとその値のディクショナリ。取得できなかった場合は null 。
/// </returns>
Result <Dictionary <object, decimal> > ITalker.GetParameters(
IEnumerable targetParameterIds)
{
var result = this.GetParameters(targetParameterIds?.OfType <TParameterId>());
return(
result.Value?.ToDictionary(kv => (object)kv.Key, kv => kv.Value),
result.Message);
}
public CloudFoundrySecurityMiddleware(RequestDelegate next, ICloudFoundryOptions options, IEnumerable <IManagementOptions> mgmtOptions, ILogger <CloudFoundrySecurityMiddleware> logger = null)
{
_next = next;
_logger = logger;
_options = options;
_mgmtOptions = mgmtOptions?.OfType <CloudFoundryManagementOptions>().SingleOrDefault();
_base = new SecurityBase(options, _mgmtOptions, logger);
}
private static bool IsTypeInQueryParameters(IEnumerable <IQueryParameter> parameters)
{
var typeFilterExists = parameters?
.OfType <EqualsFilter>()
.Any(filter => filter
.ElementOrAttributePath
.Equals("system.type", StringComparison.Ordinal));
return(typeFilterExists ?? false);
}
/// <summary>
/// Gets the enumerable as list.
/// If enumerable is an ICollectionView then it returns the SourceCollection as list.
/// </summary>
/// <param name="enumerable">The enumerable.</param>
/// <returns>Returns a list.</returns>
public static IList TryGetList(this IEnumerable enumerable)
{
if (enumerable is ICollectionView view)
{
return(view.SourceCollection as IList);
}
var list = enumerable as IList;
return(list ?? enumerable?.OfType <object>().ToList());
}
public IRenderTarget CreateRenderTarget(IEnumerable <object> surfaces)
{
var fb = surfaces?.OfType <IFramebufferPlatformSurface>().FirstOrDefault();
if (fb == null)
{
throw new ArgumentException("Avalonia.Skia.Android is only capable of drawing on framebuffer");
}
return(new FramebufferRenderTarget(fb));
}
public virtual IRenderTarget CreateRenderTarget(IEnumerable <object> surfaces)
{
var fb = surfaces?.OfType <IFramebufferPlatformSurface>().FirstOrDefault();
if (fb == null)
{
throw new Exception("Skia backend currently only supports framebuffer render target");
}
return(new FramebufferRenderTarget(fb));
}
public static async Task <Stream> LoadStreamAsync(string path, IEnumerable <IImageConstraint> constraints = null)
{
var sizeConstraint = constraints?.OfType <SizeConstraint>().FirstOrDefault();
if (".xps".Equals(Path.GetExtension(path), StringComparison.InvariantCultureIgnoreCase))
{
return(GetXpsStream(path, CalculateRenderSize(sizeConstraint)));
}
return(await GetMagickStreamAsync(path, CalculateRenderSize(sizeConstraint)));
}
internal DataContext(IEnumerable <IAuthor> authors, IEnumerable <IBook> books) : this()
{
foreach (Author author in authors?.OfType <Author>() ?? Enumerable.Empty <Author>())
{
_authors.Add(author);
}
foreach (Book book in books?.OfType <Book>() ?? Enumerable.Empty <Book>())
{
_books.Add(book);
}
}
public IRenderTarget CreateRenderTarget(IEnumerable <object> surfaces)
{
var accessor = surfaces?.OfType <Func <Gdk.Drawable> >().FirstOrDefault();
if (accessor != null)
{
return(new RenderTarget(accessor));
}
throw new NotSupportedException(string.Format(
"Don't know how to create a Cairo renderer from any of the provided surfaces."));
}
public IRenderTarget CreateRenderTarget(IEnumerable <object> surfaces)
{
var nativeWindow = surfaces?.OfType <IPlatformHandle>().FirstOrDefault();
if (nativeWindow != null)
{
if (nativeWindow.HandleDescriptor != "HWND")
{
throw new NotSupportedException("Don't know how to create a Direct2D1 renderer from " + nativeWindow.HandleDescriptor);
}
return(new HwndRenderTarget(nativeWindow));
}
throw new NotSupportedException("Don't know how to create a Direct2D1 renderer from any of provided surfaces");
}
/// <summary>
/// A generic method that can find types of SyntaxNode, used to reduce the amount
/// of boilerplate code in the rules.
/// </summary>
/// <typeparam name="T">
/// The type of SyntaxNode to find.
/// </typeparam>
/// <param name="methodSyntax">
/// A method declaration syntax for which we want to find SyntaxNode of type T.
/// </param>
/// <returns>
/// A list of violations found for the type T.
/// </returns>
private List <T> GetListOfSyntaxNode <T>(MethodDeclarationSyntax methodSyntax)
{
Contract.Requires(methodSyntax != null);
Contract.Ensures(Contract.Result <List <T> >() != null);
IEnumerable <SyntaxNode> descendantNodes = methodSyntax.DescendantNodes();
// The null checks are needed to satisfy Code Contracts. Descendant nodes
// will never be null for methodSyntax, since a MethodDeclarationSyntax
// instance will always have descendants if it itself is not null.
List <T> returnList = descendantNodes?.OfType <T>().ToList() ?? new List <T>();
return(returnList);
}
public static void WriteOptions(this XmlWriter writer, IEnumerable <ITokenOption> options, string elementName)
{
var tagOptions = options?.OfType <PersistantTokenOption>().ToArray();
if (tagOptions != null && tagOptions.Length > 0)
{
writer.WriteStartElement(elementName);
foreach (var tokenOption in tagOptions)
{
writer.WriteXml(tokenOption);
}
writer.WriteEndElement(); //elementName
}
}
public CloudFoundryEndpoint(ICloudFoundryOptions options, IEnumerable <IManagementOptions> mgmtOptions, ILogger <CloudFoundryEndpoint> logger = null)
: base(options)
{
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
_mgmtOption = mgmtOptions?.OfType <CloudFoundryManagementOptions>().SingleOrDefault();
if (_mgmtOption == null)
{
throw new ArgumentNullException(nameof(mgmtOptions));
}
_logger = logger;
}
public virtual async Task <IReadOnlyCollection <T> > Get()
{
var item = new T();
IEnumerable items = null;
switch (item)
{
case DAContractModels.Location _:
await _context.Locations.LoadAsync().ConfigureAwait(false);
items = _mapper.Map <IEnumerable <DAContractModels.Location> >(
await _context.Locations.ToListAsync().ConfigureAwait(false));
break;
case DAContractModels.Service _:
await _context.Services.LoadAsync().ConfigureAwait(false);
items = _mapper.Map <IEnumerable <DAContractModels.Service> >(
await _context.Services.ToListAsync().ConfigureAwait(false));
break;
case DAContractModels.Metric _:
await _context.Metrics.LoadAsync().ConfigureAwait(false);
items = _mapper.Map <IEnumerable <DAContractModels.Metric> >(
await _context.Metrics.ToListAsync().ConfigureAwait(false));
break;
case DAContractModels.Formula _:
await _context.Formulas.LoadAsync().ConfigureAwait(false);
items = _mapper.Map <IEnumerable <DAContractModels.Formula> >(
await _context.Formulas.ToListAsync().ConfigureAwait(false));
break;
case DAContractModels.Statistic _:
await _context.Statistics.LoadAsync().ConfigureAwait(false);
items = _mapper.Map <IEnumerable <DAContractModels.Statistic> >(
await _context.Statistics.ToListAsync().ConfigureAwait(false));
break;
}
return(items?.OfType <T>().ToArray());
}
public void PopulateFeature(IEnumerable <ApplicationPart> parts, ControllerFeature feature)
{
_ = feature ?? throw new ArgumentNullException(nameof(feature));
var appParts = parts?.OfType <IApplicationPartTypeProvider>() ?? throw new ArgumentNullException(nameof(parts));
// inspect all but those parts coming from CoreXF.Framework (fails with an ReflectionTypeLoadException)
foreach (var part in appParts.Where(x => (x as ApplicationPart)?.Name != Assembly.GetAssembly(typeof(Registry.ExtensionsLoader)).GetName().Name))
{
foreach (var type in part.Types.Where(t => ExtensionsHelper.IsController(t) && feature.Controllers.Contains(t) == false))
{
if (ExtensionsHelper.IsExtension(type.Assembly, this.logger))
{
// should be one or more, First/OrDefault() doesn't work instead
var extensionAttribute = type.GetCustomAttributes().SingleOrDefault(a => a is ExportAttribute);
if (extensionAttribute != null)
{
var area = type.Assembly.GetName().Name;
if (this.Areas.ContainsKey(area) == false)
{
this.Areas.Add(area, new List <TypeInfo>());
}
this.Areas[area].Add(type);
feature.Controllers.Add(type);
this.registry.GetExtension(((AssemblyPart)part).Assembly).AddController(type);
this.logger.LogInformation($"Controller '{type.AsType().FullName}' has been registered and is accessible.");
}
else
{
this.logger.LogWarning($"Controller '{type.AsType().FullName}' is inaccessible. Decorate it with '{nameof(ExportAttribute)}' if you want to access it.");
}
}
else
{
feature.Controllers.Add(type);
}
}
}
}
public static int GetTelecom(IEnumerable <IIfcAddress> addresses, out string email, out string phone)
{
email = null;
phone = null;
var filledCount = 0;
var telecoms = addresses?.OfType <IIfcTelecomAddress>();
if (telecoms == null)
{
return(0);
}
foreach (var telecom in telecoms)
{
if (email == null && telecom.ElectronicMailAddresses != null)
{
var ml = telecom.ElectronicMailAddresses
.FirstOrDefault(t => t != null && !string.IsNullOrWhiteSpace(t.ToString())).ToString();
if (!string.IsNullOrWhiteSpace(ml))
{
email = ml;
filledCount++;
}
}
if (phone == null && telecom.TelephoneNumbers != null)
{
var phoneNum = telecom.TelephoneNumbers
.FirstOrDefault(t => t != null && !string.IsNullOrWhiteSpace(t.ToString()))
.ToString();
if (!string.IsNullOrWhiteSpace(phoneNum))
{
phone = phoneNum;
filledCount++;
}
}
// exit enum if no more fields needed.
if (filledCount == 2)
{
return(filledCount);
}
}
return(filledCount);
}
public void PopulateFeature(IEnumerable <ApplicationPart> parts, TagHelperFeature feature)
{
if (feature == null)
{
throw new ArgumentNullException(nameof(feature));
}
var appParts = parts?.OfType <IApplicationPartTypeProvider>() ?? throw new ArgumentNullException(nameof(parts));
foreach (var part in appParts)
{
var types = part.Types.Where(t => /*ExtensionsHelper.IsController(t) && */ feature.TagHelpers.Contains(t) == false);
foreach (var type in types)
{
if (ExtensionsHelper.IsExtension(type.Assembly, this.logger))
{
// should be one or more, First/OrDefault() doesn't work instead
var extensionAttribute = type.GetCustomAttributes().SingleOrDefault(a => a is ExportAttribute);
if (extensionAttribute != null)
{
var area = type.Assembly.GetName().Name;
if (this.Areas.ContainsKey(area) == false)
{
this.Areas.Add(area, new List <TypeInfo>());
}
this.Areas[area].Add(type);
feature.TagHelpers.Add(type);
this.logger.LogInformation($"Tag Helper '{type.AsType().FullName}' has been registered and is accessible.");
}
else
{
this.logger.LogWarning($"Tag Helper '{type.AsType().FullName}' is inaccessible. Decorate it with '{nameof(ExportAttribute)}' if you want to access it.");
}
}
else
{
feature.TagHelpers.Add(type);
}
}
}
}
/// <summary>
/// ソリューションにあるアクティブなKuin Projectのプロパティを取得する。
/// WARN: 開いているドキュメントの所属プロジェクトとか、スタートアッププロジェクトは参照していない
/// 複数のKuin Projectがあるslnだとうまく動かないような。
/// </summary>
/// <returns></returns>
protected KuinProjectNodeProperties GetKuinProjectProperties()
{
var sln = (IVsSolution)_provider.GetService(typeof(SVsSolution));
try
{
IEnumerable projects =
((EnvDTE.DTE)_provider.GetService(typeof(EnvDTE.DTE)))
.ActiveSolutionProjects as IEnumerable;
var project = projects?.OfType <EnvDTE.Project>()
.Select(p => p.GetCommonProject() as KuinProjectNode)
.FirstOrDefault(p => p != null);
return(project?.NodeProperties as KuinProjectNodeProperties);
}
catch (COMException)
{
return(null);
}
}
public async Task <Either <Error, IParser <T> > > GetParserAsync <T>(string key) where T : IStandardModel
{
return(await ShouldNotNullOrEmpty(key)
.MatchAsync(async k =>
{
// Get custom parser
var parser = _customParsers?.OfType <ICustomParser <T> >().FirstOrDefault(p => p.Key == k);
if (parser != null)
{
return Right <Error, IParser <T> >(parser);
}
else
{
var inputType = MapInputType <T>();
// Get beanio parser
var inputMapping = (await _inputMappingRepository
.ListAsync(q => q.Where(e => e.Key == k && e.InputType == inputType)))
.FirstOrDefault();
if (inputMapping == null)
{
return Left <Error, IParser <T> >($"No mapping by key: {k} & type: {inputType.ToString()}");
}
else if (inputMapping.XmlConfiguration.IsNullOrEmpty())
{
return Left <Error, IParser <T> >(
$"No xml configuration by key: {k} & type: {inputType.ToString()}");
}
var mapperSourceText = await _mstEntityRepository.GetAsync(inputMapping.MapperSourceTextId);
return Right <Error, IParser <T> >(new BeanParser <T>(
inputMapping.XmlConfiguration,
_fileLoaderServices.SingleOrDefault(fl => fl.Type == inputMapping.StreamType),
_beanMapperFactory.GetBeanMapper(inputMapping.Mapper),
mapperSourceText));
}
}, errors => errors.Join()));
}
public CloudFoundryEndpointMiddleware(RequestDelegate next, CloudFoundryEndpoint endpoint, IEnumerable <IManagementOptions> mgmtOptions, ILogger <CloudFoundryEndpointMiddleware> logger = null)
: base(endpoint, mgmtOptions?.OfType <CloudFoundryManagementOptions>(), logger: logger)
{
_next = next;
_options = endpoint.Options as ICloudFoundryOptions;
}
private static TabControl GetTabControl(IEnumerable controls)
{
return(controls?.OfType <TabControl>()
.Select(c => c)
.FirstOrDefault());
}
protected virtual IXAxis GetXAxis(IEnumerable <IAxis> axises) => axises?.OfType <IXAxis>().FirstOrDefault();
public CloudFoundryHandler(CloudFoundryEndpoint endpoint, IEnumerable <ISecurityService> securityServices, IEnumerable <IManagementOptions> mgmtOptions, ILogger <CloudFoundryHandler> logger = null)
: base(endpoint, securityServices, mgmtOptions?.OfType <CloudFoundryManagementOptions>(), null, true, logger)
{
}
static public IEnumerable <KeyValuePair <DroneViewEntryGroup, IDroneViewEntryItem[]> > ListDroneViewEntryGrouped(
this IEnumerable <IListEntry> list) =>
list
?.OfType <DroneViewEntry>()
?.SequenceGroupByType <DroneViewEntry, DroneViewEntryGroup>()
?.Select(group => new KeyValuePair <DroneViewEntryGroup, IDroneViewEntryItem[]>(group.Key, group.Value?.OfType <DroneViewEntryItem>()?.ToArray()));
