/// <summary>
/// Verify ans creare an audit if possible
/// </summary>
/// <param name="InspectionId"></param>
/// <param name="SurveyId"></param>
/// <returns></returns>
public async Task <JsonResult> VerifyAndCreateAudit(int InspectionId, int SurveyId)
{
try
{
UserModel user = JwtTokenProvider.GetUserModel(Request.Cookies["token"].Value);
var result = await _prepareService.GetActiveAudit(user.UserId);
if (result != null)
{
return(Json(new { verified = false }, JsonRequestBehavior.AllowGet));
}
var newAudit = new Audit
{
SurveyId = SurveyId,
AuditorId = user.UserId,
InspectionId = InspectionId,
StartDate = DateTime.Now
};
var audit = await _prepareService.SaveAudit(newAudit);
return(Json(new { verified = true }, JsonRequestBehavior.AllowGet));
}
catch (Exception ex)
{
var message = string.Join(" | ", ModelState.Values
.SelectMany(v => v.Errors)
.Select(e => e.ErrorMessage));
return(Json(new { verified = false, message = ex.Message }, JsonRequestBehavior.AllowGet));
}
}
public override Task OnActionExecutingAsync(HttpActionContext actionContext, CancellationToken cancellationToken)
{
if (!(actionContext.Request.GetDependencyScope().GetService(typeof(ISecurityContext)) is ISecurityContext securityContext))
{
return(Task.CompletedTask);
}
var principal = actionContext.RequestContext.Principal;
var identity = principal?.Identity as ClaimsIdentity;
string username = identity?.Name;
if (string.IsNullOrEmpty(username))
{
return(Task.CompletedTask);
}
if (actionContext.Request.Headers.Authorization == null)
{
return(Task.CompletedTask);
}
var usermodel = JwtTokenProvider.GetUserModel(actionContext.Request.Headers.Authorization.Parameter);
securityContext.CurrentUser = new SecurityUser(User.FromUserModel(usermodel));
if (actionContext.Request.GetDependencyScope().GetService(typeof(ILocalizationManager)) is ILocalizationManager localizationManager)
{
localizationManager.CurrentCulture = new CultureInfo(usermodel.CurrentLanguageCode ?? usermodel.DefaultLanguageCode);
}
return(Task.CompletedTask);
}
public async Task <ActionResult> Detail(int?id, bool partial = false)
{
UserModel user = JwtTokenProvider.GetUserModel(Request.Cookies["token"].Value);
var audits = await _prepareService.GetAudits(id);
if (!audits.Any())
{
return(HttpNotFound());
}
var audit = audits.First();
if (!user.Roles.Any(r => (new[] { KnownRoles.Administrator, KnownRoles.Supervisor, KnownRoles.Documentalist }.Contains(r))) && audit.AuditorId != user.UserId && !audit.Inspection.InspectionSteps.Any(s => s.InspectorId == user.UserId))
{
return(RedirectToAction("Index", new { userId = user.UserId, partial = partial }));
}
var inspection = await _prepareService.GetInspection(audit.InspectionId);
var inspectionSteps = InspectionController.GetInspectionStepAndChilds(inspection, inspection.Publication.PublishedActions.Distinct()
.OrderBy(a => a.WBSParts, new WBSPartsComparer()).ToList());
var anomalies = await _prepareService.GetAnomalies(audit.InspectionId);
var model = AuditMapper.ToAuditViewModel(audits.FirstOrDefault());
model.Inspection = InspectionMapper.ToInspectionViewModel(inspection, inspectionSteps, anomalies.ToList());
if (partial)
{
return(PartialView(model));
}
return(View(model));
}
public async Task <ActionResult> Detail(int id, bool partial = false)
{
UserModel user = JwtTokenProvider.GetUserModel(Request.Cookies["token"].Value);
var usersRolesLanguages = await _applicationUsersService.GetUsersAndRolesAndLanguages();
var qualification = await _prepareService.GetQualification(id);
if (!user.Roles.Any(r => (new[] { KnownRoles.Administrator, KnownRoles.Supervisor, KnownRoles.Evaluator, KnownRoles.Trainer, KnownRoles.Documentalist }.Contains(r))) && qualification.UserId != user.UserId)
{
return(RedirectToAction("Index", new { userId = user.UserId, partial = partial }));
}
// Retrieve all the action of the publication
var actionSorted = qualification.Publication.PublishedActions.Distinct()
.OrderBy(a => a.WBSParts, new WBSPartsComparer())
.ToList();
var qualificationSteps = GetQualificationStepAndChilds(qualification, actionSorted);
var trainingPublications = await _prepareService.GetTrainingPublications(new[] { qualification.PublicationId });
var qualificationManageViewModel = QualificationMapper.ToQualificationViewModel(
qualification, qualificationSteps, usersRolesLanguages.Users.ToList(), trainingPublications);
if (partial)
{
return(PartialView(qualificationManageViewModel));
}
return(View(qualificationManageViewModel));
}
protected override bool AuthorizeCore(HttpContextBase httpContext)
{
var cookie = httpContext.Request.Cookies.AllKeys.Contains("token") ? httpContext.Request.Cookies["token"] : null;
if (cookie == null)
{
return(false);
}
var token = cookie.Value;
if (string.IsNullOrEmpty(token))
{
return(false);
}
var tokenIsValid = JwtTokenProvider.IsValid(token);
if (!tokenIsValid)
{
return(false);
}
var userModel = JwtTokenProvider.GetUserModel(token);
foreach (var role in allowedroles)
{
if (userModel.Roles.Any(r => r == role))
{
return(true);
}
}
return(false);
}
public JsonResult ChangeCurrentLanguage(string languageCode)
{
var userModel = JwtTokenProvider.GetUserModel(HttpContext.Request.Cookies["token"].Value);
userModel.CurrentLanguageCode = languageCode;
Response.SetAuthorizationCookie(userModel);
return(Json(new { changed = true }, JsonRequestBehavior.AllowGet));
}
public override void OnActionExecuting(ActionExecutingContext filterContext)
{
ITraceManager traceManager = DependencyResolver.Current.GetService(typeof(ITraceManager)) as ITraceManager;
try
{
IAuthenticationService authenticationService = DependencyResolver.Current.GetService(typeof(IAuthenticationService)) as IAuthenticationService;
ISecurityContext securityContext = DependencyResolver.Current.GetService(typeof(ISecurityContext)) as ISecurityContext;
ILocalizationManager localizationManager = DependencyResolver.Current.GetService(typeof(ILocalizationManager)) as ILocalizationManager;
if (securityContext == null)
{
traceManager.TraceWarning($"Security context can be retrieve from Unity. Skipping ..");
return;
}
/*IPrincipal principal = filterContext.HttpContext.User;
* ClaimsIdentity identity = principal?.Identity as ClaimsIdentity;
* string username = identity?.Name;
* if (string.IsNullOrEmpty(username))
* {
* traceManager.TraceWarning($"Claim username not found. Skipping ..");
* return;
* }*/
var user = JwtTokenProvider.GetUserModel(filterContext.HttpContext.Request.Cookies["token"].Value);
securityContext.CurrentUser = new SecurityUser(new User
{
Username = user.Username,
Firstname = user.Firstname,
Name = user.Name,
RoleCodes = user.Roles.ToList()
});
localizationManager.CurrentCulture = new CultureInfo(JwtTokenProvider.GetUserModelCurrentLanguage(filterContext.HttpContext.Request.Cookies["token"].Value));
filterContext.Controller.ViewBag.LicenseExpired = Task.Run(() => LicenseMapper.CheckLicenseIsExpired()).Result;
//Refresh cookie if not idle
filterContext.HttpContext.Response.SetAuthorizationCookie(user);
//traceManager.TraceDebug($"Current user set to {username} inside security context");
base.OnActionExecuting(filterContext);
}
catch (Exception ex)
{
traceManager.TraceError(ex, $"Error while setting action context...");
}
}
public async Task <ActionResult> Index(int?userId, bool partial = false)
{
UserModel user = JwtTokenProvider.GetUserModel(Request.Cookies["token"].Value);
if (!userId.HasValue && !user.Roles.Any(r => (new[] { KnownRoles.Administrator, KnownRoles.Supervisor, KnownRoles.Documentalist }.Contains(r))))
{
return(RedirectToAction("Index", new { userId = user.UserId, partial = partial }));
}
var audits = await _prepareService.GetAudits();
if (userId.HasValue)
{
audits = audits.Where(a => a.AuditorId == userId.Value || a.Inspection.InspectionSteps.Any(s => s.InspectorId == userId.Value));
}
var model = AuditMapper.ToAuditManageViewModel(audits);
if (partial)
{
return(PartialView(model));
}
return(View(model));
}
public async Task <ActionResult> Index(int?userId, bool partial = false)
{
UserModel user = JwtTokenProvider.GetUserModel(Request.Cookies["token"].Value);
if (!userId.HasValue && !user.Roles.Any(r => (new[] { KnownRoles.Administrator, KnownRoles.Supervisor, KnownRoles.Evaluator, KnownRoles.Trainer, KnownRoles.Documentalist }.Contains(r))))
{
return(RedirectToAction("Index", new { userId = user.UserId, partial = partial }));
}
_traceManager.TraceDebug("QualificationController starting index");
var usersRolesLanguages = await _applicationUsersService.GetUsersAndRolesAndLanguages();
var users = usersRolesLanguages.Users.ToList();
var lastTrainingPublications = await _prepareService.GetLastSameMajorPublications((int)PublishModeEnum.Formation);
var lastEvaluationPublications = await _prepareService.GetLastSameMajorPublications((int)PublishModeEnum.Evaluation);
var qualificationManageViewModel = await QualificationMapper.ToQualificationManageViewModel(lastTrainingPublications, lastEvaluationPublications, users, userId);
if (partial)
{
return(PartialView(qualificationManageViewModel));
}
return(View(qualificationManageViewModel));
}
