wendellmva/Iloan.Rules
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

chore: update service

Browse Source
This commit is contained in:
Wendell Muntslag 2024-06-19 09:43:09 +02:00
parent 49a069cef0
commit fc06dd83a9
20 changed files with 522 additions and 1362 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/iLoan.Rules.Web/Components/Layout/MainLayout.razor.cs
View File

@ -1,13 +1,11 @@
using System.Net.Http; using System.Net.Http;
using Microsoft.AspNetCore.Authorization; using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Components;
using Microsoft.AspNetCore.Components.Authorization; using Microsoft.AspNetCore.Components.Authorization;
using Microsoft.AspNetCore.Components.Forms; using Microsoft.AspNetCore.Components.Forms;
using Microsoft.AspNetCore.Components.Routing; using Microsoft.AspNetCore.Components.Routing;
using Microsoft.AspNetCore.Components.Web; using Microsoft.AspNetCore.Components.Web;
using Microsoft.AspNetCore.Components.Web.Virtualization; using Microsoft.AspNetCore.Components.Web.Virtualization;
using Microsoft.JSInterop; using Microsoft.JSInterop;
using Radzen;
using Radzen.Blazor; using Radzen.Blazor;
namespace ILoan.Rules.Web.Components.Layout namespace ILoan.Rules.Web.Components.Layout

3
src/iLoan.Rules.Web/Components/Pages/AddCoreRule.razor.cs
View File

@ -2,10 +2,9 @@ using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Linq; using System.Linq;
using System.Threading.Tasks; using System.Threading.Tasks;
using ILoan.Rules.Web.Services;
using Microsoft.JSInterop; using Microsoft.JSInterop;
using Microsoft.AspNetCore.Components;
using Microsoft.AspNetCore.Components.Web; using Microsoft.AspNetCore.Components.Web;
using Radzen;
using Radzen.Blazor; using Radzen.Blazor;
namespace ILoan.Rules.Web.Components.Pages namespace ILoan.Rules.Web.Components.Pages

3
src/iLoan.Rules.Web/Components/Pages/AddCoreRuleCriteriaOperator.razor.cs
View File

@ -2,10 +2,9 @@ using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Linq; using System.Linq;
using System.Threading.Tasks; using System.Threading.Tasks;
using ILoan.Rules.Web.Services;
using Microsoft.JSInterop; using Microsoft.JSInterop;
using Microsoft.AspNetCore.Components;
using Microsoft.AspNetCore.Components.Web; using Microsoft.AspNetCore.Components.Web;
using Radzen;
using Radzen.Blazor; using Radzen.Blazor;
namespace ILoan.Rules.Web.Components.Pages namespace ILoan.Rules.Web.Components.Pages

4
src/iLoan.Rules.Web/Components/Pages/AddCoreRuleCriterion.razor.cs
View File

@ -3,12 +3,10 @@ using System.Collections.Generic;
using System.Linq; using System.Linq;
using System.Threading.Tasks; using System.Threading.Tasks;
using DocumentFormat.OpenXml.CustomProperties; using DocumentFormat.OpenXml.CustomProperties;
using ILoan.Rules.Web.Services;
using Microsoft.JSInterop; using Microsoft.JSInterop;
using Microsoft.AspNetCore.Components;
using Microsoft.AspNetCore.Components.Web; using Microsoft.AspNetCore.Components.Web;
using Radzen;
using Radzen.Blazor; using Radzen.Blazor;
using Microsoft.EntityFrameworkCore;
namespace ILoan.Rules.Web.Components.Pages namespace ILoan.Rules.Web.Components.Pages
{ {

2
src/iLoan.Rules.Web/Components/Pages/CoreRules.razor.cs
View File

@ -4,9 +4,7 @@ using System.Linq;
using System.Threading.Tasks; using System.Threading.Tasks;
using ILoan.Rules.Web.Services; using ILoan.Rules.Web.Services;
using Microsoft.JSInterop; using Microsoft.JSInterop;
using Microsoft.AspNetCore.Components;
using Microsoft.AspNetCore.Components.Web; using Microsoft.AspNetCore.Components.Web;
using Radzen;
using Radzen.Blazor; using Radzen.Blazor;
namespace ILoan.Rules.Web.Components.Pages namespace ILoan.Rules.Web.Components.Pages

3
src/iLoan.Rules.Web/Components/Pages/EditCoreRule.razor.cs
View File

@ -1,7 +1,6 @@
using Microsoft.AspNetCore.Components; using ILoan.Rules.Web.Services;
using Microsoft.AspNetCore.Components.Web; using Microsoft.AspNetCore.Components.Web;
using Microsoft.JSInterop; using Microsoft.JSInterop;
using Radzen;
namespace ILoan.Rules.Web.Components.Pages namespace ILoan.Rules.Web.Components.Pages
{ {

4
src/iLoan.Rules.Web/Components/Pages/EditCoreRuleCriteriaOperator.razor.cs
View File

@ -3,11 +3,9 @@ using System.Collections.Generic;
using System.Linq; using System.Linq;
using System.Threading.Tasks; using System.Threading.Tasks;
using Microsoft.JSInterop; using Microsoft.JSInterop;
using Microsoft.AspNetCore.Components;
using Microsoft.AspNetCore.Components.Web; using Microsoft.AspNetCore.Components.Web;
using Radzen;
using Radzen.Blazor; using Radzen.Blazor;
using ILoan.Rules.Web.Models.Rules; using ILoan.Rules.Web.Services;
namespace ILoan.Rules.Web.Components.Pages namespace ILoan.Rules.Web.Components.Pages
{ {

4
src/iLoan.Rules.Web/Components/Pages/EditCoreRuleCriterion.razor.cs
View File

@ -3,11 +3,9 @@ using System.Collections.Generic;
using System.Linq; using System.Linq;
using System.Threading.Tasks; using System.Threading.Tasks;
using Microsoft.JSInterop; using Microsoft.JSInterop;
using Microsoft.AspNetCore.Components;
using Microsoft.AspNetCore.Components.Web; using Microsoft.AspNetCore.Components.Web;
using Radzen;
using Radzen.Blazor; using Radzen.Blazor;
using ILoan.Rules.Web.Models.Rules; using ILoan.Rules.Web.Services;
namespace ILoan.Rules.Web.Components.Pages namespace ILoan.Rules.Web.Components.Pages
{ {

369
src/iLoan.Rules.Web/Controllers/ExportController.cs
View File

@ -1,369 +0,0 @@
using System;
using System.Linq;
using System.Linq.Dynamic.Core;
using System.Data;
using System.Globalization;
using System.Collections.Generic;
using Microsoft.EntityFrameworkCore;
using Microsoft.AspNetCore.Mvc;
using System.Text;
using System.IO;
using DocumentFormat.OpenXml;
using DocumentFormat.OpenXml.Packaging;
using DocumentFormat.OpenXml.Spreadsheet;
using System.Reflection;
using Microsoft.AspNetCore.Http;
namespace ILoan.Rules.Web.Controllers
{
public partial class ExportController : Controller
{
public IQueryable ApplyQuery<T>(IQueryable<T> items, IQueryCollection query = null, bool keyless = false) where T : class
{
if (query != null)
{
if (query.ContainsKey("$expand"))
{
var propertiesToExpand = query["$expand"].ToString().Split(',');
foreach (var p in propertiesToExpand)
{
items = items.Include(p);
}
}
var filter = query.ContainsKey("$filter") ? query["$filter"].ToString() : null;
if (!string.IsNullOrEmpty(filter))
{
if(keyless)
{
items = items.ToList().AsQueryable();
}
items = items.Where(filter);
}
if (query.ContainsKey("$orderBy"))
{
items = items.OrderBy(query["$orderBy"].ToString());
}
if (query.ContainsKey("$skip"))
{
items = items.Skip(int.Parse(query["$skip"].ToString()));
}
if (query.ContainsKey("$top"))
{
items = items.Take(int.Parse(query["$top"].ToString()));
}
if (query.ContainsKey("$select"))
{
return items.Select($"new ({query["$select"].ToString()})");
}
}
return items;
}
public FileStreamResult ToCSV(IQueryable query, string fileName = null)
{
var columns = GetProperties(query.ElementType);
var sb = new StringBuilder();
foreach (var item in query)
{
var row = new List<string>();
foreach (var column in columns)
{
row.Add($"{GetValue(item, column.Key)}".Trim());
}
sb.AppendLine(string.Join(",", row.ToArray()));
}
var result = new FileStreamResult(new MemoryStream(UTF8Encoding.Default.GetBytes($"{string.Join(",", columns.Select(c => c.Key))}{System.Environment.NewLine}{sb.ToString()}")), "text/csv");
result.FileDownloadName = (!string.IsNullOrEmpty(fileName) ? fileName : "Export") + ".csv";
return result;
}
public FileStreamResult ToExcel(IQueryable query, string fileName = null)
{
var columns = GetProperties(query.ElementType);
var stream = new MemoryStream();
using (var document = SpreadsheetDocument.Create(stream, SpreadsheetDocumentType.Workbook))
{
var workbookPart = document.AddWorkbookPart();
workbookPart.Workbook = new Workbook();
var worksheetPart = workbookPart.AddNewPart<WorksheetPart>();
worksheetPart.Worksheet = new Worksheet();
var workbookStylesPart = workbookPart.AddNewPart<WorkbookStylesPart>();
GenerateWorkbookStylesPartContent(workbookStylesPart);
var sheets = workbookPart.Workbook.AppendChild(new Sheets());
var sheet = new Sheet() { Id = workbookPart.GetIdOfPart(worksheetPart), SheetId = 1, Name = "Sheet1" };
sheets.Append(sheet);
workbookPart.Workbook.Save();
var sheetData = worksheetPart.Worksheet.AppendChild(new SheetData());
var headerRow = new Row();
foreach (var column in columns)
{
headerRow.Append(new Cell()
{
CellValue = new CellValue(column.Key),
DataType = new EnumValue<CellValues>(CellValues.String)
});
}
sheetData.AppendChild(headerRow);
foreach (var item in query)
{
var row = new Row();
foreach (var column in columns)
{
var value = GetValue(item, column.Key);
var stringValue = $"{value}".Trim();
var cell = new Cell();
var underlyingType = column.Value.IsGenericType &&
column.Value.GetGenericTypeDefinition() == typeof(Nullable<>) ?
Nullable.GetUnderlyingType(column.Value) : column.Value;
var typeCode = Type.GetTypeCode(underlyingType);
if (typeCode == TypeCode.DateTime)
{
if (!string.IsNullOrWhiteSpace(stringValue))
{
cell.CellValue = new CellValue() { Text = ((DateTime)value).ToOADate().ToString(System.Globalization.CultureInfo.InvariantCulture) };
cell.DataType = new EnumValue<CellValues>(CellValues.Number);
cell.StyleIndex = (UInt32Value)1U;
}
}
else if (typeCode == TypeCode.Boolean)
{
cell.CellValue = new CellValue(stringValue.ToLowerInvariant());
cell.DataType = new EnumValue<CellValues>(CellValues.Boolean);
}
else if (IsNumeric(typeCode))
{
if (value != null)
{
stringValue = Convert.ToString(value, CultureInfo.InvariantCulture);
}
cell.CellValue = new CellValue(stringValue);
cell.DataType = new EnumValue<CellValues>(CellValues.Number);
}
else
{
cell.CellValue = new CellValue(stringValue);
cell.DataType = new EnumValue<CellValues>(CellValues.String);
}
row.Append(cell);
}
sheetData.AppendChild(row);
}
workbookPart.Workbook.Save();
}
if (stream?.Length > 0)
{
stream.Seek(0, SeekOrigin.Begin);
}
var result = new FileStreamResult(stream, "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
result.FileDownloadName = (!string.IsNullOrEmpty(fileName) ? fileName : "Export") + ".xlsx";
return result;
}
public static object GetValue(object target, string name)
{
return target.GetType().GetProperty(name).GetValue(target);
}
public static IEnumerable<KeyValuePair<string, Type>> GetProperties(Type type)
{
return type.GetProperties(BindingFlags.Public | BindingFlags.Instance)
.Where(p => p.CanRead && IsSimpleType(p.PropertyType)).Select(p => new KeyValuePair<string, Type>(p.Name, p.PropertyType));
}
public static bool IsSimpleType(Type type)
{
var underlyingType = type.IsGenericType &&
type.GetGenericTypeDefinition() == typeof(Nullable<>) ?
Nullable.GetUnderlyingType(type) : type;
if(underlyingType == typeof(System.Guid) || underlyingType == typeof(System.DateTimeOffset))
return true;
#if NET6_0_OR_GREATER
if(underlyingType == typeof(System.DateOnly) || underlyingType == typeof(System.TimeOnly))
return true;
#endif
var typeCode = Type.GetTypeCode(underlyingType);
switch (typeCode)
{
case TypeCode.Boolean:
case TypeCode.Byte:
case TypeCode.Char:
case TypeCode.DateTime:
case TypeCode.Decimal:
case TypeCode.Double:
case TypeCode.Int16:
case TypeCode.Int32:
case TypeCode.Int64:
case TypeCode.SByte:
case TypeCode.Single:
case TypeCode.String:
case TypeCode.UInt16:
case TypeCode.UInt32:
case TypeCode.UInt64:
return true;
default:
return false;
}
}
private static bool IsNumeric(TypeCode typeCode)
{
switch (typeCode)
{
case TypeCode.Decimal:
case TypeCode.Double:
case TypeCode.Int16:
case TypeCode.Int32:
case TypeCode.Int64:
case TypeCode.UInt16:
case TypeCode.UInt32:
case TypeCode.UInt64:
return true;
default:
return false;
}
}
private static void GenerateWorkbookStylesPartContent(WorkbookStylesPart workbookStylesPart1)
{
Stylesheet stylesheet1 = new Stylesheet() { MCAttributes = new MarkupCompatibilityAttributes() { Ignorable = "x14ac x16r2 xr" } };
stylesheet1.AddNamespaceDeclaration("mc", "http://schemas.openxmlformats.org/markup-compatibility/2006");
stylesheet1.AddNamespaceDeclaration("x14ac", "http://schemas.microsoft.com/office/spreadsheetml/2009/9/ac");
stylesheet1.AddNamespaceDeclaration("x16r2", "http://schemas.microsoft.com/office/spreadsheetml/2015/02/main");
stylesheet1.AddNamespaceDeclaration("xr", "http://schemas.microsoft.com/office/spreadsheetml/2014/revision");
Fonts fonts1 = new Fonts() { Count = (UInt32Value)1U, KnownFonts = true };
Font font1 = new Font();
FontSize fontSize1 = new FontSize() { Val = 11D };
Color color1 = new Color() { Theme = (UInt32Value)1U };
FontName fontName1 = new FontName() { Val = "Calibri" };
FontFamilyNumbering fontFamilyNumbering1 = new FontFamilyNumbering() { Val = 2 };
FontScheme fontScheme1 = new FontScheme() { Val = FontSchemeValues.Minor };
font1.Append(fontSize1);
font1.Append(color1);
font1.Append(fontName1);
font1.Append(fontFamilyNumbering1);
font1.Append(fontScheme1);
fonts1.Append(font1);
Fills fills1 = new Fills() { Count = (UInt32Value)2U };
Fill fill1 = new Fill();
PatternFill patternFill1 = new PatternFill() { PatternType = PatternValues.None };
fill1.Append(patternFill1);
Fill fill2 = new Fill();
PatternFill patternFill2 = new PatternFill() { PatternType = PatternValues.Gray125 };
fill2.Append(patternFill2);
fills1.Append(fill1);
fills1.Append(fill2);
Borders borders1 = new Borders() { Count = (UInt32Value)1U };
Border border1 = new Border();
LeftBorder leftBorder1 = new LeftBorder();
RightBorder rightBorder1 = new RightBorder();
TopBorder topBorder1 = new TopBorder();
BottomBorder bottomBorder1 = new BottomBorder();
DiagonalBorder diagonalBorder1 = new DiagonalBorder();
border1.Append(leftBorder1);
border1.Append(rightBorder1);
border1.Append(topBorder1);
border1.Append(bottomBorder1);
border1.Append(diagonalBorder1);
borders1.Append(border1);
CellStyleFormats cellStyleFormats1 = new CellStyleFormats() { Count = (UInt32Value)1U };
CellFormat cellFormat1 = new CellFormat() { NumberFormatId = (UInt32Value)0U, FontId = (UInt32Value)0U, FillId = (UInt32Value)0U, BorderId = (UInt32Value)0U };
cellStyleFormats1.Append(cellFormat1);
CellFormats cellFormats1 = new CellFormats() { Count = (UInt32Value)2U };
CellFormat cellFormat2 = new CellFormat() { NumberFormatId = (UInt32Value)0U, FontId = (UInt32Value)0U, FillId = (UInt32Value)0U, BorderId = (UInt32Value)0U, FormatId = (UInt32Value)0U };
CellFormat cellFormat3 = new CellFormat() { NumberFormatId = (UInt32Value)14U, FontId = (UInt32Value)0U, FillId = (UInt32Value)0U, BorderId = (UInt32Value)0U, FormatId = (UInt32Value)0U, ApplyNumberFormat = true };
cellFormats1.Append(cellFormat2);
cellFormats1.Append(cellFormat3);
CellStyles cellStyles1 = new CellStyles() { Count = (UInt32Value)1U };
CellStyle cellStyle1 = new CellStyle() { Name = "Normal", FormatId = (UInt32Value)0U, BuiltinId = (UInt32Value)0U };
cellStyles1.Append(cellStyle1);
DifferentialFormats differentialFormats1 = new DifferentialFormats() { Count = (UInt32Value)0U };
TableStyles tableStyles1 = new TableStyles() { Count = (UInt32Value)0U, DefaultTableStyle = "TableStyleMedium2", DefaultPivotStyle = "PivotStyleLight16" };
StylesheetExtensionList stylesheetExtensionList1 = new StylesheetExtensionList();
StylesheetExtension stylesheetExtension1 = new StylesheetExtension() { Uri = "{EB79DEF2-80B8-43e5-95BD-54CBDDF9020C}" };
stylesheetExtension1.AddNamespaceDeclaration("x14", "http://schemas.microsoft.com/office/spreadsheetml/2009/9/main");
StylesheetExtension stylesheetExtension2 = new StylesheetExtension() { Uri = "{9260A510-F301-46a8-8635-F512D64BE5F5}" };
stylesheetExtension2.AddNamespaceDeclaration("x15", "http://schemas.microsoft.com/office/spreadsheetml/2010/11/main");
OpenXmlUnknownElement openXmlUnknownElement4 = workbookStylesPart1.CreateUnknownElement("<x15:timelineStyles defaultTimelineStyle=\"TimeSlicerStyleLight1\" xmlns:x15=\"http://schemas.microsoft.com/office/spreadsheetml/2010/11/main\" />");
stylesheetExtension2.Append(openXmlUnknownElement4);
stylesheetExtensionList1.Append(stylesheetExtension1);
stylesheetExtensionList1.Append(stylesheetExtension2);
stylesheet1.Append(fonts1);
stylesheet1.Append(fills1);
stylesheet1.Append(borders1);
stylesheet1.Append(cellStyleFormats1);
stylesheet1.Append(cellFormats1);
stylesheet1.Append(cellStyles1);
stylesheet1.Append(differentialFormats1);
stylesheet1.Append(tableStyles1);
stylesheet1.Append(stylesheetExtensionList1);
workbookStylesPart1.Stylesheet = stylesheet1;
}
}
}

64
src/iLoan.Rules.Web/Controllers/ExportRulesController.cs
View File

@ -1,64 +0,0 @@
using System;
using System.Linq;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using System.Threading.Tasks;
using ILoan.Rules.Web.Data;
namespace ILoan.Rules.Web.Controllers
{
public partial class ExportRulesController : ExportController
{
private readonly RulesContext context;
private readonly RulesService service;
public ExportRulesController(RulesContext context, RulesService service)
{
this.service = service;
this.context = context;
}
[HttpGet("/export/Rules/corerulecriteriaoperators/csv")]
[HttpGet("/export/Rules/corerulecriteriaoperators/csv(fileName='{fileName}')")]
public async Task<FileStreamResult> ExportCoreRuleCriteriaOperatorsToCSV(string fileName = null)
{
return ToCSV(ApplyQuery(await service.GetCoreRuleCriteriaOperators(), Request.Query, false), fileName);
}
[HttpGet("/export/Rules/corerulecriteriaoperators/excel")]
[HttpGet("/export/Rules/corerulecriteriaoperators/excel(fileName='{fileName}')")]
public async Task<FileStreamResult> ExportCoreRuleCriteriaOperatorsToExcel(string fileName = null)
{
return ToExcel(ApplyQuery(await service.GetCoreRuleCriteriaOperators(), Request.Query, false), fileName);
}
[HttpGet("/export/Rules/corerules/csv")]
[HttpGet("/export/Rules/corerules/csv(fileName='{fileName}')")]
public async Task<FileStreamResult> ExportCoreRulesToCSV(string fileName = null)
{
return ToCSV(ApplyQuery(await service.GetCoreRules(), Request.Query, false), fileName);
}
[HttpGet("/export/Rules/corerules/excel")]
[HttpGet("/export/Rules/corerules/excel(fileName='{fileName}')")]
public async Task<FileStreamResult> ExportCoreRulesToExcel(string fileName = null)
{
return ToExcel(ApplyQuery(await service.GetCoreRules(), Request.Query, false), fileName);
}
[HttpGet("/export/Rules/corerulecriteria/csv")]
[HttpGet("/export/Rules/corerulecriteria/csv(fileName='{fileName}')")]
public async Task<FileStreamResult> ExportCoreRuleCriteriaToCSV(string fileName = null)
{
return ToCSV(ApplyQuery(await service.GetCoreRuleCriteria(), Request.Query, false), fileName);
}
[HttpGet("/export/Rules/corerulecriteria/excel")]
[HttpGet("/export/Rules/corerulecriteria/excel(fileName='{fileName}')")]
public async Task<FileStreamResult> ExportCoreRuleCriteriaToExcel(string fileName = null)
{
return ToExcel(ApplyQuery(await service.GetCoreRuleCriteria(), Request.Query, false), fileName);
}
}
}

243
src/iLoan.Rules.Web/Controllers/ReportController.cs
View File

@ -1,243 +0,0 @@
using System;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Http.Extensions;
using Microsoft.AspNetCore.Mvc;
namespace ILoan.Rules.Web.Controllers
{
public partial class ReportController : Controller
{
[HttpGet("/__ssrsreport")]
public async Task Get(string url)
{
if (!String.IsNullOrEmpty(url))
{
using (var httpClient = CreateHttpClient())
{
var responseMessage = await ForwardRequest(httpClient, Request, url);
CopyResponseHeaders(responseMessage, Response);
await WriteResponse(Request, url, responseMessage, Response, false);
}
}
}
[Route("/ssrsproxy/{*url}")]
public async Task Proxy()
{
var urlToReplace = String.Format("{0}://{1}{2}/{3}/", Request.Scheme, Request.Host.Value, Request.PathBase, "ssrsproxy");
var requestedUrl = Request.GetDisplayUrl().Replace(urlToReplace, "", StringComparison.InvariantCultureIgnoreCase);
var reportServerIndex = requestedUrl.IndexOf("/ReportServer", StringComparison.InvariantCultureIgnoreCase);
if (reportServerIndex == -1)
{
reportServerIndex = requestedUrl.IndexOf("/Reports", StringComparison.InvariantCultureIgnoreCase);
}
var reportUrlParts = requestedUrl.Substring(0, reportServerIndex).Split('/');
var url = String.Format("{0}://{1}:{2}{3}", reportUrlParts[0], reportUrlParts[1], reportUrlParts[2],
requestedUrl.Substring(reportServerIndex, requestedUrl.Length - reportServerIndex));
using (var httpClient = CreateHttpClient())
{
var responseMessage = await ForwardRequest(httpClient, Request, url);
CopyResponseHeaders(responseMessage, Response);
if (Request.Method == "POST")
{
await WriteResponse(Request, url, responseMessage, Response, true);
}
else
{
if (responseMessage.Content.Headers.ContentType != null && responseMessage.Content.Headers.ContentType.MediaType == "text/html")
{
await WriteResponse(Request, url, responseMessage, Response, false);
}
else
{
using (var responseStream = await responseMessage.Content.ReadAsStreamAsync())
{
await responseStream.CopyToAsync(Response.Body, 81920, HttpContext.RequestAborted);
}
}
}
}
}
partial void OnHttpClientHandlerCreate(ref HttpClientHandler handler);
private HttpClient CreateHttpClient()
{
var httpClientHandler = new HttpClientHandler();
httpClientHandler.AllowAutoRedirect = true;
httpClientHandler.UseDefaultCredentials = true;
if (httpClientHandler.SupportsAutomaticDecompression)
{
httpClientHandler.AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate;
}
OnHttpClientHandlerCreate(ref httpClientHandler);
return new HttpClient(httpClientHandler);
}
partial void OnReportRequest(ref HttpRequestMessage requestMessage);
async Task<HttpResponseMessage> ForwardRequest(HttpClient httpClient, HttpRequest currentReqest, string url)
{
var proxyRequestMessage = new HttpRequestMessage(new HttpMethod(currentReqest.Method), url);
foreach (var header in currentReqest.Headers)
{
if (header.Key != "Host")
{
proxyRequestMessage.Headers.TryAddWithoutValidation(header.Key, new string[] { header.Value });
}
}
this.OnReportRequest(ref proxyRequestMessage);
if (currentReqest.Method == "POST")
{
using (var stream = new MemoryStream())
{
await currentReqest.Body.CopyToAsync(stream);
stream.Position = 0;
string body = new StreamReader(stream).ReadToEnd();
proxyRequestMessage.Content = new StringContent(body);
if (body.IndexOf("AjaxScriptManager") != -1)
{
proxyRequestMessage.Content.Headers.Remove("Content-Type");
proxyRequestMessage.Content.Headers.Add("Content-Type", new string[] { currentReqest.ContentType });
}
}
}
return await httpClient.SendAsync(proxyRequestMessage);
}
static void CopyResponseHeaders(HttpResponseMessage responseMessage, HttpResponse response)
{
response.StatusCode = (int)responseMessage.StatusCode;
foreach (var header in responseMessage.Headers)
{
response.Headers[header.Key] = header.Value.ToArray();
}
foreach (var header in responseMessage.Content.Headers)
{
response.Headers[header.Key] = header.Value.ToArray();
}
response.Headers.Remove("transfer-encoding");
}
static async Task WriteResponse(HttpRequest currentReqest, string url, HttpResponseMessage responseMessage, HttpResponse response, bool isAjax)
{
var result = await responseMessage.Content.ReadAsStringAsync();
var ReportServer = url.Contains("/ReportServer/", StringComparison.InvariantCultureIgnoreCase) ? "ReportServer" : "Reports";
var reportUri = new Uri(url);
var proxyUrl = String.Format("{0}://{1}{2}/ssrsproxy/{3}/{4}/{5}", currentReqest.Scheme, currentReqest.Host.Value, currentReqest.PathBase,
reportUri.Scheme, reportUri.Host, reportUri.Port);
if (isAjax && result.IndexOf("|") != -1)
{
var builder = new StringBuilder();
var delimiterIndex = 0;
var length = 0;
var index = 0;
var type = "";
var id = "";
var content = "";
while (index < result.Length)
{
delimiterIndex = result.IndexOf("|", index);
if (delimiterIndex == -1)
{
break;
}
length = int.Parse(result.Substring(index, delimiterIndex - index));
if ((length % 1) != 0)
{
break;
}
index = delimiterIndex + 1;
delimiterIndex = result.IndexOf("|", index);
if (delimiterIndex == -1)
{
break;
}
type = result.Substring(index, delimiterIndex - index);
index = delimiterIndex + 1;
delimiterIndex = result.IndexOf("|", index);
if (delimiterIndex == -1)
{
break;
}
id = result.Substring(index, delimiterIndex - index);
index = delimiterIndex + 1;
if ((index + length) >= result.Length)
{
break;
}
content = result.Substring(index, length);
index += length;
if (result.Substring(index, 1) != "|")
{
break;
}
index++;
content = content.Replace($"/{ReportServer}/", $"{proxyUrl}/{ReportServer}/", StringComparison.InvariantCultureIgnoreCase);
if (content.Contains("./ReportViewer.aspx", StringComparison.InvariantCultureIgnoreCase))
{
content = content.Replace("./ReportViewer.aspx", $"{proxyUrl}/{ReportServer}/Pages/ReportViewer.aspx", StringComparison.InvariantCultureIgnoreCase);
}
else
{
content = content.Replace("ReportViewer.aspx", $"{proxyUrl}/{ReportServer}/Pages/ReportViewer.aspx", StringComparison.InvariantCultureIgnoreCase);
}
builder.Append(String.Format("{0}|{1}|{2}|{3}|", content.Length, type, id, content));
}
result = builder.ToString();
}
else
{
result = result.Replace($"/{ReportServer}/", $"{proxyUrl}/{ReportServer}/", StringComparison.InvariantCultureIgnoreCase);
if (result.Contains("./ReportViewer.aspx", StringComparison.InvariantCultureIgnoreCase))
{
result = result.Replace("./ReportViewer.aspx", $"{proxyUrl}/{ReportServer}/Pages/ReportViewer.aspx", StringComparison.InvariantCultureIgnoreCase);
}
else
{
result = result.Replace("ReportViewer.aspx", $"{proxyUrl}/{ReportServer}/Pages/ReportViewer.aspx", StringComparison.InvariantCultureIgnoreCase);
}
}
response.Headers.Remove("Content-Length");
response.Headers.Append("Content-Length", new string[] { System.Text.Encoding.UTF8.GetByteCount(result).ToString() });
await response.WriteAsync(result);
}
}
}

88
src/iLoan.Rules.Web/Controllers/UploadController.cs
View File

@ -1,88 +0,0 @@
using System;
using System.IO;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Hosting;
namespace ILoan.Rules.Web.Controllers
{
public partial class UploadController : Controller
{
private readonly IWebHostEnvironment environment;
public UploadController(IWebHostEnvironment environment)
{
this.environment = environment;
}
// Single file upload
[HttpPost("upload/single")]
public IActionResult Single(IFormFile file)
{
try
{
// Put your code here
return StatusCode(200);
}
catch (Exception ex)
{
return StatusCode(500, ex.Message);
}
}
// Multiple files upload
[HttpPost("upload/multiple")]
public IActionResult Multiple(IFormFile[] files)
{
try
{
// Put your code here
return StatusCode(200);
}
catch (Exception ex)
{
return StatusCode(500, ex.Message);
}
}
// Multiple files upload with parameter
[HttpPost("upload/{id}")]
public IActionResult Post(IFormFile[] files, int id)
{
try
{
// Put your code here
return StatusCode(200);
}
catch (Exception ex)
{
return StatusCode(500, ex.Message);
}
}
// Image file upload (used by HtmlEditor components)
[HttpPost("upload/image")]
public IActionResult Image(IFormFile file)
{
try
{
var fileName = $"{Guid.NewGuid()}{Path.GetExtension(file.FileName)}";
using (var stream = new FileStream(Path.Combine(environment.WebRootPath, fileName), FileMode.Create))
{
// Save the file
file.CopyTo(stream);
// Return the URL of the file
var url = Url.Content($"~/{fileName}");
return Ok(new { Url = url });
}
}
catch (Exception ex)
{
return StatusCode(500, ex.Message);
}
}
}
}

1
src/iLoan.Rules.Web/Data/BlankTriggerAddingConvention.cs
View File

@ -1,7 +1,6 @@
using System; using System;
using System.Linq; using System.Linq;
using System.Collections.Generic; using System.Collections.Generic;
using Microsoft.EntityFrameworkCore;
namespace ILoan.Rules.Web.Data namespace ILoan.Rules.Web.Data
{ {

2
src/iLoan.Rules.Web/Data/RulesContext.cs
View File

@ -1,8 +1,6 @@
using System; using System;
using System.Linq; using System.Linq;
using System.Collections.Generic; using System.Collections.Generic;
using Microsoft.EntityFrameworkCore;
using ILoan.Rules.Web.Models.Rules;
namespace ILoan.Rules.Web.Data namespace ILoan.Rules.Web.Data
{ {

6
src/iLoan.Rules.Web/Program.cs
View File

@ -1,7 +1,5 @@
using Radzen;
using ILoan.Rules.Web.Components; using ILoan.Rules.Web.Components;
using ILoan.Rules.Web.Services; using ILoan.Rules.Web.Services;
using Microsoft.EntityFrameworkCore;
var builder = WebApplication.CreateBuilder(args); var builder = WebApplication.CreateBuilder(args);
// Add services to the container. // Add services to the container.
@ -9,9 +7,9 @@ builder.Services.AddRazorComponents().AddInteractiveServerComponents().AddHubOpt
builder.Services.AddControllers(); builder.Services.AddControllers();
builder.Services.AddRadzenComponents(); builder.Services.AddRadzenComponents();
builder.Services.AddHttpClient(); builder.Services.AddHttpClient();
builder.Services.AddScoped<ILoan.Rules.Web.RulesService>(); builder.Services.AddScoped<RulesService>();
builder.Services.AddScoped<RuleFileGeneratorService>(); builder.Services.AddScoped<RuleFileGeneratorService>();
builder.Services.AddDbContext<ILoan.Rules.Web.Data.RulesContext>(options => builder.Services.AddDbContextFactory<ILoan.Rules.Web.Data.RulesContext>(options =>
{ {
options.UseNpgsql(builder.Configuration.GetConnectionString("RulesConnection")); options.UseNpgsql(builder.Configuration.GetConnectionString("RulesConnection"));
}); });

4
src/iLoan.Rules.Web/Properties/launchSettings.json
View File

@ -8,11 +8,11 @@
} }
}, },
"profiles": { "profiles": {
"ILoan.Rules.Web.Server": { "ILoan.Rules.Web": {
"commandName": "Project", "commandName": "Project",
"dotnetRunMessages": true, "dotnetRunMessages": true,
"launchBrowser": true, "launchBrowser": true,
"applicationUrl": "https://localhost:5001;http://localhost:5000", "applicationUrl": "https://localhost:7001;http://localhost:7000",
"environmentVariables": { "environmentVariables": {
"ASPNETCORE_ENVIRONMENT": "Development" "ASPNETCORE_ENVIRONMENT": "Development"
} }

9
src/iLoan.Rules.Web/Services/RuleFileGeneratorService.cs
View File

@ -1,7 +1,4 @@
using ILoan.Rules.Web.Data; using System.Text;
using ILoan.Rules.Web.Models.Rules;
using Microsoft.EntityFrameworkCore;
using System.Text;
namespace ILoan.Rules.Web.Services; namespace ILoan.Rules.Web.Services;
@ -80,7 +77,7 @@ INSERT INTO core.""Core_Rules"" (
sqlBuilder.AppendLine($@" sqlBuilder.AppendLine($@"
INSERT INTO core.""Core_RuleCriteria"" ( INSERT INTO core.""Core_RuleCriteria"" (
""ID"", ""RuleID"", ""Property"", ""Comparison"", ""Value"", ""ValueIsProperty"", ""ReturnCount"", ""IsThresholdCriterium"" ""ID"", ""RuleID"", ""Property"", ""Comparison"", ""Value"", ""ValueIsProperty"", ""ReturnCount"", ""IsThresholdCriterium""
) VALUES ( ) OVERRIDING SYSTEM VALUE VALUES (
{criterion.ID}, {criterion.RuleID}, '{EscapeSingleQuote(criterion.Property)}', '{EscapeSingleQuote(criterion.Comparison)}', '{EscapeSingleQuote(criterion.Value)}', {criterion.ID}, {criterion.RuleID}, '{EscapeSingleQuote(criterion.Property)}', '{EscapeSingleQuote(criterion.Comparison)}', '{EscapeSingleQuote(criterion.Value)}',
{criterion.ValueIsProperty?.ToString().ToUpper() ?? "NULL"}, {criterion.ReturnCount?.ToString().ToUpper() ?? "NULL"}, {criterion.IsThresholdCriterium?.ToString().ToUpper() ?? "NULL"} {criterion.ValueIsProperty?.ToString().ToUpper() ?? "NULL"}, {criterion.ReturnCount?.ToString().ToUpper() ?? "NULL"}, {criterion.IsThresholdCriterium?.ToString().ToUpper() ?? "NULL"}
); );
@ -93,7 +90,7 @@ INSERT INTO core.""Core_RuleCriteria"" (
sqlBuilder.AppendLine($@" sqlBuilder.AppendLine($@"
INSERT INTO core.""Core_RuleCriteriaOperator"" ( INSERT INTO core.""Core_RuleCriteriaOperator"" (
""ID"", ""RuleID"", ""Operator"" ""ID"", ""RuleID"", ""Operator""
) VALUES ( ) OVERRIDING SYSTEM VALUE (
{coreRuleCriteriaOperator.ID}, {coreRuleCriteriaOperator.RuleID}, '{EscapeSingleQuote(coreRuleCriteriaOperator.Operator1)}' {coreRuleCriteriaOperator.ID}, {coreRuleCriteriaOperator.RuleID}, '{EscapeSingleQuote(coreRuleCriteriaOperator.Operator1)}'
); );
"); ");

390
src/iLoan.Rules.Web/Services/RulesService.cs
View File

@ -1,42 +1,7 @@
using System; namespace ILoan.Rules.Web.Services;
using System.Data;
using System.Linq;
using System.Linq.Dynamic.Core;
using System.Collections.Generic;
using System.Threading.Tasks;
using System.Text.Encodings.Web;
using Microsoft.AspNetCore.Components;
using Microsoft.EntityFrameworkCore;
using Radzen;
using ILoan.Rules.Web.Data; public partial class RulesService(IDbContextFactory<RulesContext> factory, NavigationManager navigationManager)
using DocumentFormat.OpenXml.InkML;
using ILoan.Rules.Web.Models.Enums;
using ILoan.Rules.Web.Extensions;
namespace ILoan.Rules.Web
{ {
public partial class RulesService
{
RulesContext Context
{
get
{
return this.context;
}
}
private readonly RulesContext context;
private readonly NavigationManager navigationManager;
public RulesService(RulesContext context, NavigationManager navigationManager)
{
this.context = context;
this.navigationManager = navigationManager;
}
public void Reset() => Context.ChangeTracker.Entries().Where(e => e.Entity != null).ToList().ForEach(e => e.State = EntityState.Detached);
public void ApplyQuery<T>(ref IQueryable<T> items, Query query = null) public void ApplyQuery<T>(ref IQueryable<T> items, Query query = null)
{ {
if (query != null) if (query != null)
@ -44,48 +9,25 @@ namespace ILoan.Rules.Web
if (!string.IsNullOrEmpty(query.Filter)) if (!string.IsNullOrEmpty(query.Filter))
{ {
if (query.FilterParameters != null) if (query.FilterParameters != null)
{
items = items.Where(query.Filter, query.FilterParameters); items = items.Where(query.Filter, query.FilterParameters);
}
else else
{
items = items.Where(query.Filter); items = items.Where(query.Filter);
} }
if (!string.IsNullOrEmpty(query.OrderBy)) items = items.OrderBy(query.OrderBy);
if (query.Skip.HasValue) items = items.Skip(query.Skip.Value);
if (query.Top.HasValue) items = items.Take(query.Top.Value);
}
} }
if (!string.IsNullOrEmpty(query.OrderBy)) partial void OnCoreRuleCriteriaOperatorsRead(ref IQueryable<CoreRuleCriteriaOperator> items);
public async Task<IQueryable<CoreRuleCriteriaOperator>> GetCoreRuleCriteriaOperators(Query query = null)
{ {
items = items.OrderBy(query.OrderBy); var context = await factory.CreateDbContextAsync();
} var items = context.CoreRuleCriteriaOperators.AsQueryable();
if (query.Skip.HasValue)
{
items = items.Skip(query.Skip.Value);
}
if (query.Top.HasValue)
{
items = items.Take(query.Top.Value);
}
}
}
public async Task ExportCoreRuleCriteriaOperatorsToExcel(Query query = null, string fileName = null)
{
navigationManager.NavigateTo(query != null ? query.ToUrl($"export/rules/corerulecriteriaoperators/excel(fileName='{(!string.IsNullOrEmpty(fileName) ? UrlEncoder.Default.Encode(fileName) : "Export")}')") : $"export/rules/corerulecriteriaoperators/excel(fileName='{(!string.IsNullOrEmpty(fileName) ? UrlEncoder.Default.Encode(fileName) : "Export")}')", true);
}
public async Task ExportCoreRuleCriteriaOperatorsToCSV(Query query = null, string fileName = null)
{
navigationManager.NavigateTo(query != null ? query.ToUrl($"export/rules/corerulecriteriaoperators/csv(fileName='{(!string.IsNullOrEmpty(fileName) ? UrlEncoder.Default.Encode(fileName) : "Export")}')") : $"export/rules/corerulecriteriaoperators/csv(fileName='{(!string.IsNullOrEmpty(fileName) ? UrlEncoder.Default.Encode(fileName) : "Export")}')", true);
}
partial void OnCoreRuleCriteriaOperatorsRead(ref IQueryable<ILoan.Rules.Web.Models.Rules.CoreRuleCriteriaOperator> items);
public async Task<IQueryable<ILoan.Rules.Web.Models.Rules.CoreRuleCriteriaOperator>> GetCoreRuleCriteriaOperators(Query query = null)
{
var items = Context.CoreRuleCriteriaOperators.AsQueryable();
items = items.Include(i => i.CoreRule); items = items.Include(i => i.CoreRule);
@ -94,10 +36,7 @@ namespace ILoan.Rules.Web
if (!string.IsNullOrEmpty(query.Expand)) if (!string.IsNullOrEmpty(query.Expand))
{ {
var propertiesToExpand = query.Expand.Split(','); var propertiesToExpand = query.Expand.Split(',');
foreach(var p in propertiesToExpand) foreach (var p in propertiesToExpand) items = items.Include(p.Trim());
{
items = items.Include(p.Trim());
}
} }
ApplyQuery(ref items, query); ApplyQuery(ref items, query);
@ -108,13 +47,14 @@ namespace ILoan.Rules.Web
return await Task.FromResult(items); return await Task.FromResult(items);
} }
partial void OnCoreRuleCriteriaOperatorGet(ILoan.Rules.Web.Models.Rules.CoreRuleCriteriaOperator item); partial void OnCoreRuleCriteriaOperatorGet(CoreRuleCriteriaOperator item);
partial void OnGetCoreRuleCriteriaOperatorById(ref IQueryable<ILoan.Rules.Web.Models.Rules.CoreRuleCriteriaOperator> items); partial void OnGetCoreRuleCriteriaOperatorById(ref IQueryable<CoreRuleCriteriaOperator> items);
public async Task<ILoan.Rules.Web.Models.Rules.CoreRuleCriteriaOperator> GetCoreRuleCriteriaOperatorById(int id) public async Task<CoreRuleCriteriaOperator> GetCoreRuleCriteriaOperatorById(int id)
{ {
var items = Context.CoreRuleCriteriaOperators var context = await factory.CreateDbContextAsync();
var items = context.CoreRuleCriteriaOperators
.AsNoTracking() .AsNoTracking()
.Where(i => i.ID == id); .Where(i => i.ID == id);
@ -129,30 +69,28 @@ namespace ILoan.Rules.Web
return await Task.FromResult(itemToReturn); return await Task.FromResult(itemToReturn);
} }
partial void OnCoreRuleCriteriaOperatorCreated(ILoan.Rules.Web.Models.Rules.CoreRuleCriteriaOperator item); partial void OnCoreRuleCriteriaOperatorCreated(CoreRuleCriteriaOperator item);
partial void OnAfterCoreRuleCriteriaOperatorCreated(ILoan.Rules.Web.Models.Rules.CoreRuleCriteriaOperator item); partial void OnAfterCoreRuleCriteriaOperatorCreated(CoreRuleCriteriaOperator item);
public async Task<ILoan.Rules.Web.Models.Rules.CoreRuleCriteriaOperator> CreateCoreRuleCriteriaOperator(ILoan.Rules.Web.Models.Rules.CoreRuleCriteriaOperator corerulecriteriaoperator) public async Task<CoreRuleCriteriaOperator> CreateCoreRuleCriteriaOperator(
CoreRuleCriteriaOperator corerulecriteriaoperator)
{ {
OnCoreRuleCriteriaOperatorCreated(corerulecriteriaoperator); OnCoreRuleCriteriaOperatorCreated(corerulecriteriaoperator);
var context = await factory.CreateDbContextAsync();
var existingItem = Context.CoreRuleCriteriaOperators var existingItem = context.CoreRuleCriteriaOperators
.Where(i => i.ID == corerulecriteriaoperator.ID) .FirstOrDefault(i => i.ID == corerulecriteriaoperator.ID);
.FirstOrDefault();
if (existingItem != null) if (existingItem != null) throw new Exception("Item already available");
{
throw new Exception("Item already available");
}
try try
{ {
Context.CoreRuleCriteriaOperators.Add(corerulecriteriaoperator); context.CoreRuleCriteriaOperators.Add(corerulecriteriaoperator);
Context.SaveChanges(); await context.SaveChangesAsync();
} }
catch catch
{ {
Context.Entry(corerulecriteriaoperator).State = EntityState.Detached; context.Entry(corerulecriteriaoperator).State = EntityState.Detached;
throw; throw;
} }
@ -161,9 +99,10 @@ namespace ILoan.Rules.Web
return corerulecriteriaoperator; return corerulecriteriaoperator;
} }
public async Task<ILoan.Rules.Web.Models.Rules.CoreRuleCriteriaOperator> CancelCoreRuleCriteriaOperatorChanges(ILoan.Rules.Web.Models.Rules.CoreRuleCriteriaOperator item) public async Task<CoreRuleCriteriaOperator> CancelCoreRuleCriteriaOperatorChanges(CoreRuleCriteriaOperator item)
{ {
var entityToCancel = Context.Entry(item); var context = await factory.CreateDbContextAsync();
var entityToCancel = context.Entry(item);
if (entityToCancel.State == EntityState.Modified) if (entityToCancel.State == EntityState.Modified)
{ {
entityToCancel.CurrentValues.SetValues(entityToCancel.OriginalValues); entityToCancel.CurrentValues.SetValues(entityToCancel.OriginalValues);
@ -173,59 +112,54 @@ namespace ILoan.Rules.Web
return item; return item;
} }
partial void OnCoreRuleCriteriaOperatorUpdated(ILoan.Rules.Web.Models.Rules.CoreRuleCriteriaOperator item); partial void OnCoreRuleCriteriaOperatorUpdated(CoreRuleCriteriaOperator item);
partial void OnAfterCoreRuleCriteriaOperatorUpdated(ILoan.Rules.Web.Models.Rules.CoreRuleCriteriaOperator item); partial void OnAfterCoreRuleCriteriaOperatorUpdated(CoreRuleCriteriaOperator item);
public async Task<ILoan.Rules.Web.Models.Rules.CoreRuleCriteriaOperator> UpdateCoreRuleCriteriaOperator(int id, ILoan.Rules.Web.Models.Rules.CoreRuleCriteriaOperator corerulecriteriaoperator) public async Task<CoreRuleCriteriaOperator> UpdateCoreRuleCriteriaOperator(int id,
CoreRuleCriteriaOperator corerulecriteriaoperator)
{ {
OnCoreRuleCriteriaOperatorUpdated(corerulecriteriaoperator); OnCoreRuleCriteriaOperatorUpdated(corerulecriteriaoperator);
var itemToUpdate = Context.CoreRuleCriteriaOperators var context = await factory.CreateDbContextAsync();
.Where(i => i.ID == corerulecriteriaoperator.ID) var itemToUpdate = context.CoreRuleCriteriaOperators
.FirstOrDefault(); .FirstOrDefault(i => i.ID == corerulecriteriaoperator.ID);
if (itemToUpdate == null) if (itemToUpdate == null) throw new Exception("Item no longer available");
{
throw new Exception("Item no longer available");
}
var entryToUpdate = Context.Entry(itemToUpdate); var entryToUpdate = context.Entry(itemToUpdate);
entryToUpdate.CurrentValues.SetValues(corerulecriteriaoperator); entryToUpdate.CurrentValues.SetValues(corerulecriteriaoperator);
entryToUpdate.State = EntityState.Modified; entryToUpdate.State = EntityState.Modified;
Context.SaveChanges(); await context.SaveChangesAsync();
OnAfterCoreRuleCriteriaOperatorUpdated(corerulecriteriaoperator); OnAfterCoreRuleCriteriaOperatorUpdated(corerulecriteriaoperator);
return corerulecriteriaoperator; return corerulecriteriaoperator;
} }
partial void OnCoreRuleCriteriaOperatorDeleted(ILoan.Rules.Web.Models.Rules.CoreRuleCriteriaOperator item); partial void OnCoreRuleCriteriaOperatorDeleted(CoreRuleCriteriaOperator item);
partial void OnAfterCoreRuleCriteriaOperatorDeleted(ILoan.Rules.Web.Models.Rules.CoreRuleCriteriaOperator item); partial void OnAfterCoreRuleCriteriaOperatorDeleted(CoreRuleCriteriaOperator item);
public async Task<ILoan.Rules.Web.Models.Rules.CoreRuleCriteriaOperator> DeleteCoreRuleCriteriaOperator(int id) public async Task<CoreRuleCriteriaOperator> DeleteCoreRuleCriteriaOperator(int id)
{ {
var itemToDelete = Context.CoreRuleCriteriaOperators var context = await factory.CreateDbContextAsync();
.Where(i => i.ID == id) var itemToDelete = context.CoreRuleCriteriaOperators
.FirstOrDefault(); .FirstOrDefault(i => i.ID == id);
if (itemToDelete == null) if (itemToDelete == null) throw new Exception("Item no longer available");
{
throw new Exception("Item no longer available");
}
OnCoreRuleCriteriaOperatorDeleted(itemToDelete); OnCoreRuleCriteriaOperatorDeleted(itemToDelete);
Context.CoreRuleCriteriaOperators.Remove(itemToDelete); context.CoreRuleCriteriaOperators.Remove(itemToDelete);
try try
{ {
Context.SaveChanges(); await context.SaveChangesAsync();
} }
catch catch
{ {
Context.Entry(itemToDelete).State = EntityState.Unchanged; context.Entry(itemToDelete).State = EntityState.Unchanged;
throw; throw;
} }
@ -236,19 +170,30 @@ namespace ILoan.Rules.Web
public async Task ExportCoreRulesToExcel(Query query = null, string fileName = null) public async Task ExportCoreRulesToExcel(Query query = null, string fileName = null)
{ {
navigationManager.NavigateTo(query != null ? query.ToUrl($"export/rules/corerules/excel(fileName='{(!string.IsNullOrEmpty(fileName) ? UrlEncoder.Default.Encode(fileName) : "Export")}')") : $"export/rules/corerules/excel(fileName='{(!string.IsNullOrEmpty(fileName) ? UrlEncoder.Default.Encode(fileName) : "Export")}')", true); navigationManager.NavigateTo(
query != null
? query.ToUrl(
$"export/rules/corerules/excel(fileName='{(!string.IsNullOrEmpty(fileName) ? UrlEncoder.Default.Encode(fileName) : "Export")}')")
: $"export/rules/corerules/excel(fileName='{(!string.IsNullOrEmpty(fileName) ? UrlEncoder.Default.Encode(fileName) : "Export")}')",
true);
} }
public async Task ExportCoreRulesToCSV(Query query = null, string fileName = null) public async Task ExportCoreRulesToCSV(Query query = null, string fileName = null)
{ {
navigationManager.NavigateTo(query != null ? query.ToUrl($"export/rules/corerules/csv(fileName='{(!string.IsNullOrEmpty(fileName) ? UrlEncoder.Default.Encode(fileName) : "Export")}')") : $"export/rules/corerules/csv(fileName='{(!string.IsNullOrEmpty(fileName) ? UrlEncoder.Default.Encode(fileName) : "Export")}')", true); navigationManager.NavigateTo(
query != null
? query.ToUrl(
$"export/rules/corerules/csv(fileName='{(!string.IsNullOrEmpty(fileName) ? UrlEncoder.Default.Encode(fileName) : "Export")}')")
: $"export/rules/corerules/csv(fileName='{(!string.IsNullOrEmpty(fileName) ? UrlEncoder.Default.Encode(fileName) : "Export")}')",
true);
} }
partial void OnCoreRulesRead(ref IQueryable<ILoan.Rules.Web.Models.Rules.CoreRule> items); partial void OnCoreRulesRead(ref IQueryable<CoreRule> items);
public async Task<IQueryable<ILoan.Rules.Web.Models.Rules.CoreRule>> GetCoreRules(Query query = null) public async Task<IQueryable<CoreRule>> GetCoreRules(Query query = null)
{ {
var items = Context.CoreRules.AsQueryable(); var context = await factory.CreateDbContextAsync();
var items = context.CoreRules.AsQueryable();
if (query != null) if (query != null)
@ -256,10 +201,7 @@ namespace ILoan.Rules.Web
if (!string.IsNullOrEmpty(query.Expand)) if (!string.IsNullOrEmpty(query.Expand))
{ {
var propertiesToExpand = query.Expand.Split(','); var propertiesToExpand = query.Expand.Split(',');
foreach(var p in propertiesToExpand) foreach (var p in propertiesToExpand) items = items.Include(p.Trim());
{
items = items.Include(p.Trim());
}
} }
ApplyQuery(ref items, query); ApplyQuery(ref items, query);
@ -270,13 +212,14 @@ namespace ILoan.Rules.Web
return await Task.FromResult(items); return await Task.FromResult(items);
} }
partial void OnCoreRuleGet(ILoan.Rules.Web.Models.Rules.CoreRule item); partial void OnCoreRuleGet(CoreRule item);
partial void OnGetCoreRuleById(ref IQueryable<ILoan.Rules.Web.Models.Rules.CoreRule> items); partial void OnGetCoreRuleById(ref IQueryable<CoreRule> items);
public async Task<ILoan.Rules.Web.Models.Rules.CoreRule> GetCoreRuleById(int id) public async Task<CoreRule> GetCoreRuleById(int id)
{ {
var items = Context.CoreRules var context = await factory.CreateDbContextAsync();
var items = context.CoreRules
.AsNoTracking() .AsNoTracking()
.Where(i => i.ID == id); .Where(i => i.ID == id);
@ -290,30 +233,27 @@ namespace ILoan.Rules.Web
return await Task.FromResult(itemToReturn); return await Task.FromResult(itemToReturn);
} }
partial void OnCoreRuleCreated(ILoan.Rules.Web.Models.Rules.CoreRule item); partial void OnCoreRuleCreated(CoreRule item);
partial void OnAfterCoreRuleCreated(ILoan.Rules.Web.Models.Rules.CoreRule item); partial void OnAfterCoreRuleCreated(CoreRule item);
public async Task<ILoan.Rules.Web.Models.Rules.CoreRule> CreateCoreRule(ILoan.Rules.Web.Models.Rules.CoreRule corerule) public async Task<CoreRule> CreateCoreRule(CoreRule corerule)
{ {
OnCoreRuleCreated(corerule); OnCoreRuleCreated(corerule);
var existingItem = Context.CoreRules var context = await factory.CreateDbContextAsync();
.Where(i => i.ID == corerule.ID) var existingItem = context.CoreRules
.FirstOrDefault(); .FirstOrDefault(i => i.ID == corerule.ID);
if (existingItem != null) if (existingItem != null) throw new Exception("Item already available");
{
throw new Exception("Item already available");
}
try try
{ {
Context.CoreRules.Add(corerule); context.CoreRules.Add(corerule);
Context.SaveChanges(); await context.SaveChangesAsync();
} }
catch catch
{ {
Context.Entry(corerule).State = EntityState.Detached; context.Entry(corerule).State = EntityState.Detached;
throw; throw;
} }
@ -322,9 +262,10 @@ namespace ILoan.Rules.Web
return corerule; return corerule;
} }
public async Task<ILoan.Rules.Web.Models.Rules.CoreRule> CancelCoreRuleChanges(ILoan.Rules.Web.Models.Rules.CoreRule item) public async Task<CoreRule> CancelCoreRuleChanges(CoreRule item)
{ {
var entityToCancel = Context.Entry(item); var context = await factory.CreateDbContextAsync();
var entityToCancel = context.Entry(item);
if (entityToCancel.State == EntityState.Modified) if (entityToCancel.State == EntityState.Modified)
{ {
entityToCancel.CurrentValues.SetValues(entityToCancel.OriginalValues); entityToCancel.CurrentValues.SetValues(entityToCancel.OriginalValues);
@ -334,61 +275,56 @@ namespace ILoan.Rules.Web
return item; return item;
} }
partial void OnCoreRuleUpdated(ILoan.Rules.Web.Models.Rules.CoreRule item); partial void OnCoreRuleUpdated(CoreRule item);
partial void OnAfterCoreRuleUpdated(ILoan.Rules.Web.Models.Rules.CoreRule item); partial void OnAfterCoreRuleUpdated(CoreRule item);
public async Task<ILoan.Rules.Web.Models.Rules.CoreRule> UpdateCoreRule(int id, ILoan.Rules.Web.Models.Rules.CoreRule corerule) public async Task<CoreRule> UpdateCoreRule(int id, CoreRule corerule)
{ {
OnCoreRuleUpdated(corerule); OnCoreRuleUpdated(corerule);
var itemToUpdate = Context.CoreRules var context = await factory.CreateDbContextAsync();
.Where(i => i.ID == corerule.ID) var itemToUpdate = context.CoreRules
.FirstOrDefault(); .FirstOrDefault(i => i.ID == corerule.ID);
if (itemToUpdate == null) if (itemToUpdate == null) throw new Exception("Item no longer available");
{
throw new Exception("Item no longer available");
}
var entryToUpdate = Context.Entry(itemToUpdate); var entryToUpdate = context.Entry(itemToUpdate);
entryToUpdate.CurrentValues.SetValues(corerule); entryToUpdate.CurrentValues.SetValues(corerule);
entryToUpdate.State = EntityState.Modified; entryToUpdate.State = EntityState.Modified;
Context.SaveChanges(); await context.SaveChangesAsync();
OnAfterCoreRuleUpdated(corerule); OnAfterCoreRuleUpdated(corerule);
return corerule; return corerule;
} }
partial void OnCoreRuleDeleted(ILoan.Rules.Web.Models.Rules.CoreRule item); partial void OnCoreRuleDeleted(CoreRule item);
partial void OnAfterCoreRuleDeleted(ILoan.Rules.Web.Models.Rules.CoreRule item); partial void OnAfterCoreRuleDeleted(CoreRule item);
public async Task<ILoan.Rules.Web.Models.Rules.CoreRule> DeleteCoreRule(int id) public async Task<CoreRule> DeleteCoreRule(int id)
{ {
var itemToDelete = Context.CoreRules var context = await factory.CreateDbContextAsync();
var itemToDelete = context.CoreRules
.Where(i => i.ID == id) .Where(i => i.ID == id)
.Include(i => i.CoreRuleCriteria) .Include(i => i.CoreRuleCriteria)
.Include(i => i.CoreRuleCriteriaOperators) .Include(i => i.CoreRuleCriteriaOperators)
.FirstOrDefault(); .FirstOrDefault();
if (itemToDelete == null) if (itemToDelete == null) throw new Exception("Item no longer available");
{
throw new Exception("Item no longer available");
}
OnCoreRuleDeleted(itemToDelete); OnCoreRuleDeleted(itemToDelete);
Context.CoreRules.Remove(itemToDelete); context.CoreRules.Remove(itemToDelete);
try try
{ {
Context.SaveChanges(); await context.SaveChangesAsync();
} }
catch catch
{ {
Context.Entry(itemToDelete).State = EntityState.Unchanged; context.Entry(itemToDelete).State = EntityState.Unchanged;
throw; throw;
} }
@ -399,19 +335,30 @@ namespace ILoan.Rules.Web
public async Task ExportCoreRuleCriteriaToExcel(Query query = null, string fileName = null) public async Task ExportCoreRuleCriteriaToExcel(Query query = null, string fileName = null)
{ {
navigationManager.NavigateTo(query != null ? query.ToUrl($"export/rules/corerulecriteria/excel(fileName='{(!string.IsNullOrEmpty(fileName) ? UrlEncoder.Default.Encode(fileName) : "Export")}')") : $"export/rules/corerulecriteria/excel(fileName='{(!string.IsNullOrEmpty(fileName) ? UrlEncoder.Default.Encode(fileName) : "Export")}')", true); navigationManager.NavigateTo(
query != null
? query.ToUrl(
$"export/rules/corerulecriteria/excel(fileName='{(!string.IsNullOrEmpty(fileName) ? UrlEncoder.Default.Encode(fileName) : "Export")}')")
: $"export/rules/corerulecriteria/excel(fileName='{(!string.IsNullOrEmpty(fileName) ? UrlEncoder.Default.Encode(fileName) : "Export")}')",
true);
} }
public async Task ExportCoreRuleCriteriaToCSV(Query query = null, string fileName = null) public async Task ExportCoreRuleCriteriaToCSV(Query query = null, string fileName = null)
{ {
navigationManager.NavigateTo(query != null ? query.ToUrl($"export/rules/corerulecriteria/csv(fileName='{(!string.IsNullOrEmpty(fileName) ? UrlEncoder.Default.Encode(fileName) : "Export")}')") : $"export/rules/corerulecriteria/csv(fileName='{(!string.IsNullOrEmpty(fileName) ? UrlEncoder.Default.Encode(fileName) : "Export")}')", true); navigationManager.NavigateTo(
query != null
? query.ToUrl(
$"export/rules/corerulecriteria/csv(fileName='{(!string.IsNullOrEmpty(fileName) ? UrlEncoder.Default.Encode(fileName) : "Export")}')")
: $"export/rules/corerulecriteria/csv(fileName='{(!string.IsNullOrEmpty(fileName) ? UrlEncoder.Default.Encode(fileName) : "Export")}')",
true);
} }
partial void OnCoreRuleCriteriaRead(ref IQueryable<ILoan.Rules.Web.Models.Rules.CoreRuleCriterion> items); partial void OnCoreRuleCriteriaRead(ref IQueryable<CoreRuleCriterion> items);
public async Task<IQueryable<ILoan.Rules.Web.Models.Rules.CoreRuleCriterion>> GetCoreRuleCriteria(Query query = null) public async Task<IQueryable<CoreRuleCriterion>> GetCoreRuleCriteria(Query query = null)
{ {
var items = Context.CoreRuleCriteria.AsQueryable(); var context = await factory.CreateDbContextAsync();
var items = context.CoreRuleCriteria.AsQueryable();
items = items.Include(i => i.CoreRule); items = items.Include(i => i.CoreRule);
@ -420,10 +367,7 @@ namespace ILoan.Rules.Web
if (!string.IsNullOrEmpty(query.Expand)) if (!string.IsNullOrEmpty(query.Expand))
{ {
var propertiesToExpand = query.Expand.Split(','); var propertiesToExpand = query.Expand.Split(',');
foreach(var p in propertiesToExpand) foreach (var p in propertiesToExpand) items = items.Include(p.Trim());
{
items = items.Include(p.Trim());
}
} }
ApplyQuery(ref items, query); ApplyQuery(ref items, query);
@ -434,13 +378,14 @@ namespace ILoan.Rules.Web
return await Task.FromResult(items); return await Task.FromResult(items);
} }
partial void OnCoreRuleCriterionGet(ILoan.Rules.Web.Models.Rules.CoreRuleCriterion item); partial void OnCoreRuleCriterionGet(CoreRuleCriterion item);
partial void OnGetCoreRuleCriterionById(ref IQueryable<ILoan.Rules.Web.Models.Rules.CoreRuleCriterion> items); partial void OnGetCoreRuleCriterionById(ref IQueryable<CoreRuleCriterion> items);
public async Task<ILoan.Rules.Web.Models.Rules.CoreRuleCriterion> GetCoreRuleCriterionById(int id) public async Task<CoreRuleCriterion> GetCoreRuleCriterionById(int id)
{ {
var items = Context.CoreRuleCriteria var context = await factory.CreateDbContextAsync();
var items = context.CoreRuleCriteria
.AsNoTracking() .AsNoTracking()
.Where(i => i.ID == id); .Where(i => i.ID == id);
@ -455,30 +400,27 @@ namespace ILoan.Rules.Web
return await Task.FromResult(itemToReturn); return await Task.FromResult(itemToReturn);
} }
partial void OnCoreRuleCriterionCreated(ILoan.Rules.Web.Models.Rules.CoreRuleCriterion item); partial void OnCoreRuleCriterionCreated(CoreRuleCriterion item);
partial void OnAfterCoreRuleCriterionCreated(ILoan.Rules.Web.Models.Rules.CoreRuleCriterion item); partial void OnAfterCoreRuleCriterionCreated(CoreRuleCriterion item);
public async Task<ILoan.Rules.Web.Models.Rules.CoreRuleCriterion> CreateCoreRuleCriterion(ILoan.Rules.Web.Models.Rules.CoreRuleCriterion corerulecriterion) public async Task<CoreRuleCriterion> CreateCoreRuleCriterion(CoreRuleCriterion corerulecriterion)
{ {
OnCoreRuleCriterionCreated(corerulecriterion); OnCoreRuleCriterionCreated(corerulecriterion);
var context = await factory.CreateDbContextAsync();
var existingItem = Context.CoreRuleCriteria var existingItem = context.CoreRuleCriteria
.Where(i => i.ID == corerulecriterion.ID) .FirstOrDefault(i => i.ID == corerulecriterion.ID);
.FirstOrDefault();
if (existingItem != null) if (existingItem != null) throw new Exception("Item already available");
{
throw new Exception("Item already available");
}
try try
{ {
Context.CoreRuleCriteria.Add(corerulecriterion); context.CoreRuleCriteria.Add(corerulecriterion);
Context.SaveChanges(); await context.SaveChangesAsync();
} }
catch catch
{ {
Context.Entry(corerulecriterion).State = EntityState.Detached; context.Entry(corerulecriterion).State = EntityState.Detached;
throw; throw;
} }
@ -487,9 +429,10 @@ namespace ILoan.Rules.Web
return corerulecriterion; return corerulecriterion;
} }
public async Task<ILoan.Rules.Web.Models.Rules.CoreRuleCriterion> CancelCoreRuleCriterionChanges(ILoan.Rules.Web.Models.Rules.CoreRuleCriterion item) public async Task<CoreRuleCriterion> CancelCoreRuleCriterionChanges(CoreRuleCriterion item)
{ {
var entityToCancel = Context.Entry(item); var context = await factory.CreateDbContextAsync();
var entityToCancel = context.Entry(item);
if (entityToCancel.State == EntityState.Modified) if (entityToCancel.State == EntityState.Modified)
{ {
entityToCancel.CurrentValues.SetValues(entityToCancel.OriginalValues); entityToCancel.CurrentValues.SetValues(entityToCancel.OriginalValues);
@ -499,59 +442,53 @@ namespace ILoan.Rules.Web
return item; return item;
} }
partial void OnCoreRuleCriterionUpdated(ILoan.Rules.Web.Models.Rules.CoreRuleCriterion item); partial void OnCoreRuleCriterionUpdated(CoreRuleCriterion item);
partial void OnAfterCoreRuleCriterionUpdated(ILoan.Rules.Web.Models.Rules.CoreRuleCriterion item); partial void OnAfterCoreRuleCriterionUpdated(CoreRuleCriterion item);
public async Task<ILoan.Rules.Web.Models.Rules.CoreRuleCriterion> UpdateCoreRuleCriterion(int id, ILoan.Rules.Web.Models.Rules.CoreRuleCriterion corerulecriterion) public async Task<CoreRuleCriterion> UpdateCoreRuleCriterion(int id, CoreRuleCriterion corerulecriterion)
{ {
OnCoreRuleCriterionUpdated(corerulecriterion); OnCoreRuleCriterionUpdated(corerulecriterion);
var context = await factory.CreateDbContextAsync();
var itemToUpdate = Context.CoreRuleCriteria var itemToUpdate = context.CoreRuleCriteria
.Where(i => i.ID == corerulecriterion.ID) .FirstOrDefault(i => i.ID == corerulecriterion.ID);
.FirstOrDefault();
if (itemToUpdate == null) if (itemToUpdate == null) throw new Exception("Item no longer available");
{
throw new Exception("Item no longer available");
}
var entryToUpdate = Context.Entry(itemToUpdate); var entryToUpdate = context.Entry(itemToUpdate);
entryToUpdate.CurrentValues.SetValues(corerulecriterion); entryToUpdate.CurrentValues.SetValues(corerulecriterion);
entryToUpdate.State = EntityState.Modified; entryToUpdate.State = EntityState.Modified;
Context.SaveChanges(); await context.SaveChangesAsync();
OnAfterCoreRuleCriterionUpdated(corerulecriterion); OnAfterCoreRuleCriterionUpdated(corerulecriterion);
return corerulecriterion; return corerulecriterion;
} }
partial void OnCoreRuleCriterionDeleted(ILoan.Rules.Web.Models.Rules.CoreRuleCriterion item); partial void OnCoreRuleCriterionDeleted(CoreRuleCriterion item);
partial void OnAfterCoreRuleCriterionDeleted(ILoan.Rules.Web.Models.Rules.CoreRuleCriterion item); partial void OnAfterCoreRuleCriterionDeleted(CoreRuleCriterion item);
public async Task<ILoan.Rules.Web.Models.Rules.CoreRuleCriterion> DeleteCoreRuleCriterion(int id) public async Task<CoreRuleCriterion> DeleteCoreRuleCriterion(int id)
{ {
var itemToDelete = Context.CoreRuleCriteria var context = await factory.CreateDbContextAsync();
.Where(i => i.ID == id) var itemToDelete = context.CoreRuleCriteria
.FirstOrDefault(); .FirstOrDefault(i => i.ID == id);
if (itemToDelete == null) if (itemToDelete == null) throw new Exception("Item no longer available");
{
throw new Exception("Item no longer available");
}
OnCoreRuleCriterionDeleted(itemToDelete); OnCoreRuleCriterionDeleted(itemToDelete);
Context.CoreRuleCriteria.Remove(itemToDelete); context.CoreRuleCriteria.Remove(itemToDelete);
try try
{ {
Context.SaveChanges(); await context.SaveChangesAsync();
} }
catch catch
{ {
Context.Entry(itemToDelete).State = EntityState.Unchanged; context.Entry(itemToDelete).State = EntityState.Unchanged;
throw; throw;
} }
@ -563,6 +500,7 @@ namespace ILoan.Rules.Web
// get properties from CoreRuleCriterion as a disctinct list for type ahead // get properties from CoreRuleCriterion as a disctinct list for type ahead
public List<string> GetProperties() public List<string> GetProperties()
{ {
var context = factory.CreateDbContext();
var properties = context.CoreRuleCriteria.Select(c => c.Property).Distinct().OrderBy(x => x).ToList(); var properties = context.CoreRuleCriteria.Select(c => c.Property).Distinct().OrderBy(x => x).ToList();
return properties; return properties;
} }
@ -571,8 +509,4 @@ namespace ILoan.Rules.Web
{ {
return EnumExtensions.ToList<RuleComparison>(); return EnumExtensions.ToList<RuleComparison>();
} }
}
} }

11
src/iLoan.Rules.Web/Usings.cs Normal file
View File

@ -0,0 +1,11 @@
// Global using directives
global using ILoan.Rules.Web.Data;
global using ILoan.Rules.Web.Extensions;
global using ILoan.Rules.Web.Models.Enums;
global using ILoan.Rules.Web.Models.Rules;
global using Microsoft.AspNetCore.Components;
global using Microsoft.EntityFrameworkCore;
global using Radzen;
global using System.Linq.Dynamic.Core;
global using System.Text.Encodings.Web;

2
src/iLoan.Rules.Web/appsettings.json
View File

@ -18,7 +18,7 @@
}, },
"Parameters": { "Parameters": {
"GeneratorRoot": "C:\\iloan\\iloan-base-dev\\migrations", "GeneratorRoot": "C:\\iloan\\iloan-base-dev\\migrations",
"StartSeqNo": 104, "StartSeqNo": 117,
"StartRuleId": 480 "StartRuleId": 480
} }
} }