public DashboardEditorController()
{
eventButtons = new List <AnalysisEventButtonVM> ();
editDashboardKeyContext = new KeyContext();
editDashboardKeyContext.AddAction(
new KeyAction(App.Current.HotkeysService.GetByName(GeneralUIHotkeys.DELETE),
() => ViewModel.DeleteButton.Execute(ViewModel.Selection.FirstOrDefault()), 10)
);
}
protected override IBuildContext BuildMethodCall(ExpressionBuilder builder, MethodCallExpression methodCall, BuildInfo buildInfo)
{
var sequenceExpr = methodCall.Arguments[0];
var sequence = builder.BuildSequence(new BuildInfo(buildInfo, sequenceExpr));
var groupingType = methodCall.Type.GetGenericArgumentsEx()[0];
var keySelector = (LambdaExpression)methodCall.Arguments[1].Unwrap();
var elementSelector = (LambdaExpression)methodCall.Arguments[2].Unwrap();
if (methodCall.Arguments[0].NodeType == ExpressionType.Call)
{
var call = (MethodCallExpression)methodCall.Arguments[0];
if (call.Method.Name == "Select")
{
var type = ((LambdaExpression)call.Arguments[1].Unwrap()).Body.Type;
if (type.IsGenericTypeEx() && type.GetGenericTypeDefinition() == typeof(ExpressionBuilder.GroupSubQuery <,>))
{
sequence = new SubQueryContext(sequence);
}
}
}
var key = new KeyContext(buildInfo.Parent, keySelector, sequence);
var groupSql = builder.ConvertExpressions(key, keySelector.Body.Unwrap(), ConvertFlags.Key);
if (sequence.SelectQuery.Select.IsDistinct ||
sequence.SelectQuery.GroupBy.Items.Count > 0 ||
groupSql.Any(_ => !(_.Sql is SqlField || _.Sql is SelectQuery.Column)))
{
sequence = new SubQueryContext(sequence);
key = new KeyContext(buildInfo.Parent, keySelector, sequence);
groupSql = builder.ConvertExpressions(key, keySelector.Body.Unwrap(), ConvertFlags.Key);
}
foreach (var sql in groupSql)
{
sequence.SelectQuery.GroupBy.Expr(sql.Sql);
}
new QueryVisitor().Visit(sequence.SelectQuery.From, e =>
{
if (e.ElementType == QueryElementType.JoinedTable)
{
var jt = (SelectQuery.JoinedTable)e;
if (jt.JoinType == SelectQuery.JoinType.Inner)
{
jt.IsWeak = false;
}
}
});
var element = new SelectContext(buildInfo.Parent, elementSelector, sequence /*, key*/);
var groupBy = new GroupByContext(buildInfo.Parent, sequenceExpr, groupingType, sequence, key, element);
return(groupBy);
}
public void NextIdentity_CallTenTimes_ShouldIncrementEachCall()
{
var keyContext = new KeyContext();
for (var i = 1; i <= 10; i++)
{
Assert.That(keyContext.NextIdentity, Is.EqualTo(i));
}
}
public GroupByContext(IBuildContext parent, Expression sequenceExpr, Type groupingType, IBuildContext sequence, KeyContext key, SelectContext element)
: base(parent, sequence, null)
{
_sequenceExpr = sequenceExpr;
_key = key;
_element = element;
_groupingType = groupingType;
key.Parent = this;
}
protected override IParseContext ParseMethodCall(ExpressionParser parser, IParseContext parent, MethodCallExpression methodCall, SqlQuery sqlQuery)
{
var sequence = parser.ParseSequence(parent, methodCall.Arguments[0], sqlQuery);
var sequenceExpr = methodCall.Arguments[0];
var groupingType = methodCall.Type.GetGenericArguments()[0];
var keySelector = (LambdaExpression)methodCall.Arguments[1].Unwrap();
var elementSelector = (LambdaExpression)methodCall.Arguments[2].Unwrap();
if (methodCall.Arguments[0].NodeType == ExpressionType.Call)
{
var call = (MethodCallExpression)methodCall.Arguments[0];
if (call.Method.Name == "Select")
{
var type = ((LambdaExpression)call.Arguments[1].Unwrap()).Body.Type;
if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(ExpressionParser.GroupSubQuery<,>))
{
sequence = new SubQueryContext(sequence);
}
}
}
var key = new KeyContext(keySelector, sequence);
var groupSql = parser.ParseExpressions(key, keySelector.Body.Unwrap(), ConvertFlags.Key);
if (groupSql.Any(_ => !(_.Sql is SqlField || _.Sql is SqlQuery.Column)))
{
sequence = new SubQueryContext(sequence);
key = new KeyContext(keySelector, sequence);
groupSql = parser.ParseExpressions(key, keySelector.Body.Unwrap(), ConvertFlags.Key);
}
sequence.SqlQuery.GroupBy.Items.Clear();
foreach (var sql in groupSql)
sequence.SqlQuery.GroupBy.Expr(sql.Sql);
new QueryVisitor().Visit(sequence.SqlQuery.From, e =>
{
if (e.ElementType == QueryElementType.JoinedTable)
{
var jt = (SqlQuery.JoinedTable)e;
if (jt.JoinType == SqlQuery.JoinType.Inner)
jt.IsWeak = false;
}
});
var element = new SelectContext (elementSelector, sequence);
var groupBy = new GroupByContext(sequenceExpr, groupingType, sequence, key, element);
return groupBy;
}
public void TestKeyContextWithOnlyPlayAction()
{
KeyContext context = new KeyContext();
context.AddAction(play);
App.Current.KeyContextManager.NewKeyContexts(new List <KeyContext> {
context
});
App.Current.KeyContextManager.HandleKeyPressed(spaceHotkey);
App.Current.KeyContextManager.HandleKeyPressed(rightHotkey);
Assert.AreEqual(1, countPlay);
Assert.AreEqual(0, countForward);
}
public void FixtureTearDown()
{
using (var context = new KeyContext())
{
foreach (var id in keys)
{
var key = context.Keys.FirstOrDefault(k => k.ID == id);
context.Keys.Remove(key);
context.SaveChanges();
var keyAudits = context.KeyAudits.Where(ke => ke.ID == id);
context.KeyAudits.RemoveRange(keyAudits);
context.SaveChanges();
}
}
}
public ActionResult Delete(int id, Key deleteKey)
{
try
{
using (var context = new KeyContext())
{
Key key = context.Keys.FirstOrDefault(k => k.ID == id);
context.Keys.Remove(key);
context.SaveChanges();
}
return(RedirectToAction("Index"));
}
catch (Exception e)
{
return(View("Error", e));
}
}
public async Task SetUp()
{
var dashboard = Utils.DashboardDummy.Default();
dashboard.InsertTimer();
dashboardVM = new DashboardVM {
Model = dashboard
};
dashboardVM.Mode = DashboardMode.Edit;
var viewModel = new DummyDashboardManagerVM(dashboardVM);
controller = new DashboardEditorController();
controller.SetViewModel(viewModel);
await controller.Start();
KeyContext context = new KeyContext();
}
public ActionResult Create(int?id, Key newKey)
{
try
{
newKey.Updated = DateTime.Now;
using (var context = new KeyContext())
{
context.Keys.Add(newKey);
context.SaveChanges();
}
return(RedirectToAction("Index"));
}
catch (Exception e)
{
return(View("Error", e));
}
}
public ActionResult Edit(int id, Key editKey)
{
try
{
editKey.Updated = DateTime.Now;
using (var context = new KeyContext())
{
context.Entry(editKey).State = EntityState.Modified;
context.SaveChanges();
}
return(RedirectToAction("Index"));
}
catch (Exception e)
{
return(View("Error", e));
}
}
public void HandleSubcategories_OneSubElementTagged_TempContextCreated()
{
// Arrange
KeyContext context = new KeyContext();
context.KeyActions.AddRange((List <KeyAction>)controller.GetDefaultKeyActions());
App.Current.KeyContextManager.AddContext(context);
HotKey key = App.Current.Keyboard.ParseName("h");
HotKey subkey = App.Current.Keyboard.ParseName("t");
projectVM.Dashboard.ViewModels [0].HotKey.Model = key;
((AnalysisEventButtonVM)projectVM.Dashboard.ViewModels [0]).Tags.First().HotKey = subkey;
((AnalysisEventButtonVM)projectVM.Dashboard.ViewModels [0]).CurrentTime = new Time();
AutoResetEvent resetEvent = new AutoResetEvent(false);
mockToolkit.Setup(x => x.Invoke(It.IsAny <EventHandler> ())).Callback((EventHandler e) => {
Task actionExecution = Task.Factory.StartNew(() => e(null, null));
actionExecution.Wait();
resetEvent.Set();
});
int taggedElements = 0;
bool newTagEventCreated = false;
App.Current.EventsBroker.Subscribe <NewTagEvent> ((x) => {
newTagEventCreated = true;
taggedElements = x.Tags.Count;
});
// Act
int existentContexts = App.Current.KeyContextManager.CurrentKeyContexts.Count;
App.Current.KeyContextManager.HandleKeyPressed(key);
App.Current.KeyContextManager.HandleKeyPressed(subkey);
Thread.Sleep(1000); // time has to be expired
Task.Factory.StartNew(() => timer.Raise(x => x.Elapsed += null, new EventArgs() as ElapsedEventArgs));
resetEvent.WaitOne(1000);
// Assert
Assert.IsTrue(newTagEventCreated);
Assert.AreEqual(1, taggedElements);
Assert.AreEqual(0, ((AnalysisEventButtonVM)projectVM.Dashboard.ViewModels [0]).SelectedTags.Count);
}
public void TestAddTemporalContext()
{
KeyContext context = new KeyContext();
context.AddAction(forward);
context.AddAction(play);
KeyContext tempContext = new KeyContext();
tempContext.AddAction(fastForward);
App.Current.KeyContextManager.NewKeyContexts(new List <KeyContext> {
context
});
App.Current.KeyContextManager.AddContext(tempContext);
Assert.AreEqual(tempContext,
App.Current.KeyContextManager.CurrentKeyContexts [
App.Current.KeyContextManager.CurrentKeyContexts.Count - 1]);
}
public void TestHotkeyNotFallbacksCorrectly()
{
bool fallback = false;
VAS.App.Current.EventsBroker.Subscribe <KeyPressedEvent> (
(e) => fallback = true
);
KeyContext context = new KeyContext();
context.AddAction(play);
context.AddAction(forward);
App.Current.KeyContextManager.NewKeyContexts(new List <KeyContext> {
context
});
App.Current.KeyContextManager.HandleKeyPressed(spaceHotkey);
Assert.AreEqual(false, fallback);
}
public GroupByContext(
IBuildContext?parent,
Expression sequenceExpr,
Type groupingType,
IBuildContext sequence,
KeyContext key,
SelectContext element,
bool isGroupingGuardDisabled)
: base(parent, sequence, null)
{
_sequenceExpr = sequenceExpr;
_key = key;
Element = element;
_groupingType = groupingType;
_isGroupingGuardDisabled = isGroupingGuardDisabled;
key.Parent = this;
}
public void Test_TagAndUntag_HomePlayer1()
{
// Arrange
KeyContext context = new KeyContext();
context.KeyActions.AddRange((List <KeyAction>)controller.GetDefaultKeyActions());
App.Current.KeyContextManager.AddContext(context);
HotKey homeTeamKey = App.Current.Keyboard.ParseName("<Shift_L>+n");
HotKey player1Key = App.Current.Keyboard.ParseName("1");
// Act
bool taggedStart = projectVM.HomeTeam.ViewModels
.FirstOrDefault(x => ((LMPlayerVM)x).Number == Convert.ToInt32("1"))
.Tagged;
resetEvent.Reset();
App.Current.KeyContextManager.HandleKeyPressed(homeTeamKey);
App.Current.KeyContextManager.HandleKeyPressed(player1Key);
Thread.Sleep(1000);
Task.Factory.StartNew(() => timer.Raise(x => x.Elapsed += null, new EventArgs() as ElapsedEventArgs));
resetEvent.WaitOne(1000);
bool taggedOnce = projectVM.HomeTeam.ViewModels
.FirstOrDefault(x => ((LMPlayerVM)x).Number == Convert.ToInt32("1"))
.Tagged;
resetEvent.Reset();
App.Current.KeyContextManager.HandleKeyPressed(homeTeamKey);
App.Current.KeyContextManager.HandleKeyPressed(player1Key);
Thread.Sleep(1000);
Task.Factory.StartNew(() => timer.Raise(x => x.Elapsed += null, new EventArgs() as ElapsedEventArgs));
resetEvent.WaitOne(1000);
bool taggedTwice = projectVM.HomeTeam.ViewModels
.FirstOrDefault(x => ((LMPlayerVM)x).Number == Convert.ToInt32("1"))
.Tagged;
// Assert
Assert.AreEqual(taggedStart, !taggedOnce);
Assert.AreEqual(taggedOnce, !taggedTwice);
}
private KeyContext GenerateSshKey()
{
var random = new SecureRandom(new CryptoApiRandomGenerator());
var strength = 2048;
var parameters = new KeyGenerationParameters(random, strength);
var keyPairGenerator = new RsaKeyPairGenerator();
keyPairGenerator.Init(parameters);
var keyPair = keyPairGenerator.GenerateKeyPair();
var keyContext = new KeyContext();
// var privateKeyInfo = PrivateKeyInfoFactory.CreatePrivateKeyInfo(keyPair.Private);
// var privateKey = Convert.ToBase64String(privateKeyInfo.GetEncoded(Asn1Encodable.Ber));
using (var writer = new StringWriter())
{
var pem = new PemWriter(writer);
pem.WriteObject(keyPair.Private);
keyContext.PrivateKey = writer.ToString();
}
var publicKeyParameter = (RsaKeyParameters)keyPair.Public;
using (var memory = new MemoryStream())
{
WriteBytes(memory, Encoding.ASCII.GetBytes("ssh-rsa"));
WriteBytes(memory, publicKeyParameter.Exponent.ToByteArray());
WriteBytes(memory, publicKeyParameter.Modulus.ToByteArray());
var publicKeyBase64 = Convert.ToBase64String(memory.ToArray());
keyContext.PublicKey = $"ssh-rsa {publicKeyBase64} generated-key";
}
_secretTracker.AddSecret(keyContext.PrivateKey);
return(keyContext);
}
public KeyContext key()
{
KeyContext _localctx = new KeyContext(Context, State);
EnterRule(_localctx, 4, RULE_key);
try {
EnterOuterAlt(_localctx, 1);
{
State = 21;
Match(ELEMENT);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
ErrorHandler.ReportError(this, re);
ErrorHandler.Recover(this, re);
}
finally {
ExitRule();
}
return(_localctx);
}
public KeyContext key()
{
KeyContext _localctx = new KeyContext(Context, State);
EnterRule(_localctx, 10, RULE_key);
try {
State = 60;
switch (TokenStream.La(1))
{
case IDENTIFIER:
_localctx = new IdentifierKeyContext(_localctx);
EnterOuterAlt(_localctx, 1);
{
State = 58; ((IdentifierKeyContext)_localctx).Key = Match(IDENTIFIER);
}
break;
case STRING:
_localctx = new StringKeyContext(_localctx);
EnterOuterAlt(_localctx, 2);
{
State = 59; ((StringKeyContext)_localctx).Key = Match(STRING);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
ErrorHandler.ReportError(this, re);
ErrorHandler.Recover(this, re);
}
finally {
ExitRule();
}
return(_localctx);
}
protected Task <bool> Initialize(dynamic data)
{
CreateViewModel(data);
CreateControllers(data);
foreach (IController controller in Controllers)
{
controller.SetViewModel(ViewModel);
}
Panel.SetViewModel(ViewModel);
foreach (IController controller in Controllers)
{
KeyContext.KeyActions.AddRange(controller.GetDefaultKeyActions());
}
KeyContext panelKeyContext = Panel?.GetKeyContext();
if (panelKeyContext != null)
{
KeyContext.KeyActions.AddRange(panelKeyContext.KeyActions);
}
return(AsyncHelpers.Return(true));
}
public KeyContext GetKeyContext()
{
var keyContext = new KeyContext();
keyContext.AddAction(
new VKeyAction(App.Current.HotkeysService.GetByName(GeneralUIHotkeys.ZOOM_IN),
() => codingwidget1.ZoomIn()));
keyContext.AddAction(
new VKeyAction(App.Current.HotkeysService.GetByName(GeneralUIHotkeys.ZOOM_OUT),
() => codingwidget1.ZoomOut()));
keyContext.AddAction(
new VKeyAction(App.Current.HotkeysService.GetByName(GeneralUIHotkeys.FIT_TIMELINE),
() => codingwidget1.FitTimeline()));
keyContext.AddAction(
new VKeyAction(App.Current.HotkeysService.GetByName(LMGeneralUIHotkeys.SHOW_DASHBOARD),
() => codingwidget1.ShowDashboard()));
keyContext.AddAction(
new VKeyAction(App.Current.HotkeysService.GetByName(LMGeneralUIHotkeys.SHOW_TIMELINE),
() => codingwidget1.ShowTimeline()));
return(keyContext);
}
public StringKeyContext(KeyContext context)
{
CopyFrom(context);
}
public void NextIdentity_FirstCall_ShouldReturnOne()
{
var keyContext = new KeyContext();
Assert.That(keyContext.NextIdentity, Is.EqualTo(1));
}
protected override IBuildContext BuildMethodCall(ExpressionBuilder builder, MethodCallExpression methodCall, BuildInfo buildInfo)
{
var sequenceExpr = methodCall.Arguments[0];
var wrapSequence = false;
LambdaExpression?groupingKey = null;
var groupingKind = GroupingType.Default;
if (sequenceExpr.NodeType == ExpressionType.Call)
{
var call = (MethodCallExpression)methodCall.Arguments[0];
if (call.IsQueryable("Select"))
{
var selectParam = (LambdaExpression)call.Arguments[1].Unwrap();
var type = selectParam.Body.Type;
if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(ExpressionBuilder.GroupSubQuery <,>))
{
wrapSequence = true;
var selectParamBody = selectParam.Body.Unwrap();
MethodCallExpression?groupingMethod = null;
if (selectParamBody is MemberInitExpression mi)
{
var assignment = mi.Bindings.OfType <MemberAssignment>().FirstOrDefault(m => m.Member.Name == "Key");
if (assignment?.Expression.NodeType == ExpressionType.Call)
{
var mc = (MethodCallExpression)assignment.Expression;
if (mc.IsSameGenericMethod(Methods.LinqToDB.GroupBy.Rollup, Methods.LinqToDB.GroupBy.Cube, Methods.LinqToDB.GroupBy.GroupingSets))
{
groupingMethod = mc;
groupingKey = (LambdaExpression)mc.Arguments[0].Unwrap();
if (mc.IsSameGenericMethod(Methods.LinqToDB.GroupBy.Rollup))
{
groupingKind = GroupingType.Rollup;
}
else if (mc.IsSameGenericMethod(Methods.LinqToDB.GroupBy.Cube))
{
groupingKind = GroupingType.Cube;
}
else if (mc.IsSameGenericMethod(Methods.LinqToDB.GroupBy.GroupingSets))
{
groupingKind = GroupingType.GroupBySets;
}
else
{
throw new InvalidOperationException();
}
}
}
}
if (groupingMethod != null && groupingKey != null)
{
sequenceExpr = sequenceExpr.Replace(groupingMethod, groupingKey.Body.Unwrap());
}
}
}
}
var sequence = builder.BuildSequence(new BuildInfo(buildInfo, sequenceExpr));
var keySequence = sequence;
var groupingType = methodCall.Type.GetGenericArguments()[0];
var keySelector = (LambdaExpression)methodCall.Arguments[1].Unwrap() !;
var elementSelector = (LambdaExpression)methodCall.Arguments[2].Unwrap() !;
if (wrapSequence)
{
sequence = new SubQueryContext(sequence);
}
sequence = new SubQueryContext(sequence);
var key = new KeyContext(buildInfo.Parent, keySelector, sequence);
if (groupingKind != GroupingType.GroupBySets)
{
var groupSql = builder.ConvertExpressions(key, keySelector.Body.Unwrap(), ConvertFlags.Key, null);
var allowed = groupSql.Where(s => !QueryHelper.IsConstant(s.Sql));
foreach (var sql in allowed)
{
sequence.SelectQuery.GroupBy.Expr(sql.Sql);
}
}
else
{
var goupingSetBody = groupingKey !.Body;
var groupingSets = EnumGroupingSets(goupingSetBody).ToArray();
if (groupingSets.Length == 0)
{
throw new LinqException($"Invalid groping sets expression '{goupingSetBody}'.");
}
foreach (var groupingSet in groupingSets)
{
var groupSql = builder.ConvertExpressions(keySequence, groupingSet, ConvertFlags.Key, null);
sequence.SelectQuery.GroupBy.Items.Add(
new SqlGroupingSet(groupSql.Select(s => keySequence.SelectQuery.Select.AddColumn(s.Sql))));
}
}
sequence.SelectQuery.GroupBy.GroupingType = groupingKind;
var element = new SelectContext(buildInfo.Parent, elementSelector, sequence /*, key*/);
var groupBy = new GroupByContext(buildInfo.Parent, sequenceExpr, groupingType, sequence, key, element, builder.IsGroupingGuardDisabled);
Debug.WriteLine("BuildMethodCall GroupBy:\n" + groupBy.SelectQuery);
return(groupBy);
}
public KeyRepository(KeyContext context)
{
_context = context;
}
public KeyContext key()
{
KeyContext _localctx = new KeyContext(Context, State);
EnterRule(_localctx, 6, RULE_key);
int _la;
try {
EnterOuterAlt(_localctx, 1);
{
State = 71;
ErrorHandler.Sync(this);
_la = TokenStream.LA(1);
do
{
{
State = 71;
ErrorHandler.Sync(this);
switch (TokenStream.LA(1))
{
case PLAINCHAR:
{
State = 68; Match(PLAINCHAR);
}
break;
case ESCAPE:
{
State = 69; Match(ESCAPE);
State = 70;
_la = TokenStream.LA(1);
if (!((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ESCAPE) | (1L << SPACE) | (1L << PAIR_SEPERATOR) | (1L << PLAINCHAR))) != 0)))
{
ErrorHandler.RecoverInline(this);
}
else
{
ErrorHandler.ReportMatch(this);
Consume();
}
}
break;
default:
throw new NoViableAltException(this);
}
}
State = 73;
ErrorHandler.Sync(this);
_la = TokenStream.LA(1);
} while (_la == ESCAPE || _la == PLAINCHAR);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
ErrorHandler.ReportError(this, re);
ErrorHandler.Recover(this, re);
}
finally {
ExitRule();
}
return(_localctx);
}
protected override IBuildContext BuildMethodCall(ExpressionBuilder builder, MethodCallExpression methodCall, BuildInfo buildInfo)
{
var sequenceExpr = methodCall.Arguments[0];
var sequence = builder.BuildSequence(new BuildInfo(buildInfo, sequenceExpr));
var groupingType = methodCall.Type.GetGenericArgumentsEx()[0];
var keySelector = (LambdaExpression)methodCall.Arguments[1].Unwrap();
var elementSelector = (LambdaExpression)methodCall.Arguments[2].Unwrap();
if (methodCall.Arguments[0].NodeType == ExpressionType.Call)
{
var call = (MethodCallExpression)methodCall.Arguments[0];
if (call.Method.Name == "Select")
{
var type = ((LambdaExpression)call.Arguments[1].Unwrap()).Body.Type;
if (type.IsGenericTypeEx() && type.GetGenericTypeDefinition() == typeof(ExpressionBuilder.GroupSubQuery <,>))
{
sequence = new SubQueryContext(sequence);
}
}
}
var key = new KeyContext(buildInfo.Parent, keySelector, sequence);
var groupSql = builder.ConvertExpressions(key, keySelector.Body.Unwrap(), ConvertFlags.Key);
if (sequence.SelectQuery.Select.IsDistinct ||
sequence.SelectQuery.GroupBy.Items.Count > 0 ||
groupSql.Any(_ => !(_.Sql is SqlField || _.Sql is SelectQuery.Column)))
{
sequence = new SubQueryContext(sequence);
key = new KeyContext(buildInfo.Parent, keySelector, sequence);
groupSql = builder.ConvertExpressions(key, keySelector.Body.Unwrap(), ConvertFlags.Key);
}
else if (groupSql.Length == 1 && groupSql.Any(_ => _.Sql is SelectQuery.Column))
{
//var columns = (SelectQuery.Column) groupSql[0]. Sql;
//var value = columns.Expression as SqlValue;
//if (value != null && value.SystemType.Name.Equals("String"))
//{
// // var allColumns = value.Value.ToString().Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
// sequence.SelectQuery.GroupBy.Items.Add(new SqlField {Name = value.Value.ToString(),PhysicalName ="columnString" });
// }
}
foreach (var sql in groupSql)
{
sequence.SelectQuery.GroupBy.Expr(sql.Sql);
}
new QueryVisitor().Visit(sequence.SelectQuery.From, (e, table_cloumn) =>
{
if (e.ElementType == QueryElementType.JoinedTable)
{
var jt = (SelectQuery.JoinedTable)e;
if (jt.JoinType == SelectQuery.JoinType.Inner)
{
jt.IsWeak = false;
}
}
});
var element = new SelectContext(buildInfo.Parent, elementSelector, sequence /*, key*/);
var groupBy = new GroupByContext(buildInfo.Parent, sequenceExpr, groupingType, sequence, key, element);
return(groupBy);
}
public KeysController(KeyContext context)
{
_context = context;
}
public virtual void CopyFrom(KeyContext context)
{
base.CopyFrom(context);
}
public IdentifierKeyContext(KeyContext context)
{
CopyFrom(context);
}
