public override object Build(BuilderContext context)
{
return new IgnoreRouteInternal(context.Builtin.Properties.GetRawValue("url"))
{
Constraints = this.ResolveValues(context.Builtin.Properties.GetValue<string>("constraints"), context.Builtin)
};
}
public override object Build(BuilderContext context)
{
Builtin builtin = context.Builtin;
var node = new Zongsoft.Web.Controls.TreeViewNode(builtin.Name, builtin.Properties.GetValue<string>("text"))
{
Icon = builtin.Properties.GetValue<string>("icon"),
Text = builtin.Properties.GetValue<string>("text"),
ToolTip = builtin.Properties.GetValue<string>("tooltip"),
Description = builtin.Properties.GetValue<string>("description"),
NavigateUrl = builtin.Properties.GetValue<string>("url") ?? string.Empty,
NavigateCssClass = builtin.Properties.GetValue<string>("navigateCssClass"),
CssClass = builtin.Properties.GetValue<string>("cssClass"),
ListCssClass = builtin.Properties.GetValue<string>("listCssClass"),
Selected = builtin.Properties.GetValue<bool>("selected", false),
Visible = builtin.Properties.GetValue<bool>("visible", true),
};
node.Image.CssClass = builtin.Properties.GetValue<string>("image-cssClass");
node.Image.Dimension = builtin.Properties.GetValue<Zongsoft.Web.Controls.Dimension>("image-dimension", Controls.Dimension.None);
node.Image.ImageUrl = builtin.Properties.GetValue<string>("image-url");
node.Image.NavigateUrl = builtin.Properties.GetValue<string>("image-navigateUrl");
node.Image.Placeholder = builtin.Properties.GetValue<string>("image-placeholder");
//返回构建的目标对象
return node;
}
protected override void OnBuilt(BuilderContext context)
{
Control itemControl = context.Result as Control;
if(itemControl == null)
return;
itemControl.ID = context.Builtin.Name;
Control ownerControl = context.Owner as Control ?? context.Parameter as Control;
if(ownerControl == null)
return;
string index = context.Builtin.Properties.GetValue<string>("index");
if(!string.IsNullOrWhiteSpace(index))
{
for(int i = 0; i < ownerControl.Controls.Count; i++)
{
if(string.Equals(ownerControl.Controls[i].ID, index, StringComparison.OrdinalIgnoreCase))
{
ownerControl.Controls.AddAt(i, itemControl);
return;
}
}
}
ownerControl.Controls.Add(itemControl);
}
public void TestNoPoliciesReturnsNull()
{
PolicyList policies = new PolicyList();
BuilderContext context = new BuilderContext(null, null, policies);
Assert.IsNull(context.Policies.Get<IBuilderPolicy>(typeof (object), null));
}
public void SetUp( BuilderContext obj )
{
// var routes = this._junctionEdge.EdgeBuilder.Routes;
// var convertedRoutes = this.ConvertRoutes( routes, obj, this._junctionEdge ).ToArray();
// TODO Remove Routes from this element
this._junctionEdge.Routes = new StandardRoutes( Enumerable.Empty<BuildRoute>());
}
/// <summary>
/// Builds the ExpressionQuery:
/// - parses Expressions and builds row creator
/// - checks names unicity
/// </summary>
/// <param name="expressions"></param>
/// <param name="queryContext"></param>
/// <returns></returns>
protected virtual ExpressionQuery BuildExpressionQuery(ExpressionChain expressions, QueryContext queryContext)
{
var builderContext = new BuilderContext(queryContext);
BuildExpressionQuery(expressions, builderContext);
CheckTablesAlias(builderContext);
CheckParametersAlias(builderContext);
return builderContext.ExpressionQuery;
}
public void SetUp(BuilderContext obj)
{
// this._lane.LaneCornerBuild.Routes.CalculateProbabilities();
// var routes = this._lane.LaneCornerBuild.Routes;
// var convertedRoutes = this.ConvertRoutes( routes, obj, this._lane ).ToArray();
// TODO Remove Routes from this element
this._lane.Routes = new StandardRoutes( Enumerable.Empty<BuildRoute>() );
}
public void Connect( BuilderContext builderContext )
{
this._junctionEdge.Junction = builderContext.GetObject<LaneJunction>( this._junctionEdge.EdgeBuilder.Connector.JunctionEdge.Parent );
if ( this._junctionEdge.EdgeBuilder.Connector.Edge != null )
{
this._junctionEdge.Next = builderContext.GetObject<IRoadElement>( this._junctionEdge.EdgeBuilder.Connector.Edge.Parent );
}
}
public override object Build(BuilderContext context)
{
return new HtmlForm()
{
Action = context.Builtin.Properties.GetValue<string>("action"),
Method = context.Builtin.Properties.GetValue<string>("method"),
};
}
private BuildRoute ConvertRoute( BuildMode.Controls.Route route, BuilderContext context, IRoadElement routeOwner )
{
return new BuildRoute( this.GetRouteElements( route, context, routeOwner ) )
{
Probability = route.Probability,
Name = route.Name,
Owner = routeOwner,
};
}
public void Connect( BuilderContext builderContext )
{
var connectedLane = this._carsRemover.CarsRemoverBuilder.Connector.OpositeEdge;
if ( connectedLane == null )
{
return;
}
this._carsRemover.Lane = builderContext.GetObject<Lane>( connectedLane.Parent );
}
public void CanSetPoliciesUsingTheContext()
{
BuilderContext context = new BuilderContext(null, null, null);
MockCreationPolicy policy = new MockCreationPolicy();
context.Policies.Set<IBuilderPolicy>(policy, typeof (object), "foo");
Assert.AreSame(policy, context.Policies.Get<IBuilderPolicy>(typeof (object), "foo"));
}
internal EntitySetExpression(TableExpression sourceTable, MemberInfo memberInfo, Type entitySetType, BuilderContext builderContext, ExpressionDispatcher dispatcher)
: base(ExpressionType, entitySetType)
{
this.builderContext = builderContext;
this.EntitySetType = entitySetType;
this.dispatcher = dispatcher;
this.sourceTable = sourceTable;
this.memberInfo = memberInfo;
ParseExpression(sourceTable);
}
public IEnumerable<IRoadElement> ConvertToSimulationMode( IEnumerable<IControl> controls )
{
Contract.Requires( controls != null );
var context = new BuilderContext( this._roadInformationFactory );
controls.Where( c => c != null )
.SelectMany( this.GetAction )
.OrderBy( a => a.Order )
.ForEach( a => a.Action( context ) );
return context.Elements;
}
public void TestSettingAndRetrievePolicy()
{
PolicyList policies = new PolicyList();
MockCreationPolicy policy = new MockCreationPolicy();
policies.Set<IBuilderPolicy>(policy, typeof (object), null);
BuilderContext context = new BuilderContext(null, null, policies);
IBuilderPolicy outPolicy = context.Policies.Get<IBuilderPolicy>(typeof (object), null);
Assert.IsNotNull(outPolicy);
Assert.AreSame(policy, outPolicy);
}
public override object Build(BuilderContext context)
{
string url = context.Builtin.Properties.GetRawValue("url");
if(string.IsNullOrWhiteSpace(url))
return base.Build(context);
TemplateControl template = context.Owner as TemplateControl;
if(template != null)
return template.LoadControl(url);
return null;
}
public void SettingPolicyViaContextDoesNotAffectPoliciesPassedToContextConstructor()
{
PolicyList policies = new PolicyList();
MockCreationPolicy policy1 = new MockCreationPolicy();
policies.Set<IBuilderPolicy>(policy1, typeof (object), null);
BuilderContext context = new BuilderContext(null, null, policies);
MockCreationPolicy policy2 = new MockCreationPolicy();
context.Policies.Set<IBuilderPolicy>(policy2, typeof (string), null);
Assert.AreEqual(1, policies.Count);
}
public override object Build(BuilderContext context)
{
string path = context.Builtin.Properties.GetRawValue("path");
PluginTreeNode node = null;
if(PluginPath.IsPath(path))
node = context.PluginTree.Find(path);
else
node = context.PluginTree.Find(context.Builtin.FullPath);
return new Sitemap(node)
{
ID = context.Builtin.Name,
CssClass = context.Builtin.Properties.GetValue<string>("cssClass"),
};
}
public override object Build(BuilderContext context)
{
var treeView = new Zongsoft.Web.Controls.TreeView()
{
ID = context.Builtin.Name,
CssClass = context.Builtin.Properties.GetValue<string>("cssClass"),
DataSource = context.Builtin.Properties.GetValue<object>("dataSource"),
IsDropdown = context.Builtin.Properties.GetValue<bool>("isDropdown"),
RenderMode = context.Builtin.Properties.GetValue<Zongsoft.Web.Controls.ListRenderMode>("renderMode", Zongsoft.Web.Controls.ListRenderMode.List),
Height = context.Builtin.Properties.GetValue<Zongsoft.Web.Controls.Unit>("height", Zongsoft.Web.Controls.Unit.Empty),
Width = context.Builtin.Properties.GetValue<Zongsoft.Web.Controls.Unit>("width", Zongsoft.Web.Controls.Unit.Empty),
ScrollbarMode = context.Builtin.Properties.GetValue<Zongsoft.Web.Controls.ScrollbarMode>("scrollbarMode", Zongsoft.Web.Controls.ScrollbarMode.None),
SelectionMode = context.Builtin.Properties.GetValue<Zongsoft.Web.Controls.SelectionMode>("selectionMode", Zongsoft.Web.Controls.SelectionMode.None),
Visible = context.Builtin.Properties.GetValue<bool>("visible", true),
};
return treeView;
}
private IEnumerable<RouteElement> GetRouteElements( BuildMode.Controls.Route route, BuilderContext context, IRoadElement routeOwner )
{
return route.Items.Select( ( index, prev, current, next ) =>
{
var nextElement = next != null ? next.Control : null;
var prevElement = prev != null ? prev.Control : null;
if ( prevElement == null && index == 0 )
{
prevElement = routeOwner.BuildControl;
}
return new RouteElement
{
PriorityType = current.PriorityType,
RoadElement = this.GetRoadElement( context, current.Control ),
Length = this.GetLength( prevElement, current, nextElement ),
CanStopOnIt = current.CanStop,
};
} );
}
protected override void OnBuilt(BuilderContext context)
{
if(context.Owner == null)
return;
var node = context.Result as Zongsoft.Web.Controls.TreeViewNode;
if(node == null)
return;
//根据所有者对象的类型，将当前目标对象添加到其子项列表中
if(context.Owner is Zongsoft.Web.Controls.TreeViewNode)
{
((Zongsoft.Web.Controls.TreeViewNode)context.Owner).Nodes.Add(node);
}
else if(context.Owner is Zongsoft.Web.Controls.TreeView)
{
((Zongsoft.Web.Controls.TreeView)context.Owner).Nodes.Add(node);
}
}
protected override void OnBuilt(BuilderContext context)
{
if(context.Result is RouteBase)
{
var routes = RouteTable.Routes;
if(context.Owner is RouteCollection)
routes = (RouteCollection)context.Owner;
routes.Add(context.Builtin.Name, (RouteBase)context.Result);
}
else if(context.Result is System.Web.Http.Routing.IHttpRoute)
{
var routes = System.Web.Http.GlobalConfiguration.Configuration.Routes;
if(context.Owner is System.Web.Http.HttpRouteCollection)
routes = (System.Web.Http.HttpRouteCollection)context.Owner;
routes.Add(context.Builtin.Name, (System.Web.Http.Routing.IHttpRoute)context.Result);
}
else
base.OnBuilt(context);
}
public override void Parse(System.Linq.Expressions.Expression expression)
{
_expression = expression;
parser.ElementType = ElementType;
parser.Parse(expression);
var provider = ProviderFactory.CreateProvider(ConfigManager.DataBaseType);
var builderFactory = provider.CreateSqlBuilderFactory();
var builder = builderFactory.CreateSqlBuilder();
BuilderContext context = new BuilderContext();
var sqlType = SqlType.Select;
if (parser.IsCallAny)
{
context.Take = 1;
}
if (parser.IsDelete)
{
sqlType = SqlType.Delete;
}
else if (parser.IsUpdate)
{
sqlType = SqlType.Update;
}
context.SqlType = sqlType;
context.Pager = parser.Skip != -1 && parser.Take != -1;
context.SortColumns = parser.SortColumns;
context.Joins = parser.Joins;
context.UpdateResult = parser.UpdateResult;
context.Skip = parser.Skip;
context.Take = parser.Take;
context.AggregationColumns = parser.AggregationColumns;
context.Columns = parser.Columns;
context.NoLockTables = parser.NoLockTables;
context.Conditions = parser.Conditions;
context.ElementType = parser.ElementType;
Result = builder.BuildSql(context);
}
public override object Build(BuilderContext context)
{
Builtin builtin = context.Builtin;
string url = builtin.Properties.GetRawValue("url");
var defaults = ResolveValues(builtin.Properties.GetValue<string>("defaults"), builtin);
var dataTokens = ResolveValues(builtin.Properties.GetValue<string>("dataTokens"), builtin);
var constraints = ResolveValues(builtin.Properties.GetValue<string>("constraints"), builtin);
if(!dataTokens.ContainsKey("area"))
{
object area = null;
if(constraints.TryGetValue("area", out area))
dataTokens.Add("area", area);
else
dataTokens.Add("area", VirtualPathUtility.GetArea(url));
}
if(this.IsApiUrl(url))
{
return System.Web.Http.GlobalConfiguration.Configuration.Routes.CreateRoute(
url,
defaults,
constraints,
dataTokens);
}
else
{
return new Route(url,
defaults,
constraints,
dataTokens,
builtin.Properties.GetValue<IRouteHandler>("handler", new System.Web.Mvc.MvcRouteHandler()));
}
}
protected abstract void ConvertToSqlConditional(Expression exp, ref CharWriteBuffer sb, BuilderContext context);
public virtual Expression Optimize(Expression expression, BuilderContext builderContext)
{
return(expression.Recurse(e => Analyze(e, builderContext)));
}
/// <summary>
/// Registers an external parameter
/// Since these can be complex expressions, we don't try to identify them
/// and push them every time
/// The only loss may be a small memory loss (if anyone can prove me that the same Expression can be used twice)
/// </summary>
/// <param name="expression"></param>
/// <param name="alias"></param>
/// <param name="builderContext"></param>
/// <returns></returns>
public virtual InputParameterExpression RegisterParameter(Expression expression, string alias, BuilderContext builderContext)
{
var queryParameterExpression = new InputParameterExpression(expression, alias);
builderContext.ExpressionQuery.Parameters.Add(queryParameterExpression);
return(queryParameterExpression);
}
public BuildStepService(BuilderContext context, IMapper mapper) : base(context, mapper)
{
}
private BuildResultCode BuildSlave()
{
// Mount build path
((FileSystemProvider)VirtualFileSystem.ApplicationData).ChangeBasePath(builderOptions.BuildDirectory);
VirtualFileSystem.CreateDirectory(VirtualFileSystem.ApplicationDatabasePath);
// Open ServiceWire Client Channel
using (var client = new NpClient <IProcessBuilderRemote>(new NpEndPoint(builderOptions.SlavePipe), new StrideServiceWireSerializer()))
{
RegisterRemoteLogger(client);
// Make sure to laod all assemblies containing serializers
// TODO: Review how costly it is to do so, and possibily find a way to restrict what needs to be loaded (i.e. only app plugins?)
foreach (var assemblyLocation in client.Proxy.GetAssemblyContainerLoadedAssemblies())
{
AssemblyContainer.Default.LoadAssemblyFromPath(assemblyLocation, builderOptions.Logger);
}
// Create scheduler
var scheduler = new Scheduler();
var status = ResultStatus.NotProcessed;
// Schedule command
string buildPath = builderOptions.BuildDirectory;
Builder.OpenObjectDatabase(buildPath, VirtualFileSystem.ApplicationDatabaseIndexName);
var logger = builderOptions.Logger;
MicroThread microthread = scheduler.Add(async() =>
{
// Deserialize command and parameters
Command command = client.Proxy.GetCommandToExecute();
// Run command
var inputHashes = FileVersionTracker.GetDefault();
var builderContext = new BuilderContext(inputHashes, null);
var commandContext = new RemoteCommandContext(client.Proxy, command, builderContext, logger);
MicrothreadLocalDatabases.MountDatabase(commandContext.GetOutputObjectsGroups());
command.PreCommand(commandContext);
status = await command.DoCommand(commandContext);
command.PostCommand(commandContext, status);
// Returns result to master builder
client.Proxy.RegisterResult(commandContext.ResultEntry);
});
while (true)
{
scheduler.Run();
// Exit loop if no more micro threads
lock (scheduler.MicroThreads)
{
if (!scheduler.MicroThreads.Any())
{
break;
}
}
Thread.Sleep(0);
}
// Rethrow any exception that happened in microthread
if (microthread.Exception != null)
{
builderOptions.Logger.Fatal(microthread.Exception.ToString());
return(BuildResultCode.BuildError);
}
if (status == ResultStatus.Successful || status == ResultStatus.NotTriggeredWasSuccessful)
{
return(BuildResultCode.Successful);
}
return(BuildResultCode.BuildError);
}
}
public override SLE.Expression MakeExpression(BuilderContext ctx)
{
return Binary.MakeExpression (ctx, Left, Right);
}
async void OnItemSelected(object sender, SelectedItemChangedEventArgs args)
{
if (IsBusy)
{
return;
}
IsBusy = true;
//viewModel.Items.Clear();
var item = args.SelectedItem as Models.Character;
if (item == null)
{
return;
}
BuilderContext Context = new BuilderContext(item.Player);
PluginManager manager = new PluginManager();
manager.Add(new SpellPoints());
manager.Add(new SingleLanguage());
Context.Plugins = manager;
if (App.AutoSaveDuringPlay)
{
Task.Run(async() =>
{
if (Context.Player.FilePath is IFile file)
{
string name = file.Name;
IFile target = await(await App.Storage.CreateFolderAsync("Backups", CreationCollisionOption.OpenIfExists).ConfigureAwait(false)).CreateFileAsync(name, CreationCollisionOption.ReplaceExisting).ConfigureAwait(false);
using (Stream fout = await target.OpenAsync(FileAccess.ReadAndWrite))
{
using (Stream fin = await file.OpenAsync(FileAccess.Read))
{
await fin.CopyToAsync(fout);
}
};
}
}).Forget();
}
Context.UndoBuffer = new LinkedList <Player>();
Context.RedoBuffer = new LinkedList <Player>();
Context.UnsavedChanges = 0;
ItemsListView.SelectedItem = null;
LoadingProgress loader = new LoadingProgress(Context);
LoadingPage l = new LoadingPage(loader);
await Navigation.PushModalAsync(l);
var t = l.Cancel.Token;
try
{
await loader.Load(t).ConfigureAwait(false);
t.ThrowIfCancellationRequested();
PlayerViewModel model = new PlayerViewModel(Context);
Device.BeginInvokeOnMainThread(async() =>
{
await Navigation.PopModalAsync(false);
await Navigation.PushModalAsync(new NavigationPage(new FlowPage(model)));
});
}
catch (OperationCanceledException) {
}
finally
{
IsBusy = false;
(sender as ListView).SelectedItem = null;
}
// Manually deselect item
}
/// <summary>
/// Promotes a table to a common parent between its current scope and our current scope
/// </summary>
/// <param name="tableExpression"></param>
/// <param name="builderContext"></param>
/// <returns></returns>
protected virtual TableExpression PromoteTable(TableExpression tableExpression, BuilderContext builderContext)
{
int currentIndex = 0;
SelectExpression oldSelect = null;
SelectExpression commonScope = null;
TableExpression foundTable = null;
do
{
// take a select
oldSelect = builderContext.SelectExpressions[currentIndex];
// look for a common scope
if (oldSelect != builderContext.CurrentSelect)
{
commonScope = FindCommonScope(oldSelect, builderContext.CurrentSelect);
if (commonScope != null)
{
// if a common scope exists, look for an equivalent table in that select
for (int tableIndex = 0; tableIndex < oldSelect.Tables.Count && foundTable == null; tableIndex++)
{
if (oldSelect.Tables[tableIndex].IsEqualTo(tableExpression))
{
// found a matching table!
foundTable = oldSelect.Tables[tableIndex];
}
}
}
}
++currentIndex;
}while (currentIndex < builderContext.SelectExpressions.Count && foundTable == null);
if (foundTable != null)
{
oldSelect.Tables.Remove(foundTable);
commonScope.Tables.Add(foundTable);
}
return(foundTable);
}
public GroupService(BuilderContext context, IMapper mapper, INotificationsService notificationsService) : base(context, mapper)
{
_notificationsService = notificationsService;
}
public override SLE.Expression MakeExpression (BuilderContext ctx)
{
return expr.MakeExpression (ctx);
}
public PlayerModel(BuilderContext context)
{
Context = context;
}
public ColumnExpression CreateColumn(TableExpression table, MemberInfo memberInfo, BuilderContext builderContext)
{
var dataMember = builderContext.QueryContext.DataContext.Mapping.GetTable(table.Type).RowType
.GetDataMember(memberInfo);
if (dataMember == null)
{
return(null);
}
return(new ColumnExpression(table, dataMember));
}
public override SLE.Expression MakeExpression (BuilderContext ctx)
{
#if STATIC
return base.MakeExpression (ctx);
#else
#if NET_4_0 || MONODROID
if (type.IsStruct && !obj.Expression.Type.IsValueType)
return SLE.Expression.Unbox (obj.Expression, type.GetMetaInfo ());
if (obj.Expression.NodeType == SLE.ExpressionType.Parameter) {
if (((SLE.ParameterExpression) obj.Expression).IsByRef)
return obj.Expression;
}
#endif
return SLE.Expression.Convert (obj.Expression, type.GetMetaInfo ());
#endif
}
/// <summary>
/// Creates a default TableExpression
/// </summary>
/// <param name="tableType"></param>
/// <param name="builderContext"></param>
/// <returns></returns>
public virtual TableExpression CreateTable(Type tableType, BuilderContext builderContext)
{
return(new TableExpression(tableType, DataMapper.GetTableName(tableType, builderContext.QueryContext.DataContext)));
}
protected void ConvertToSqlValue(Type type, object value, ref CharWriteBuffer sb, BuilderContext context)
{
MemberExpression memberProperty = null;
if (context.MemberContext.MemberAccessStack.Count > 0)
{
memberProperty = context.MemberContext.MemberAccessStack.Pop();
}
bool memberPropertyHandled = ConvertToSqlValueRender(memberProperty, type, value, ref sb, context);
if (memberProperty != null)
{
if (!memberPropertyHandled)
{
throw new NotSupportedException($"{type.FullName}.{memberProperty.Member.Name} not supported");
}
context.MemberContext.MemberAccessStack.Push(memberProperty);
}
}
public override System.Linq.Expressions.Expression MakeExpression(BuilderContext ctx)
{
return(expr.MakeExpression(ctx));
}
public ProjectGroupService(BuilderContext context, IMapper mapper) : base(context, mapper)
{
}
private void ConvertToSqlUnary(Operator prefixOperation, string suffixOperation, Expression exp, ref CharWriteBuffer sb, BuilderContext context)
{
context.MemberContext.OperatorStack.Push(prefixOperation);
var unary = exp as UnaryExpression;
sb.Write(OperatorToString(prefixOperation));
ConvertToSql(unary.Operand, ref sb, context);
sb.Write(suffixOperation);
context.MemberContext.OperatorStack.Pop();
}
public override SLE.Expression MakeExpression(BuilderContext ctx)
{
return expr.MakeExpression (ctx);
}
private void ConvertToSqlBinary(Operator operation, Expression exp, ref CharWriteBuffer sb, BuilderContext context)
{
context.MemberContext.OperatorStack.Push(operation);
var binary = exp as BinaryExpression;
var binaryLeft = binary.Left;
var binaryRight = binary.Right;
if (operation == Operator.Equals || operation == Operator.NotEquals)
{
var leftNull = IsNull(binaryLeft);
var rightNull = false;
if (leftNull == false)
{
rightNull = IsNull(binaryRight);
}
if (leftNull || rightNull)
{
operation = operation == Operator.Equals ? Operator.EqualsNull : Operator.NotEqualsNull;
if (leftNull)
{
binaryLeft = binaryRight;
}
binaryRight = null;
}
}
sb.Write('(');
ConvertToSql(binaryLeft, ref sb, context);
sb.Write(')');
sb.Write(OperatorToString(operation));
if (binaryRight != null)
{
sb.Write('(');
ConvertToSql(binaryRight, ref sb, context);
sb.Write(')');
}
else
{
sb.Write(" NULL");
}
context.MemberContext.OperatorStack.Pop();
}
public override bool OpenUrl(UIApplication app, NSUrl url, NSDictionary options)
{
Task.Run(async() =>
{
if ("Inbox".Equals(Path.GetFileName(Path.GetDirectoryName(url.Path))))
{
IFolder incoming = await App.Storage.CreateFolderAsync("Incoming", CreationCollisionOption.OpenIfExists);
IFile f = await FileSystem.Current.GetFileFromPathAsync(url.Path);
await f.MoveAsync(Path.Combine(incoming.Path, f.Name), NameCollisionOption.GenerateUniqueName);
Xamarin.Forms.Device.BeginInvokeOnMainThread(async() =>
{
App.MainTab.SelectedItem = App.MainTab.Children[3];
await App.MainTab.Children[3].Navigation.PopToRootAsync();
await App.MainTab.Children[3].Navigation.PushAsync(new FileBrowser(incoming));
});
}
else if (url.Path?.EndsWith(".cb5") ?? false)
{
url.StartAccessingSecurityScopedResource();
try {
//using (MemoryStream s = new MemoryStream()) {
// NSInputStream stream = NSInputStream.FromUrl(url);
// byte[] buffer = new byte[1024];
// while (stream.HasBytesAvailable()) {
// int read = (int)stream.Read(buffer, 1024);
// s.Write(buffer, 0, read);
// }
// s.Seek(0, SeekOrigin.Begin);
//NSFileHandle fs = NSFileHandle.OpenReadUrl(url, out NSError err);
//NSData data = fs.ReadDataToEndOfFile();
//fs.CloseFile();
//using (Stream f = data.AsStream()) {AsStream
//new MyInputStream(NSInputStream.FromUrl(url))) {
//NSData d = await url.LoadDataAsync("text/xml");
//File.OpenRead(url.Path)
using (Stream s = File.OpenRead(url.Path)) {
Player player = Player.Serializer.Deserialize(s) as Player;
BuilderContext Context = new BuilderContext(player);
PluginManager manager = new PluginManager();
manager.Add(new SpellPoints());
manager.Add(new SingleLanguage());
manager.Add(new CustomBackground());
manager.Add(new NoFreeEquipment());
Context.Plugins = manager;
Context.UndoBuffer = new LinkedList <Player>();
Context.RedoBuffer = new LinkedList <Player>();
Context.UnsavedChanges = 0;
Xamarin.Forms.Device.BeginInvokeOnMainThread(async() =>
{
LoadingProgress loader = new LoadingProgress(Context);
LoadingPage l = new LoadingPage(loader, false);
App.MainTab.SelectedItem = App.MainTab.Children[1];
await App.MainTab.Children[2].Navigation.PushModalAsync(l);
var t = l.Cancel.Token;
try
{
await loader.Load(t).ConfigureAwait(false);
t.ThrowIfCancellationRequested();
PlayerBuildModel model = new PlayerBuildModel(Context);
Xamarin.Forms.Device.BeginInvokeOnMainThread(async() =>
{
await App.MainTab.Children[1].Navigation.PopModalAsync(false);
await App.MainTab.Children[1].Navigation.PushModalAsync(new NavigationPage(new FlowPage(model)));
});
} catch (Exception e) {
ConfigManager.LogError(e);
}
});
}
url.StopAccessingSecurityScopedResource();
}
catch (Exception e)
{
ConfigManager.LogError(e);
}
}
else if (url.Path.StartsWith(App.Storage.Path, System.StringComparison.Ordinal))
{
Xamarin.Forms.Device.BeginInvokeOnMainThread(async() =>
{
App.MainTab.SelectedItem = App.MainTab.Children[3];
await App.MainTab.Children[3].Navigation.PopToRootAsync();
await App.MainTab.Children[3].Navigation.PushAsync(new FileBrowser(await FileSystem.Current.GetFolderFromPathAsync(Path.GetDirectoryName(url.Path))));
});
}
else
{
url.StartAccessingSecurityScopedResource();
IFolder incoming = await App.Storage.CreateFolderAsync("Incoming", CreationCollisionOption.OpenIfExists);
IFile target = await incoming.CreateFileAsync(url.LastPathComponent, CreationCollisionOption.GenerateUniqueName);
using (Stream f = File.OpenRead(url.Path))
{
using (Stream o = await target.OpenAsync(PCLStorage.FileAccess.ReadAndWrite))
{
await f.CopyToAsync(o);
}
}
url.StopAccessingSecurityScopedResource();
Xamarin.Forms.Device.BeginInvokeOnMainThread(async() =>
{
App.MainTab.SelectedItem = App.MainTab.Children[3];
await App.MainTab.Children[3].Navigation.PopToRootAsync();
await App.MainTab.Children[3].Navigation.PushAsync(new FileBrowser(incoming));
});
}
}).Forget();
return(true);
}
private void ConvertToSqlConstant(Expression exp, ref CharWriteBuffer sb, BuilderContext context)
{
var constant = exp as ConstantExpression;
ConvertToSqlConstantStack(constant.Type, constant.Value, ref sb, context);
}
public async Task <ResultStatus> TryExecuteRemote(Command command, BuilderContext builderContext, IExecuteContext executeContext, LocalCommandContext commandContext)
{
while (!CanSpawnParallelProcess())
{
await Task.Delay(1, command.CancellationToken);
}
var address = "Stride/CompilerApp/PackageBuilderApp/" + Guid.NewGuid();
var arguments = $"--slave=\"{address}\" --build-path=\"{builderOptions.BuildDirectory}\"";
using (var debugger = VisualStudioDebugger.GetAttached())
{
if (debugger != null)
{
arguments += $" --reattach-debugger={debugger.ProcessId}";
}
}
// Start ServiceWire pipe for communication with process
var processBuilderRemote = new ProcessBuilderRemote(assemblyContainer, commandContext, command);
var host = new NpHost(address, null, null, new StrideServiceWireSerializer());
host.AddService <IProcessBuilderRemote>(processBuilderRemote);
var startInfo = new ProcessStartInfo
{
// Note: try to get exec server if it exists, otherwise use CompilerApp.exe
FileName = (string)AppDomain.CurrentDomain.GetData("RealEntryAssemblyFile") ?? typeof(PackageBuilder).Assembly.Location,
Arguments = arguments,
WorkingDirectory = Environment.CurrentDirectory,
CreateNoWindow = true,
UseShellExecute = false,
RedirectStandardOutput = true,
RedirectStandardError = true,
};
host.Open();
var output = new List <string>();
var process = new Process {
StartInfo = startInfo
};
process.Start();
process.OutputDataReceived += (_, args) => LockProcessAndAddDataToList(process, output, args);
process.ErrorDataReceived += (_, args) => LockProcessAndAddDataToList(process, output, args);
process.BeginOutputReadLine();
process.BeginErrorReadLine();
// Note: we don't want the thread to schedule another job since the CPU core will be in use by the process, so we do a blocking WaitForExit.
process.WaitForExit();
host.Close();
NotifyParallelProcessEnded();
if (process.ExitCode != 0)
{
executeContext.Logger.Error($"Remote command crashed with output:{Environment.NewLine}{string.Join(Environment.NewLine, output)}");
}
if (processBuilderRemote.Result != null)
{
// Register results back locally
foreach (var outputObject in processBuilderRemote.Result.OutputObjects)
{
commandContext.RegisterOutput(outputObject.Key, outputObject.Value);
}
// Register log messages
foreach (var logMessage in processBuilderRemote.Result.LogMessages)
{
commandContext.Logger.Log(logMessage);
}
// Register tags
foreach (var tag in processBuilderRemote.Result.TagSymbols)
{
commandContext.AddTag(tag.Key, tag.Value);
}
}
return(command.CancellationToken.IsCancellationRequested ? ResultStatus.Cancelled : (process.ExitCode == 0 ? ResultStatus.Successful : ResultStatus.Failed));
}
private void ConvertToSqlConstantStack(Type type, object value, ref CharWriteBuffer sb, BuilderContext context)
{
if (context.MemberContext.MemberAccessStack.Count > 0)
{
var memberProperty = context.MemberContext.MemberAccessStack.Pop();
if (value == null)
{
sb.Write("NULL");
}
else
{
switch (memberProperty.Member.MemberType)
{
case MemberTypes.Field:
{
var field = memberProperty.Member as FieldInfo;
object fieldValue = field.GetValue(value);
ConvertToSqlConstantStack(field.FieldType, fieldValue, ref sb, context);
break;
}
case MemberTypes.Property:
{
var property = memberProperty.Member as PropertyInfo;
object propertyValue = property.GetValue(value);
ConvertToSqlConstantStack(property.PropertyType, propertyValue, ref sb, context);
break;
}
default:
throw new NotImplementedException();
}
}
context.MemberContext.MemberAccessStack.Push(memberProperty);
}
else
{
ConvertToSqlValue(type, value, ref sb, context);
}
}
private Expression AnalyzeBinaryBoolean(Expression expression, BuilderContext builderContext)
{
if (expression.Type != typeof(bool))
{
return(expression);
}
var bin = expression as BinaryExpression;
if (bin == null)
{
return(expression);
}
bool canOptimizeLeft = bin.Left.NodeType == ExpressionType.Constant && bin.Left.Type == typeof(bool);
bool canOptimizeRight = bin.Right.NodeType == ExpressionType.Constant && bin.Right.Type == typeof(bool);
if (canOptimizeLeft && canOptimizeRight)
{
return(Expression.Constant(expression.Evaluate()));
}
if (canOptimizeLeft || canOptimizeRight)
{
switch (expression.NodeType)
{
case ExpressionType.AndAlso:
if (canOptimizeLeft)
{
if ((bool)bin.Left.Evaluate())
{
return(bin.Right); // (TRUE and X) == X
}
else
{
return(bin.Left); // (FALSE and X) == FALSE
}
}
if (canOptimizeRight)
{
if ((bool)bin.Right.Evaluate())
{
return(bin.Left); // (X and TRUE) == X
}
else
{
return(bin.Right); // (X and FALSE) == FALSE
}
}
break;
case ExpressionType.OrElse:
if (canOptimizeLeft)
{
if ((bool)bin.Left.Evaluate())
{
return(bin.Left); // (TRUE or X) == TRUE
}
else
{
return(bin.Right); // (FALSE or X) == X
}
}
if (canOptimizeRight)
{
if ((bool)bin.Right.Evaluate())
{
return(bin.Right); // (X or TRUE) == TRUE
}
else
{
return(bin.Left); // (X or FALSE) == X
}
}
break;
case ExpressionType.Equal:
// TODO: this optimization should work for Unary Expression Too
// this actually produce errors becouse of string based Sql generation
canOptimizeLeft = canOptimizeLeft && bin.Right is BinaryExpression;
if (canOptimizeLeft)
{
if ((bool)bin.Left.Evaluate())
{
return(bin.Right); // (TRUE == X) == X
}
else
{
return(Expression.Not(bin.Right)); // (FALSE == X) == not X
}
}
canOptimizeRight = canOptimizeRight && bin.Left is BinaryExpression;
// TODO: this optimization should work for Unary Expression Too
// this actually produce errors becouse of string based Sql generation
if (canOptimizeRight)
{
if ((bool)bin.Right.Evaluate())
{
return(bin.Left); // (X == TRUE) == X
}
else
{
return(Expression.Not(bin.Left)); // (X == FALSE) == not X
}
}
break;
case ExpressionType.NotEqual:
canOptimizeLeft = canOptimizeLeft && bin.Right is BinaryExpression;
// TODO: this optimization should work for Unary Expression Too
// this actually produce errors becouse of string based Sql generation
if (canOptimizeLeft)
{
if ((bool)bin.Left.Evaluate())
{
return(Expression.Not(bin.Right)); // (TRUE != X) == not X
}
else
{
return(bin.Right); // (FALSE != X) == X
}
}
canOptimizeRight = canOptimizeRight && bin.Left is BinaryExpression;
// TODO: this optimization should work for Unary Expression Too
// this actually produce errors becouse of string based Sql generation
if (canOptimizeRight)
{
if ((bool)bin.Right.Evaluate())
{
return(Expression.Not(bin.Left)); // (X != TRUE) == not X
}
else
{
return(bin.Left); // (X != FALSE) == X
}
}
break;
}
}
return(expression);
}
protected abstract void ConvertToSqlParameterModel(ModelDetail modelDetail, ref CharWriteBuffer sb, BuilderContext context, bool parameterInContext);
public virtual void UnregisterParameter(InputParameterExpression expression, BuilderContext builderContext)
{
builderContext.ExpressionQuery.Parameters.Remove(expression);
}
/// <summary>
/// Registers an association
/// </summary>
/// <param name="tableExpression">The table holding the member, to become the joinedTable</param>
/// <param name="tableMemberInfo"></param>
/// <param name="otherType"></param>
/// <param name="builderContext"></param>
/// <returns></returns>
public virtual TableExpression RegisterAssociation(TableExpression tableExpression, MemberInfo tableMemberInfo,
Type otherType, BuilderContext builderContext)
{
IList <MemberInfo> otherKeys;
TableJoinType joinType;
string joinID;
var theseKeys = DataMapper.GetAssociation(tableExpression, tableMemberInfo, otherType, out otherKeys,
out joinType, out joinID, builderContext.QueryContext.DataContext);
// if the memberInfo has no corresponding association, we get a null, that we propagate
if (theseKeys == null)
{
return(null);
}
// the current table has the foreign key, the other table the referenced (usually primary) key
if (theseKeys.Count != otherKeys.Count)
{
throw Error.BadArgument("S0128: Association arguments (FK and ref'd PK) don't match");
}
// we first create the table, with the JoinID, and we MUST complete the table later, with the Join() method
var otherTableExpression = new TableExpression(otherType, DataMapper.GetTableName(otherType, builderContext.QueryContext.DataContext), joinID);
Expression joinExpression = null;
var createdColumns = new List <ColumnExpression>();
for (int keyIndex = 0; keyIndex < theseKeys.Count; keyIndex++)
{
// joinedKey is registered, even if unused by final select (required columns will be filtered anyway)
Expression otherKey = RegisterColumn(otherTableExpression, otherKeys[keyIndex], builderContext);
// foreign is created, we will store it later if this assocation is registered too
Expression thisKey = CreateColumn(tableExpression, theseKeys[keyIndex], builderContext);
createdColumns.Add((ColumnExpression)thisKey);
// if the key is nullable, then convert it
// TODO: this will probably need to be changed
if (otherKey.Type.IsNullable())
{
otherKey = Expression.Convert(otherKey, otherKey.Type.GetNullableType());
}
if (thisKey.Type.IsNullable())
{
thisKey = Expression.Convert(thisKey, thisKey.Type.GetNullableType());
}
// the other key is set as left operand, this must be this way
// since some vendors (SQL Server) don't support the opposite
var referenceExpression = Expression.Equal(otherKey, thisKey);
// if we already have a join expression, then we have a double condition here, so "AND" it
if (joinExpression != null)
{
joinExpression = Expression.And(joinExpression, referenceExpression);
}
else
{
joinExpression = referenceExpression;
}
}
// we complete the table here, now that we have all join information
otherTableExpression.Join(joinType, tableExpression, joinExpression);
// our table is created, with the expressions
// now check if we didn't register exactly the same
var existingTable = (from t in builderContext.EnumerateScopeTables() where t.IsEqualTo(otherTableExpression) select t).SingleOrDefault();
if (existingTable != null)
{
return(existingTable);
}
builderContext.CurrentSelect.Tables.Add(otherTableExpression);
foreach (var createdColumn in createdColumns)
{
builderContext.CurrentSelect.Columns.Add(createdColumn);
}
return(otherTableExpression);
}
public SLE.Expression MakeAssignExpression (BuilderContext ctx, Expression source)
{
return obj.Expression;
}
/// <summary>
/// Registers a where clause in the current context scope
/// </summary>
/// <param name="whereExpression"></param>
/// <param name="builderContext"></param>
public virtual void RegisterWhere(Expression whereExpression, BuilderContext builderContext)
{
builderContext.CurrentSelect.Where.Add(whereExpression);
}
public override SLE.Expression MakeExpression (BuilderContext ctx)
{
#if STATIC
return base.MakeExpression (ctx);
#else
return SLE.Expression.Block (expr.MakeExpression (ctx), SLE.Expression.Default (type.GetMetaInfo ()));
#endif
}
/// <summary>
/// Registers all columns of a table.
/// </summary>
/// <param name="tableExpression"></param>
/// <param name="builderContext"></param>
/// <returns></returns>
public virtual IEnumerable <ColumnExpression> RegisterAllColumns(TableExpression tableExpression, BuilderContext builderContext)
{
foreach (var metaMember in builderContext.QueryContext.DataContext.Mapping.GetTable(tableExpression.Type).RowType.PersistentDataMembers)
{
yield return(RegisterColumn(tableExpression, metaMember.Member, builderContext));
}
}
public override SLE.Expression MakeExpression (BuilderContext ctx)
{
return Binary.MakeExpression (ctx, Left, Right);
}
/// <summary>
/// Builds a Row builder, based on a given list of parameters
/// </summary>
/// <param name="tableType"></param>
/// <param name="parameters"></param>
/// <param name="builderContext"></param>
/// <returns></returns>
public virtual LambdaExpression BuildTableReader(Type tableType, IList <string> parameters, BuilderContext builderContext)
{
var dataRecordParameter = Expression.Parameter(typeof(IDataRecord), "dataRecord");
var mappingContextParameter = Expression.Parameter(typeof(MappingContext), "mappingContext");
//var table = builderContext.QueryContext.DataContext.Mapping.GetTable(tableType);
var bindings = new List <MemberBinding>();
for (int parameterIndex = 0; parameterIndex < parameters.Count; parameterIndex++)
{
var parameter = parameters[parameterIndex];
var memberInfo = tableType.GetTableColumnMember(parameter);
if (memberInfo == null)
{
memberInfo = tableType.GetSingleMember(parameter, BindingFlags.Public | BindingFlags.NonPublic
| BindingFlags.Instance | BindingFlags.IgnoreCase);
}
#if !MONO_STRICT
if (memberInfo == null && parameter.Contains('_'))
{
memberInfo = tableType.GetSingleMember(parameter.Replace("_", ""), BindingFlags.Public | BindingFlags.NonPublic
| BindingFlags.Instance | BindingFlags.IgnoreCase);
}
#endif
// TODO real error
if (memberInfo == null)
{
throw new ArgumentException(string.Format("Invalid column '{0}'", parameter));
}
//var column = DataMapper.GetColumnName(tableType, memberInfo, builderContext.QueryContext.DataContext);
//var columnName = DataMapper.GetColumnName(tableType, memberInfo, builderContext.QueryContext.DataContext);
var invoke = GetOutputValueReader(memberInfo.GetMemberType(), parameterIndex, //GetTableIndex(parameters, columnName),
dataRecordParameter, mappingContextParameter);
var parameterColumn = GetOutputValueReader(invoke, dataRecordParameter, mappingContextParameter,
builderContext);
var binding = Expression.Bind(memberInfo, parameterColumn);
bindings.Add(binding);
}
var newExpression = Expression.New(tableType);
var initExpression = Expression.MemberInit(newExpression, bindings);
return(Expression.Lambda(initExpression, dataRecordParameter, mappingContextParameter));
}
public override System.Linq.Expressions.Expression MakeExpression (BuilderContext ctx)
{
return expr.MakeExpression (ctx);
}
/// <summary>
/// Returns an existing table or registers the current one
/// </summary>
/// <param name="tableExpression"></param>
/// <param name="builderContext"></param>
/// <returns>A registered table or the current newly registered one</returns>
public virtual TableExpression RegisterTable(TableExpression tableExpression, BuilderContext builderContext)
{
// 1. Find the table in current scope
var foundTableExpression = (from t in builderContext.EnumerateScopeTables()
where t.IsEqualTo(tableExpression)
select t).SingleOrDefault();
if (foundTableExpression != null)
{
return(foundTableExpression);
}
// 2. Find it in all scopes, and promote it to current scope.
foundTableExpression = PromoteTable(tableExpression, builderContext);
if (foundTableExpression != null)
{
return(foundTableExpression);
}
// 3. Add it
builderContext.CurrentSelect.Tables.Add(tableExpression);
return(tableExpression);
}
