public void ProvideFault(Exception ex, MessageVersion version, ref Message msg)
{
_logger.Error("ServiceExceptionsHandler received unhandled exception", ex);
var fe = new FaultException <UnhandledException>(UnhandledException.CreateFromEx(ex));
var mf = fe.CreateMessageFault();
msg = Message.CreateMessage(version, mf, string.Empty);
_logger.Error("ServiceExceptionsHandler handled exception and sent ex data to client");
}
protected override void OnStart(string[] args)
{
Logger.Debug("Starting up the service...");
/*
* your service startup logic goes here. do not block, return imediately, start a task perhaps to
* perform all the startup overhead.
*
* There are ways to request more time during on start or onstop, see the article in this project HowTo-Article.pdf
*/
var task = new Task(() =>
{
try
{
Thread.Sleep(10000);
throw new Exception("something went wrong...");
}
catch (Exception e)
{
Logger.Error("This should trigger service Stop.", e);
this.StopService();
}
});
task.Start();
}
//--------------------------------------------------------------------------------
/// <summary>
/// Error response
/// </summary>
//--------------------------------------------------------------------------------
internal HttpResponseMessage Error(Exception error, IServiceLogger logger)
{
if (error is TargetInvocationException)
{
error = ((TargetInvocationException)error).InnerException;
}
var logKey = CurrentLogKey;
logger.Error($"{logKey} Service Error: {error.Message}", error);
var statusCode = HttpStatusCode.BadRequest;
var response = new ServiceResponse(null);
if (error is ServiceOperationException)
{
var serviceError = error as ServiceOperationException;
response.ErrorCode = serviceError.ErrorCode.ToString();
response.ErrorMessage = serviceError.Message + $"\r\nThe Log Key for this error is {logKey}";
}
else
{
response.ErrorCode = ServiceOperationError.FatalError.ToString();
statusCode = HttpStatusCode.InternalServerError;
response.ErrorMessage = $"There was a fatal service error.\r\nThe Log Key for this error is {logKey}\r\n{GetExceptionHint(error)}";
}
return(new HttpResponseMessage(statusCode)
{
Content = new StringContent(JsonConvert.SerializeObject(response, Formatting.Indented), Encoding.UTF8, "application/json")
});
}
//--------------------------------------------------------------------------------
/// <summary>
/// Framework for handling background jobs.
/// </summary>
//--------------------------------------------------------------------------------
internal void SafelyTryJob(IServiceLogger logger, Action tryme)
{
try
{
tryme();
}
catch (Exception e)
{
var logKey = CurrentLogKey;
logger.Error($"{logKey} Fatal Error: {e.ToString()}", e);
}
}
public async Task Invoke(HttpContext httpContext)
{
var environment = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT");
var traceId = httpContext.Request.Headers[Constants.TraceIdHeader].ToString();
if (!string.IsNullOrEmpty(traceId) || environment == "Development")
{
await _next.Invoke(httpContext);
}
else
{
_logger.Error($"A request is missing {Constants.TraceIdHeader} Header");
httpContext.Response.StatusCode = 403;
await httpContext.Response.WriteAsync("Missing some important headers");
}
}
public override async Task OnDisconnectedAsync(Exception exception)
{
// When user closes a browser tab or call stop() connection
// we need to ensure to notify all users about offline state
// This method is a same logic of Offline
var isOffline = await _chatContext.TakeOfflineAsync(new OnlineUser
{
UserName = Context.UserIdentifier
});
if (isOffline)
{
try
{
var allOpenningSessions = _chatContext.GetAllActiveSessions(Context.UserIdentifier);
if (allOpenningSessions != null)
{
foreach (var session in allOpenningSessions)
{
// Persist it on Db
session.LeaveDate = DateTime.UtcNow;
await _chatSessionRepository.UpsertAsync(session.ToSession(true));
session.IsInDb = true;
session.IsDirty = false;
}
}
_chatContext.CloseAllUnlistenRooms(Context.UserIdentifier);
}
catch (Exception ex)
{
_logger.Error(ex, "There are some problems when saving chat session");
}
finally
{
// Ensure we still send notify
await Clients.Others.Offline(Context.UserIdentifier);
}
}
await base.OnDisconnectedAsync(exception);
}
public async Task Invoke(HttpContext httpContext)
{
var environment = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT");
var userSessionId = httpContext.Request.Headers[Constants.UserSessionIdHeader].ToString();
var skipCheck = httpContext.Items[Constants.SkipCheckPortalHeaders] != null ? (bool)httpContext.Items[Constants.SkipCheckPortalHeaders] : false;
if (
!string.IsNullOrEmpty(userSessionId) ||
skipCheck)
{
httpContext.Items[Constants.UserSessionIdHeader] = StringUtil.DecodeBase64ToUTF8(userSessionId);
await _next.Invoke(httpContext);
}
else
{
_logger.Error($"A request is missing {Constants.UserSessionIdHeader} Header");
httpContext.Response.StatusCode = 403;
await httpContext.Response.WriteAsync("Missing some important headers");
}
}
public async Task <GenerateCodeResponseModel> CreateCode(GenerateCodeRequestModel model)
{
var collectApp = _appServiceProvider.GetAppsByIds(model.Apps);
var collectStandards = _standardServiceProvider.GetStandardComponentsByIds(model.Standards);
var collectTree = _standardServiceProvider.GetStandardComponentsByIds(model.Tree);
var collectArray = _standardServiceProvider.GetStandardComponentsByIds(model.Array);
var collectCharts = _chartServiceProvider.GetChartsByIds(model.Charts);
var collectDynamicLists = _dynamicListServiceProvider.GetDynamicListsByIds(model.DynamicLists);
var collectDatabases = _databaseServiceProvider.GetDatabaseConnectionsByIds(model.Databases);
var collectPages = _pageServiceProvider.GetPagesByIds(model.Pages);
var collectCompositeControls = _compositeControlServiceProvider.GetByIds(model.CompositeControls);
await Task.WhenAll(
collectApp,
collectStandards,
collectCharts,
collectDatabases,
collectDynamicLists,
collectPages,
collectCompositeControls);
var appCodes = new List <CodeGenerableResult>();
if (collectApp.Result != null && collectApp.Result.Any())
{
foreach (var app in collectApp.Result)
{
try
{
appCodes.Add(app.GenerateCode());
}
catch (Exception ex)
{
_logger.Error(ex, $"Cannot generate code for app {app.Name}");
}
}
}
var standardCodes = new List <CodeGenerableResult>();
if (collectStandards.Result != null && collectStandards.Result.Any())
{
foreach (var standard in collectStandards.Result)
{
try
{
standardCodes.Add(standard.GenerateCode());
}
catch (Exception ex)
{
_logger.Error(ex, $"Cannot generate code for standard component {standard.Name}");
}
}
}
var treeCodes = new List <CodeGenerableResult>();
if (collectTree.Result != null && collectTree.Result.Any())
{
foreach (var tree in collectTree.Result)
{
try
{
treeCodes.Add(tree.GenerateCode());
}
catch (Exception ex)
{
_logger.Error(ex, $"Cannot generate code for tree {tree.Name}");
}
}
}
var arrayCodes = new List <CodeGenerableResult>();
if (collectArray.Result != null && collectArray.Result.Any())
{
foreach (var array in collectArray.Result)
{
try
{
arrayCodes.Add(array.GenerateCode());
}
catch (Exception ex)
{
_logger.Error(ex, $"Cannot generate code for array standard {array.Name}");
}
}
}
var databaseCodes = new List <CodeGenerableResult>();
if (collectDatabases.Result != null && collectDatabases.Result.Any())
{
foreach (var database in collectDatabases.Result)
{
try
{
databaseCodes.Add(database.GenerateCode());
}
catch (Exception ex)
{
_logger.Error(ex, $"Cannot generate code for database {database.Name}");
}
}
}
var chartCodes = new List <CodeGenerableResult>();
if (collectCharts.Result != null && collectCharts.Result.Any())
{
foreach (var chart in collectCharts.Result)
{
try
{
chartCodes.Add(chart.GenerateCode());
}
catch (Exception ex)
{
_logger.Error(ex, $"Cannot generate code for chart {chart.Name}");
}
}
}
var pageCodes = new List <CodeGenerableResult>();
if (collectPages.Result != null && collectPages.Result.Any())
{
foreach (var page in collectPages.Result)
{
try
{
pageCodes.Add(page.GenerateCode());
}
catch (Exception ex)
{
_logger.Error(ex, $"Cannot generate code for page {page.Name}");
}
}
}
var dynamicListCodes = new List <CodeGenerableResult>();
if (collectDynamicLists.Result != null && collectDynamicLists.Result.Any())
{
foreach (var dynamicList in collectDynamicLists.Result)
{
try
{
dynamicListCodes.Add(dynamicList.GenerateCode());
}
catch (Exception ex)
{
_logger.Error(ex, $"Cannot generate code for page {dynamicList.Name}");
}
}
}
var compositeControlCodes = new List <CodeGenerableResult>();
if (collectCompositeControls.Result != null && collectCompositeControls.Result.Any())
{
foreach (var control in collectCompositeControls.Result)
{
try
{
compositeControlCodes.Add(control.GenerateCode());
}
catch (Exception ex)
{
_logger.Error(ex, $"Cannot generate code for composite code {control.Name}");
}
}
}
var response = new GenerateCodeResponseModel();
var stringBuilder = new StringBuilder();
_ = stringBuilder.AppendLine("using System;");
_ = stringBuilder.AppendLine("using System.Threading.Tasks;");
_ = stringBuilder.AppendLine("using System.Collections.Generic;");
_ = stringBuilder.AppendLine("namespace CustomVersion");
_ = stringBuilder.AppendLine("{");
_ = stringBuilder.AppendLine($" public class {model.FileName} : LetPortal.Portal.IPortalVersion");
_ = stringBuilder.AppendLine($" {{");
_ = stringBuilder.AppendLine($" public string VersionNumber => \"{model.VersionNumber}\";");
_ = stringBuilder.AppendLine($" public Task Downgrade(LetPortal.Core.Versions.IVersionContext versionContext)");
_ = stringBuilder.AppendLine($" {{");
foreach (var appCode in appCodes)
{
_ = stringBuilder.AppendLine(appCode.DeletingCode);
}
foreach (var databaseCode in databaseCodes)
{
_ = stringBuilder.AppendLine(databaseCode.DeletingCode);
}
foreach (var standardCode in standardCodes)
{
_ = stringBuilder.AppendLine(standardCode.DeletingCode);
}
foreach (var treeCode in treeCodes)
{
_ = stringBuilder.AppendLine(treeCode.DeletingCode);
}
foreach (var arrayCode in arrayCodes)
{
_ = stringBuilder.AppendLine(arrayCode.DeletingCode);
}
foreach (var dynamicListCode in dynamicListCodes)
{
_ = stringBuilder.AppendLine(dynamicListCode.DeletingCode);
}
foreach (var chartCode in chartCodes)
{
_ = stringBuilder.AppendLine(chartCode.DeletingCode);
}
foreach (var pageCode in pageCodes)
{
_ = stringBuilder.AppendLine(pageCode.DeletingCode);
}
foreach (var controlCode in compositeControlCodes)
{
_ = stringBuilder.AppendLine(controlCode.DeletingCode);
}
_ = stringBuilder.AppendLine($" return System.Threading.Tasks.Task.CompletedTask;");
_ = stringBuilder.AppendLine($" }}");
_ = stringBuilder.AppendLine($" public Task Upgrade(LetPortal.Core.Versions.IVersionContext versionContext)");
_ = stringBuilder.AppendLine($" {{");
foreach (var appCode in appCodes)
{
_ = stringBuilder.AppendLine(appCode.InsertingCode);
}
foreach (var databaseCode in databaseCodes)
{
_ = stringBuilder.AppendLine(databaseCode.InsertingCode);
}
foreach (var standardCode in standardCodes)
{
_ = stringBuilder.AppendLine(standardCode.InsertingCode);
}
foreach (var treeCode in treeCodes)
{
_ = stringBuilder.AppendLine(treeCode.InsertingCode);
}
foreach (var arrayCode in arrayCodes)
{
_ = stringBuilder.AppendLine(arrayCode.InsertingCode);
}
foreach (var dynamicListCode in dynamicListCodes)
{
_ = stringBuilder.AppendLine(dynamicListCode.InsertingCode);
}
foreach (var chartCode in chartCodes)
{
_ = stringBuilder.AppendLine(chartCode.InsertingCode);
}
foreach (var pageCode in pageCodes)
{
_ = stringBuilder.AppendLine(pageCode.InsertingCode);
}
foreach (var controlCode in compositeControlCodes)
{
_ = stringBuilder.AppendLine(controlCode.InsertingCode);
}
_ = stringBuilder.AppendLine($" return System.Threading.Tasks.Task.CompletedTask;");
_ = stringBuilder.AppendLine($" }}");
_ = stringBuilder.AppendLine($" }}");
_ = stringBuilder.AppendLine("}");
response.Content = stringBuilder.ToString();
response.FileName = model.FileName + ".cs";
return(response);
}
public void HandleValidation(ValidationException ex, IDeployEvents callback)
{
_logger.Error("Validation exception is catched", ex);
HandleException(ex);
}
