public ActionResult GetRow(int rowId)
{
var model = new RowViewModel();
model.Id = rowId;
return(PartialView("OrderRow", model));
}
public decimal GetServiceTax(int category)
{
var model = new RowViewModel();
ServiceFactory sf = new ServiceFactory();
return(sf.GetCategory(category).GetServiceTax());
}
public void AfterCallingFilterHandleProperRowsShouldBeLoaded()
{
var filterValue = "A";
_dataTableColumns.Add(new DataTableColumn {
PropertyName = _columnPropertyName
});
var annRowModel = new RowViewModel {
Name = "Ann"
};
IReadOnlyCollection <Json> expectedCollection = new List <RowViewModel>
{
annRowModel
};
_dataProviderMock
.When(() => _dataProviderMock.Object.FilterOrderConfiguration.Filters.Any(x => x.Value == filterValue))
.Setup(x => x.CurrentPageRows).Returns(expectedCollection);
InitSut();
var firstNameColumn = _sut.Columns.First(x => x.PropertyName == _columnPropertyName);
firstNameColumn.Handle(new UniDataTable.ColumnsViewModel.Input.Filter {
Value = filterValue
});
_sut.Pages.Should().ContainSingle().Which.Rows.Should().ContainSingle(x => x == annRowModel);
}
/// <summary>
/// Prevents user from selecting a row that shouldn't be selected e.g. the Counts row
/// </summary>
/// <param name="grid"></param>
/// <param name="firstSelectedRowFound">Row that user is trying to select</param>
static void ClearSelectionIfRowIsNotSelectable(DataGrid grid, RowViewModel firstSelectedRowFound)
{
if (firstSelectedRowFound != null && !firstSelectedRowFound.IsSelectable)
{
grid.SelectedCells.Clear();
}
}
private void DataGrid_CellDrop(object sender, DragEventArgs e)
{
DataGridCell dgc = sender as DataGridCell;
if (_draggedData != null && !_isMultipleCells)
{
MappedValue selectedCell = _draggedData as MappedValue;
RowViewModel sourceRowModel = (selectedCell.RowBinding as RowViewModel);
ColumnsViewModel sourceColumnModel = (selectedCell.ColumnBinding as ColumnsViewModel);
RowViewModel targetRowModel = ((BindableColumn.ViewModel.RowViewModel)(dgc.DataContext));
ColumnsViewModel targetColumnModel = ((BindableColumn.ViewModel.ColumnsViewModel)((dgc.Column).Header));
targetCell = targetRowModel.Name + targetColumnModel.Currency;
sourceCell = sourceRowModel.Name + sourceColumnModel.Currency;
if (sourceCell == targetCell)
{
RemoveDraggedAdorner();
RemoveInsertionAdorner();
(this._sourceItemsControl as DataGrid).UnselectAllCells();
dgc.IsSelected = false;
return;
}
MappedValueCollection mappedValueCollection = this._mappedValueCollection;
var movingCellData = mappedValueCollection.ReturnIfExistAddIfNot(sourceColumnModel, sourceRowModel);
if (mappedValueCollection.AddCellValue(targetRowModel, targetColumnModel, movingCellData))
{
if (movingCellData.Value != null)
{
dgc.IsSelected = true;
}
mappedValueCollection.EmptyCellValue(sourceRowModel, sourceColumnModel);
}
}
else if (_draggedData != null && _isMultipleCells)
{
RowViewModel targetRowModel = ((BindableColumn.ViewModel.RowViewModel)(dgc.DataContext));
ColumnsViewModel targetColumnModel = ((BindableColumn.ViewModel.ColumnsViewModel)((dgc.Column).Header));
targetCell = targetRowModel.Name + targetColumnModel.Currency;
if (MoveMultipleCells(targetCell, this._multipleDraggedData.Count))
{
this._multipleDraggedData.Clear();
}
}
RemoveDraggedAdorner();
RemoveInsertionAdorner();
this._multipleDraggedData.Clear();
(this._sourceItemsControl as DataGrid).UnselectAllCells();
}
public void AddRowAfterConnect_WillCreateRowInRepo()
{
_repo.Setup(x => x.CreateOrUpdateRow(It.IsAny<Row>())).Returns<Row>(Task.FromResult);
_box.Connect(_repo.Object);
var row = new RowViewModel {Id = 1};
_box.Rows.Add(row);
_repo.Verify(x => x.CreateOrUpdateRow(It.Is<Row>(b => b.Id == row.Id)), Times.Once);
}
public void RemoveRowAfterConnect_WillRemoveRowFromRepo()
{
var row = new RowViewModel {Id = 1};
_box.Rows.Add(row);
_repo.Setup(x => x.CreateOrUpdateRow(It.Is<Row>(b => b.Id == row.Id)))
.Returns(Task.FromResult(new Row { Id = row.Id }));
_box.Connect(_repo.Object);
_box.Rows.Remove(row);
_repo.Verify(x => x.DeleteRow(It.Is<int>(id => id == row.Id)), Times.Once);
}
public void ChangeRowAfterConnect_WillChangeRowInRepo()
{
const string name = "name";
var row = new RowViewModel {Id = 1};
_box.Rows.Add(row);
_repo.Setup(x => x.CreateOrUpdateRow(It.Is<Row>(b => b.Id == row.Id)))
.Returns(Task.FromResult(new Row { Id = row.Id }));
_box.Connect(_repo.Object);
row.Name = name;
_repo.Verify(x => x.CreateOrUpdateRow(
It.Is<Row>(b => b.Id == row.Id && name.Equals(b.Name))),
Times.Once);
}
/// <summary>
/// Prevents User from selecting items from different Rows, as it doesn't make sense to analyse them together
/// </summary>
/// <param name="grid"></param>
static void LimitSelectionToOneRow(DataGrid grid)
{
RowViewModel firstSelectedRowFound = null;
foreach (DataGridCellInfo gridCellInfo in grid.SelectedCells)
{
if (firstSelectedRowFound == null)
{
firstSelectedRowFound = (RowViewModel)gridCellInfo.Item;
}
else if (IsOnAnotherRow(gridCellInfo, firstSelectedRowFound))
{
grid.SelectedCells.Remove(gridCellInfo);
}
}
ClearSelectionIfRowIsNotSelectable(grid, firstSelectedRowFound);
}
public void Init(bool isDirectory)
{
var leftSynchronizedItem = new SynchronizedItem("LeftItem", isDirectory, null);
var rightSynchronizedItem = new SynchronizedItem("RightItem", isDirectory, null);
var leftItemViewModel = new ItemViewModel(leftSynchronizedItem);
var rightItemViewModel = new ItemViewModel(rightSynchronizedItem);
var rowViewModel = new RowViewModel(leftItemViewModel, rightItemViewModel, null);
Assert.Equal(leftItemViewModel, rowViewModel.LeftItem);
Assert.Equal(rightItemViewModel, rowViewModel.RightItem);
Assert.Equal(isDirectory, rowViewModel.IsDirectory);
Assert.Empty(rowViewModel.ChildRows); // Пока дочерние строки не добавлялись.
Assert.False(rowViewModel.InProcess);
// Пока команды синхронизации не заданы, кнопки команд должны быть не видиммы.
Assert.False(rowViewModel.CommandButtonIsVisible);
}
private void DragSource_SelectedCellsChanged(object sender, SelectedCellsChangedEventArgs e)
{
IList <DataGridCellInfo> selectedCells = (sender as DataGrid).SelectedCells;
this._multipleDraggedData.Clear();
selectedCells.ToList().ForEach(x =>
{
RowViewModel rowModel = x.Item as RowViewModel;
ColumnsViewModel columnModel = x.Column.Header as ColumnsViewModel;
MappedValue value = AttachedColumnBehavior.GetMappedValues(sender as DependencyObject).ReturnIfExistAddIfNot(columnModel, rowModel);
var selectedCell = rowModel.Name + columnModel.Currency;
if (value.Value != null && selectedCells.Count > 1 && !_multipleDraggedData.ContainsKey(selectedCell))
{
this._multipleDraggedData.Add(selectedCell, value);
}
});
_isMultipleCells = selectedCells.Count > 1;
}
public RowViewModel GetSectionRow(Row theRow)
{
var theSeat = new RowViewModel {
VenueId = theRow.Section.Venue.VenueId,
VenueName = theRow.Section.Venue.VenueName,
SectionId = theRow.Section.SectionId,
SectionName = theRow.Section.SectionName,
SectionSeatCapacity = (from seat in _context.Seat
join row in _context.Row on seat.Row.RowId equals row.RowId
join section in _context.Section on row.Section.SectionId equals section.SectionId
where row.Section.SectionId == theRow.Section.SectionId
select seat).Count(),
Rows = _context.Row.Where(r => r.RowId == theRow.RowId)
.Select(r => new RowDetailViewModel {
RowId = r.RowId,
RowName = r.RowName,
SeatNames = _context.Seat
.Where(se => se.Row.RowId == r.RowId)
.Select(se => se.SeatName).ToList()
}).ToList()
};
return(theSeat);
}
public List <TableStructureViewModel> GetTable()
{
var tables = new List <TableStructureViewModel>();
var mapper = Mappings.GetMapper();
var tablesDb = _tableService.GetAll();
var columnDb = _tableColumnService.GetAll();
foreach (var table in tablesDb)
{
var mappedColumns = mapper.Map <List <ColumnVieModel> >(columnDb);
var parentColumns = mappedColumns.Where(w => !w.ParentId.HasValue).ToList();
foreach (var column in parentColumns)
{
column.ChildColumns = mappedColumns.Where(w => w.ParentId == column.Id).ToList();
}
tables.Add(new TableStructureViewModel
{
Columns = parentColumns
});
}
var rowsEntities = _tableRowService.GetAll();
var rowsItemEntities = _tableRowItemService.GetAll();
foreach (var table in tables)
{
var rows = new List <RowViewModel>();
foreach (var row in rowsEntities)
{
var rowItem = new RowViewModel
{
RowId = row.Id,
TableId = row.TableColumnId
};
foreach (var column in table.Columns)
{
if (column.IsInitial && column.ChildColumns.Count == 0 || column.ChildColumns.Count == 0)
{
rowItem.RowItems.Add(new RowItemViewModel
{
ColumnId = column.Id,
Values = rowsItemEntities.Where(w => w.TableColumnId == column.Id && w.TableRowId == row.Id)
.Select(s => new RowItemTemplate
{
Id = s.Id,
Value = s.Value
}).ToList()
});
}
else
{
foreach (var childColumn in column.ChildColumns)
{
rowItem.RowItems.Add(new RowItemViewModel
{
ColumnId = childColumn.Id,
Values = rowsItemEntities.Where(w => w.TableColumnId == childColumn.Id && w.TableRowId == row.Id)
.Select(s => new RowItemTemplate
{
Id = s.Id,
Value = s.Value
}).ToList()
});
}
}
}
rows.Add(rowItem);
}
table.Rows = rows;
}
return(tables);
}
private void DropTarget_PreviewDrop(object sender, DragEventArgs e)
{
object draggedItem = e.Data.GetData(this._format.Name);
int indexRemoved = -1;
if (draggedItem != null)
{
if ((e.Effects & DragDropEffects.Move) != 0 && (this._sourceItemsControl == this._targetItemsControl || GetIsDropRejectFromOthers(this._targetItemsControl)))
{
this._targetDataContext = (sender as DataGrid).DataContext;
// Remove the selected Cell here from Mapped Values
DataGrid dgc = sender as DataGrid;
RowViewModel sourceRowHeader = ((RowViewModel)(dgc.CurrentItem));
ColumnsViewModel sourceColumnHeader = ((ColumnsViewModel)((dgc.CurrentColumn).Header));
string srcCell = sourceRowHeader.Name + sourceColumnHeader.Currency;
MappedValueCollection sourceCell = AttachedColumnBehavior.GetMappedValues(sender as DependencyObject);
MappedValue mappedValue = sourceCell.ReturnIfExistAddIfNot(sourceColumnHeader, sourceRowHeader);
int getIndex = sourceCell.IndexOf(mappedValue);
//var hitTestInfo = (sender as DataGrid).InputHitTest(new Point{ X = e.})
sourceCell[getIndex].Value = (draggedItem as MappedValue).Value;
//indexRemoved = RemoveItemFromItemsControl(this._sourceItemsControl, draggedItem);
}
// This happens when we drag an item to a later position within the same ItemsControl.
if (indexRemoved != -1 && this._sourceItemsControl == this._targetItemsControl && indexRemoved < this._insertionIndex)
{
this._insertionIndex--;
}
if (!GetIsDropRejectFromOthers(this._targetItemsControl))
{
IEnumerable itemsSource = _targetItemsControl.ItemsSource;
Type type = itemsSource.GetType();
Type genericIListType = type.GetInterface("IList`1");
int elementsCount = 0;
if (genericIListType != null)
{
elementsCount = (int)type.GetProperty("Count").GetValue(itemsSource, null);
}
if (elementsCount > this._insertionIndex)
{
RemoveItemFromItemsControlByIndex(this._targetItemsControl, this._insertionIndex);
InsertItemInItemsControl(this._targetItemsControl, draggedItem, this._insertionIndex);
if (this._sourceItemsControl == this._targetItemsControl)
{
Type draggedType = draggedItem.GetType();
object newitem = Activator.CreateInstance(draggedType);
InsertItemInItemsControl(this._sourceItemsControl, newitem, indexRemoved);
}
}
}
else
{
Type draggedType = draggedItem.GetType();
object newitem = Activator.CreateInstance(draggedType);
//InsertItemInItemsControl(this._sourceItemsControl, newitem, indexRemoved);
}
RemoveDraggedAdorner();
RemoveInsertionAdorner();
}
e.Handled = true;
}
public CellViewModel(Y_NORM_NORMATIVE_CELL cell, RowViewModel rowViewModel)
{
_entity = cell;
Row = rowViewModel;
Messenger.Default.Register<GenericMessage<MessageArgsParameterCallback>>(this, MessageEditParameterCallbackHandler);
Messenger.Default.Register<GenericMessage<MessageArgsParameterValuesCallback>>(this, MessageEditParameterValuesCallbackHandler);
CommandEditParameter = new RelayCommand(CommandEditParameterRelease);
CommandEditParameterValues = new RelayCommand(CommandEditParameterValuesRelease);
CommandRemoveController = new RelayCommand(CommandRemoveControllerRelease);
if (Controller == null)
{
if (_entity.CONTROLLER == null)
{
_entity.CONTROLLER = HeadViewModel.Controllers.NewKey();
_entity.Y_NORM_NORMATIVE_CONTROLLER = new Y_NORM_NORMATIVE_CONTROLLER { CONTROLLER = (int)_entity.CONTROLLER };
}
_entity.CONTROLLER = _entity.CONTROLLER ?? HeadViewModel.Controllers.NewKey();
if (!HeadViewModel.Controllers.ContainsKey(_entity.CONTROLLER))
{
Controller = new Controller();
HeadViewModel.Controllers.Add(_entity.CONTROLLER, Controller);
}
else
{
Controller = HeadViewModel.Controllers[_entity.CONTROLLER];
}
}
Controller.Add(this);
}
public object Clone(RowViewModel row)
{
var cellEntity = new Y_NORM_NORMATIVE_CELL
{
ID = _entity.ID,
ID_ROW = _entity.ID_ROW,
ID_COLUMN = _entity.ID_COLUMN,
ID_PARAM = _entity.ID_PARAM,
PARAM_VALUE = _entity.PARAM_VALUE,
CONTROLLER = _entity.CONTROLLER,
Y_NORM_NORMATIVE_CONTROLLER = _entity.Y_NORM_NORMATIVE_CONTROLLER,
Y_NORM_NORMATIVE_ROW = row.Entity,
Y_NORM_PARAMETERS = _entity.Y_NORM_PARAMETERS
};
row.Entity.Y_NORM_NORMATIVE_CELL.Add(cellEntity);
var cell = new CellViewModel(cellEntity, row);
return cell;
}
/// <summary>
/// 현재 viewStatus와 sheetViewModel을 이용하여 grouepdRows와 groupedRowViewModels를 생성함
/// 문제는 columnViewModel의
/// </summary>
/// <param name="sheetViewModel"></param>
public void Generate(SheetViewModel sheetViewModel)
{
List <ColumnViewModel> orderedColumnViewModels = sheetViewModel.ColumnViewModels;
Int32 index = 0;
if (IsEmpty)
{
// 어차피 allRow가 보일 것이므로 RowViewModel 을 만들어 줄 필요는 없음
}
else if (IsN) // 이 경우는 뉴메리컬 하나만 선택되어 비닝 된 결과가 보이는 경우이다.
{
ColumnViewModel selected = FirstColumn;
GroupedRows = Bin(selected, sheetViewModel.FilteredRows);
GroupedRowViewModels = new List <RowViewModel>();
// 여기서 groupedRows가 소팅되어야함
// 그런데 여기서는 선택되지 않은 컬럼의 경우에는 어차피 어그리게이션되므로 소팅 순서가 의미가 없음 따라서 선택된 컬럼에 대해서만 소팅하면 된다
GroupedRows.Sort(new GroupedRowComparer(sheetViewModel, this));
foreach (GroupedRows groupedRows in GroupedRows)
{
if (groupedRows.Rows.Count == 0)
{
continue;
}
RowViewModel rowViewModel = new RowViewModel(sheetViewModel.MainPageViewModel)
{
Index = index++,
Rows = groupedRows.Rows
};
foreach (ColumnViewModel columnViewModel in orderedColumnViewModels)
{
Cell cell = new Cell();
cell.ColumnViewModel = columnViewModel;
if (columnViewModel == selected)
{
Bin bin = groupedRows.Keys[selected] as Bin;
String content = bin.ToString() + $" ({groupedRows.Rows.Count})";
cell.RawContent = content;
cell.Content = content;
}
else if (columnViewModel.Type == ColumnType.Categorical)
{
Int32 uniqueCount = groupedRows.Rows.Select(r => r.Cells[columnViewModel.Index].Content).Distinct().Count();
cell.Content = $"({uniqueCount})";
cell.RawContent = $"({uniqueCount})";
}
else //numerical
{
Object aggregated = columnViewModel.AggregativeFunction.Aggregate(groupedRows.Rows.Select(r => (Double)r.Cells[columnViewModel.Index].Content));
String formatted = Formatter.FormatAuto4((Double)aggregated);
cell.RawContent = formatted;
cell.Content = Double.Parse(formatted);
}
rowViewModel.Cells.Add(cell);
}
GroupedRowViewModels.Add(rowViewModel);
}
}
else if (IsNN)
{
GroupedRowViewModels = new List <RowViewModel>();
RowViewModel rowViewModel = new RowViewModel(sheetViewModel.MainPageViewModel)
{
Index = 0,
Rows = sheetViewModel.FilteredRows
};
foreach (ColumnViewModel columnViewModel in orderedColumnViewModels)
{
Cell cell = new Cell();
cell.ColumnViewModel = columnViewModel;
if (columnViewModel.Type == ColumnType.Categorical)
{
Int32 uniqueCount = sheetViewModel.FilteredRows.Select(r => r.Cells[columnViewModel.Index].Content).Distinct().Count();
cell.Content = $"({uniqueCount})";
cell.RawContent = $"({uniqueCount})";
}
else if (columnViewModel.Type == ColumnType.Numerical)
{
Object aggregated = columnViewModel.AggregativeFunction.Aggregate(sheetViewModel.FilteredRows.Select(r => (Double)r.Cells[columnViewModel.Index].Content));
String formatted = Formatter.FormatAuto4((Double)aggregated);
cell.RawContent = formatted;
cell.Content = Double.Parse(formatted);
}
rowViewModel.Cells.Add(cell);
}
GroupedRowViewModels.Add(rowViewModel);
}
else if (CategoricalCount > 0)// 이 경우는 categorical이든 datetime이든 뭔가로 그룹핑이 된 경우
{
GroupedRows = GroupRecursive(
sheetViewModel.FilteredRows,
CategoricalColumnViewModels.ToList(),
0);
GroupedRows.Sort(new GroupedRowComparer(sheetViewModel, this));
GroupedRowViewModels = new List <RowViewModel>();
foreach (GroupedRows groupedRows in GroupedRows)
{
RowViewModel rowViewModel = new RowViewModel(sheetViewModel.MainPageViewModel)
{
Index = index++,
Rows = groupedRows.Rows
};
foreach (ColumnViewModel columnViewModel in orderedColumnViewModels)
{
Cell cell = new Cell();
cell.ColumnViewModel = columnViewModel;
if (groupedRows.Keys.ContainsKey(columnViewModel))
{
Object content = groupedRows.Keys[columnViewModel];
cell.Content = content;
cell.RawContent = cell.Content.ToString();
}
else if (columnViewModel.Type == ColumnType.Categorical)
{
Int32 uniqueCount = groupedRows.Rows.Select(r => r.Cells[columnViewModel.Index].Content).Distinct().Count();
cell.Content = $"({uniqueCount})";
cell.RawContent = $"({uniqueCount})";
}
else if (columnViewModel.Type == ColumnType.Numerical)
{
Object aggregated = columnViewModel.AggregativeFunction.Aggregate(groupedRows.Rows.Select(r => (Double)r.Cells[columnViewModel.Index].Content));
String formatted = Formatter.FormatAuto4((Double)aggregated);
cell.RawContent = formatted;
cell.Content = Double.Parse(formatted);
}
rowViewModel.Cells.Add(cell);
}
GroupedRowViewModels.Add(rowViewModel);
}
}
else
{
;
}
}
private async Task InsertHead(IDim head, int after)
{
var ts = await dialCoord
.ShowInputAsync(this, "Info", "Enter new name",
new MetroDialogSettings
{
AffirmativeButtonText = "OK",
NegativeButtonText = "Cancel",
DefaultText = head.Name
});
if (string.IsNullOrEmpty(ts))
{
return;
}
EnableMatrix = false;
switch (head)
{
case ColumnViewModel column:
{
var tempColumns = Columns.ToList();
var index = tempColumns.IndexOf(head) + after;
var cvm = new ColumnViewModel
{
Name = ts,
BoardId = column.BoardId
};
tempColumns.Insert(index, cvm);
Box.Columns.Add(cvm);
var i = 0;
foreach (var it in tempColumns)
{
it.Order = i;
i++;
}
}
break;
case RowViewModel row:
{
var tempRows = Rows.ToList();
var index = tempRows.IndexOf(head) + after;
var rvm = new RowViewModel
{
Name = ts,
BoardId = row.BoardId
};
tempRows.Insert(index, rvm);
Box.Rows.Add(rvm);
var i = 0;
foreach (var it in tempRows)
{
it.Order = i;
i++;
}
}
break;
}
// Rebuild matrix
this.EnableMatrix = true;
NormalizeGridCommand
.Execute()
.Subscribe();
}
public Model.ViewModel.GridVM GetGridViewModelForObject(IQueryable <object> collection, string objectId, string objectType, string bindingPath, CollectionViewModelParameters parameters)
{
var gv = new Model.ViewModel.GridVM();
gv.PropertyValue = $"{collection.Cast<object>().FirstOrDefault()?.GetType().Name}[{collection.Count()}]";
var firstElement = collection.Cast <object>().FirstOrDefault();
if (firstElement == null)
{
return(gv);
}
var elementType = firstElement.GetType();
var elementIdPropertyName = dataService.GetIdPropertyName(elementType);
var propertyInfos = viewConfigurationService.GetGridCollumnInPropertyGrid(elementType, elementIdPropertyName);
var idProperty = elementType.GetProperty(elementIdPropertyName);
bool isFirst = true;
var page = collection.Skip(parameters.Page * parameters.PageSize).Take(parameters.PageSize);
int iRow = 0;
foreach (var element in page)
{
var row = new RowViewModel();
row.Cells = new CellViewModel[propertyInfos.Length];
var rowId = idProperty.GetValue(element);
row.Id = rowId?.ToString();
row.ElementTypeFullName = helper.GetTypeName(elementType);
row.EditUrl = helper.GetEditUrlForClass(row.Id, elementType);
for (int i = 0; i < propertyInfos.Length; i++)
{
var cellProperty = propertyInfos[i];
var cellValue = cellProperty.GetValue(element);
var cellPropertyType = cellProperty.PropertyType;
var cellType = helper.CheckPropType(cellPropertyType);
if (isFirst)
{
var cvm = new ColumnViewModel()
{
BindingPath = cellProperty.Name, Header = cellProperty.Name
};
gv.Columns.Add(cvm);
}
var cell = new CellViewModel()
{
IsBigString = helper.IsBigString(cellValue, BaseService.EnumPreviewType.Grid),
Value = helper.GetPreview(cellValue, BaseService.EnumPreviewType.Grid)
};
cell.MainObjectId = objectId;
cell.MainObjectType = objectType;
cell.BindingPath = $"{bindingPath}[{iRow}].{cellProperty.Name}";
row.Cells[i] = cell;
if (cellType == PropertyTypes.Class)
{
if (cellValue != null)
{
var valueType = cellValue.GetType();
var idPropName = dataService.GetIdPropertyName(valueType);
var idProp = valueType.GetProperty(idPropName);
var id = idProp.GetValue(cellValue)?.ToString();
cell.EditUrl = helper.GetEditUrlForClass(id, valueType);
}
}
else if (cellType == PropertyTypes.Collection)
{
cell.EditUrl = helper.GetEditUrlForCollection(helper.GetCollectionElementType(cellPropertyType), rowId, elementType);
}
}
gv.Rows.Add(row);
isFirst = false;
iRow++;
}
return(gv);
}
private async Task CreateCommandExecute()
{
// 1. Checks
if (string.IsNullOrWhiteSpace(BoardName) || string.IsNullOrWhiteSpace(FileName) ||
string.IsNullOrWhiteSpace(FolderName))
{
await dialCoord.ShowMessageAsync(this, "Error", "Empty string");
return;
}
if (!Directory.Exists(FolderName))
{
await dialCoord.ShowMessageAsync(this, "Error", "Directory does not exists");
return;
}
string uri = FolderName + "\\" + FileName;
if (!IsNewFile && !File.Exists(uri))
{
await dialCoord.ShowMessageAsync(this, "Error", "File not found");
return;
}
if (IsNewFile && File.Exists(uri))
{
await dialCoord.ShowMessageAsync(this, "Error", "File already exists");
return;
}
if (Columns.Count == 0)
{
await dialCoord.ShowMessageAsync(this, "Error", "Need add columns");
return;
}
if (Rows.Count == 0)
{
await dialCoord.ShowMessageAsync(this, "Error", "Need add rows");
return;
}
// 2. Create board (or get from preloaded)
BoxViewModel box;
if (IsNewFile)
{
box = await appModel.Create(uri);
if (!box.Loaded)
{
throw new Exception("File not loaded");
}
appConfig.UpdateRecent(uri, false);
}
else
{
box = await appModel.Load(uri);
if (!box.Loaded)
{
appConfig.RemoveRecent(uri);
appModel.Remove(uri);
await dialCoord.ShowMessageAsync(this, "Error", "File was damaged");
return;
}
if (box.Boards.Items.Any(x => x.Name == BoardName))
{
await dialCoord.ShowMessageAsync(this, "Error", "Board name already used");
return;
}
}
var bvm = new BoardViewModel
{
Name = BoardName,
Created = DateTime.Now,
Modified = DateTime.Now
};
box.Boards.Add(bvm);
// 3. Normalize grid
double colSize = Columns.Count == 1 ? 100 : 100 / (Columns.Count - 1);
for (var i = 0; i < Columns.Count; i++)
{
Columns[i].Order = i;
}
double rowSize = Rows.Count == 1 ? 100 : 100 / (Rows.Count - 1);
for (var i = 0; i < Rows.Count; i++)
{
Rows[i].Order = i;
}
// 4. Create columns
foreach (var cvm in Columns)
{
var colToAdd = new ColumnViewModel
{
BoardId = bvm.Id,
Size = (int)colSize * 10,
Order = cvm.Order,
Name = cvm.Name
};
box.Columns.Add(colToAdd);
}
// 5. Create rows
foreach (var rvm in Rows)
{
var rowToAdd = new RowViewModel
{
BoardId = bvm.Id,
Size = (int)rowSize * 10,
Order = rvm.Order,
Name = rvm.Name
};
box.Rows.Add(rowToAdd);
}
shell.ShowView <BoardView>(
viewRequest: new BoardViewRequest {
ViewId = uri, Box = box, Board = bvm
},
options: new UiShowOptions {
Title = BoardName
});
this.Close();
}
static bool IsOnAnotherRow(DataGridCellInfo gridCellInfo, RowViewModel firstFoundSelectedRow)
{
return(gridCellInfo.Item != firstFoundSelectedRow);
}