public AuthorizationController(IAuthorizationRepository authorizeRepository, IMapper mapper, IHashingService hashingService, ITokenService tokenService)
{
this.authorizeRepository = authorizeRepository;
this.mapper = mapper;
this.hashingService = hashingService;
this.tokenService = tokenService;
}
public AuthorizationService(IAuthorizationRepository authRepo, IMapper mapper,
IConfiguration config)
{
this.config = config;
this.mapper = mapper;
this.authRepo = authRepo;
}
private void SetupEntities()
{
user = new User {
Name = "Ayende"
};
account = new Account {
Name = "south sand"
};
session.Save(user);
session.Save(account);
authorizationService = ServiceLocator.Current.GetInstance <IAuthorizationService>();
permissionService = ServiceLocator.Current.GetInstance <IPermissionsService>();
permissionsBuilderService = ServiceLocator.Current.GetInstance <IPermissionsBuilderService>();
authorizationRepository = ServiceLocator.Current.GetInstance <IAuthorizationRepository>();
authorizationRepository.CreateUsersGroup("Administrators");
authorizationRepository.CreateEntitiesGroup("Important Accounts");
authorizationRepository.CreateOperation("/Account/Edit");
authorizationRepository.CreateOperation("/Account/Disable");
authorizationRepository.AssociateUserWith(user, "Administrators");
authorizationRepository.AssociateEntityWith(account, "Important Accounts");
}
/// <summary>
/// Counstructor
/// </summary>
/// <param name="fastFoodDbContext">FastFoodDbContext - Injection</param>
/// <param name="foodRepository">FoodRepository - Injection</param>
/// <param name="paymentRepository">PaymentRepository - Injection</param>
/// <param name="userRepository">UserRepository - Injection</param>
/// <param name="paymentMethodRepository">PaymentMethodRepository - Injection</param>
/// <param name="sentEmailRepository">SentEmailRepository - Injection</param>
/// <param name="sentMessageRepository">SentMessageRepository - Injection</param>
/// <param name="authorizationRepository">AuthorizationRepository - Injection</param>
public UnitOfWork
(
FastFoodDbContext fastFoodDbContext,
IFoodRepository foodRepository,
IPaymentRepository paymentRepository,
IUserRepository userRepository,
IPaymentMethodRepository paymentMethodRepository,
ISentEmailRepository sentEmailRepository,
ISentMessageRepository sentMessageRepository,
IAuthorizationRepository authorizationRepository
)
{
_fastFoodDbContext = fastFoodDbContext;
FoodRepository = foodRepository;
PaymentRepository = paymentRepository;
UserRepository = userRepository;
PaymentMethodRepository = paymentMethodRepository;
SentEmailRepository = sentEmailRepository;
SentMessageRepository = sentMessageRepository;
AuthorizationRepository = authorizationRepository;
// Setup the DbContext
FoodRepository.DbContext = _fastFoodDbContext;
PaymentRepository.DbContext = _fastFoodDbContext;
UserRepository.DbContext = _fastFoodDbContext;
PaymentMethodRepository.DbContext = _fastFoodDbContext;
SentEmailRepository.DbContext = _fastFoodDbContext;
SentMessageRepository.DbContext = _fastFoodDbContext;
AuthorizationRepository.DbContext = _fastFoodDbContext;
}
public CheckAccessFunctions(ITokenValidator tokenValidator, IJsonHttpContentValidator jsonHttpContentValidator, IMicrosoftGraphRepository microsoftGraphRepository, IAuthorizationRepository authorizationRepository)
{
this.tokenValidator = tokenValidator ?? throw new ArgumentNullException(nameof(tokenValidator));
this.jsonHttpContentValidator = jsonHttpContentValidator ?? throw new ArgumentNullException(nameof(jsonHttpContentValidator));
this.microsoftGraphRepository = microsoftGraphRepository ?? throw new ArgumentNullException(nameof(microsoftGraphRepository));
this.authorizationRepository = authorizationRepository ?? throw new ArgumentNullException(nameof(authorizationRepository));
}
public AuthorizationValidation(IHttpContextAccessor contextAccessor,
IAuthorizationRepository authorizationRepository,
IPersonRepository personRepository) : base(contextAccessor)
{
_authorizationRepository = authorizationRepository;
_personRepository = personRepository;
}
public AddAuthorizationRoleCommandHandler(IRoleRepository roleRepository,
IAuthorizationRepository authorizationRepository)
{
_authorizationRepository = authorizationRepository ??
throw new ArgumentNullException(nameof(authorizationRepository));
_roleRepository = roleRepository ?? throw new ArgumentNullException(nameof(roleRepository));
}
public static async Task <IStatusGeneric <RoleToPermissions> > CreateRoleWithPermissionsAsync(
string roleName,
string description,
IEnumerable <Permission> permissionInRole,
IAuthorizationRepository repository)
{
if (roleName == null)
{
throw new ArgumentNullException(nameof(roleName));
}
if (repository == null)
{
throw new ArgumentNullException(nameof(repository));
}
var status = new StatusGenericHandler <RoleToPermissions>();
RoleToPermissions roleToPermissions = await repository.GetRoleToPermissionAsync(roleName);
if (roleToPermissions != null)
{
status.AddError("That role already exists");
return(status);
}
return(status.SetResult(new RoleToPermissions(roleName, description, permissionInRole)));
}
public static IAuthorizationRepository GetAuthorizationRepo()
{
if (authRepo == null)
authRepo = new AuthorizationRepository();
return authRepo;
}
private void SetupEntities()
{
user = new User();
user.Name = "Ayende";
account = new Account();
account.Name = "south sand";
UnitOfWork.CurrentSession.Save(user);
UnitOfWork.CurrentSession.Save(account);
authorizationService = IoC.Resolve<IAuthorizationService>();
permissionService = IoC.Resolve<IPermissionsService>();
permissionsBuilderService = IoC.Resolve<IPermissionsBuilderService>();
authorizationRepository = IoC.Resolve<IAuthorizationRepository>();
authorizationRepository.CreateUsersGroup("Administrators");
authorizationRepository.CreateEntitiesGroup("Important Accounts");
authorizationRepository.CreateOperation("/Account/Edit");
UnitOfWork.Current.TransactionalFlush();
authorizationRepository.AssociateUserWith(user, "Administrators");
authorizationRepository.AssociateEntityWith(account, "Important Accounts");
UnitOfWork.Current.TransactionalFlush();
}
public AuthorizationService(
IAuthorizationRepository repository,
IConfiguration configuration
)
{
_repository = repository;
_configuration = configuration;
}
public RoleService(IMapper mapper, IRoleRepository repository, IAuthorizationRepository authorizationRep)
{
this.mapper = mapper;
this.repository = repository;
this.authorizationRep = authorizationRep;
CheckAuthorization();
}
public UserGroupListController(IDynamicExpressionQuery dynamicExpressionQuery,
IAuthorizationRepository authorizationRepository,
IEntityListGrid<UserGroupDto> grid)
{
_dynamicExpressionQuery = dynamicExpressionQuery;
_authorizationRepository = authorizationRepository;
_grid = grid;
}
public AddPermissionsToUserClaimsFactory(
UserManager <IdentityUser> userManager,
IOptions <IdentityOptions> optionsAccessor,
IAuthorizationRepository repository)
: base(userManager, optionsAccessor)
{
_repository = repository ?? throw new ArgumentNullException(nameof(repository));
}
/// <summary>
/// 获取权限系统存储服务
/// </summary>
/// <returns></returns>
public static IAuthorizationRepository GetAuthorizationRepository()
{
Initialize();
if (_azRepository == null)
{
_azRepository = System.Activator.CreateInstance(Type.GetType(_azRepositoryType), _config) as IAuthorizationRepository;
}
return(_azRepository);
}
/// <summary>
/// 获取权限系统存储服务
/// </summary>
/// <returns></returns>
public static IAuthorizationRepository GetAuthorizationRepository()
{
Initialize();
if (_azRepository == null)
{
_azRepository = System.Activator.CreateInstance(Type.GetType(_azRepositoryType),_config) as IAuthorizationRepository;
}
return _azRepository;
}
public UserGroupPermissionListController(IDynamicExpressionQuery dynamicExpressionQuery,
IPermissionsService permissionsService,
IAuthorizationRepository authorizationRepository)
{
_dynamicExpressionQuery = dynamicExpressionQuery;
_grid = ObjectFactory.Container.GetInstance<IEntityListGrid<PermissionDto>>("group");
_permissionsService = permissionsService;
_authorizationRepository = authorizationRepository;
}
public SessionAuthenticationHandler(
IOptionsMonitor <AuthenticationSchemeOptions> options,
ILoggerFactory logger,
UrlEncoder encoder,
ISystemClock clock,
IAuthorizationRepository authorizationRepository)
: base(options, logger, encoder, clock)
{
_authorizationRepository = authorizationRepository;
}
public OrderRepository(
IOrderAuthorizationRepository orderAuthorizationRepository,
IAuthorizationRepository authorizationRepository,
AcmeContext context) : base(context)
{
OrderAuthorizationRepository = orderAuthorizationRepository
?? throw new ArgumentNullException(nameof(orderAuthorizationRepository));
AuthorizationRepository = authorizationRepository
?? throw new ArgumentNullException(nameof(authorizationRepository));
}
public UserListController(IDynamicExpressionQuery dynamicExpressionQuery,
IEntityListGrid<UserLoginInfo> grid,
IRepository repository,
IAuthorizationRepository authorizationRepository)
{
_dynamicExpressionQuery = dynamicExpressionQuery;
_grid = grid;
_repository = repository;
_authorizationRepository = authorizationRepository;
}
public AuthorizationLogic(IAuthorizationRepository authorizationRepository,
IConfiguration configuration,
IHttpContextAccessor contextAccessor,
IPushNotificationService pushNotificationService)
{
_authorizationRepository = authorizationRepository;
_configuration = configuration;
_contextAccessor = contextAccessor;
_pushNotificationService = pushNotificationService;
}
public InvoiceApplicationService(
IAuthorizationRepository authorizationRepository,
IInvoiceRepository invoiceRepository,
IUnitOfWork unitOfWork,
IDateService dateService)
{
_authorizationRepository = authorizationRepository;
_invoiceRepository = invoiceRepository;
_unitOfWork = unitOfWork;
_dateService = dateService;
}
public AccountController(
IAuthorizationRepository repository,
UserManager <IdentityUser> userManager,
SignInManager <IdentityUser> signInManager,
IEmailSender emailSender,
ILogger <AccountController> logger) : base(logger)
{
_repository = repository;
_userManager = userManager;
_signInManager = signInManager;
_emailSender = emailSender;
}
public PermissionController(IRepository repository,
IPermissionsService permissionsService,
IAuthorizationRepository authorizationRepository,
IPermissionsBuilderService permissionsBuilderService,
ISelectListItemService selectListItemService)
{
_repository = repository;
_permissionsService = permissionsService;
_authorizationRepository = authorizationRepository;
_permissionsBuilderService = permissionsBuilderService;
_selectListItemService = selectListItemService;
}
public UserController(
IRepository repository,
ISaveEntityService saveEntityService,
ISecurityDataService securityDataService,
ISelectListItemService selectListItemService,
IAuthorizationRepository authorizationRepository)
{
_repository = repository;
_saveEntityService = saveEntityService;
_securityDataService = securityDataService;
_selectListItemService = selectListItemService;
_authorizationRepository = authorizationRepository;
}
public async Task <int> GetUserId(HttpRequest req)
{
AuthGUID authGUID = await GetGUIDAsync(req);
if (!authGUID.Acces || authGUID.GUID == "")
{
return(0);
}
IAuthorizationRepository authRepository = DIContainer.Instance.GetService <IAuthorizationRepository>();
return(authRepository.GetUserId(authGUID.GUID, false));
}
public ChallengeService(IChallengeRepository challengeRepository,
IAuthorizationRepository authorizationRepository,
IAccountService accountService,
IOptions <ServerOptions> options)
: base(options)
{
ChallengeRepository = challengeRepository
?? throw new ArgumentNullException(nameof(challengeRepository));
AuthorizationRepository = authorizationRepository
?? throw new ArgumentNullException(nameof(authorizationRepository));
AccountService = accountService
?? throw new ArgumentNullException(nameof(accountService));
}
public HomeController(
Microsoft.AspNetCore.Identity.UserManager <IdentityUser> userManager,
SignInManager <IdentityUser> signInManager,
ILogger <RegisterModel> logger,
IEmailSender emailSender,
ApplicationDbContext DB,
IAuthorizationRepository authorization)
{
_userManager = userManager;
_signInManager = signInManager;
_logger = logger;
_emailSender = emailSender; this.dbContext = DB;
this.authorizationRepository = authorization;
}
public async Task <AuthResultModel> AuthForDoctorOrPatient(HttpRequest req, int userId)
{
AuthGUID authGUID = await GetGUIDAsync(req);
if (!authGUID.Acces || authGUID.GUID == "")
{
return(new AuthResultModel(false, AuthStatusCode.Unauthorized));
}
IAuthorizationRepository authRepository = DIContainer.Instance.GetService <IAuthorizationRepository>();
return(authRepository.HasAcces(userId, authGUID.GUID)
? new AuthResultModel(true, AuthStatusCode.Ok)
: new AuthResultModel(false, AuthStatusCode.Forbidden));
}
protected override void SetUp()
{
base.SetUp();
var currentConversation = ServiceLocator.Current.GetInstance<IConversation>();
using (currentConversation.SetAsCurrent())
{
_authZRepo = ServiceLocator.Current.GetInstance<AuthorizationRepositoryFactory>().Create();
_userRepository = ServiceLocator.Current.GetInstance<UserRepository>();
_permissionBuilderService = ServiceLocator.Current.GetInstance<PermissionsBuilderServiceFactory>().Create();
_seniorUser = _userRepository.Create(new User { Name = "Senior" });
_juniorUser = _userRepository.Create(new User { Name = "Junior" });
_seniorMgrs = _authZRepo.CreateUsersGroup("Senior Managers");
_juniorMgrs = _authZRepo.CreateUsersGroup("Junior Managers");
_op4Senior = _authZRepo.CreateOperation("/Operation/ForSenior");
currentConversation.Flush();
_op4Junior = _authZRepo.CreateOperation("/Operation/ForJunior");
_authZRepo.AssociateUserWith(_seniorUser, _seniorMgrs);
_authZRepo.AssociateUserWith(_juniorUser, _juniorMgrs);
_permissionBuilderService
.Allow(_op4Junior)
.For(_juniorMgrs)
.OnEverything()
.DefaultLevel()
.Save();
_permissionBuilderService
.Deny(_op4Senior)
.For(_juniorMgrs)
.OnEverything()
.DefaultLevel()
.Save();
_permissionBuilderService
.Allow(_op4Senior)
.For(_seniorMgrs)
.OnEverything()
.DefaultLevel()
.Save();
currentConversation.Flush();
}
_targetController = ServiceLocator.Current.GetInstance<PermissionController>();
}
public HomeController(
Microsoft.AspNetCore.Identity.UserManager <IdentityUser> userManager,
SignInManager <IdentityUser> signInManager,
ILogger <RegisterModel> logger,
IEmailSender emailSender,
IAuthorizationRepository authorization, IPatientsRepository patients, ITemporaryPatientsRepository temporaryPatients, ITurnsRepository turns)
{
_userManager = userManager;
_signInManager = signInManager;
_logger = logger;
_emailSender = emailSender;
this.authorizationRepository = authorization;
this.patientsRepository = patients;
this.temporaryPatientsRepository = temporaryPatients;
this.turnsRepository = turns;
}
public async Task <AuthResultModel> AuthForDoctor(HttpRequest req, int doctorId)
{
AuthGUID authGUID = await GetGUIDAsync(req);
if (!authGUID.AuthResult.Result)
{
return(authGUID.AuthResult);
}
IAuthorizationRepository authRepository = DIContainer.Instance.GetService <IAuthorizationRepository>();
if (authRepository.UserAuth(doctorId, authGUID.GUID, true))
{
return(new AuthResultModel(true, AuthStatusCode.Ok));
}
return(new AuthResultModel(false, AuthStatusCode.Forbidden));
}
public ConverterService(
IAuthorizationRepository authorizationRepository,
IChallengeRepository challengeRepository,
IOrderAuthorizationRepository orderAuthorizationRepository,
IExternalAccountRepository externalAccountRepository,
IOptions <ServerOptions> options)
: base(options)
{
AuthorizationRepository = authorizationRepository
?? throw new ArgumentNullException(nameof(authorizationRepository));
ChallengeRepository = challengeRepository
?? throw new ArgumentNullException(nameof(challengeRepository));
OrderAuthorizationRepository = orderAuthorizationRepository
?? throw new ArgumentNullException(nameof(orderAuthorizationRepository));
ExternalAccountRepository = externalAccountRepository
?? throw new ArgumentNullException(nameof(externalAccountRepository));
}
/**
* Authorization Check for every call
*/
public async Task <AuthResultModel> CheckAuthorization(HttpRequest req, int userId = 0, bool isDoctor = false)
{
// Get AuthentificationHeader from request
AuthenticationHeaderValue.TryParse(req.Headers[HeaderNames.Authorization], out var authHeader);
if (authHeader == null)
{
return(new AuthResultModel(false, AuthStatusCode.Unauthorized));
}
// Token validation with Auth0 servers
ClaimsPrincipal claims = await Auth0.ValidateTokenAsync(authHeader);
if (claims == null)
{
return(new AuthResultModel(false, AuthStatusCode.Unauthorized));
}
// Get Token Guid for Authorization
string tokenGuid = claims.FindFirst("http://schemas.xmlsoap.org/ws/2005/05/identity/claims/nameidentifier").Value;
IAuthorizationRepository authRepository = DIContainer.Instance.GetService <IAuthorizationRepository>();
// If userId needs to come from token, only calls the method GetAccountId if userId is zero
if (userId == 0 && authRepository.GetUserId(tokenGuid, isDoctor) == 0)
{
return(new AuthResultModel(false, AuthStatusCode.Forbidden));
}
// When a call is from a Doctor that needs info about a patient, the following method will be called
// UserId is here patientId
if (isDoctor && authRepository.CheckDoctorAcces(userId, tokenGuid))
{
return(new AuthResultModel(true, AuthStatusCode.Ok));
}
// When a call is from a patient of doctor and only ask for information about the same user the following method will be called
if (userId != 0 && !authRepository.UserAuth(userId, tokenGuid, isDoctor))
{
return(new AuthResultModel(false, AuthStatusCode.Forbidden));
}
return(new AuthResultModel(true, AuthStatusCode.Ok));
}
public async Task <IStatusGeneric> DeleteRoleAsync(
string roleName,
bool isRemoveFromUsers,
IAuthorizationRepository repository)
{
if (repository == null)
{
throw new ArgumentNullException(nameof(repository));
}
var status = new StatusGenericHandler {
Message = "Deleted role successfully."
};
RoleToPermissions roleToUpdate = await repository.GetRoleToPermissionAsync(roleName);
if (roleToUpdate == null)
{
return(status.AddError("That role doesn't exists"));
}
ICollection <UserToRole> usersWithRoles = await repository.GetUsersToRoleByNameAsync(roleName);
if (usersWithRoles.Any())
{
if (!isRemoveFromUsers)
{
return(status.AddError($"That role is used by {usersWithRoles.Count} and you didn't ask for them to be updated."));
}
await repository.DeleteAsync(usersWithRoles);
status.Message = $"Removed role from {usersWithRoles.Count} user and then deleted role successfully.";
}
await repository.DeleteAsync(roleToUpdate);
return(status);
}
public static async Task <IStatusGeneric <UserToRole> > AddRoleToUserAsync(
string userId,
string roleName,
IAuthorizationRepository repository)
{
if (userId == null)
{
throw new ArgumentNullException(nameof(userId));
}
if (roleName == null)
{
throw new ArgumentNullException(nameof(roleName));
}
if (repository == null)
{
throw new ArgumentNullException(nameof(repository));
}
var status = new StatusGenericHandler <UserToRole>();
UserToRole userToRole = await repository.GetUserToRoleAsync(userId, roleName);
if (userToRole != null)
{
status.AddError($"The user already has the Role '{roleName}'.");
return(status);
}
RoleToPermissions roleToAdd = await repository.GetRoleToPermissionAsync(roleName);
if (roleToAdd == null)
{
status.AddError($"Could not find the Role '{roleName}'.");
return(status);
}
return(status.SetResult(new UserToRole(userId, roleToAdd)));
}
public RihnoRoleProvider()
{
var cfg = new Configuration()
.SetProperty(Environment.ConnectionDriver, typeof(Sql2008ClientDriver).AssemblyQualifiedName)
.SetProperty(Environment.Dialect, typeof(MsSql2008Dialect).AssemblyQualifiedName)
.SetProperty(Environment.ConnectionString, Storage.RhinoConnectionString)//ConfigurationManager.AppSettings["RhinoSecurity.ConnectionString"]) amit 23052017
.SetProperty(Environment.ReleaseConnections, "on_close")
.SetProperty(Environment.UseSecondLevelCache, "true")
.SetProperty(Environment.UseQueryCache, "true")
.SetProperty(Environment.CacheProvider, typeof(HashtableCacheProvider).AssemblyQualifiedName)
.AddAssembly(typeof(AMS.Broker.DataStore.User).Assembly);
Security.Configure <AMS.Broker.DataStore.User>(cfg, SecurityTableStructure.Prefix);
Factory = cfg.BuildSessionFactory();
Session = Factory.OpenSession();
Session.FlushMode = FlushMode.Always;
AuthRepository = new AuthorizationRepository(Session);
PermissionsBuilderService = new PermissionsBuilderService(Session, AuthRepository);
PermissionService = new PermissionsService(AuthRepository, Session);
AuthorizationService = new AuthorizationService(PermissionService, AuthRepository);
}
/// <summary>
/// Initializes a new instance of the <see cref="PermissionsService"/> class.
/// </summary>
/// <param name="authorizationRepository">The authorization editing service.</param>
/// <param name="session">The NHibernate session</param>
public PermissionsService(IAuthorizationRepository authorizationRepository,
ISession session)
{
this.authorizationRepository = authorizationRepository;
this.session = session;
}
public AuthorizationService()
{
_repository = new AuthorizationRepository(_context);
}
public PermissionsController(IRepository repository,IPermissionsService permissionsService,IAuthorizationRepository authorizationRepository)
{
_repository = repository;
_permissionsService = permissionsService;
_authorizationRepository = authorizationRepository;
}
/// <summary>
/// Initializes a new instance of the <see cref="AuthorizationService"/> class.
/// </summary>
/// <param name="permissionsService">The permissions service.</param>
/// <param name="authorizationRepository">The authorization editing service.</param>
public AuthorizationService(IPermissionsService permissionsService,
IAuthorizationRepository authorizationRepository)
{
this.permissionsService = permissionsService;
this.authorizationRepository = authorizationRepository;
}
private void SetupEntities()
{
user = new User {Name = "Ayende"};
account = new Account {Name = "south sand"};
session.Save(user);
session.Save(account);
authorizationService = ServiceLocator.Current.GetInstance<IAuthorizationService>();
permissionService = ServiceLocator.Current.GetInstance<IPermissionsService>();
permissionsBuilderService = ServiceLocator.Current.GetInstance<IPermissionsBuilderService>();
authorizationRepository = ServiceLocator.Current.GetInstance<IAuthorizationRepository>();
authorizationRepository.CreateUsersGroup("Administrators");
authorizationRepository.CreateEntitiesGroup("Important Accounts");
authorizationRepository.CreateOperation("/Account/Edit");
authorizationRepository.AssociateUserWith(user, "Administrators");
authorizationRepository.AssociateEntityWith(account, "Important Accounts");
}
/// <summary>
/// Initializes a new instance of the <see cref="AuthorizationService"/> class.
/// </summary>
/// <param name="permissionsService">The permissions service.</param>
/// <param name="authorizationRepository">The authorization editing service.</param>
public AuthorizationService(IPermissionsService permissionsService,
IAuthorizationRepository authorizationRepository)
{
this.permissionsService = permissionsService;
this.authorizationRepository = authorizationRepository;
}
/// <summary>
/// Initializes a new instance of the <see cref="PermissionsBuilderService"/> class.
/// </summary>
/// <param name="session">The nhibernate session</param>
/// <param name="authorizationRepository">The authorization editing service.</param>
public PermissionsBuilderService(ISession session, IAuthorizationRepository authorizationRepository)
{
this.session = session;
this.authorizationRepository = authorizationRepository;
}
public void TestFixtureSetUp()
{
ServiceLocatorImpl = Init();
AuthZRepository = ServiceLocator.Current.GetInstance<IAuthorizationRepository>();
AuthZService = ServiceLocator.Current.GetInstance<IAuthorizationService>();
}
/// <summary>
/// Initializes the controller with dependency injection.
/// </summary>
/// <param name="dashParam">Implementation of IDashboardRepository.</param>
/// <param name="authParam">Implementation of IAuthorizationRepository.</param>
public DashboardController(IDashboardRepository dashParam, IAuthorizationRepository authParam, ISiteSettingRepository siteParam)
{
repo = dashParam;
authRepo = authParam;
site = siteParam;
}
public UserGroupController(IAuthorizationRepository authorizationRepository, IRepository repository)
{
_authorizationRepository = authorizationRepository;
_repository = repository;
}
