c # – How to avoid the superuser of the business?

I have developed a 3-level architecture program package. The persistence layer is developed through the use of the Repository Pattern and the Entity Framework 6 Code First Approach.

This package program has many features and I define a superuser (administrator), who has all the rights, in the initial creation script. Therefore, the operation of the company can create the required data (users, roles, etc.) by the Superuser account for initial use and can also manage them when necessary.

But, Superuser must be ignored of all the characteristics of the business. For example, this user should not appear on the user list page or can not assign any tasks.

The question is & # 39; What is the best way to avoid the Superuser of commercial functions? & # 39;.

To illustrate something better, we can think of & # 39; Community & # 39; user of Software Engineering site.

How to avoid & # 39; Community & # 39; user to gain reputation?

The use of the static help class is shown as:

Public static class tester
{
public static bool CanUserGoFurther (string username)
{
var superUserList = GetSuperUsers ();
return! superUserList.Any (u => u.UserName == username);
}

public static bool CanUserGoFurther (int userId)
{
var superUserList = GetSuperUsers ();
return! superUserList.Any (u => u.Id == userId);
}

Public static list FilterUsers (IEnumerable users)
{
return users.Except (GetSuperUsers ()). ToList ();
}

Private static list GetSuperUsers ()
{
return new list();
}
}

Public class ReputationService
{

Public void AddReputation (string userName, int rep)
{
if (! Checker.CanUserGoFurther (userName))
he came back;

// ...
}

Public void AddReputation (int userId, int rep)
{
if (! Checker.CanUserGoFurther (userId))
he came back;

// ...
}
}

I must also provide two functions, one that includes a superuser and another that does
Does not include the superuser method and let the other service determine which one to use?

public service class
{
private readonly UserRepository _userRepository;

Public UserService (UserRepository userRepository)
{
_userRepository = userRepository;
}

Public list GetUsersWithSuperUsers ()
{
returns _userRepository.GetAll ();
}

Public list GetUsersWithoutSuperUsers ()
{
return Checker.FilterUsers (_userRepository.GetAll ());
}
}

Public class SomeService
{
private read-only UserService _userService;

SomeService public (UserService userService)
{
_userService = userService;
}

public vacuum SomeFunction1 ()
{
var users = _userService.GetUsersWithoutSuperUsers ();

// ..
}

public vacuum SomeFunction2 ()
{
var users = _userService.GetUsersWithSuperUsers ();

// ..
}
}

It may seem good when there are 2 or 3 services, but when there are more than 30 services it is painful and I feel something is wrong.

Is there any better way to overcome this problem or can it improve current?