public LoginPage()
{
InitializeComponent();
controlsVM = (Application.Current as App).ControlsVM;
dashBoardVM = (Application.Current as App).DashVM;
mapVM = (Application.Current as App).MapVM;
errorVm = (Application.Current as App).ErrorVm;
}
public static ErrorVm GetErrorVm(string message, ErrorType type)
{
var vm = new ErrorVm();
vm.ErrorMessage = message;
vm.Type = type;
return(vm);
}
private ErrorVm GetExceptionObject(ExceptionContext context)
{
var result = new ErrorVm
{
Message = context.Exception.Message,
StackTrace = context.Exception.StackTrace
};
return(result);
}
private static StringBuilder TextEntryLog(ErrorVm logEntry)
{
var sb = new StringBuilder();
sb.Append(Assembly.GetExecutingAssembly().GetName().Name).Append("|");
sb.Append(logEntry.CardNumber).Append("|");
sb.Append(logEntry.ErrorMessage.Replace(Environment.NewLine, " ")).Append("|");
sb.Append(logEntry.ErrorId).Append("|");
sb.Append(DateTime.Now);
return(sb);
}
public ControlsPage(MapVM map, ControlsVM controls, DashBoardVM dashBoard, ErrorVm error)
{
errorVm = error;
mapVM = map;
controlsVM = controls;
dashBoardVM = dashBoard;
InitializeComponent();
Map.DataContext = mapVM;
DashBoard.DataContext = dashBoardVM;
Controls.DataContext = controlsVM;
Error.DataContext = errorVm;
}
/// <summary>
/// Build Error and write response.
/// </summary>
/// <param name="context">Http context.</param>
/// <param name="exception">Current exception.</param>
/// <returns>Error response body.</returns>
private static Task BuildErrorResponse(HttpContext context, Exception exception)
{
// default
context.Response.ContentType = "application/json";
context.Response.StatusCode = StatusCodes.Status500InternalServerError;
// error wrappée
ErrorVm errorVm = new ErrorVm();
errorVm.Code = ErrorCode.GenericServer;
errorVm.Message = localizer[Constants.Errors.InternalServerError];
#if DEBUG
errorVm.DebugMessage = exception.Message;
errorVm.StackTrace = exception.StackTrace;
#endif
if (exception is ConcurrentAccessException)
{
errorVm.Code = ErrorCode.ConcurrentAccess;
errorVm.Message = "acces concurrent";
}
else if (exception is ForeignKeyException)
{
errorVm.Code = ErrorCode.ForeignKey;
errorVm.Message = "error fk";
}
else if (exception is UniqueKeyException)
{
errorVm.Code = ErrorCode.UniqueKeyConstraint;
errorVm.Message = "unique key";
}
else if (exception is AuthorizationException)
{
errorVm.Code = ErrorCode.AccessDenied;
errorVm.Message = "accès refusé";
context.Response.StatusCode = context.User.Identity.IsAuthenticated
? (int)StatusCodes.Status403Forbidden
: (int)StatusCodes.Status401Unauthorized;
}
else if (exception is EntityNotFoundException)
{
errorVm.Code = ErrorCode.NotFound;
errorVm.Message = "entité non trouvée";
context.Response.StatusCode = StatusCodes.Status404NotFound;
}
string errorString = JsonConvert.SerializeObject(errorVm);
return(context.Response.WriteAsync(errorString));
}
public async Task UpdateUser_Concurrency_Ko(string verb, string url)
{
this.fixture.MockUser.Ts = 1234; // mock wrong ts
string jsonIn = JsonConvert.SerializeObject(this.fixture.MockUser);
var request = new HttpRequestMessage(new HttpMethod(verb), string.Format(url, this.fixture.MockUser.Id));
request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", this.fixture.JwtToken);
request.Content = new StringContent(jsonIn, Encoding.UTF8, "application/json");
var response = await this.fixture.HttpClient.SendAsync(request);
var jsonOut = response.Content.ReadAsStringAsync().Result;
ErrorVm vm = JsonConvert.DeserializeObject <ErrorVm>(jsonOut);
Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); // http 500
Assert.Equal(ErrorCode.ConcurrentAccess, vm.Code); // code spécific accès concurrent
}
public async override Task ExecuteResultAsync(ActionContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
var errorVm = new ErrorVm()
{
Code = ErrorCode.ValidationFailed,
ValidationDictionnay = ToValidation(modelState)
};
var jsonResult = new JsonResult(errorVm);
jsonResult.StatusCode = StatusCodes.Status400BadRequest;
await jsonResult.ExecuteResultAsync(context);
}
public ErrorVm Init(long userId, long id)
{
//Get current user
var user = BlUser.LoadSingle(userId);
var error = LoadSingle(userId, id);
var toRet = new ErrorVm
{
Type = BlCode.GetCodeByLanguage(user, BlCode.LoadSingle(userId, "ErrorType", error.Type.ToUiString())),
Severity = BlCode.GetCodeByLanguage(user, BlCode.LoadSingle(userId, "ErrorSeverity", error.Severity.ToUiString())),
Source = error.Source,
Text = error.Text,
UserName = BlUser.LoadSingle(error.UserId).UserName,
Branch = BlBranch.GetBranchName(user.Id, error.BranchId),
Date = error.EntryDate.ToString(true)
};
return(toRet);
}
public async Task CreateUser_ValidationFailed(string verb, string url)
{
var emptyMock = new UserVm()
{
};
string jsonIn = JsonConvert.SerializeObject(emptyMock);
var request = new HttpRequestMessage(new HttpMethod(verb), url);
request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", this.fixture.JwtToken);
request.Content = new StringContent(jsonIn, Encoding.UTF8, "application/json");
var response = await this.fixture.HttpClient.SendAsync(request);
var jsonOut = response.Content.ReadAsStringAsync().Result;
ErrorVm vm = JsonConvert.DeserializeObject <ErrorVm>(jsonOut);
Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode); // http 400
Assert.Equal(ErrorCode.ValidationFailed, vm.Code); // validation failed
}
/// <summary>
/// Si une exception est lancée depuis un controller
/// </summary>
/// <param name="filterContext">Contexte du filtre</param>
public override void OnException(HttpActionExecutedContext filterContext)
{
if (filterContext == null)
{
throw new ArgumentNullException("filterContext est null");
}
// création du message
ErrorVm errorVm = ErrorVm.LoadException(filterContext.Exception);
// init du message succes=false
MessageCoreVm msg = new MessageCoreVm()
{
ErrorObject = errorVm,
Success = false
};
// création de la réponse
filterContext.Response = filterContext.Request.CreateResponse(HttpStatusCode.OK, msg);
}
public void LogEntry(ErrorVm logEntry)
{
var logFileInfo = new FileInfo(LogFilePath);
var logDirInfo = new DirectoryInfo(logFileInfo.DirectoryName);
if (!logDirInfo.Exists)
{
logDirInfo.Create();
}
var isnew = !logFileInfo.Exists;
var fileStream = isnew ? logFileInfo.Create() : new FileStream(LogFilePath, FileMode.Append);
var sb = TextEntryLog(logEntry);
var log = new StreamWriter(fileStream);
if (isnew)
{
log.WriteLine(TextHeader().ToString());
}
log.WriteLine(sb.ToString());
log.Close();
}
public async void Validate_Ko()
{
// valide un user vide
UserVm userVm = new UserVm();
var validator = new UserValidator();
var results = validator.Validate(userVm);
// simul modelstate d'un controller
ModelStateDictionary mockModelState = new ModelStateDictionary();
results.AddToModelState(mockModelState, null);
// simul ValidationFailedResult
// TODO test ValidationFailedResult possible ?
var errorVm = new ErrorVm()
{
Code = ErrorCode.ValidationFailed,
ValidationDictionnay = ValidationFailedResult.ToValidation(mockModelState)
};
// compare avec format du json attendu
string json = JsonConvert.SerializeObject(errorVm);
string jsonCheck =
@"{ ""code"":6,
""validation"":
{
""Email"":[""Email cannot be empty""],
""LastName"":[""LastName cannot be empty""],
""Password"":[""Password cannot be empty""],
""UserName"":[""User Name cannot be empty""],
""FirstName"":[""FirstName cannot be empty""]
}
}";
bool jsonOk = JToken.DeepEquals(JToken.Parse(json), JToken.Parse(jsonCheck));
Assert.False(mockModelState.IsValid);
Assert.True(jsonOk);
}
public IActionResult Index(int id)
{
var vm = new ErrorVm
{
StatusCode = id,
RequestId = HttpContext.TraceIdentifier,
TraceId = Activity.Current?.Id ?? string.Empty
};
var statusCodeReExecuteFeature = HttpContext.Features.Get <IStatusCodeReExecuteFeature>();
if (statusCodeReExecuteFeature != null)
{
vm.Path =
statusCodeReExecuteFeature.OriginalPathBase
+ statusCodeReExecuteFeature.OriginalPath
+ statusCodeReExecuteFeature.OriginalQueryString;
}
var exceptionHandlerPathFeature = HttpContext.Features.Get <IExceptionHandlerPathFeature>();
Exception error = null;
if (exceptionHandlerPathFeature != null)
{
vm.Path = exceptionHandlerPathFeature.Path;
error = exceptionHandlerPathFeature.Error;
}
using (_logger.BeginScope(new Dictionary <string, object> {
{ "StatusCode", id }
}))
{
_logger.LogError(error, "System error");
}
return(View(vm));
}
public AccountController()
{
Dal = new CashMachineDal();
ErrorVm = new ErrorVm();
Log = new Log();
}
