public HomeController(NoteDBContext noteDBContext, IStyle style, ISortOrder sortOrder, IFilter filter)
{
_noteDBContext = noteDBContext;
_style = style;
_sortOrder = sortOrder;
_filter = filter;
}
public Task <IGridData <string> > GetAsync(GridRange gridRange, ISortOrder sortOrder = null)
{
var t = GridDataSource.GetGridDataAsync(_evaluation.Expression, gridRange, sortOrder);
if (t == null)
{
// May happen when R host is not running
Trace.Fail(Invariant($"{nameof(VariableViewModel)} returned null grid data"));
return(Task.FromResult <IGridData <string> >(null));
}
return(t);
}
public static async Task<IGridData<string>> GetGridDataAsync(IRSession rSession, string expression, GridRange? gridRange, ISortOrder sortOrder = null) {
await TaskUtilities.SwitchToBackgroundThread();
string rows = gridRange?.Rows.ToRString();
string columns = gridRange?.Columns.ToRString();
string rowSelector = (sortOrder != null && !sortOrder.IsEmpty) ? sortOrder.GetRowSelector() : "";
string expr = Invariant($"rtvs:::grid_data({expression}, {rows}, {columns}, {rowSelector})");
try {
return await rSession.EvaluateAsync<GridData>(expr, REvaluationKind.Normal);
} catch (RException ex) {
var message = Invariant($"Grid data evaluation failed:{Environment.NewLine}{ex.Message}");
await VsAppShell.Current.Services.Log.WriteAsync(LogVerbosity.Normal, MessageCategory.Error, message);
return null;
}
}
protected virtual void OnRowInserted(PXCache sender, PXRowInsertedEventArgs e)
{
if (e.Row != null)
{
Table focus = GetFocus();
if (focus != null)
{
InsertAboveFocus((Table)e.Row, focus);
}
ISortOrder row = (ISortOrder)e.Row;
if (row.SortOrder == null)
{
row.SortOrder = row.LineNbr;
}
}
}
public GenericFluentEventQuery <T> EventQuery <T, TSort>(DateTime fromDate, DateTime toDate, ISortableLimit limit, int limitCount, ISortOrder sortOrder, Expression <Func <T, TSort> > sortProperty, string queryName = "ChronologicalQuery") where T : new()
{
var populatedSortProperty = Property <TSort> .Create(sortProperty);
var populatedSort = Sort.Create(sortOrder, populatedSortProperty);
var populatedLimit = Limit.CreateLimit(limit, limitCount, populatedSort);
return(new GenericFluentEventQuery <T>(queryName, Search.Span(fromDate, toDate), populatedLimit, this));
}
private async Task DrawVisualsAsync(GridUpdateType updateType, bool suppressNotification, CancellationToken token, ISortOrder sortOrder) {
Rect visualViewport = new Rect(
Points.HorizontalOffset,
Points.VerticalOffset,
Points.ViewportWidth,
Points.ViewportHeight);
GridRange newViewport = Points.ComputeDataViewport(visualViewport);
if (newViewport.Rows.Count < 1 || newViewport.Columns.Count < 1) {
return;
}
// pull data from provider
try {
var data = await DataProvider.GetAsync(newViewport, sortOrder);
if (data == null) {
throw new InvalidOperationException("Couldn't fetch grid data");
}
if (!data.Grid.Range.Contains(newViewport)
|| !data.ColumnHeader.Range.Contains(newViewport.Columns)
|| !data.RowHeader.Range.Contains(newViewport.Rows)) {
throw new InvalidOperationException("Couldn't acquire enough data");
}
// actual drawing runs in UI thread
await Task.Factory.StartNew(
() => DrawVisuals(newViewport, data, updateType, visualViewport, suppressNotification),
token,
TaskCreationOptions.None,
_ui);
} catch (OperationCanceledException) { }
}
public static Task <IGridData <string> > GetGridDataAsync(string expression, GridRange?gridRange, ISortOrder sortOrder = null) => GetGridDataAsync(VsAppShell.Current.ExportProvider.GetExportedValue <IRInteractiveWorkflowProvider>().GetOrCreate().RSession, expression, gridRange, sortOrder);
public static async Task <IGridData <string> > GetGridDataAsync(IRSession rSession, string expression, GridRange?gridRange, ISortOrder sortOrder = null)
{
await TaskUtilities.SwitchToBackgroundThread();
string rows = gridRange?.Rows.ToRString();
string columns = gridRange?.Columns.ToRString();
string rowSelector = (sortOrder != null && !sortOrder.IsEmpty) ? sortOrder.GetRowSelector() : "";
string expr = Invariant($"rtvs:::grid_data({expression}, {rows}, {columns}, {rowSelector})");
using (var evaluator = await rSession.BeginEvaluationAsync()) {
try {
return(await evaluator.EvaluateAsync <GridData>(expr, REvaluationKind.Normal));
} catch (RException ex) {
var message = Invariant($"Grid data evaluation failed:{Environment.NewLine}{ex.Message}");
GeneralLog.Write(message);
return(null);
}
}
}
private async Task DrawVisualsAsync(GridUpdateType updateType, bool suppressNotification, CancellationToken token, ISortOrder sortOrder)
{
var visualViewport = new Rect(Points.HorizontalOffset, Points.VerticalOffset, Points.ViewportWidth, Points.ViewportHeight);
var newViewport = Points.ComputeDataViewport(visualViewport);
if (newViewport.Rows.Count < 1 || newViewport.Columns.Count < 1)
{
return;
}
// pull data from provider
try {
var data = await DataProvider.GetAsync(newViewport, sortOrder);
if (data == null)
{
throw new InvalidOperationException("Couldn't fetch grid data");
}
if (!data.Grid.Range.Contains(newViewport) ||
!data.ColumnHeader.Range.Contains(newViewport.Columns) ||
!data.RowHeader.Range.Contains(newViewport.Rows))
{
throw new InvalidOperationException("Couldn't acquire enough data");
}
await DrawVisualsAsync(newViewport, data, updateType, visualViewport, suppressNotification, token);
} catch (OperationCanceledException) { }
}
public static async Task <IGridData <string> > GetGridDataAsync(IRSession rSession, string expression, GridRange?gridRange, ISortOrder sortOrder = null)
{
await TaskUtilities.SwitchToBackgroundThread();
string rows = gridRange?.Rows.ToRString();
string columns = gridRange?.Columns.ToRString();
string rowSelector = (sortOrder != null && !sortOrder.IsEmpty) ? sortOrder.GetRowSelector() : "";
string expr = Invariant($"rtvs:::grid_data({expression}, {rows}, {columns}, {rowSelector})");
try {
return(await rSession.EvaluateAsync <GridData>(expr, REvaluationKind.Normal));
} catch (RException ex) {
var message = Invariant($"Grid data evaluation failed:{Environment.NewLine}{ex.Message}");
VsAppShell.Current.Services.Log.Write(LogVerbosity.Normal, MessageCategory.Error, message);
return(null);
}
}
private async Task DrawVisualsAsync(GridUpdateType updateType, bool suppressNotification, CancellationToken token, ISortOrder sortOrder)
{
Rect visualViewport = new Rect(
Points.HorizontalOffset,
Points.VerticalOffset,
Points.ViewportWidth,
Points.ViewportHeight);
GridRange newViewport = Points.ComputeDataViewport(visualViewport);
if (newViewport.Rows.Count < 1 || newViewport.Columns.Count < 1)
{
return;
}
// pull data from provider
try {
var data = await DataProvider.GetAsync(newViewport, sortOrder);
if (!data.Grid.Range.Contains(newViewport) ||
!data.ColumnHeader.Range.Contains(newViewport.Columns) ||
!data.RowHeader.Range.Contains(newViewport.Rows))
{
throw new InvalidOperationException("Couldn't acquire enough data");
}
// actual drawing runs in UI thread
await Task.Factory.StartNew(
() => DrawVisuals(newViewport, data, updateType, visualViewport, suppressNotification),
token,
TaskCreationOptions.None,
_ui);
} catch (OperationCanceledException) { }
}
public async Task <IGridData <string> > GetGridDataAsync(string expression, GridRange?gridRange, ISortOrder sortOrder = null)
{
await TaskUtilities.SwitchToBackgroundThread();
var rows = gridRange?.Rows.ToRString();
var columns = gridRange?.Columns.ToRString();
var rowSelector = (sortOrder != null && !sortOrder.IsEmpty) ? sortOrder.GetRowSelector() : "";
if (_gridData != null && _expression == expression && _rows == rows && _columns == columns && _rowSelector == rowSelector)
{
return(_gridData);
}
var expr = Invariant($"rtvs:::grid_data({expression}, {rows}, {columns}, {rowSelector})");
try {
_gridData = await _session.EvaluateAsync <GridData>(expr, REvaluationKind.Normal);
_expression = expression;
_rows = rows;
_columns = columns;
_rowSelector = rowSelector;
} catch (RException ex) {
var message = Invariant($"Grid data evaluation failed:{Environment.NewLine}{ex.Message}");
VsAppShell.Current.Log().Write(LogVerbosity.Normal, MessageCategory.Error, message);
}
return(_gridData);
}
public static async Task <IGridData <string> > GetGridDataAsync(string expression, GridRange?gridRange, ISortOrder sortOrder = null)
{
await TaskUtilities.SwitchToBackgroundThread();
var rSession = VsAppShell.Current.ExportProvider.GetExportedValue <IRSessionProvider>().GetInteractiveWindowRSession();
string rows = gridRange?.Rows.ToRString();
string columns = gridRange?.Columns.ToRString();
using (var evaluator = await rSession.BeginEvaluationAsync()) {
try {
string exp;
if (sortOrder != null && !sortOrder.IsEmpty)
{
if (gridRange.Value.Columns.Count > 1)
{
string dataFrameSortExpression = sortOrder.GetDataFrameSortFunction();
exp = Invariant($"rtvs:::grid_data({expression}, {rows}, {columns}, {dataFrameSortExpression.ToRStringLiteral()})");
}
else
{
int sortType = sortOrder.IsPrimaryDescending ? 2 : 1;
exp = Invariant($"rtvs:::grid_data({expression}, {rows}, {columns}, NULL, {sortType})");
}
}
else
{
exp = Invariant($"rtvs:::grid_data({expression}, {rows}, {columns})");
}
return(await evaluator.EvaluateAsync <GridData>(exp, REvaluationKind.Normal));
} catch (RException ex) {
var message = Invariant($"Grid data evaluation failed:{Environment.NewLine}{ex.Message}");
GeneralLog.Write(message);
return(null);
}
}
}
public Task <IGridData <string> > GetAsync(GridRange gridRange, ISortOrder sortOrder = null) => _dataSource.GetGridDataAsync(_dataObject.Expression, gridRange, sortOrder);
public static Task<IGridData<string>> GetGridDataAsync(string expression, GridRange? gridRange, ISortOrder sortOrder = null) =>
GetGridDataAsync(VsAppShell.Current.ExportProvider.GetExportedValue<IRInteractiveWorkflowProvider>().GetOrCreate().RSession, expression, gridRange, sortOrder);
