//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldCacheCheck()
public virtual void shouldCacheCheck()
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.camunda.bpm.engine.impl.db.ListQueryParameterObject query = new org.camunda.bpm.engine.impl.db.ListQueryParameterObject();
ListQueryParameterObject query = new ListQueryParameterObject();
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.camunda.bpm.engine.impl.db.AuthorizationCheck authCheck = query.getAuthCheck();
AuthorizationCheck authCheck = query.AuthCheck;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.HashMap<String, Object> expectedQueryParams = new java.util.HashMap<String, Object>();
Dictionary <string, object> expectedQueryParams = new Dictionary <string, object>();
expectedQueryParams["userId"] = AUTHENTICATED_USER_ID;
expectedQueryParams["authGroupIds"] = AUTHENTICATED_GROUPS;
// given
when(mockedConfiguration.AuthorizationCheckRevokes).thenReturn(ProcessEngineConfiguration.AUTHORIZATION_CHECK_REVOKE_AUTO);
when(mockedEntityManager.selectBoolean(eq("selectRevokeAuthorization"), eq(expectedQueryParams))).thenReturn(true);
// if
authorizationManager.configureQuery(query);
authorizationManager.configureQuery(query);
// then
assertEquals(true, authCheck.RevokeAuthorizationCheckEnabled);
verify(mockedEntityManager, times(1)).selectBoolean(eq("selectRevokeAuthorization"), eq(expectedQueryParams));
}
public async Task <IActionResult> OnPostAsync(string EventID)
{
if (EventID == null)
{
return(NotFound());
}
if (!AuthorizationCheck.Event(_context, EventID, User.Identity.Name))
{
return(Forbid());
}
if (!ModelState.IsValid)
{
return(Page());
}
Team.EventID = EventID;
Team.ExpPTS = Services.CalculateTeamMetrics.ComputedTeamScore(Team);
_context.Team.Add(Team);
await _context.SaveChangesAsync();
return(RedirectToPage("./Index", new
{
EventID = Team.EventID,
}));
}
public async Task <ActionResult> OnGetQuickAddTeam(string EventID, string TeamNumber, string TeamName, string OfficialMatchID)
{
if (EventID == null)
{
return(NotFound());
}
if (!AuthorizationCheck.Event(_context, EventID, User.Identity.Name))
{
return(Forbid());
}
Team Team = new Team
{
EventID = EventID,
TeamNumber = TeamNumber,
TeamName = TeamName
};
await _context.AddAsync(Team);
await _context.SaveChangesAsync();
var _EventID = EventID;
var _OfficialMatchID = OfficialMatchID;
return(RedirectToPage("./Edit", new { EventID = _EventID, OfficialMatchID = _OfficialMatchID, }));
}
public async Task <IActionResult> OnGetDelete(string EventID, string TeamID, string ScoutedMatchID)
{
if (EventID == null || TeamID == null || ScoutedMatchID == null)
{
return(NotFound());
}
if (!AuthorizationCheck.ScoutedMatch(_context, ScoutedMatchID, User.Identity.Name))
{
return(Forbid());
}
ScoutedMatch ScoutedMatch = await _context.ScoutedMatch.FindAsync(ScoutedMatchID);
if (ScoutedMatch != null)
{
Team ScoutedTeam = await _context.Team.FindAsync(TeamID);
IList <int> Scores = await _context.ScoutedMatch.AsNoTracking().Where(s => s.TeamID == TeamID).Select(s => s.Score).ToListAsync();
Scores.Remove(ScoutedMatch.Score);
ScoutedTeam.AvgPTS = Math.Round(Scores.Average(), 1);
_context.Team.Update(ScoutedTeam);
_context.ScoutedMatch.Remove(ScoutedMatch);
await _context.SaveChangesAsync();
}
var _EventID = EventID;
var _TeamID = TeamID;
return(RedirectToPage("./Index", new
{
EventID = _EventID,
TeamID = _TeamID,
}));
}
public async Task <IActionResult> OnGetAsync(string EventID, string OfficialMatchID)
{
if (EventID == null || OfficialMatchID == null)
{
return(NotFound());
}
if (!AuthorizationCheck.OfficialMatch(_context, OfficialMatchID, User.Identity.Name))
{
return(Forbid());
}
if (await _context.Team.AsNoTracking().Where(t => t.EventID == EventID).CountAsync() < 4)
{
return(Forbid());
}
eventID = EventID;
OfficialMatch = await _context.OfficialMatch.FirstOrDefaultAsync(m => m.ID == OfficialMatchID);
AuthorizedTeams = await _context.Team.AsNoTracking().Where(t => t.EventID == EventID).OrderBy(t => t.TeamNumber.PadLeft(5)).ToListAsync();
if (OfficialMatch == null)
{
return(NotFound());
}
return(Page());
}
public async Task <ActionResult> OnGetDelete(string EventID)
{
if (EventID == null)
{
return(NotFound());
}
if (!AuthorizationCheck.Event(_context, EventID, User.Identity.Name))
{
return(Forbid());
}
Event Event = await _context.Event.FindAsync(EventID);
if (Event != null)
{
List <Team> RemovedTeams = await _context.Team.Where(t => t.EventID == EventID).ToListAsync();
List <OfficialMatch> RemovedOfficialMatches = await _context.OfficialMatch.Where(t => t.EventID == EventID).ToListAsync();
_context.Team.RemoveRange(RemovedTeams);
_context.OfficialMatch.RemoveRange(RemovedOfficialMatches);
_context.Event.Remove(Event);
await _context.SaveChangesAsync();
}
return(RedirectToPage("./Index"));
}
public async Task <IActionResult> OnPostAsync(string EventID)
{
if (EventID == null)
{
return(NotFound());
}
if (!AuthorizationCheck.Event(_context, EventID, User.Identity.Name))
{
return(Forbid());
}
if (!ModelState.IsValid)
{
return(Page());
}
OfficialMatch.EventID = EventID;
_context.OfficialMatch.Add(OfficialMatch);
IList <Models.OfficialMatch> AuthorizedOfficialMatches = await _context.OfficialMatch.Where(s => s.EventID == EventID).ToListAsync();
AuthorizedOfficialMatches.Add(OfficialMatch);
AuthorizedTeams = await _context.Team.AsNoTracking().Where(t => t.EventID == EventID).ToListAsync();
IList <Team> TeamsWithScores = CalculateTeamMetrics.CalculateAllMetrics(AuthorizedTeams, AuthorizedOfficialMatches);
_context.Team.UpdateRange(TeamsWithScores);
await _context.SaveChangesAsync();
var _EventID = EventID;
return(RedirectToPage("./Index", new
{
EventID = _EventID,
}));
}
public async Task <ActionResult> OnGetAsync(string EventID, string TeamID)
{
if (EventID == null || TeamID == null)
{
return(NotFound());
}
if (!AuthorizationCheck.Team(_context, TeamID, User.Identity.Name))
{
return(Forbid());
}
eventID = EventID;
teamID = TeamID;
AuthorizedScoutedMatches = _context.ScoutedMatch.AsNoTracking().Where(s => s.TeamID == TeamID);
QualificationScoutedMatches = await AuthorizedScoutedMatches.Where(s => s.MatchType == MatchType.Qualification).ToListAsync();
SemifinalsScoutedMatches = await AuthorizedScoutedMatches.Where(s => s.MatchType == MatchType.Semifinal).ToListAsync();
FinalsScoutedMatches = await AuthorizedScoutedMatches.Where(s => s.MatchType == MatchType.Final).ToListAsync();
PracticeScoutedMatches = await AuthorizedScoutedMatches.Where(s => s.MatchType == MatchType.Practice).ToListAsync();
NumberOfScoutedMatches = await AuthorizedScoutedMatches.CountAsync();
if (NumberOfScoutedMatches != 0)
{
HighestScore = await AuthorizedScoutedMatches.MaxAsync(s => s.Score);
AverageScore = Math.Round(await AuthorizedScoutedMatches.AverageAsync(s => s.Score), 2);
NumberOfPenalties = await AuthorizedScoutedMatches.SumAsync(s => s.MinorPenalties + s.MajorPenalties);
}
return(Page());
}
public async Task <ActionResult> OnGetDelete(string EventID, string OfficialMatchID)
{
if (EventID == null || OfficialMatchID == null)
{
return(NotFound());
}
if (!AuthorizationCheck.OfficialMatch(_context, OfficialMatchID, User.Identity.Name))
{
return(Forbid());
}
OfficialMatch OfficialMatch = await _context.OfficialMatch.FindAsync(OfficialMatchID);
IList <OfficialMatch> AuthorizedOfficialMatches = await _context.OfficialMatch.Where(s => s.EventID == EventID).ToListAsync();
AuthorizedTeams = await _context.Team.AsNoTracking().Where(t => t.EventID == EventID).ToListAsync();
IList <Team> TeamsWithScores = CalculateTeamMetrics.CalculateAllMetrics(AuthorizedTeams, AuthorizedOfficialMatches);
_context.Team.UpdateRange(TeamsWithScores);
if (OfficialMatch != null)
{
_context.OfficialMatch.Remove(OfficialMatch);
await _context.SaveChangesAsync();
}
var _EventID = EventID;
return(RedirectToPage("./Index", new
{
EventID = _EventID,
}));
}
public async Task <ActionResult> OnGetDelete(string EventID, string TeamID)
{
if (EventID == null || TeamID == null)
{
return(NotFound());
}
if (!AuthorizationCheck.Team(_context, TeamID, User.Identity.Name))
{
return(Forbid());
}
IList <OfficialMatch> RemovedOfficialMatches = await _context.OfficialMatch.Where(o => o.Red1TeamID == TeamID || o.Red2TeamID == TeamID || o.Blue1TeamID == TeamID || o.Blue2TeamID == TeamID).ToListAsync();
IList <ScoutedMatch> RemovedScoutedMatches = await _context.ScoutedMatch.Where(m => m.TeamID == TeamID).ToListAsync();
Team Team = await _context.Team.FindAsync(TeamID);
if (Team != null)
{
_context.Team.Remove(Team);
_context.RemoveRange(RemovedOfficialMatches);
_context.RemoveRange(RemovedScoutedMatches);
await _context.SaveChangesAsync();
}
var _EventID = EventID;
return(RedirectToPage("./Index", new
{
EventID = _EventID,
}));
}
// authorization checks on queries ////////////////////////////////
//public virtual void ConfigureQuery(ListQueryParameterObject query)
//{
// AuthorizationCheck authCheck = query.AuthCheck;
// authCheck.PermissionChecks.Clear();
// if (AuthCheckExecuted)
// {
// Authentication currentAuthentication = CurrentAuthentication;
// authCheck.AuthUserId = currentAuthentication.UserId;
// authCheck.AuthGroupIds = currentAuthentication.GroupIds;
// EnableQueryAuthCheck(authCheck);
// }
// else
// {
// authCheck.AuthorizationCheckEnabled = false;
// authCheck.AuthUserId = null;
// authCheck.AuthGroupIds = null;
// }
//}
public virtual void EnableQueryAuthCheck(AuthorizationCheck authCheck)
{
IList <string> authGroupIds = authCheck.AuthGroupIds;
string authUserId = authCheck.AuthUserId;
authCheck.AuthorizationCheckEnabled = true;
authCheck.AuthGroupIds = FilterAuthenticatedGroupIds(authGroupIds);
authCheck.RevokeAuthorizationCheckEnabled = IsRevokeAuthCheckEnabled(authUserId, authGroupIds) ?? false;
}
//protected internal override void ConfigureQuery(ListQueryParameterObject query, Resources resource)
//{
// ConfigureQuery(query, resource, "RES.ID_");
//}
//public virtual void ConfigureQuery(ListQueryParameterObject query, Resources resource, string queryParam)
//{
// ConfigureQuery(query, resource, queryParam, Permissions.Read);
//}
//public virtual void ConfigureQuery(ListQueryParameterObject query, Resources resource, string queryParam, Permissions permission)
//{
// ConfigureQuery(query);
// AddPermissionCheck(query, resource, queryParam, permission);
//}
//protected internal virtual void AddPermissionCheck(ListQueryParameterObject query,Resources resource, string queryParam, Permissions permission)
//{
// CommandContext commandContext = CommandContext;
// if (AuthorizationEnabled && CurrentAuthentication != null && commandContext.AuthorizationCheckEnabled)
// {
// PermissionCheck permCheck = NewPermissionCheck();
// permCheck.Resource = resource;
// permCheck.ResourceIdQueryParam = queryParam;
// permCheck.Permission = permission;
// query.AuthCheck.AddAtomicPermissionCheck(permCheck);
// }
//}
protected internal virtual void AddPermissionCheck(AuthorizationCheck authCheck, CompositePermissionCheck compositeCheck)
{
CommandContext commandContext = CommandContext;
if (AuthorizationEnabled && CurrentAuthentication != null && commandContext.AuthorizationCheckEnabled)
{
authCheck.PermissionChecks = compositeCheck;
}
}
/// <summary>
/// Returns whether the SiteMapNode is accessible to the current user.
/// </summary>
public override bool IsAccessibleToUser(HttpContext context, SiteMapNode node)
{
// We are checking Rights, and other custom attributes here.
// Roles may also be part of the SiteMapNode. Let the base class
// check for that. If false, return false, otherwise, continue
// with our checks.
if (!base.IsAccessibleToUser(context, node))
{
return(false);
}
bool primaryBlogInstanceOnly;
if (!string.IsNullOrWhiteSpace(node["primaryBlogInstanceOnly"]) && bool.TryParse(node["primaryBlogInstanceOnly"], out primaryBlogInstanceOnly))
{
if (primaryBlogInstanceOnly && !Blog.CurrentInstance.IsPrimary)
{
return(false);
}
}
if (!Utils.StringIsNullOrWhitespace(node["rights"]))
{
// By default, all specified Rights must exist.
// We allow this to be overridden via the "rightsAuthorizationCheck"
// attribute.
AuthorizationCheck authCheck = AuthorizationCheck.HasAll;
if (!Utils.StringIsNullOrWhitespace(node["rightsAuthorizationCheck"]))
{
authCheck = Utils.ParseEnum <AuthorizationCheck>(node["rightsAuthorizationCheck"], AuthorizationCheck.HasAll);
}
string[] rightsRaw = node["rights"].Split(new char[] { ';', ',' }, StringSplitOptions.RemoveEmptyEntries);
List <Rights> rightsToCheck = new List <Rights>();
foreach (string r in rightsRaw)
{
Rights right = Utils.ParseEnum <Rights>(r.Trim(), Rights.None);
if (right != Rights.None)
{
rightsToCheck.Add(right);
}
}
if (rightsToCheck.Count > 0)
{
return(Security.IsAuthorizedTo(authCheck, rightsToCheck.ToArray()));
}
}
return(true);
}
/// <summary>
/// If the current user does not have the requested rights, either redirects to the login page,
/// or throws a SecurityException.
/// </summary>
/// <param name="authCheck"></param>
/// <param name="redirectIfUnauthorized">
/// If true and user does not have rights, redirects to the login page or homepage.
/// If false and user does not have rights, throws a security exception.
/// </param>
/// <param name="rights"></param>
public static void DemandUserHasRight(AuthorizationCheck authCheck, bool redirectIfUnauthorized, params Rights[] rights)
{
if (!IsAuthorizedTo(authCheck, rights))
{
if (redirectIfUnauthorized)
{
RedirectForUnauthorizedRequest();
}
else
{
throw new SecurityException("User doesn't have the right to perform this");
}
}
}
public IActionResult OnGet(string EventID)
{
if (EventID == null)
{
return(NotFound());
}
if (!AuthorizationCheck.Event(_context, EventID, User.Identity.Name))
{
return(Forbid());
}
eventID = EventID;
return(Page());
}
public async Task <IActionResult> OnPostAsync(string EventID, string TeamID, string ScoutedMatchID)
{
if (!ModelState.IsValid)
{
return(Page());
}
if (EventID == null || TeamID == null || ScoutedMatchID == null)
{
return(NotFound());
}
if (!AuthorizationCheck.ScoutedMatch(_context, ScoutedMatchID, User.Identity.Name))
{
return(Forbid());
}
_context.Attach(ScoutedMatch).State = EntityState.Modified;
eventID = EventID;
teamID = TeamID;
ScoutedMatch.TeamID = TeamID;
ScoutedMatch.Score = CalculateTeamMetrics.ComputeScoutedMatchScore(ScoutedMatch);
Team ScoutedTeam = await _context.Team.FindAsync(TeamID);
try
{
await _context.SaveChangesAsync();
IList <int> Scores = await _context.ScoutedMatch.AsNoTracking().Where(s => s.TeamID == TeamID).Select(s => s.Score).ToListAsync();
ScoutedTeam.AvgPTS = Math.Round(Scores.Average(), 1);
_context.Team.Update(ScoutedTeam);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ScoutedMatchExists(ScoutedMatch.ID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToPage("./Index", new { EventID = eventID, TeamID = teamID, }));
}
public virtual bool IsAuthorized(string userId, IList <string> groupIds, IList <PermissionCheck> permissionChecks)
{
if (!AuthorizationEnabled)
{
return(true);
}
IList <string> filteredGroupIds = FilterAuthenticatedGroupIds(groupIds);
bool isRevokeAuthorizationCheckEnabled = IsRevokeAuthCheckEnabled(userId, groupIds) ?? false;
AuthorizationCheck authCheck = new AuthorizationCheck(userId, filteredGroupIds, permissionChecks, isRevokeAuthorizationCheckEnabled);
//return DbEntityManager.SelectBoolean("isUserAuthorizedForResource", authCheck);
throw new NotImplementedException();
}
public virtual bool isAuthorized(string userId, IList <string> groupIds, CompositePermissionCheck compositePermissionCheck)
{
foreach (PermissionCheck permissionCheck in compositePermissionCheck.AllPermissionChecks)
{
if (!isResourceValidForPermission(permissionCheck))
{
throw LOG.invalidResourceForPermission(permissionCheck.Resource.resourceName(), permissionCheck.Permission.Name);
}
}
IList <string> filteredGroupIds = filterAuthenticatedGroupIds(groupIds);
bool isRevokeAuthorizationCheckEnabled = isRevokeAuthCheckEnabled(userId, groupIds);
AuthorizationCheck authCheck = new AuthorizationCheck(userId, filteredGroupIds, compositePermissionCheck, isRevokeAuthorizationCheckEnabled);
return(DbEntityManager.selectBoolean("isUserAuthorizedForResource", authCheck));
}
public Void execute(CommandContext commandContext)
{
AuthorizationManager authorizationManager = outerInstance.spyOnSession(commandContext, typeof(AuthorizationManager));
TaskQueryImpl taskQuery = (TaskQueryImpl)spy(outerInstance.processEngine.TaskService.createTaskQuery());
AuthorizationCheck authCheck = spy(new AuthorizationCheck());
when(taskQuery.AuthCheck).thenReturn(authCheck);
taskQuery.list();
verify(authorizationManager, atLeastOnce()).filterAuthenticatedGroupIds(eq(testGroupIds));
verify(authCheck, atLeastOnce()).AuthGroupIds = (IList <string>)argThat(containsInAnyOrder(testGroupIds.ToArray()));
return(null);
}
public Void execute(CommandContext commandContext)
{
AuthorizationManager authorizationManager = outerInstance.spyOnSession(commandContext, typeof(AuthorizationManager));
TaskQueryImpl taskQuery = (TaskQueryImpl)spy(outerInstance.processEngine.TaskService.createTaskQuery());
AuthorizationCheck authCheck = spy(new AuthorizationCheck());
when(taskQuery.AuthCheck).thenReturn(authCheck);
taskQuery.list();
verify(authorizationManager, atLeastOnce()).filterAuthenticatedGroupIds(eq(testGroupIds));
verify(authCheck).AuthGroupIds = eq(System.Linq.Enumerable.Empty <string>());
return(null);
}
/// <summary>
/// Returns whether the current user passes authorization on the rights based on the given AuthorizationCheck.
/// </summary>
/// <param name="authCheck"></param>
/// <param name="rights"></param>
/// <returns></returns>
public static bool IsAuthorizedTo(AuthorizationCheck authCheck, IEnumerable <Rights> rights)
{
if (rights.Count() == 0)
{
// Always return false for this. If there's a mistake where authorization
// is being checked for on an empty collection, we don't want to return
// true.
return(false);
}
else
{
var roles = Security.GetCurrentUserRoles();
if (authCheck == AuthorizationCheck.HasAny)
{
foreach (var right in rights)
{
if (Right.HasRight(right, roles))
{
return(true);
}
}
return(false);
}
else if (authCheck == AuthorizationCheck.HasAll)
{
bool authCheckPassed = true;
foreach (var right in rights)
{
if (!Right.HasRight(right, roles))
{
authCheckPassed = false;
break;
}
}
return(authCheckPassed);
}
else
{
throw new NotSupportedException();
}
}
}
public Void execute(CommandContext commandContext)
{
AuthorizationManager authorizationManager = outerInstance.spyOnSession(commandContext, typeof(AuthorizationManager));
DbEntityManager dbEntityManager = outerInstance.spyOnSession(commandContext, typeof(DbEntityManager));
outerInstance.authorizationService.isUserAuthorized(testUserId, null, Permissions.READ, Resources.TASK);
verify(authorizationManager, atLeastOnce()).filterAuthenticatedGroupIds(eq((IList <string>)null));
ArgumentCaptor <AuthorizationCheck> authorizationCheckArgument = ArgumentCaptor.forClass(typeof(AuthorizationCheck));
verify(dbEntityManager).selectBoolean(eq("isUserAuthorizedForResource"), authorizationCheckArgument.capture());
AuthorizationCheck authorizationCheck = authorizationCheckArgument.Value;
assertTrue(authorizationCheck.AuthGroupIds.Count == 0);
return(null);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldUseCfgValue_always()
public virtual void shouldUseCfgValue_always()
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.camunda.bpm.engine.impl.db.ListQueryParameterObject query = new org.camunda.bpm.engine.impl.db.ListQueryParameterObject();
ListQueryParameterObject query = new ListQueryParameterObject();
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.camunda.bpm.engine.impl.db.AuthorizationCheck authCheck = query.getAuthCheck();
AuthorizationCheck authCheck = query.AuthCheck;
// given
when(mockedConfiguration.AuthorizationCheckRevokes).thenReturn(ProcessEngineConfiguration.AUTHORIZATION_CHECK_REVOKE_ALWAYS);
// if
authorizationManager.configureQuery(query);
// then
assertEquals(true, authCheck.RevokeAuthorizationCheckEnabled);
verifyNoMoreInteractions(mockedEntityManager);
}
// authorization checks on queries ////////////////////////////////
public virtual void configureQuery(ListQueryParameterObject query)
{
AuthorizationCheck authCheck = query.AuthCheck;
authCheck.PermissionChecks.clear();
if (AuthCheckExecuted)
{
Authentication currentAuthentication = CurrentAuthentication;
authCheck.AuthUserId = currentAuthentication.UserId;
authCheck.AuthGroupIds = currentAuthentication.GroupIds;
enableQueryAuthCheck(authCheck);
}
else
{
authCheck.AuthorizationCheckEnabled = false;
authCheck.AuthUserId = null;
authCheck.AuthGroupIds = null;
}
}
public async Task <IActionResult> OnGetAsync(string EventID)
{
if (EventID == null)
{
return(NotFound());
}
if (!AuthorizationCheck.Event(_context, EventID, User.Identity.Name))
{
return(Forbid());
}
if (await _context.Team.AsNoTracking().Where(t => t.EventID == EventID).CountAsync() < 4)
{
return(Forbid());
}
eventID = EventID;
AuthorizedTeams = await _context.Team.AsNoTracking().Where(t => t.EventID == EventID).AsQueryable <Team>().OrderBy(s => s.TeamNumber.PadLeft(5)).ToListAsync();
return(Page());
}
public async Task <ActionResult> OnGetAsync(string EventID)
{
if (EventID == null)
{
return(NotFound());
}
if (!AuthorizationCheck.Event(_context, EventID, User.Identity.Name))
{
return(Forbid());
}
eventID = EventID;
await GetAndSeparateData(EventID);
int BestRedScore = AuthorizedOfficialMatches.Max(m => m.RedScore).GetValueOrDefault();
int BestBlueScore = AuthorizedOfficialMatches.Max(m => m.BlueScore).GetValueOrDefault();
BestScore = System.Math.Max(BestRedScore, BestBlueScore);
TeamCount = await _context.Team.AsNoTracking().Where(t => t.EventID == EventID).CountAsync();
try
{
int ScoresSum = 0;
foreach (var Match in AuthorizedOfficialMatches)
{
ScoresSum += Match.RedScore.GetValueOrDefault();
ScoresSum += Match.BlueScore.GetValueOrDefault();
}
AverageScore = ScoresSum / (AuthorizedOfficialMatches.Count() * 2);
AverageScore = System.Math.Round(AverageScore, 2);
MatchesPerTeam = AuthorizedOfficialMatches.Count() * 4 / AuthorizedTeams.Count;
MatchesPerTeam = System.Math.Round(MatchesPerTeam, 2);
}
catch
{
AverageScore = 0;
MatchesPerTeam = 0;
}
return(Page());
}
public async Task <IActionResult> OnGetAsync(string EventID, string TeamID)
{
if (EventID == null || TeamID == null)
{
return(NotFound());
}
if (!AuthorizationCheck.Team(_context, TeamID, User.Identity.Name))
{
return(Forbid());
}
teamID = TeamID;
eventID = EventID;
Team = await _context.Team.FirstOrDefaultAsync(m => m.ID == TeamID);
if (Team == null)
{
return(NotFound());
}
return(Page());
}
public async Task <ActionResult> OnGetAsync()
{
if (!User.Identity.IsAuthenticated)
{
return(Forbid());
}
AllEvents = await _context.Event.AsNoTracking().ToListAsync();
AuthorizedEvents = new List <Event>();
foreach (var Event in AllEvents)
{
if (AuthorizationCheck.Event(_context, Event.ID, User.Identity.Name))
{
AuthorizedEvents.Add(Event);
}
}
CurrentEvents = AuthorizedEvents.Where(e => e.StartDate <= DateTime.Today && e.EndDate >= DateTime.Today).ToList();
UpcomingEvents = AuthorizedEvents.Where(e => e.StartDate > DateTime.Today).ToList();
PastEvents = AuthorizedEvents.Where(e => e.EndDate < DateTime.Today).ToList();
return(Page());
}
// process definition query ////////////////////////////////
public virtual void configureProcessDefinitionQuery(ProcessDefinitionQueryImpl query)
{
configureQuery(query, PROCESS_DEFINITION, "RES.KEY_");
if (query.StartablePermissionCheck)
{
AuthorizationCheck authorizationCheck = query.AuthCheck;
if (!authorizationCheck.RevokeAuthorizationCheckEnabled)
{
CompositePermissionCheck permCheck = (new PermissionCheckBuilder()).atomicCheck(PROCESS_DEFINITION, "RES.KEY_", Permissions.CREATE_INSTANCE).build();
query.addProcessDefinitionCreatePermissionCheck(permCheck);
}
else
{
CompositePermissionCheck permissionCheck = (new PermissionCheckBuilder()).conjunctive().atomicCheck(PROCESS_DEFINITION, "RES.KEY_", READ).atomicCheck(PROCESS_DEFINITION, "RES.KEY_", Permissions.CREATE_INSTANCE).build();
addPermissionCheck(authorizationCheck, permissionCheck);
}
}
}
public async Task <IActionResult> OnGetAsync(string EventID)
{
// Authorization checks
if (!User.Identity.IsAuthenticated || !AuthorizationCheck.Event(_context, EventID, User.Identity.Name))
{
return(Forbid());
}
if (EventID == null)
{
return(NotFound());
}
Event = await _context.Event.FirstOrDefaultAsync(m => m.ID == EventID);
if (Event == null)
{
return(NotFound());
}
return(Page());
}
/// <summary>
/// If the current user does not have the requested rights, either redirects to the login page,
/// or throws a SecurityException.
/// </summary>
/// <param name="authCheck"></param>
/// <param name="redirectIfUnauthorized">
/// If true and user does not have rights, redirects to the login page or homepage.
/// If false and user does not have rights, throws a security exception.
/// </param>
/// <param name="rights"></param>
public static void DemandUserHasRight(AuthorizationCheck authCheck, bool redirectIfUnauthorized, params Rights[] rights)
{
if (!IsAuthorizedTo(authCheck, rights))
{
if (redirectIfUnauthorized)
{
RedirectForUnauthorizedRequest();
}
else
{
throw new SecurityException("User doesn't have the right to perform this");
}
}
}
/// <summary>
/// Returns whether the current user passes authorization on the rights based on the given AuthorizationCheck.
/// </summary>
/// <param name="authCheck"></param>
/// <param name="rights"></param>
/// <returns></returns>
public static bool IsAuthorizedTo(AuthorizationCheck authCheck, IEnumerable<Rights> rights)
{
if (rights.Count() == 0)
{
// Always return false for this. If there's a mistake where authorization
// is being checked for on an empty collection, we don't want to return
// true.
return false;
}
else
{
var roles = Security.GetCurrentUserRoles();
if (authCheck == AuthorizationCheck.HasAny)
{
foreach (var right in rights)
{
if (Right.HasRight(right, roles))
{
return true;
}
}
return false;
}
else if (authCheck == AuthorizationCheck.HasAll)
{
bool authCheckPassed = true;
foreach (var right in rights)
{
if (!Right.HasRight(right, roles))
{
authCheckPassed = false;
break;
}
}
return authCheckPassed;
}
else
{
throw new NotSupportedException();
}
}
}
/// <summary>
/// Returns whether the current user passes authorization on the rights based on the given AuthorizationCheck.
/// </summary>
/// <param name="authCheck"></param>
/// <param name="rights"></param>
/// <returns></returns>
public static bool IsAuthorizedTo(AuthorizationCheck authCheck, params Rights[] rights)
{
return IsAuthorizedTo(authCheck, rights.ToList());
}