public void NewRowAdded(RowModel row)
{
TableRowView v = row.GetView(parentActivity);
rows.Add(v);
tableView.AddView(v.GetView());
}
public bool FilterAllows(RowModel m)
{
var s = m.Status;
return (!HideIgnored || s != TestStatus.Ignored)
&& (!HideSuccess || (s != TestStatus.Success && s != TestStatus.SuccessWithMessage))
&& (string.IsNullOrEmpty(RowFilter) || SmartFilter(m.Name + "|" + m.Summary, RowFilter) > -1);
}
public void RowAdded(RowModel model, int index)
{
TableRowView v = model.GetView(parentActivity);
rows.Insert(index, v);
tableView.AddView(v.GetView(), index + ADDITIONAL_ROWS);
}
public RowModel Add()
{
var rowModel = new RowModel();
Rows.Add(rowModel);
return(rowModel);
}
public void NewRowAdded(RowModel newRow)
{
foreach (TableView view in tableViews)
{
view.NewRowAdded(newRow);
}
}
private RowModel RowBuilder(int rowNumber, string rawString, List <Value> rowUseRules, List <Base> rules)
{
string decriptedResult = rawString;
foreach (Value rowUseRule in rowUseRules.OrderByDescending(x => x.Order))
{
Base rule = rules.ElementAt(rowUseRule.Rule);
decriptedResult = decriptedResult.Replace(rule.Source, rule.Replacement);
}
var chartArray = decriptedResult.ToCharArray();
var rowResult = new RowModel()
{
Row = rowNumber,
Letters = new List <LetterPositionModel>()
};
for (int column = 0; column < chartArray.Count(); column++)
{
var currentLetter = new LetterPositionModel()
{
Character = chartArray.ElementAt(column),
Column = column,
isDifferentColor = false
};
rowResult.Letters.Add(currentLetter);
}
return(rowResult);
}
private void SetRowValue(RowModel row, ColumnModel column, DataRow dic)
{
string val;
var key = column.Index.ToString();
var raw = row.LastRaw(column.Index);
// Get first index of new line
if (raw == null)
{
val = null;
}
else
{
if (raw.Length > 500)
{
raw = raw.Substring(0, 500) + "...";
}
var newLine = raw.IndexOf('\n');
if (newLine == 0)
{
val = "...";
}
else if (newLine > 0)
{
val = raw.Substring(0, newLine) + "...";
}
else
{
val = raw;
}
}
if (row.WillInsert)
{
dic[key + "_background"] = "New";
}
else if (row.WillDelete)
{
dic[key + "_background"] = "Deleted";
}
else if (row.IsModified(column.Index))
{
dic[key + "_background"] = "Modified";
}
else
{
dic[key + "_background"] = null;
}
if (val == null)
{
dic[key] = "NULL";
dic[key + "_color"] = "SecondaryTextBrush";
}
else
{
dic[key] = val;
dic[key + "_color"] = "CommonTextBrush";
}
}
private static RowModel ParseGecoRow(TableModel table, string CustomerName, int TotalRow)
{
int counter = 1;
RowModel displayRow = new RowModel();
CellModel cellName = new CellModel();
cellName.Value = CustomerName;
displayRow.Cells.Add(cellName);
for (int i = 6; i < 45; i += 3)
{
var Row = Common.ReadRow(table, TotalRow);
CellModel cell = new CellModel();
if (Common.EmptyCellChecker(Row, i))
{
cell.Value = "0";
}
else
{
cell = Common.GetCell(Row, i);
Console.WriteLine(cell.Value);
}
counter++;
displayRow.Cells.Add(cell);
}
return(displayRow);
}
public void RowAdded(RowModel row, int index)
{
ItemView v = row.GetItemView(parentActivity);
items.Add(v);
itemsView.AddView(v.GetView());
}
public static TableModel GecoCogeTotalMerger(TableModel gecoDisplayTable, TableModel cogeDisplayTable)
{
TableModel TotalDisplayTable = new TableModel();
RowModel headerRow = GetMonthHeader(gecoDisplayTable);
TotalDisplayTable.Body.Add(headerRow);
foreach (var row in gecoDisplayTable.Body)
{
RowModel GecoRow = new RowModel();
if (row.Cells[0].Value == "Total")
{
Console.WriteLine("Done");
GecoRow = row;
TotalDisplayTable.Body.Add(GecoRow);
}
}
foreach (var row in cogeDisplayTable.Body)
{
RowModel CogeRow = new RowModel();
if (row.Cells[0].Value == "TOTAL")
{
Console.WriteLine("Done");
CogeRow = row;
TotalDisplayTable.Body.Add(CogeRow);
}
}
return(TotalDisplayTable);
}
/*
* public override DataSet ExecutePlan()
* {
* DataSet ds = new DataSet("MannDB");
*
* foreach (var item in vehicleTypeProducers)
* {
* DataTable dt = new DataTable(item.Key);
*
* foreach (var columnString in columnStrings)
* {
* dt.Columns.Add(columnString, typeof(string));
* }
*
* foreach (var producer in item.Value)
* {
* ModelDocumentRequestor modelDR = new ModelDocumentRequestor($"{baseUrl}{producer.Link}");
* ModelParser modelParser = new ModelParser(modelDR);
* ITitleLinkPair[] models = modelParser.Parse();
*
* foreach (var model in models)
* {
* ModelPageDocumentRequestor mpDR = new ModelPageDocumentRequestor($"{baseUrl}{model.Link}");
* ModelPageParser mpParser = new ModelPageParser(mpDR);
* string[] modelPages = mpParser.Parse();
*
* foreach (var modelPage in modelPages)
* {
* ModelDetailDocumentRequestor mdDR = new ModelDetailDocumentRequestor($"{baseUrl}{modelPage}");
* ModelDetailParser mdParser = new ModelDetailParser(mdDR);
* ModelPageModel modelPageModel = mdParser.Parse();
*
* RowModel rm = new RowModel();
* rm.VehicleType = item.Key;
* rm.Producer = producer.Title;
* rm.Model = model.Title;
* rm.ModelType = modelPageModel.ModelType;
* rm.MotorCode = modelPageModel.MotorCode;
* rm.kW = modelPageModel.kW;
* rm.PS = modelPageModel.PS;
* rm.Year = modelPageModel.Year;
*
* FilterNodeModel fnModelAir = addFilterInfo(mdDR, FilterTypes.Air);
* if (!String.IsNullOrEmpty(fnModelAir.Filters))
* {
* rm.AirFilters = fnModelAir.Filters;
* rm.AirFilterDimensions = addFilterDimensions(fnModelAir.FilterUrls, FilterTypes.Air);
* }
*
* FilterNodeModel fnModelOil = addFilterInfo(mdDR, FilterTypes.Oil);
* if (!String.IsNullOrEmpty(fnModelOil.Filters))
* {
* rm.OilFilters = fnModelOil.Filters;
* rm.OilFilterDimensions = addFilterDimensions(fnModelOil.FilterUrls, FilterTypes.Oil);
* }
*
* FilterNodeModel fnModelFuel = addFilterInfo(mdDR, FilterTypes.Fuel);
* if (!String.IsNullOrEmpty(fnModelFuel.Filters))
* {
* rm.FuelFilters = fnModelFuel.Filters;
* rm.FuelFilterDimensions = addFilterDimensions(fnModelFuel.FilterUrls, FilterTypes.Fuel);
* }
*
* FilterNodeModel fnModelInterior = addFilterInfo(mdDR, FilterTypes.Interior);
* if (!String.IsNullOrEmpty(fnModelInterior.Filters))
* {
* rm.InteriorFilters = fnModelInterior.Filters;
* rm.InteriorFilterDimensions = addFilterDimensions(fnModelInterior.FilterUrls, FilterTypes.Interior);
* }
*
* FilterNodeModel fnModelOther = addFilterInfo(mdDR, FilterTypes.Other);
* if (!String.IsNullOrEmpty(fnModelOther.Filters))
* {
* rm.OtherFilters = fnModelOther.Filters;
* rm.OtherFilterDimensions = addFilterDimensions(fnModelOther.FilterUrls, FilterTypes.Other);
* }
*
* DataRow row = convertRowModelToRow(dt, rm);
* dt.Rows.Add(row);
* }
* }
* }
*
* ds.Tables.Add(dt);
* }
*
* return ds;
* }
*/
private DataRow convertRowModelToRow(DataTable dt, RowModel rm)
{
DataRow row = dt.NewRow();
row[0] = rm.VehicleType;
row[1] = rm.Producer;
row[2] = rm.Model;
row[3] = rm.ModelType;
row[4] = rm.MotorCode;
row[5] = rm.kW;
row[6] = rm.PS;
row[7] = rm.Year;
row[8] = rm.AirFilters;
row[9] = rm.AirFilterDimensions;
row[10] = rm.OilFilters;
row[11] = rm.OilFilterDimensions;
row[12] = rm.FuelFilters;
row[13] = rm.FuelFilterDimensions;
row[14] = rm.InteriorFilters;
row[15] = rm.InteriorFilterDimensions;
row[16] = rm.OtherFilters;
row[17] = rm.OtherFilterDimensions;
return(row);
}
public void NotifyRowAdded(int index, RowModel row)
{
foreach (TableView view in tableViews)
{
view.RowAdded(row, index);
}
}
public bool FilterAllows(RowModel m)
{
var s = m.Status;
return((!HideIgnored || s != TestStatus.Ignored) &&
(!HideSuccess || (s != TestStatus.Success && s != TestStatus.SuccessWithMessage)) &&
(string.IsNullOrEmpty(RowFilter) || SmartFilter(m.Name + "|" + m.Summary, RowFilter) > -1));
}
/// <summary>
/// Получаем список моделей строк
/// </summary>
/// <param name="listUserSettings">Список пользовательских настроек со строками</param>
private List <RowModel> CreateModelList(List <UserSettings> listUserSettings)
{
var rowModelList = new List <RowModel>();
if (IsOneColumn())
{
var firstCellPosition = GetStartPoint();
// Проходимся по циклу всех строк
for (int j = 4; j < _tsd.NumberOfRows; j++)
{
var rowModel = new RowModel()
{
coordinate = new XYZ(firstCellPosition.X, firstCellPosition.Y - (0.08431759) * (j - 4), firstCellPosition.Z), //понять как вычислить толщину строки
SheduleFieldList = new List <ScheduleFieldModel>(),
NumberOfRow = j,
NumberOfColumn = 1
};
rowModelList.Add(rowModel);
}
FillListModelParameters(rowModelList);
return(rowModelList);
}
else
{
// Стартовая позиция первой модели
var firstCellPosition = GetStartPoint();
// опеределяем смещение равно ширине спеки
double dx = 0;
for (int i = 0; i < _tsd.NumberOfColumns; i++)
{
dx += _tsd.GetColumnWidth(i);
}
dx += 0.031168; //Добавление отступа между спек
var numberOfRow = 4;
foreach (var el in listUserSettings)
{
for (int j = 0; j < el.NumberOfRow; j++)
{
var rowModel = new RowModel()
{
coordinate = new XYZ(firstCellPosition.X + dx * listUserSettings.IndexOf(el), firstCellPosition.Y - (0.08431759) * (j), firstCellPosition.Z), //понять как вычислить толщину строки
SheduleFieldList = new List <ScheduleFieldModel>(),
NumberOfRow = numberOfRow,
NumberOfColumn = listUserSettings.IndexOf(el) + 1
};
rowModelList.Add(rowModel);
numberOfRow++;
}
}
FillListModelParameters(rowModelList);
return(rowModelList);
}
}
public virtual void DoRemove()
{
if (RowModel != null)
{
if (MessageBox.Show("Bạn có muốn xóa bản ghi đã chọn không?", "Thông báo", MessageBoxButtons.YesNo) == System.Windows.Forms.DialogResult.Yes)
{
RowModel.Delete();
}
}
}
private static RowModel GetRowGeco(RowModel row, bool Header)
{
int intervalCount = 0;
var gecoRow = new RowModel();
int gecoStartCol = _GecoStartCol;
for (int i = 0; i < row.Cells.Count; i++)
{
CellModel cell = row.Cells[i];
if (i == 0 && Header == true)
{
var tempCell = "Customers";
var pandlCell = new CellModel();
pandlCell.Value = tempCell;
gecoRow.Cells.Add(pandlCell);
}
if (i > gecoStartCol)
{
intervalCount += 1;
if (intervalCount == 1)
{
var pandlCell = new CellModel();
var tempCell = cell.Value;
if (string.IsNullOrEmpty(tempCell))
{
tempCell = Header == false ? "0.00" : i == 42 ? "Total" : " ";
}
else
{
if (Header == false)
{
tempCell = CommonUtils.DeciString(tempCell);
}
else
{
}
}
pandlCell.Value = tempCell;
gecoRow.Cells.Add(pandlCell);
}
if (intervalCount == 3)
{
intervalCount = 0;
}
}
//colCount += 1;
if (i == 44)
{
return(gecoRow);
}
}
return(gecoRow);
}
IImmutableList <RowModel> UpdateRows(
IImmutableList <RowModel> visibleRows,
Dictionary <ILiveElement, Action <RowModel> > updates)
{
//while (visibleRows.Count < 30)
// visibleRows = visibleRows.Add(new RowModel(_tree));
// First update all rows currently attached to an element
Queue <RowModel> freeRows = new Queue <RowModel>();
foreach (var rowModel in visibleRows)
{
var rowModelLocal = rowModel; // Shouldn't be necesarry in C# 5 or higher, doing it just to be safe.
rowModel.Element.Do(
el =>
{
Action <RowModel> update;
if (updates.TryGetValue(el, out update))
{
update(rowModelLocal);
updates.Remove(el);
}
else
{
freeRows.Enqueue(rowModelLocal);
}
},
() => { freeRows.Enqueue(rowModelLocal); });
}
// Now update all remaining elements
foreach (var update in updates.Values)
{
RowModel rowModel;
if (freeRows.Count > 0)
{
rowModel = freeRows.Dequeue();
}
else
{
rowModel = new RowModel(_tree);
visibleRows = visibleRows.Add(rowModel);
}
update(rowModel);
}
// And then detach any leftover rows
// (we don't free row templates if tree is resized smaller)
while (freeRows.Count > 0)
{
freeRows.Dequeue().Detach();
}
return(visibleRows);
}
private static string FetchCellFromRow(RowModel row, int col)
{
for (int i = 0; i < row.Cells.Count; i++)
{
CellModel Cell = row.Cells[i];
if (i == col)
{
return(Cell.Value);
}
}
return(" ");
}
public void WhenModel_Then_ShouldReturnHtml()
{
var rm = new RowModel()
{
Label = "Name",
LabelValue = "Robin"
};
var viewComponent = new Row();
var results = viewComponent.Invoke(rm);
results.Should().NotBeNull();
}
private void FillFamilyInstance(FamilyInstance familyInstance, RowModel rowModel)
{
foreach (Parameter parameter in familyInstance.Parameters)
{
foreach (var field in rowModel.SheduleFieldList)
{
if (parameter.Definition.Name == field.FieldName)
{
parameter.Set(field.ValueAsString);
}
}
}
}
public void WhenModelLabelValueNull_Then_ShouldReturnHtml()
{
var rm = new RowModel();
rm.Label = "Name";
rm.LabelValue = null;
var label = rm.Label;
var labelValue = rm.LabelValue;
var viewComponent = new Row();
var results = viewComponent.Invoke(rm);
results.Should().NotBeNull();
}
private static TableModel GecoGather(List <Models.GecoPosition> gecoPositions, TableModel table)
{
TableModel displayTable = new TableModel();
for (int i = 0; i < gecoPositions.Count; i++)
{
var GecoRow = new RowModel();
GecoRow = ParseGecoRow(table, gecoPositions[i].CustomerName, gecoPositions[i].TotalRow);
displayTable.Body.Add(GecoRow);
}
return(displayTable);
}
public static TableModel SortTable(TableModel table)
{
TableModel table1 = new TableModel();
IList <RowModel> rowsModel;
RowModel BottomRow = new RowModel();
RowModel OtherRow = new RowModel();
rowsModel = table.Body;
table1.Body = rowsModel.OrderBy(test => test.Cells[0].Value).ToList();
table1.Header = table.Header;
table1.Footer = table.Footer;
return(table1);
}
public static RowModel SizeRow(RowModel Row, int Size, int StartCol)
{
RowModel retRow = new RowModel();
for (int i = StartCol; i < (StartCol + Size); i++)
{
string cellValue = Row.Cells[i].Value;
CellModel cellModel = new CellModel();
cellModel.Value = cellValue;
retRow.Cells.Add(cellModel);
}
return(retRow);
}
public LocationSiteModel BuildLocation(LocationsModel locationsModel)
{
var locations = locationsModel.Value;
var warehouses = locations.GroupBy(x => x.Warehouse)
.Select(loc => new { Name = loc.Key, Items = loc.ToList() });
var location = new LocationSiteModel();
location.Warehouses = new List <WarehouseModel>();
foreach (var warehouse in warehouses)
{
var warehouseLocal = new WarehouseModel();
warehouseLocal.Name = warehouse.Name;
warehouseLocal.Gates = new List <GateModel>();
var gates = warehouse.Items.GroupBy(x => x.Gate)
.Select(g => new { Name = g.Key, Items = g.ToList() });
foreach (var gate in gates)
{
var gateLocal = new GateModel {
Name = gate.Name
};
gateLocal.Rows = new List <RowModel>();
var rows = gate.Items.GroupBy(x => x.Row)
.Select(r => new { Name = r.Key, Items = r.ToList() });
foreach (var row in rows)
{
var rowLocal = new RowModel
{
Name = row.Name
};
var positions = row.Items.GroupBy(x => x.Position)
.Select(p => new PositionModel {
Name = p.Key
});
rowLocal.Positions = new List <PositionModel>(positions);
gateLocal.Rows.Add(rowLocal);
}
warehouseLocal.Gates.Add(gateLocal);
}
location.Warehouses.Add(warehouseLocal);
}
return(location);
}
public static void Run([TimerTrigger("0 */1 * * * *")] TimerInfo myTimer, TraceWriter log)
{
// Initialize Dynamics 365 client
var client = new CrmServiceClient(ConfigurationHelper.ConnectionString);
// Fetch feedbacks from Dynamics
var query = new QueryExpression("xms_feedback")
{
NoLock = true
};
query.ColumnSet = new ColumnSet("xms_usercode", "xms_rating", "xms_productcode", "createdon");
var records = client.RetrieveMultiple(query);
// CSV rows
var builder = new StringBuilder();
foreach (var feedback in records.Entities)
{
var row = new RowModel
{
Product = feedback.GetAttributeValue <string>("xms_productcode"),
Rating = feedback.GetAttributeValue <int>("xms_rating"),
CreatedOn = feedback.GetAttributeValue <DateTime>("createdon"),
User = feedback.GetAttributeValue <string>("xms_usercode")
};
builder.AppendLine(row.ToString());
}
// Azure upload
var storageAccount = CloudStorageAccount.Parse(ConfigurationHelper.StorageConnection);
var blobClient = storageAccount.CreateCloudBlobClient();
var container = blobClient.GetContainerReference("input-files");
if (container.CreateIfNotExists())
{
var perms = new BlobContainerPermissions {
PublicAccess = BlobContainerPublicAccessType.Container
};
container.SetPermissions(perms);
}
var blockBlob = container.GetBlockBlobReference("usage\\interactions.csv");
blockBlob.UploadText(builder.ToString());
// SB Notification
// await ServiceBusNotifier.Notify();
}
protected override void OnAdd()
{
var model = this.ContextItem as TableModel;
if (model != null)
{
var itemToAdd = new RowModel()
{
ColumnName = "NewRow", DataType = DataType.String
};
var addCommand = new UndoableDelegateCommand("Add new row", new Action <object>((o) => this.AddNewRow(model, itemToAdd)), new Action <object>((o) => this.RemoveRow(model, itemToAdd)));
this.Diagram.UndoRedoService.ExecuteCommand(addCommand);
}
}
private static ExcelWorksheet AddHeader(TableModel tableModel, ExcelWorksheet excelWorksheet)
{
int colCounter = 1;
RowModel row = tableModel.Header;
foreach (var cell in row.Cells)
{
excelWorksheet.Cells[1, colCounter].StyleName = "Header";
excelWorksheet.Cells[1, colCounter].Value = CellDeNuller(cell).Value;
colCounter = colCounter + 1;
}
return(excelWorksheet);
}
public static CellModel GetCell(RowModel row, int cellNumber)
{
int cellCount = 1;
foreach (var cell in row.Cells)
{
if (cellCount == cellNumber)
{
return(cell);
}
cellCount += 1;
}
return(null);
}
public void SaveColumns(RowModel model)
{
try
{
_repo.Path = model.FileParameters.FilePath;
_repo.Separator = model.FileParameters.SeparatorValue;
_repo.FirstRowIsColumns = model.FileParameters.FirstRowIsColumns;
_repo.SaveColumns(model.Row);
}
catch (Exception ex)
{
//Логирование или вывод пользователю. Но это уже в продакшене
}
}
public override NodeViewModelBase DeserializeNode(IShape shape, SerializationInfo info)
{
NodeViewModelBase node = null;
if (shape is TableShape)
{
var table = new TableModel();
if (info["Content"] != null)
{
table.Content = info["Content"].ToString();
}
if (info["MyIsCollapsed"] != null)
{
table.IsCollapsed = bool.Parse(info["MyIsCollapsed"].ToString());
}
node = table;
}
else
{
var row = new RowModel();
if (info["ColumnName"] != null)
{
row.ColumnName = info["ColumnName"].ToString();
}
if (info["DataType"] != null)
{
row.DataType = (DataType)Enum.Parse(typeof(DataType), info["DataType"].ToString(), true);
}
node = row;
}
if (info["MyPosition"] != null)
{
node.Position = Utils.ToPoint(info["MyPosition"].ToString()).Value;
}
if (info[this.NodeUniqueIdKey] != null)
{
var nodeUniquekey = info[this.NodeUniqueIdKey].ToString();
if (!this.CachedNodes.ContainsKey(nodeUniquekey))
{
this.CachedNodes.Add(nodeUniquekey, node);
}
}
return(node);
}
internal bool IsFilteredOut(RowModel m)
{
throw new NotImplementedException();
}
