private void Generate(string sql)
{
try
{
Cursor = Cursors.WaitCursor;
var adoHandler = new SqlParser(SelectedConnectionString, sql);
resultItemBindingSource.DataSource = adoHandler.ResultItems;
tabResult.TabPages.Clear();
foreach (var resultItem in adoHandler.ResultItems)
{
var tabPage = new TabPage {
Text = resultItem.EntityName, Margin = new Padding(0)
};
tabResult.TabPages.Add(tabPage);
var content = new ResultContent {
Dock = DockStyle.Fill
};
content.Initiate(resultItem);
tabPage.Controls.Add(content);
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "GenerateClass", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
finally
{
Cursor = Cursors.Default;
}
}
private static Task HandleExceptionAsync(HttpContext context, Exception exception)
{
Console.WriteLine($"ErrorHandlingMiddleware : {exception.Message}");
var code = HttpStatusCode.InternalServerError; // 500 if unexpected
//TODO: use custom exceptions for this?
if (exception is ApplicationException)
{
code = HttpStatusCode.BadRequest;
}
//TODO: determine other possible exception type and how to respond - eg, HttpStatusCode.Unauthorized;
ResultContent <object> resultContent = ResultContent <object> .Failure(exception.Message);
resultContent.Exception = exception;
resultContent.StatusCode = code;
var result = JsonConvert.SerializeObject(resultContent,
new JsonSerializerSettings {
ContractResolver = new CamelCasePropertyNamesContractResolver()
});
context.Response.ContentType = "application/json";
context.Response.StatusCode = (int)code;
return(context.Response.WriteAsync(result));
}
/// <summary>
/// 加密内容对象
/// </summary>
/// <typeparam name="T">数据类型</typeparam>
/// <param name="content">内容对象</param>
/// <returns></returns>
public static ResultContent <string> EncryptContent <T>(ResultContent <T> content)
{
return(new ResultContent <string>
{
Code = content.Code,
Message = content.Message,
Data = UnityConfig.Container.Resolve <ICrypt>().Encrypt(JsonConvert.SerializeObject(content.Data))
});
}
private void GenerateAllTable(string[] tables)
{
tabResult.TabPages.Clear();
var path = Path.Combine(Application.StartupPath, "Classes");
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
}
foreach (var table in tables)
{
try
{
var sql = AdjustSqlFromText(table);
Cursor = Cursors.WaitCursor;
var adoHandler = new SqlParser(SelectedConnectionString, sql);
resultItemBindingSource.DataSource = adoHandler.ResultItems;
foreach (var resultItem in adoHandler.ResultItems)
{
var tabPage = new TabPage {
Text = resultItem.EntityName, Margin = new Padding(0)
};
tabResult.TabPages.Add(tabPage);
var content = new ResultContent {
Dock = DockStyle.Fill
};
content.Initiate(resultItem);
tabPage.Controls.Add(content);
if (cb_saveAs.Checked)
{
using (var file = File.CreateText($@"{path}\{table}.cs"))
{
file.Write(resultItem.Code);
}
}
}
}
catch (Exception ex)
{
MessageBox.Show("GenerateClass", ex.Message, MessageBoxButtons.OK, MessageBoxIcon.Error);
}
finally
{
Cursor = Cursors.Default;
}
}
if (cb_saveAs.Checked)
{
Process.Start("explorer.exe", path);
}
//Clipboard.SetText(string.Join("\n", results.ToArray()));
}
private void HandleException(ExceptionContext context)
{
ResultContent <string> serviceError;
if (context.Exception is UnauthorizedAccessException)
{
serviceError = ResultContent <string> .Failure(HttpStatusCode.Unauthorized, "Unauthorized Access");
context.HttpContext.Response.StatusCode = (int)HttpStatusCode.Unauthorized;
_logger.LogError(serviceError.ToString());
}
else
{
serviceError = ResultContent <string> .Failure(HttpStatusCode.InternalServerError, context.Exception?.Message, "", context.Exception);
context.HttpContext.Response.StatusCode = (int)HttpStatusCode.InternalServerError;
_logger.LogError(serviceError.ToString());
}
context.Result = new JsonResult(serviceError);
}
public void OnException_Should_Set_Context_Result_As_UnAuthorized()
{
var context = new ExceptionContext(_actionContext, Enumerable.Empty <IFilterMetadata>().ToList())
{
Exception = new UnauthorizedAccessException()
};
var exceptionFilter = new ServiceExceptionFilter(_mockLoggerFactory.Object);
exceptionFilter.OnException(context);
JsonResult jsonResult = context.Result as JsonResult;
ResultContent <string> result = jsonResult.Value as ResultContent <string>;
string errorMessage = result.ErrorMessage;
bool isError = !result.IsSuccess;
context.Result.Should().BeOfType(typeof(JsonResult));
context.HttpContext.Response.StatusCode.Should().Be((int)HttpStatusCode.Unauthorized);
errorMessage.Should().NotBeNullOrEmpty();
isError.Should().BeTrue();
}
public override Task OnResultExecutionAsync(ResultExecutingContext context, ResultExecutionDelegate next)
{
if (context.ModelState.IsValid)
{
return(base.OnResultExecutionAsync(context, next));
}
if (context.ModelState.Keys.Any())
{
Dictionary <string, string[]> errors = context
.ModelState
.ToDictionary(kvp => kvp.Key, kvp => kvp.Value.Errors.Select(e => e.ErrorMessage).ToArray());
var resultContent = ResultContent <string> .Failure(HttpStatusCode.BadRequest, "Validation Errors", errors);
context.Result = new BadRequestObjectResult(resultContent);
}
else
{
context.Result = new BadRequestObjectResult(context.ModelState);
}
return(base.OnResultExecutionAsync(context, next));
}
public void OnExceptionAsync_Should_Set_Context_Result_As_InternalServerError()
{
string exceptionMessage = "Some Exception";
var context = new ExceptionContext(_actionContext, Enumerable.Empty <IFilterMetadata>().ToList())
{
Exception = new Exception(exceptionMessage)
};
var exceptionFilter = new ServiceExceptionFilter(_mockLoggerFactory.Object);
exceptionFilter.OnExceptionAsync(context);
JsonResult jsonResult = context.Result as JsonResult;
ResultContent <string> result = jsonResult.Value as ResultContent <string>;
string errorMessage = result.ErrorMessage;
bool isError = !result.IsSuccess;
context.Result.Should().BeOfType(typeof(JsonResult));
context.HttpContext.Response.StatusCode.Should().Be((int)HttpStatusCode.InternalServerError);
errorMessage.Should().Contain(exceptionMessage);
isError.Should().BeTrue();
}
public async Task ArchiveAnalysis(int analysisId, Stream outStream)
{
outStream = outStream ?? throw new ArgumentNullException(nameof(outStream));
if (analysisId <= 0)
{
throw new ArgumentException("Analysis id must be greater than zero.", nameof(analysisId));
}
var analysis = _ctx.Analyses
.Include(a => a.Visualizations)
.Include(a => a.Request)
.ThenInclude(r => r.DataSet)
.Include(a => a.Request)
.ThenInclude(r => r.DataSet)
.ThenInclude(r => r.Visualizations)
.Include(a => a.Result)
.FirstOrDefault(a => a.Id == analysisId);
if (analysis is null)
{
throw new AnalysisNotFoundException($"Analysis with id '{analysisId}' doesn't exist.");
}
var dataSet = analysis.Request.DataSet;
var req = analysis.Request;
var res = analysis.Result;
var dataSetInfo = JsonConvert.SerializeObject(new
{
Name = dataSet.Name,
FileType = dataSet.FileType.ToString(),
NodeCount = dataSet.NodeCount,
EdgeCount = dataSet.EdgeCount,
LayerCount = dataSet.LayerCount,
LayerNames = dataSet.LayerNames,
ActorNames = dataSet.ActorNames,
});
var edgeList = dataSet.EdgeList;
var originalData = dataSet.Content;
var analyzedEdgeList = res.AnalyzedNetworkEdgeList;
var communityList = res.CommunityList;
var actorToCommunity = res.ActorToCommunity;
var requestContent = new RequestContent
{
CreateDate = req.CreateDate,
Approach = req.Approach.ToString(),
AnalysisAlgorithm = req.AnalysisAlgorithm.ToString(),
AnalysisAlgorithmParameters = req.AnalysisAlgorithmParameters
};
if (req.Approach == AnalysisApproach.SingleLayerFlattening)
{
requestContent.FlatteningAlgorithm = analysis.Request.FlatteningAlgorithm.ToString();
requestContent.FlatteningAlgorithmParameters = analysis.Request.FlatteningAlgorithmParameters;
}
else if (req.Approach == AnalysisApproach.SingleLayerOnly)
{
requestContent.SelectedLayer = dataSet.LayerNames[req.SelectedLayer];
}
var resultContent = new ResultContent();
if (req.Approach.IsSingleLayerApproach())
{
resultContent.Coverage = res.Coverage;
resultContent.Modularity = res.Modularity;
resultContent.Performance = res.Performance;
}
else
{
resultContent.Exclusivities = res.Exclusivities;
resultContent.Homogenities = res.Homogenities;
resultContent.Modularities = res.Modularities;
resultContent.Performances = res.Performances;
resultContent.Coverages = res.Coverages;
resultContent.Varieties = res.Varieties;
}
using (var memoryStream = new MemoryStream())
{
using (var archive = new ZipArchive(memoryStream, ZipArchiveMode.Create, true))
{
await WriteContent(archive, "/dataset/dataset-info.json", dataSetInfo);
await WriteContent(archive, "/dataset/data" + dataSet.FileType.ToExtension(), dataSet.Content);
await WriteContent(archive, "request.json", JsonConvert.SerializeObject(requestContent));
await WriteContent(archive, "result.json", JsonConvert.SerializeObject(resultContent));
await WriteContent(archive, "analyzed-data.edgelist.txt", analyzedEdgeList);
await WriteContent(archive, "community-list.txt", communityList);
await WriteContent(archive, "actor-to-community.json", JsonConvert.SerializeObject(actorToCommunity));
if (dataSet.FileType != FileType.EdgeList)
{
await WriteContent(archive, "dataset/data.edgelist.txt", edgeList);
}
var diagonal = dataSet.Visualizations.FirstOrDefault(v => v.Type == VisualizationType.MultiLayer_Diagonal);
if (diagonal != null)
{
await WriteContent(archive, "dataset/images/diagonal.svg", diagonal.SvgImage);
}
var slices = dataSet.Visualizations.FirstOrDefault(v => v.Type == VisualizationType.MultiLayer_Slices);
if (slices != null)
{
await WriteContent(archive, "dataset/images/slices.svg", slices.SvgImage);
}
foreach (var vis in analysis.Visualizations)
{
if (vis != null)
{
await WriteContent(archive, $"images/{vis.Title}.svg", vis.SvgImage);
}
}
}
memoryStream.Seek(0, SeekOrigin.Begin);
await memoryStream.CopyToAsync(outStream);
outStream.Seek(0, SeekOrigin.Begin);
}
}
