public async Task OnGetAsync(long?id, long?pid)
{
if (id.HasValue)
{
//编辑
Dto = await _service.GetByIdAsync(id.Value);
if (Dto == null)
{
throw new KuDataNotFoundException("无法取得数据!");
}
if (Dto.ParentId.HasValue)
{
Parents = await _service.GetParentsAsync(Dto.ParentId.Value);
}
ViewData["Mode"] = "Edit";
}
else
{
//新增
Dto = new ColumnDto();
if (pid.HasValue)
{
Dto.ParentId = pid.Value;
Parents = await _service.GetParentsAsync(pid.Value);
}
else
{
Dto.ParentId = null;
}
ViewData["Mode"] = "Add";
}
}
public void SetUp()
{
_columnDto = new ColumnDto {
Name = "Test"
};
_viewModel = new LayoutItemViewModel(_columnDto);
}
public int DeleteRowFromTable(string tableName, ColumnDto column, string operatorSymbol, string value, ConnectionDto connDto)
{
try
{
using var con = new NpgsqlConnection(ConnectionString(connDto));
con.Open();
using var cmd = new NpgsqlCommand();
cmd.Connection = con;
cmd.CommandText = $"DELETE FROM {tableName} WHERE {column.ColumnName} {operatorSymbol} ";
if (RequiresQuotes(column.Value))
{
cmd.CommandText += $"'{value}'";
}
else
{
cmd.CommandText += $"{value}";
}
NpgsqlDataReader dr = cmd.ExecuteReader();
con.Close();
return(dr.RecordsAffected);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
private static List <ColumnDto> LoadXml()
{
List <ColumnDto> columns = new List <ColumnDto>();
//将XML文件加载进来
XDocument document = XDocument.Load(filePath);
//获取到XML的根元素进行操作
XElement root = document.Root;
//获取根元素下的所有子元素
IEnumerable <XElement> enumerable = root.Elements();
foreach (XElement column in enumerable)
{
ColumnDto columnDto = new ColumnDto();
foreach (XElement property in column.Elements())
{
if (property.Name == nameof(columnDto.Name))
{
columnDto.Name = property.Value;
}
else if (property.Name == nameof(columnDto.AliasName))
{
columnDto.AliasName = property.Value;
}
else if (property.Name == nameof(columnDto.IsCanNotModify))
{
columnDto.IsCanNotModify = bool.Parse(property.Value);
}
//Console.WriteLine($"{property.Name}:{property.Value}");
}
columns.Add(columnDto);
//Console.WriteLine(column.Attribute("id").Value);
}
return(columns);
}
private void rows_delete_delete_button_Click(object sender, EventArgs e)
{
var tableName = dash_tables_listBox.SelectedItem?.ToString();
var columnName = rows_delete_column_comboBox.SelectedItem?.ToString();
var opSymbol = rows_delete_operator_comboBox.SelectedItem?.ToString();
var value = rows_delete_value_textBox.Text;
if (string.IsNullOrWhiteSpace(tableName) || string.IsNullOrWhiteSpace(columnName) || string.IsNullOrWhiteSpace(opSymbol) || string.IsNullOrWhiteSpace(value))
{
HandleError("Table, column, operator, and value must be selected.");
return;
}
try
{
var column = new ColumnDto()
{
ColumnName = columnName.Split('(')[0].Trim(),
Value = columnName.Split('(')[1].TrimEnd(')')
};
var count = _sql.DeleteRowFromTable($"{dash_statusStrip_schema_value.Text}.{tableName}", column, opSymbol, value, connDto);
rows_delete_value_textBox.Text = string.Empty;
rows_delete_column_comboBox.SelectedIndex = -1;
rows_delete_operator_comboBox.SelectedIndex = -1;
WriteToLog($"Successfully deleted {count} row(s)");
}
catch (Exception ex)
{
HandleError("Error deleting row(s):", ex);
return;
}
}
public async Task <long> CreateAsync(ColumnDto specialColumn, CancellationToken cancellation = default)
{
var entity = Mapper.Map <ColumnDto, Column>(specialColumn);
var result = await _columnStorage.CreateAsync(entity, cancellation);
return(result.Id);
}
public static ValidationResult Validate(this ColumnDto dto)
{
if (string.IsNullOrWhiteSpace(dto.Catalog))
{
return(new ValidationResult(CatalogIsEmptyErrorMessage));
}
if (string.IsNullOrWhiteSpace(dto.Schema))
{
return(new ValidationResult(SchemaIsEmptyErrorMessage));
}
if (string.IsNullOrWhiteSpace(dto.Name))
{
return(new ValidationResult(NameIsEmptyErrorMessage));
}
if (string.IsNullOrWhiteSpace(dto.Type))
{
return(new ValidationResult(TypeIsEmptyErrorMessage));
}
if (string.IsNullOrWhiteSpace(dto.IsNullable))
{
return(new ValidationResult(NullableIsEmptyErrorMessage));
}
return(new ValidationResult());
}
public override SectionDto CreateDto(TestContext context)
{
var format = (FormatFunc)context.Formatter.Format;
// Materialize it because we'll be modifying it.
var columns = Columns.ToList();
// Use all columns by default if none-specified.
if (!Columns.Any())
{
columns = context.Data.Columns.Cast <DataColumn>().Select(c => new ColumnMetadata
{
Name = c.ColumnName,
Total = ColumnTotal.Last
})
.ToList();
}
var section = new SectionDto
{
Heading = format(Heading),
Table = new TripleTableDto(columns.Select(column => ColumnDto.Create <string>((column.Display ?? column.Name).ToString())))
};
var table = section.Table;
// Filter rows before processing them.
var filteredRows = context.Data.Select(context.TestCase.Filter);
// We'll use it a lot so materialize it.
var groupColumns = columns.Where(x => x.IsGroupKey).ToList();
var rowGroups = filteredRows.GroupBy(row => row.GroupKey(groupColumns), GroupKeyEqualityComparer);
// Create aggregated rows and add them to the final data-table.
var aggregatedRows =
from rowGroup in rowGroups
select(from column in columns select Aggregate(column, rowGroup));
foreach (var row in aggregatedRows)
{
table.Body.Add(row);
}
// Add the footer row with column options.
table.Foot.Add(columns.Select(column => string.Join(", ", StringifyColumnOption(column))).ToList());
return(section);
IEnumerable <string> StringifyColumnOption(ColumnMetadata column)
{
if (column.IsGroupKey)
{
yield return("Key");
}
if (column.Filter != null && !(column.Filter is Unchanged))
{
yield return(column.Filter.GetType().Name);
}
yield return(column.Total.ToString());
}
}
/// <summary>
/// 转到新建栏目页面
/// </summary>
/// <returns></returns>
public ActionResult AddColumn()
{
ViewBag.ColumnTitle = "新建栏目";
var model = new ColumnDto();
return(View(model));
}
public override SectionDto CreateDto(TestContext context)
{
var format = (FormatFunc)context.Formatter.Format;
var section = new SectionDto
{
Heading = format(Heading),
Table = new TripleTableDto(new[]
{
ColumnDto.Create <string>("Property"),
ColumnDto.Create <string>("Value")
})
};
var table = section.Table;
table.Body.Add(nameof(Gunter.Data.TestCase.Filter), context.TestCase.Filter);
table.Body.Add(nameof(Gunter.Data.TestCase.Expression), context.TestCase.Expression);
table.Body.Add(nameof(Gunter.Data.TestCase.Assert), context.TestCase.Assert.ToString());
table.Body.Add(nameof(Gunter.Data.TestCase.OnPassed), context.TestCase.OnPassed.ToString());
table.Body.Add(nameof(Gunter.Data.TestCase.OnFailed), context.TestCase.OnFailed.ToString());
table.Body.Add(nameof(Gunter.Data.TestCounter.RunTestElapsed), format($"{RuntimeVariable.TestCounter.AssertElapsed.ToString(TimespanFormat)}"));
table.Body.Add(nameof(Gunter.Data.TestCase.Profiles), $"[{string.Join(", ", context.TestCase.Profiles.Select(p => $"'{p}'"))}]");
return(section);
}
public async Task <JsonResult> AddOrUpdateColumn(ColumnDto model)
{
await _columnAppService.AddOrUpdateColumn(model);
return(Json(new AjaxResponse {
TargetUrl = "Index"
}));
}
public ColumnDto AddColumn(ColumnDto input)
{
input.Id = _columns.Max(col => col.Id) + 1;
input.OrderNo = _columns.Max(col => col.OrderNo) + 1;
_columns.Add(input.ToEntity());
return(input);
}
public virtual void SetUp()
{
_columnDto = new ColumnDto();
_columns = new List <Column>();
_mockRepository = new Mock <IColumnRepository>();
_mockAdapter = new Mock <IColumnAdapter>();
}
public static Column ToEntity(this ColumnDto dto)
{
return(new Column
{
Id = dto.Id,
OrderNo = dto.OrderNo,
Title = dto.Title,
UserId = dto.UserId
});
}
public static ColumnDto ColumnDto(string name = null)
{
var dto = new ColumnDto();
if (!string.IsNullOrEmpty(name))
{
dto = dto.WithName(name);
}
return(dto);
}
public async Task <bool> UpdateAsync(ColumnDto specialColumn, CancellationToken cancellation = default)
{
var entity = await _columnStorage.FindByIdAsync(specialColumn.Id, cancellation);
if (entity == null)
{
return(false);
}
Mapper.Map(specialColumn, entity);
return(await _columnStorage.UpdateAsync(entity) > 0);
}
public Column(ColumnDto dto)
: this(dto.Name, dto.Type)
{
if (dto.Timeline == null)
{
return;
}
foreach (var slice in dto.Timeline.Where(p => p != null))
{
_timeline.Insert(slice.Start, slice);
}
}
private KeyValuePair <string, IColumn> MapColumn(IMap map, ColumnDto column, Database schema, ISqlDialect sqlDialect)
{
// figure out the type
Type type = sqlDialect.GetTypeFromString(column.DbTypeName, column.Length, column.Precision).GetCLRType();
var col = (IReverseEngineeringColumn)Activator.CreateInstance(typeof(Column <>).MakeGenericType(type));
col.ColumnSpecification = column;
var mapColumn = (IColumn)col;
mapColumn.DbName = column.Name;
sqlDialect.UpdateColumnFromSpecification(mapColumn, new ColumnSpecification {
DbTypeName = column.DbTypeName,
Length = column.Length,
Precision = (byte?)column.Precision,
Scale = (byte?)column.Scale
});
mapColumn.IsAutoGenerated = column.IsAutoGenerated;
mapColumn.IsExcludedByDefault = false;
mapColumn.IsIgnored = false;
mapColumn.IsNullable = column.IsNullable;
mapColumn.IsPrimaryKey = column.IsPrimaryKey; // HACK - MySql issue with primary keys?
if (mapColumn.IsPrimaryKey)
{
map.PrimaryKey = mapColumn;
}
mapColumn.Map = map;
// figure out the relationship
var foreignKey = schema.GetForeignKeyForColumn(column.Name, map.Table);
if (foreignKey != null)
{
mapColumn.Relationship = RelationshipType.ManyToOne;
mapColumn.Name = this.convention.PropertyNameForManyToOneColumnName(column.Name);
col.ForeignKeyTableName = foreignKey.ReferencedTableName;
col.TypeMap = this.typeMap;
if (!this.manyToOneColumns.ContainsKey(foreignKey.ReferencedTableName))
{
this.manyToOneColumns.Add(foreignKey.ReferencedTableName, new List <IColumn>());
}
this.manyToOneColumns[foreignKey.ReferencedTableName].Add(mapColumn);
}
else
{
mapColumn.Relationship = RelationshipType.None;
mapColumn.Name = column.Name;
}
return(new KeyValuePair <string, IColumn>(mapColumn.Name, mapColumn));
}
public void SaveColumnData(int ColumnOrder, ColumnDto ColumnsData, string TableName)
{
UserEntities db = new UserEntities();
var defaultColumnValues = db.ColumnUsersSettings.Where(x => x.ColumnText == ColumnsData.ColumnText && x.GridName == TableName).FirstOrDefault();
ColumnUsersSetting gridColumn = new ColumnUsersSetting();
gridColumn.IsVisible = true;
gridColumn.ColumnWidth = ColumnsData.ColumnWidth;
gridColumn.ColumnOrder = ColumnOrder;
gridColumn.ColumnText = ColumnsData.ColumnText;
gridColumn.GridName = TableName;
gridColumn.ColumnType = defaultColumnValues.ColumnType;
gridColumn.ColumnFilterId = defaultColumnValues.ColumnFilterId;
db.ColumnUsersSettings.Add(gridColumn);
db.SaveChanges();
}
public void SetUp()
{
_columnDto = new ColumnDto()
{
Id = 1,
Name = "Test"
};
_mockMessageBus = new Mock <IMessageBus>();
_mockMessageBus.Setup(p => p.Execute(It.IsAny <GetAllAxisColumnsQuery>()))
.Returns(new List <ColumnDto> {
_columnDto
});
_mockMessageBus.Setup(p => p.Execute(It.IsAny <GetYAxisColumnQuery>()))
.Returns(_columnDto);
_viewModel = new YAxisLayoutViewModel(_mockMessageBus.Object);
}
private async Task <ColumnDto> ColumnToUpdate(string userId)
{
int minCount = Int32.MaxValue;
ColumnDto minCountColumn = null;
IList <ColumnDto> columnDtos = await _columnRepository.Get(userId);
foreach (ColumnDto columnDto in columnDtos)
{
if (columnDto.NoteIds.Length < minCount)
{
minCount = columnDto.NoteIds.Length;
minCountColumn = columnDto;
}
}
return(minCountColumn);
}
public void SetUp()
{
_columnDto = new ColumnDto();
_column = new ColumnBuilder().Build();
_columns = new List <Column> {
_column
};
_mockRepository = new Mock <IColumnRepository>();
_mockRepository.Setup(p => p.GetAll()).Returns(_columns);
_mockAdapter = new Mock <IColumnAdapter>();
_mockAdapter.Setup(p => p.Adapt(_column)).Returns(_columnDto);
_handler = new GetAllColumnsQueryHandler(
_mockRepository.Object,
_mockAdapter.Object);
}
public virtual void SetUp()
{
_columnDto = new ColumnDto();
_column = new ColumnBuilder().Build();
_layout = new ScatterPlotLayoutBuilder()
.Build();
_scatterPlot = new ScatterPlotBuilder()
.WithLayout(_layout)
.Build();
_mockRepository = new Mock <IViewRepository>();
_mockRepository.Setup(p => p.Get <ScatterPlot>())
.Returns(_scatterPlot);
_mockAdapter = new Mock <IColumnAdapter>();
_mockAdapter.Setup(p => p.Adapt(_column))
.Returns(_columnDto);
}
/// <summary>
/// 添加或修改栏目
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public async Task AddOrUpdateColumn(ColumnDto model)
{
//拿到网站配置
var siteOption =
await _cacheManager.GetCache <string, SiteOptionDto>(EasyFastConsts.TemplateCacheKey)
.GetAsync("siteOptionCache", () => _siteConfigAppService.GetSiteOption());
if (string.IsNullOrWhiteSpace(model.IndexHtmlRule))
{
model.IndexHtmlRule = "#";
}
else if (!model.IndexHtmlRule.Contains("#") && model.IndexHtmlRule.Contains("html"))
{
if (!string.IsNullOrWhiteSpace(siteOption.HTMLDir) && !model.IndexHtmlRule.Contains(siteOption.HTMLDir))
{
model.IndexHtmlRule = siteOption.HTMLDir + model.IndexHtmlRule;
}
}
if (string.IsNullOrWhiteSpace(model.ListHtmlRule))
{
model.ListHtmlRule = $@"{model.Dir}List\list_{{Page}}.html";
}
if (string.IsNullOrWhiteSpace(model.ContentHtmlRule))
{
model.ContentHtmlRule = $@"{model.Dir}Content\{{Year}}\{{Month}}\{{Day}}\{model.Name}_{{Id}}.html";
}
else if (!model.ContentHtmlRule.Contains(".html"))
{
model.ContentHtmlRule += ".html";
}
if (!string.IsNullOrWhiteSpace(siteOption.HTMLDir) && !model.ListHtmlRule.Contains(siteOption.HTMLDir) && model.ListHtmlRule.Contains("html"))
{
model.ListHtmlRule = siteOption.HTMLDir + model.ListHtmlRule;
}
if (!string.IsNullOrWhiteSpace(siteOption.HTMLDir) && !model.ContentHtmlRule.Contains(siteOption.HTMLDir) && model.ContentHtmlRule.Contains("html"))
{
model.ContentHtmlRule = siteOption.HTMLDir + model.ContentHtmlRule;
}
await _columnRepository.InsertOrUpdateAsync(model.MapTo <Core.Entities.Column>());
}
public override SectionDto CreateDto(TestContext context)
{
var format = (FormatFunc)context.Formatter.Format;
// Initialize the data-table;
var section = new SectionDto
{
Heading = format(Heading),
Table = new TripleTableDto(new[]
{
ColumnDto.Create <string>("Property"),
ColumnDto.Create <string>("Value")
})
};
var table = section.Table;
table.Body.Add("Type", context.DataSource.GetType().Name);
table.Body.Add("Query", context.Query);
table.Body.Add("RowCount", context.Data.Rows.Count.ToString());
table.Body.Add("Elapsed", format($"{RuntimeVariable.TestCounter.GetDataElapsed.ToString(TimespanFormat)}"));
var hasTimestampColumn = context.Data.Columns.Contains(TimestampColumn);
var hasRows = context.Data.Rows.Count > 0; // If there are no rows Min/Max will throw.
if (hasTimestampColumn && hasRows)
{
var timestampMin = context.Data.AsEnumerable().Min(r => r.Field <DateTime>(TimestampColumn));
var timestampMax = context.Data.AsEnumerable().Max(r => r.Field <DateTime>(TimestampColumn));
table.Body.Add(new List <string> {
"Timestamp: min", timestampMin.ToString(CultureInfo.InvariantCulture)
});
table.Body.Add(new List <string> {
"Timestamp: max", timestampMax.ToString(CultureInfo.InvariantCulture)
});
var timespan = timestampMax - timestampMin;
table.Body.Add(new List <string> {
"Timespan", timespan.ToString(TimespanFormat, CultureInfo.InvariantCulture)
});
}
return(section);
}
public async Task <ActionResult <Note> > PutImage(string id, IFormCollection form)
{
ObjectId objectId = new ObjectId(id);
string userId = HttpContext.User.GetUserId();
ColumnDto columnToUpdate = await ColumnToUpdate(userId);
var note = new NoteDto
{
Header = form["header"],
Body = form["body"],
Id = objectId,
UserId = userId,
Position = new PositionDto {
Column = form["position"]
}
};
string accessToken = form["accessToken"];
IFormFile imageFile = form.Files.FirstOrDefault();
if (imageFile != null)
{
NewPhoto uploadedPhoto = await _photoService.AddPhoto(accessToken, userId, imageFile);
note.ImagePath = uploadedPhoto.Id;
var processedPhoto = await _photoService.GetPhoto(accessToken, uploadedPhoto.Id);
note.ImageUrl = $"{processedPhoto.BaseUrl}=w2048-h1024";
}
var updateDef = new UpdateDefinitionBuilder <NoteDto>()
.Set(x => x.Body, note.Body)
.Set(x => x.Header, note.Header)
.Set(x => x.ImagePath, note.ImagePath)
.Set(x => x.ImageUrl, note.ImageUrl);
await _notesCollection.UpdateOneAsync(f => f.Id == objectId, updateDef);
Note returnNote = _mapper.Map <Note>(note);
return(new ActionResult <Note>(returnNote));
}
public void SetUp()
{
_columnDto = new ColumnDto();
_mockMessageBus = new Mock <IMessageBus>();
_mockMessageBus.Setup(p => p.Execute(It.IsAny <GetAllSizeColumnsQuery>()))
.Returns(new List <ColumnDto> {
_columnDto
});
_mockMessageBus.Setup(p => p.Execute(It.IsAny <GetSizeColumnQuery>()))
.Returns(_columnDto);
_mockMessageBus.Setup(p => p.Execute(It.IsAny <GetLowerSizeQuery>()))
.Returns(0.1d);
_mockMessageBus.Setup(p => p.Execute(It.IsAny <GetUpperSizeQuery>()))
.Returns(0.9d);
_viewModel = new SizeLayoutViewModel(
_mockMessageBus.Object);
}
public void SetUp()
{
_columnDto = new ColumnDto()
{
Id = 1,
Name = "Test"
};
_colorPalette = new ColorPalette("Test", new List <Domain.Colors.Color>());
_mockMessageBus = new Mock <IMessageBus>();
_mockMessageBus.Setup(p => p.Execute(It.IsAny <GetAllColorColumnsQuery>()))
.Returns(new List <ColumnDto> {
_columnDto
});
_mockMessageBus.Setup(p => p.Execute(It.IsAny <GetColorColumnQuery>()))
.Returns(_columnDto);
_viewModel = new ColorLayoutViewModel(
_mockMessageBus.Object);
}
public async Task <IActionResult> UpdateColumn(int id, [FromBody] ColumnDto columnDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var column = await _context.Columns.FirstOrDefaultAsync(c => c.Id == id);
if (column == null)
{
return(NotFound());
}
_mapper.Map <ColumnDto, Column>(columnDto, column);
await _context.SaveChangesAsync();
var columnToReturn = _mapper.Map <Column, ColumnDto>(column);
return(Ok(columnToReturn));
}
public static ColumnDefinition ToColumnDefinition(this ColumnDto columnDto, IMapper mapper)
{
if (!Enum.TryParse <DataTypes>(columnDto.DataType, true, out var dataType))
{
throw new NotSupportedException($"Data Type {columnDto.DataType} is not supported in {nameof(ColumnMapperHelper)}::{nameof(ToColumnDefinition)}");
}
switch (dataType)
{
case DataTypes.VarChar2:
return(mapper.Map <VarChar2ColumnDefinition>(columnDto));
case DataTypes.NVarChar2:
return(mapper.Map <NVarChar2ColumnDefinition>(columnDto));
case DataTypes.Number:
return(mapper.Map <NumberColumnDefinition>(columnDto));
case DataTypes.Date:
return(mapper.Map <DateColumnDefinition>(columnDto));
case DataTypes.Raw:
return(mapper.Map <RawColumnDefinition>(columnDto));
case DataTypes.Char:
return(mapper.Map <CharColumnDefinition>(columnDto));
case DataTypes.NChar:
return(mapper.Map <NCharColumnDefinition>(columnDto));
case DataTypes.Clob:
return(mapper.Map <ClobColumnDefinition>(columnDto));
case DataTypes.NClob:
return(mapper.Map <NClobColumnDefinition>(columnDto));
default:
throw new NotSupportedException($"Data Type {dataType} is not supported in {nameof(ColumnMapperHelper)}::{nameof(ToColumnDefinition)}");
}
}
