public override void AfterModule(ModuleDefinition module)
{
foreach (var ie in Implementations.OfType <InterfaceBasedEventSource>())
{
module.Types.Remove(ie.Old);
}
}
public ContentResult SelectedItemsContextMenu(string webQueryName, string implementationsKey, string prefix)
{
var lites = this.ParseLiteKeys <Entity>();
if (lites.IsEmpty())
{
return(Content(""));
}
object queryName = Finder.ResolveQueryName(webQueryName);
Implementations implementations = implementationsKey == "[All]" ? Implementations.ByAll :
Implementations.By(implementationsKey.Split(new string[] { "," }, StringSplitOptions.RemoveEmptyEntries).Select(t => Navigator.ResolveType(t)).ToArray());
var items = ContextualItemsHelper.GetContextualItemListForLites(new SelectedItemsMenuContext
{
Url = RouteHelper.New(),
ControllerContext = this.ControllerContext,
Lites = lites,
QueryName = queryName,
Implementations = implementations,
Prefix = prefix,
});
if (items.IsNullOrEmpty())
{
return(Content(""));
}
var sb = new HtmlStringBuilder(items.Select(mi => mi.ToHtml()));
sb.Add(new MvcHtmlString(@"<script>$(function(){ $('[data-toggle=""tooltip""]').tooltip({}); });</script>"));
return(Content(sb.ToHtml().ToString()));
}
internal static MetaExpression FromRoute(Type type, Implementations? implementations, PropertyRoute pr)
{
if (pr == null)
return new MetaExpression(type.UnNullify().CleanType(), new DirtyMeta(implementations, new Meta[0]));
return new MetaExpression(type.UnNullify().CleanType(), new CleanMeta(implementations, new[] { pr }));
}
public Implementations FindImplementations(PropertyRoute route)
{
if (route.PropertyRouteType == PropertyRouteType.LiteEntity)
{
route = route.Parent;
}
Type type = route.RootType;
if (!Tables.ContainsKey(type))
{
return(Schema.Current.Settings.GetImplementations(route));
}
Field field = TryFindField(Table(type), route.Members);
//if (field == null)
// return Implementations.ByAll;
FieldReference refField = field as FieldReference;
if (refField != null)
{
return(Implementations.By(refField.FieldType.CleanType()));
}
FieldImplementedBy ibField = field as FieldImplementedBy;
if (ibField != null)
{
return(Implementations.By(ibField.ImplementationColumns.Keys.ToArray()));
}
FieldImplementedByAll ibaField = field as FieldImplementedByAll;
if (ibaField != null)
{
return(Implementations.ByAll);
}
Implementations?implementations = CalculateExpressionImplementations(route);
if (implementations != null)
{
return(implementations.Value);
}
var ss = Schema.Current.Settings;
if (route.Follow(r => r.Parent)
.TakeWhile(t => t.PropertyRouteType != PropertyRouteType.Root)
.Any(r => ss.FieldAttribute <IgnoreAttribute>(r) != null))
{
var ib = ss.FieldAttribute <ImplementedByAttribute>(route);
var iba = ss.FieldAttribute <ImplementedByAllAttribute>(route);
return(Implementations.TryFromAttributes(route.Type.CleanType(), route, ib, iba) ?? Implementations.By());
}
throw new InvalidOperationException("Impossible to determine implementations for {0}".FormatWith(route, typeof(IEntity).Name));
}
public static InjectionPlan Serialize(Implementations.InjectionPlan.InjectionPlan ip)
{
if (ip is Implementations.InjectionPlan.Constructor)
{
Implementations.InjectionPlan.Constructor cons = (Implementations.InjectionPlan.Constructor)ip;
Implementations.InjectionPlan.InjectionPlan[] args = cons.GetArgs();
InjectionPlan[] protoArgs = new InjectionPlan[args.Length];
for (int i = 0; i < args.Length; i++)
{
protoArgs[i] = Serialize(args[i]);
}
return NewConstructor(ip.GetNode().GetFullName(), protoArgs.ToList<InjectionPlan>());
}
if (ip is Implementations.InjectionPlan.Subplan)
{
Implementations.InjectionPlan.Subplan sp = (Implementations.InjectionPlan.Subplan)ip;
Implementations.InjectionPlan.InjectionPlan[] args = sp.GetPlans();
InjectionPlan[] subPlans = new InjectionPlan[args.Length];
for (int i = 0; i < args.Length; i++)
{
subPlans[i] = Serialize(args[i]);
}
return NewSubplan(ip.GetNode().GetFullName(), sp.GetSelectedIndex(), subPlans.ToList<InjectionPlan>());
}
if (ip is CsInstance)
{
CsInstance ji = (CsInstance)ip;
return NewInstance(ip.GetNode().GetFullName(), ji.GetInstanceAsString());
}
Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Throw(new IllegalStateException(
"Encountered unknown type of InjectionPlan: " + ip), LOGGER);
return null;
}
public override void AfterModule(ModuleDefinition module)
{
foreach (var method in Implementations.SelectMany(ies => ies.New.Methods))
{
method.Body.OptimizeMacros();
}
}
public override List<Lite<Entity>> Autocomplete(Implementations implementations, string subString, int count)
{
if (string.IsNullOrEmpty(subString))
return new List<Lite<Entity>>();
return AutocompleteUtils.FindLiteLike(implementations, subString, 5);
}
public DorukOtomotiv()
{
InitializeComponent();
DataTable reportData = new Implementations().GetRportDataFromHTMLToDataTable();
dataGridView1.DataSource = reportData;
}
public override Implementations?GetImplementations()
{
var cleanType = PropertyInfo.PropertyType.CleanType();
if (!typeof(IEntity).IsAssignableFrom(cleanType))
{
return(null);
}
var fi = Reflector.TryFindFieldInfo(Parent.Type, PropertyInfo);
if (fi != null)
{
return(Implementations.FromAttributes(cleanType, null,
fi.GetCustomAttribute <ImplementedByAttribute>(),
fi.GetCustomAttribute <ImplementedByAllAttribute>()));
}
if (cleanType.IsAbstract)
{
throw new InvalidOperationException("Impossible to determine implementations for {0}".FormatWith(PropertyInfo.PropertyName()));
}
return(Implementations.By(cleanType));
}
public static Implementations GetImplementations(PropertyRoute route)
{
if (!typeof(ModelEntity).IsAssignableFrom(route.RootType))
{
throw new InvalidOperationException("Route {0} is not rooted on a {1}".FormatWith(route, typeof(ModifiableEntity).Name));
}
PropertyRoute fieldRoute = route;
if (fieldRoute.PropertyRouteType == PropertyRouteType.LiteEntity)
{
fieldRoute = fieldRoute.Parent !;
}
if (fieldRoute.PropertyRouteType == PropertyRouteType.MListItems)
{
fieldRoute = fieldRoute.Parent !;
}
return(Implementations.FromAttributes(
route.Type.CleanType(),
route,
fieldRoute.FieldInfo !.GetCustomAttribute <ImplementedByAttribute>(),
fieldRoute.FieldInfo !.GetCustomAttribute <ImplementedByAllAttribute>()));
}
protected void Page_Load(object sender, EventArgs e)
{
#region previous reports
//var reportData = new Implementations().GetReportData();
/*
* var sonuc = from c in reportData
* group c by new
* {
* c.WorkOrderID,
* c.DelayTypeID,
* c.DelayTypeName
* } into gcs
*
* select new
* {
* isemri = gcs.Key.WorkOrderID,
* GecikmeTipi = gcs.Key.DelayTypeName,
* GecikmeSayisi = gcs.Count(),
* GecikmeToplamSüresi = gcs.Sum(x => x.DelayMinutes)
* };
*
* GridView1.AutoGenerateColumns = true;
* GridView1.DataSource = sonuc.ToList();
* GridView1.DataBind();
*
* GridView2.AutoGenerateColumns = true;
* GridView2.DataSource = reportData.ToList();
* GridView2.DataBind();
*/
#endregion
string s = new Implementations().GetRportHTMLFromReportData();
Response.Write(s);
}
public override void BeforeModule(ModuleDefinition module)
{
foreach (var ie in Implementations.OfType <TemplateBasedEventSource>())
{
module.Types.Add(ie.New);
}
}
public static void Initialise(TestContext testContext)
{
Implementations.Register(Factory.Singleton);
Factory.Singleton.RegisterInstance <IApplicationInformation>(ApplicationInformation.Object);
ApplicationInformation.Setup(a => a.CultureInfo).Returns((CultureInfo)null);
}
public PropertyRoute Add(MemberInfo member)
{
using (HeavyProfiler.LogNoStackTrace("PR.Add", () => member.Name))
{
if (member is MethodInfo && ((MethodInfo)member).IsInstantiationOf(MixinDeclarations.miMixin))
{
member = ((MethodInfo)member).GetGenericArguments()[0];
}
if (this.Type.IsIEntity() && PropertyRouteType != PropertyRouteType.Root)
{
Implementations imp = GetImplementations();
Type?only;
if (imp.IsByAll || (only = imp.Types.Only()) == null)
{
throw new InvalidOperationException("Attempt to make a PropertyRoute on a {0}. Cast first".FormatWith(imp));
}
return(new PropertyRoute(Root(only), member));
}
return(new PropertyRoute(this, member));
}
}
public DirtyMeta(Implementations? implementations, Meta[] properties)
: base(implementations)
{
CleanMetas = properties.OfType<CleanMeta>().Concat(
properties.OfType<DirtyMeta>().SelectMany(d => d.CleanMetas))
.ToReadOnly();
}
public DynamicQueryBucket(object queryName, Func <IDynamicQueryCore> lazyQueryCore, Implementations entityImplementations)
{
if (lazyQueryCore == null)
{
throw new ArgumentNullException("lazyQueryCore");
}
this.QueryName = queryName ?? throw new ArgumentNullException("queryName");
this.EntityImplementations = entityImplementations;
this.Core = new ResetLazy <IDynamicQueryCore>(() =>
{
var core = lazyQueryCore();
core.QueryName = QueryName;
core.StaticColumns.Where(sc => sc.IsEntity).SingleEx(() => "Entity column on {0}".FormatWith(QueryUtils.GetKey(QueryName)));
core.EntityColumnFactory().Implementations = entityImplementations;
var errors = core.StaticColumns.Where(sc => sc.Implementations == null && sc.Type.CleanType().IsIEntity()).CommaAnd(a => $"'{a.Name}'");
if (errors.HasText())
{
throw new InvalidOperationException("Column {0} of query '{1}' do(es) not have implementations deffined. Use Column extension method".FormatWith(errors, QueryUtils.GetKey(QueryName)));
}
return(core);
});
}
public void AddListener(ListenerBase impl)
{
impl.OnAccept += (l, inStream, outStream) =>
{
Enroll(inStream, outStream);
};
Implementations.Add(impl);
}
public static void Initialise(TestContext testContext)
{
Implementations.Register(Factory.Singleton);
global::VirtualRadar.Library.Implementations.Register(Factory.Singleton); // <-- need IAircraftComparer defined for sort tests.
global::VirtualRadar.Owin.Implementations.Register(Factory.Singleton); // <-- need most of this for web API controller tests.
global::VirtualRadar.WebServer.Implementations.Register(Factory.Singleton); // <-- need IResponder defined for response content tests.
}
bool IsNavigableEntity(object queryName)
{
var queryDescription = DynamicQueryManager.Current.QueryDescription(queryName);
Implementations implementations = queryDescription.Columns.SingleEx(a => a.IsEntity).Implementations.Value;
return(implementations.IsByAll || implementations.Types.Any(t => Navigator.IsNavigable(t, null, isSearch: true)));
}
internal static bool AllCanRead(this Implementations implementations, Func <Type, TypeAllowedAndConditions> getAllowed)
{
if (implementations.IsByAll)
{
return(true);
}
return(implementations.Types.All(t => getAllowed(t).MaxUI() != TypeAllowedBasic.None));
}
public static JsTypeInfo[] ToJsTypeInfos(this Implementations implementations, bool isSearch, string prefix)
{
if (implementations.IsByAll)
{
return(null);
}
return(implementations.Types.Select(t => ToJsTypeInfo(t, isSearch, prefix)).ToArray());
}
public override List <Lite <Entity> > Autocomplete(Implementations implementations, string subString, int count)
{
if (string.IsNullOrEmpty(subString))
{
return(new List <Lite <Entity> >());
}
return(Server.Return((IBaseServer bs) => bs.FindLiteLike(implementations, subString, 5)));
}
//--------------------//
#region Clone
/// <summary>
/// Creates a deep copy of this <see cref="Selections"/> instance.
/// </summary>
/// <returns>The new copy of the <see cref="Selections"/>.</returns>
public Selections Clone()
{
var selections = new Selections {
UnknownAttributes = UnknownAttributes, UnknownElements = UnknownElements, InterfaceUri = InterfaceUri, Command = Command
};
selections.Implementations.AddRange(Implementations.CloneElements());
return(selections);
}
public static void Serialize(string fileName, Implementations.InjectionPlan.InjectionPlan ip)
{
InjectionPlan plan = Serialize(ip);
using (var file = File.Create(fileName))
{
Serializer.Serialize<InjectionPlan>(file, plan);
}
}
static string TypeLinks(this Implementations implementations, Type type)
{
if (implementations.IsByAll)
{
return(HelpMessage.Any.NiceToString() + " " + type.TypeLink());
}
return(implementations.Types.CommaOr(TypeLink));
}
private void UpdateImplementation()
{
var selectedImlementation = _options.TestRunner;
if (Implementations.Contains(selectedImlementation))
{
Implementation = selectedImlementation;
}
}
public IEnumerator <T> GetEnumerator()
{
return(Client
.LRange(Key, 0, -1)
.Cast <string>()
.Select(itemKey => Implementations.GetActivatorFor(typeof(T), Context, itemKey))
.Select(act => act())
.Cast <T>()
.GetEnumerator());
}
public void AssertImplementedBy <T>(Expression <Func <T, object> > propertyRoute, Type typeToImplement) where T : Entity
{
var propRoute = PropertyRoute.Construct(propertyRoute);
Implementations imp = GetImplementations(propRoute);
if (imp.IsByAll || !imp.Types.Contains(typeToImplement))
{
throw new InvalidOperationException("Route {0} is not ImplementedBy {1}".FormatWith(propRoute, typeToImplement.Name));
}
}
public void MetaConditional()
{
var dic = DynamicQueryCore.QueryMetadata(
from a in Database.Query <AlbumEntity>()
select new { Author = a.Id > 1 ? (ArtistEntity)a.Author : (IAuthorEntity)(BandEntity)a.Author }
);
DirtyMeta meta = (DirtyMeta)dic["Author"];
Assert.Equal(meta.Implementations, Implementations.By(typeof(ArtistEntity), typeof(BandEntity)));
}
public void MetaCoallesce()
{
var dic = DynamicQuery.QueryMetadata(
from a in Database.Query <AlbumEntity>()
select new { Author = (ArtistEntity)a.Author ?? (IAuthorEntity)(BandEntity)a.Author }
);
DirtyMeta meta = (DirtyMeta)dic["Author"];
Assert.AreEqual(meta.Implementations, Implementations.By(typeof(ArtistEntity), typeof(BandEntity)));
}
internal static List <Implementer> Resolve(Implementations implementations)
{
List <Implementer> implementers = new List <Implementer>();
if (implementations.HasFlag(Implementations.INotifyPropertyChanged))
{
implementers.Add(new INotifyPropertyChangedImplementer());
}
return(implementers);
}
public static void Initialise(TestContext testContext)
{
Implementations.Register(Factory.Singleton);
global::VirtualRadar.Library.Implementations.Register(Factory.Singleton); // <-- need IAircraftComparer defined for sort tests.
global::VirtualRadar.WebServer.Implementations.Register(Factory.Singleton); // <-- need IResponder defined for response content tests.
AWhewell.Owin.Implementations.Register(Factory.Singleton); // <-- need Owin library registered for middleware tests
AWhewell.Owin.Host.Ram.Implementations.Register(Factory.Singleton); // <-- need RAM host library registered for controller tests
AWhewell.Owin.WebApi.Implementations.Register(Factory.Singleton); // <-- need Web API library registered for web API tests
}
static Implementations DefaultImplementations(Type type, object queryName)
{
var property = type.GetProperty("Entity", BindingFlags.Instance | BindingFlags.Public);
if (property == null)
{
throw new InvalidOperationException("Entity property not found on query {0}".FormatWith(QueryUtils.GetKey(queryName)));
}
return(Implementations.By(property.PropertyType.CleanType()));
}
/// <summary>
/// Gets a configuration type from the manager
/// </summary>
/// <param name="configType">The type of configuration to get</param>
public object GetConfig(Type configType)
{
// If the implementation is not found, throw exception
if (!Implementations.GetConfigImplementations().Any(x => x.Type == configType))
{
throw new ConfigNotFoundException($"Configuration of type {configType.ToString()} not found.");
}
// Return the runtime instance of the implementation
return(Implementations.GetBaseImplementation(configType).RuntimeInstance);
}
/// <summary>
/// Gets a configuration type from the manager
/// </summary>
/// <typeparam name="TConfig">The type of configuration to get</typeparam>
public TConfig GetConfig <TConfig>()
{
// If the implementation is not found, throw exception
if (!Implementations.GetConfigImplementations().Any(x => x.Type == typeof(TConfig)))
{
throw new ConfigNotFoundException($"Configuration of type {typeof(TConfig).ToString()} not found.");
}
// Return the runtime instance of the implementation
return(Implementations.GetImplementation <TConfig>().RuntimeInstance);
}
public ExtensionToken(QueryToken parent, string key, Type type, bool isProjection,
string unit, string format,
Implementations? implementations,
string isAllowed, PropertyRoute propertyRoute)
: base(parent)
{
var shouldHaveImplementations = typeof(IEntity).IsAssignableFrom((isProjection ? type.ElementType() : type).CleanType());
if (shouldHaveImplementations && implementations == null)
throw new ArgumentException("Extension token '{0}' (of type {1}) registered on type {2} has no implementations".FormatWith(key, type.TypeName(), parent.Type.CleanType().TypeName()));
this.key= key;
this.type = type;
this.isProjection = isProjection;
this.unit = unit;
this.format = format;
this.implementations = implementations;
this.isAllowed = isAllowed;
this.propertyRoute = propertyRoute;
}
void OnStepExecutedEvent(object sender, Implementations.Extenders.StepInfo e)
{
Console.WriteLine(e.Description);
}
protected Meta(Implementations? implementations)
{
this.Implementations = implementations;
}
public CleanMeta(Implementations? implementations, params PropertyRoute[] propertyRoutes)
: base(implementations)
{
this.PropertyRoutes = propertyRoutes;
}
public TypeReferenceTS(Type type, Implementations? implementations)
{
this.IsCollection = type != typeof(string) && type != typeof(byte[]) && type.ElementType() != null;
var clean = type == typeof(string) ? type : (type.ElementType() ?? type);
this.IsLite = clean.IsLite();
this.IsNotNullable = clean.IsValueType && !clean.IsNullable();
this.IsEmbedded = clean.IsEmbeddedEntity();
if (this.IsEmbedded && !this.IsCollection)
this.TypeNiceName = type.NiceName();
this.Name = implementations?.Key() ?? TypeScriptType(type);
}
static MetaExpression MakeDirtyMeta(Type type, Implementations? implementations, params Expression[] expression)
{
var metas = expression.OfType<MetaExpression>().Select(a => a.Meta).NotNull().ToArray();
return new MetaExpression(type, new DirtyMeta(implementations, metas));
}
internal static Implementations CastImplementations(Implementations implementations, Type cleanType)
{
if (implementations.IsByAll)
{
if (!Schema.Current.Tables.ContainsKey(cleanType))
throw new InvalidOperationException("Tye type {0} is not registered in the schema as a concrete table".Formato(cleanType));
return Signum.Entities.Implementations.By(cleanType);
}
if (implementations.Types.All(cleanType.IsAssignableFrom))
return implementations;
return Signum.Entities.Implementations.By(implementations.Types.Where(cleanType.IsAssignableFrom).ToArray());
}
