public AdminUsersServiceTests()
{
_adminUsersRepositoryMock.Setup(o => o.TryCreateAsync(It.IsAny <AdminUserEncrypted>()))
.ReturnsAsync((AdminUserEncrypted adminUserEncrypted) => true);
_credentialsClientMock.Setup(o => o.Admins.CreateAsync(It.IsAny <AdminCredentialsCreateRequest>()))
.ReturnsAsync((AdminCredentialsCreateRequest request) =>
new CredentialsCreateResponse {
Error = CredentialsError.None
});
_customerProfileClientMock.Setup(o => o.AdminProfiles.AddAsync(It.IsAny <AdminProfileRequest>()))
.ReturnsAsync((AdminProfileRequest request) => new AdminProfileResponse
{
Data = new AdminProfile
{
AdminId = request.AdminId,
Email = request.Email,
FirstName = request.FirstName,
LastName = request.LastName
},
ErrorCode = AdminProfileErrorCodes.None
});
_service = new AdminUserService(
_adminUsersRepositoryMock.Object,
_credentialsClientMock.Object,
_customerProfileClientMock.Object,
_permissionsServiceMock.Object,
EmptyLogFactory.Instance,
_notificationsServiceMock.Object,
_permissionsCacheMock.Object);
}
public UsersController(IAdminUserService users, IMapper mapper, RoleManager <IdentityRole> roleManager, UserManager <User> userManager)
{
this.users = users;
this.mapper = mapper;
this.roleManager = roleManager;
this.userManager = userManager;
}
// /Api/Admin/{action}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="tokenValidationSettings"></param>
/// <param name="frontendSettingsOptions"></param>
/// <param name="userService"></param>
/// <param name="adminUserService"></param>
/// <param name="notificationService"></param>
/// <param name="permissionService"></param>
/// <param name="groupService"></param>
/// <param name="roleService"></param>
/// <param name="bulletinService"></param>
/// <param name="permissionProviders"></param>
/// <param name="menuProviders"></param>
public AdminController(
TokenValidationSettings tokenValidationSettings,
IOptions <FrontendSettings> frontendSettingsOptions,
IUserService userService,
IAdminUserService adminUserService,
INotificationService notificationService,
IPermissionService permissionService,
IGroupService groupService,
IRoleService roleService,
IBulletinService bulletinService,
IEnumerable <IPermissionProvider> permissionProviders,
IEnumerable <IMenuProvider> menuProviders)
{
_tokenValidationSettings = tokenValidationSettings;
_frontendSettings = frontendSettingsOptions.Value;
_userService = userService;
_adminUserService = adminUserService;
_notificationService = notificationService;
_permissionService = permissionService;
_groupService = groupService;
_roleService = roleService;
_bulletinService = bulletinService;
_permissionProviders = permissionProviders;
_menuProviders = menuProviders;
}
public UsersForAdminCsvPublishService(CloudBlobClient blobClient,
IAdminUserService adminUserService,
IMapper mapper) : base(blobClient, new UserForAdminCsvFormatter())
{
_adminUserService = adminUserService;
_mapper = mapper;
}
public UsersAdminController(IAdminUserService adminUserService, RoleManager <IdentityRole> roleManager,
UserManager <User> userManager)
{
this.adminUserService = adminUserService;
this.roleManager = roleManager;
this.userManager = userManager;
}
public async Task GetAllUsers_WithData_ShouldReturnAllUsers()
{
var context = BookStoreDbContextInMemoryFactory.InitializeContext();
await SeedData(context);
this.userService = new AdminUserService(context);
List <AdminUserListingServiceModel> expectedData = GetTestData().To <AdminUserListingServiceModel>().ToList();
List <AdminUserListingServiceModel> actualData = await this.userService.GetAllUsers().ToListAsync();
Assert.Equal(expectedData.Count, actualData.Count);
foreach (var actualUser in actualData)
{
Assert.True(expectedData.Any(user => actualUser.Username == user.Username &&
actualUser.Email == user.Email), "AdminUserService GetAllUsers() does not work properly");
}
for (int i = 0; i < expectedData.Count; i++)
{
var expectedEntry = expectedData[i];
var actualEntry = actualData[i];
Assert.True(expectedEntry.Username == actualEntry.Username, "Username is not returned properly.");
Assert.True(expectedEntry.Email == actualEntry.Email, "Email is not returned properly.");
}
}
public UsersForAdminCsvPublishService(CloudBlobClient blobClient,
IAdminUserService adminUserService,
IMapper mapper) : base(blobClient, new UserForAdminCsvFormatter())
{
_adminUserService = adminUserService;
_mapper = mapper;
}
public UsersController(IAdminUserService users, RoleManager <IdentityRole> roleManager,
UserManager <User> userManager)
{
this._users = users;
this._roleManager = roleManager;
this._userManager = userManager;
}
public Validator(IAdminUserService adminUserService)
{
RuleFor(x => x.UserName).NotEmpty().MaximumLength(20).WithName("账号")
.MustAsync(async(account, cancel) =>
{
var res = await adminUserService.AnyByAccountAsync(AccountMode.UserName, account, 0, cancel);
return(!res);
})
.WithMessage(c => $"该账号已存在。");
RuleFor(x => x.Mobile)
.NotEmpty()
.Matches("^[1][3-9]\\d{9}$").WithMessage("手机号格式不正确。")
.MustAsync(async(account, cancel) =>
{
var res = await Web.GetService <IAdminUserService>().AnyByAccountAsync(AccountMode.Mobile, account, 0, cancel);
return(!res);
})
.WithMessage(c => $"该手机号码已存在。");
RuleFor(x => x.Password).NotEmpty().MaximumLength(30).WithName("密码");
RuleFor(x => x.Name).NotEmpty().MaximumLength(20).WithName("名字");
RuleFor(x => x.Company).NotEmpty().MaximumLength(30).WithName("公司");
RuleFor(x => x.Location).NotEmpty().MaximumLength(30).WithName("位置");
RuleFor(x => x.Name).NotEmpty().MaximumLength(20).WithName("名字");
}
public AdminUserManager(
IAdminUserService service,
ILogger <AdminUserManager> log)
{
svc = service;
this.log = log;
}
// /Api/Admin/{action}
/// <summary>
/// Constructor
/// </summary>
/// <param name="environment"></param>
/// <param name="tokenValidationSettings"></param>
/// <param name="tokenService"></param>
/// <param name="frontendSettingsOptions"></param>
/// <param name="avatarSettingsOptions"></param>
/// <param name="userService"></param>
/// <param name="adminUserService"></param>
/// <param name="notificationService"></param>
/// <param name="permissionService"></param>
/// <param name="groupService"></param>
/// <param name="roleService"></param>
/// <param name="bulletinService"></param>
/// <param name="userActionLogService"></param>
/// <param name="moduleMetaDataProviders"></param>
/// <param name="menuProviders"></param>
/// <param name="logger"></param>
public AdminController(
IHostingEnvironment environment,
TokenValidationSettings tokenValidationSettings,
ITokenService tokenService,
IOptions <FrontendSettings> frontendSettingsOptions,
IOptions <AvatarSettings> avatarSettingsOptions,
IUserService userService,
IAdminUserService adminUserService,
INotificationService notificationService,
IPermissionService permissionService,
IGroupService groupService,
IRoleService roleService,
IBulletinService bulletinService,
IUserActionLogService userActionLogService,
IEnumerable <IModuleMetaDataProvider> moduleMetaDataProviders,
IEnumerable <IMenuProvider> menuProviders,
ILogger <AdminController> logger)
{
_environment = environment;
_tokenValidationSettings = tokenValidationSettings;
_tokenService = tokenService;
_frontendSettings = frontendSettingsOptions.Value;
_avatarSettings = avatarSettingsOptions.Value;
_userService = userService;
_adminUserService = adminUserService;
_notificationService = notificationService;
_permissionService = permissionService;
_groupService = groupService;
_roleService = roleService;
_bulletinService = bulletinService;
_userActionLogService = userActionLogService;
_moduleMetaDataProviders = moduleMetaDataProviders;
_menuProviders = menuProviders;
_logger = logger;
}
public object login(Dictionary <string, object> dicParas)
{
string userMobile = dicParas.ContainsKey("userMobile") ? dicParas["userMobile"].ToString() : string.Empty;
string password = dicParas.ContainsKey("password") ? dicParas["password"].ToString() : string.Empty;
string imgCode = dicParas.ContainsKey("imgCode") ? dicParas["imgCode"].ToString() : string.Empty;
//验证码
if (!ValidateImgCache.Exist(imgCode.ToUpper()))
{
return(ResponseModelFactory.CreateModel(isSignKeyReturn, Return_Code.T, "", Result_Code.F, "验证码无效"));
}
ValidateImgCache.Remove(imgCode.ToUpper());
IAdminUserService adminUserService = BLLContainer.Resolve <IAdminUserService>();
var model = adminUserService.GetModels(p => p.Mobile.Equals(userMobile)).FirstOrDefault <t_AdminUser>();
if (model == null)
{
return(ResponseModelFactory.CreateModel(isSignKeyReturn, Return_Code.T, "", Result_Code.F, "用户不存在"));
}
else
{
if (model.Password.Equals(password))
{
string token = XCGameManaAdminUserTokenBusiness.SetToken(model.Mobile, model.Id);
var obj = new { token = token };
return(ResponseModelFactory.CreateAnonymousSuccessModel(isSignKeyReturn, obj));
}
else
{
return(ResponseModelFactory.CreateModel(isSignKeyReturn, Return_Code.T, "", Result_Code.F, "密码不正确"));
}
}
}
public StatisticsController(IFolloweeStatisticsService followeeStatisticsService, ITweetStatisticsService tweetStatisticsService, IStatisticsService statisticsService, IAdminUserService adminUserSevice)
{
this.followeeStatisticsService = followeeStatisticsService ?? throw new ArgumentNullException(nameof(followeeStatisticsService));
this.tweetStatisticsService = tweetStatisticsService ?? throw new ArgumentNullException(nameof(tweetStatisticsService));
this.statisticsService = statisticsService ?? throw new ArgumentNullException(nameof(statisticsService));
this.adminUserSevice = adminUserSevice ?? throw new ArgumentNullException(nameof(adminUserSevice));
}
public AuthorizationServerProvider(IUserService userService, IAdminUserService adminUserService,
IAppService appService, ICommandBus commandBus)
{
this.userService = userService;
this.adminUserService = adminUserService;
this.appService = appService;
this.commandBus = commandBus;
}
//public HomeController(TestService testservice)
//{
// this.testservice = testservice;
//}
public HomeController(IAdminUserService adminuserservice, IUserService userservice, IHostingEnvironment hostevn, IMemoryCache memoryCache, ILogger <HomeController> logger)
{
this.adminuserservice = adminuserservice;
this.userservice = userservice;
this.hostevn = hostevn;
_cache = memoryCache;
this.logger = logger;
}
public IActionResult About()
{
//ViewData["Message"] = "Your application description page.";
IAdminUserService service = (IAdminUserService)HttpContext.RequestServices.GetService(typeof(IAdminUserService));
service.GetPwd("aa");
return(View());
}
public AdminUsersController(IAdminUserService adminUserService,
IMapper mapper,
ICsvPublishServiceFactory csvPublishServiceFactory)
{
_adminUserService = adminUserService;
_mapper = mapper;
_csvPublishServiceFactory = csvPublishServiceFactory;
}
public UsersController(RoleManager <IdentityRole> roleManager, UserManager <User> userManager, IAdminUserService adminUserService, IUserService userService, IOrderService orderService)
{
this.roleManager = roleManager;
this.userManager = userManager;
this.adminUserService = adminUserService;
this.userService = userService;
this.orderService = orderService;
}
public AdminUsersController(IAdminUserService adminUserService,
IMapper mapper,
ICsvPublishServiceFactory csvPublishServiceFactory)
{
_adminUserService = adminUserService;
_mapper = mapper;
_csvPublishServiceFactory = csvPublishServiceFactory;
}
public AuthorizationServerProvider(IUserService userService, IAdminUserService adminUserService,
IAppService appService, ICommandBus commandBus)
{
this.userService = userService;
this.adminUserService = adminUserService;
this.appService = appService;
this.commandBus = commandBus;
}
public AdminUsersController(IAdminUserService users,
IAdminSpecialtyService specialties,
IAdminMedCenterService medCenters)
{
this.users = users;
this.specialties = specialties;
this.medCenters = medCenters;
}
public UsersController(UserManager <User> userManager,
RoleManager <IdentityRole> roleManager,
IAdminUserService users)
: base(userManager)
{
this.roleManager = roleManager;
this.users = users;
}
public void OnAuthorization(AuthorizationContext filterContext)
{
CheckPermissionAttribute[] perAttrs = (CheckPermissionAttribute[])filterContext.ActionDescriptor.GetCustomAttributes(typeof(CheckPermissionAttribute), false);
if (perAttrs.Length <= 0)
{
return;
}
long?userId = (long?)filterContext.HttpContext.Session["LoginUserId"];
if (userId == null)
{
if (filterContext.HttpContext.Request.IsAjaxRequest())
{
AjaxResult ajaxResult = new AjaxResult();
ajaxResult.Status = "redirect";
ajaxResult.Data = "/Main/Login";
ajaxResult.ErrorMsg = "请登录";
filterContext.Result = new JsonNetResult()
{
Data = ajaxResult
};
return;
}
else
{
filterContext.Result = new RedirectResult("/Main/Login");
return;
}
}
IAdminUserService adminUserServ = (IAdminUserService)DependencyResolver.Current.GetService(typeof(IAdminUserService));
foreach (var perAttr in perAttrs)
{
if (!adminUserServ.HasPermission((long)userId, perAttr.Permission))
{
if (filterContext.HttpContext.Request.IsAjaxRequest())
{
AjaxResult ajaxResult = new AjaxResult();
ajaxResult.Status = "error";
ajaxResult.ErrorMsg = $"没有{perAttr.Permission}权限";
filterContext.Result = new JsonNetResult()
{
Data = ajaxResult
};
return;
}
else
{
filterContext.Result = new ContentResult()
{
Content = $"没有{perAttr.Permission}权限"
};
return;
}
}
}
}
public AppStateProvider(IAdminUserService adminUserService, AuthenticationStateProvider authenticationStateProvider)
{
var user = authenticationStateProvider.GetAuthenticationStateAsync().Result.User;
if (user.Identity.IsAuthenticated && int.TryParse(user.Claims.FirstOrDefault(m => m.Type.ToString() == "UserGuid").Value, out int userGuid))
{
_adminUserEntity = adminUserService.GetAdminUser(userGuid);
}
}
public AdminsController
(
IAdminUserService adminUserService,
ILogger <AdminsController> logger,
IUrlHelper urlHelper
) : base(logger, urlHelper)
{
_adminUserService = adminUserService;
}
public HomeController(Person person, User user, IAdminUserService au, ILogService log /*, IMemoryCache _cache*/)
{
this.person = person;
this.user = user;
this.au = au;
this.log = log;
//this.hostingEnvironment = hostingEnvironment;
//this._cache = _cache;
}
public AdminsController(
IAdminUserService adminUserService,
IMapper mapper,
IAutofillValuesService autofillValuesService)
{
_adminUserService = adminUserService;
_mapper = mapper;
_autofillValuesService = autofillValuesService;
}
//由于此类不归AutoFac管治，因此无法注入
// public IAdminUserService userService { get; set; }
public void OnAuthorization(AuthorizationContext filterContext)
{
//获得当前要执行的Action上标注的CheckPermissionAttribute实例对象
CheckPermissionAttribute[] permAttrs = (CheckPermissionAttribute[])filterContext.ActionDescriptor
.GetCustomAttributes(typeof(CheckPermissionAttribute), false);
if (permAttrs.Length == 0)
{
//没有标注任何的CheckPermissionAttribute
return;
}
//得到当前登录用户ID
long?userId = (long?)filterContext.HttpContext.Session["LoginUserId"];
if (userId == null)
{
//修改filterContext.Result，真正的Action方法就不会执行了
filterContext.Result = new ContentResult()
{
Content = "没有登录"
};
return;
}
else
{
//由于ZSZAuthorizationFilter不是被AutoFac创建，因此不会自动进行属性的注入
//需要手动获取Service对象
IAdminUserService userService = DependencyResolver.Current.GetService <IAdminUserService>();
//检查权限，用Action上的Attribute跟数据库中用户的权限对比
foreach (var permAttr in permAttrs)
{
if (!userService.HasPermission(userId.Value, permAttr.Permission))
{
if (filterContext.HttpContext.Request.IsAjaxRequest())
{
filterContext.Result = new JsonNetResult
{
Data = new AjaxResult
{
Status = "redirect",
ErrorMsg = "没有权限",
Data = "/Main/Login",
},
};
}
else
{
filterContext.Result = new ContentResult
{
Content = $"没有{permAttr.Permission}权限",
};
}
return;
}
}
}
}
public UsersController(
IAdminUserService adminUserService,
RoleManager <IdentityRole> roleManager,
UserManager <User> userManager)
{
_adminUserService = adminUserService;
_roleManager = roleManager;
_userManager = userManager;
}
public UsersController(
IAdminUserService admins,
UserManager <User> userManager,
RoleManager <IdentityRole> roleManager)
{
this.users = admins;
this.userManager = userManager;
this.roleManager = roleManager;
}
public UsersController(
IAdminUserService users,
UserManager <User> userManager,
RoleManager <Role> roleManager)
{
this.users = users;
this.userManager = userManager;
this.roleManager = roleManager;
}
public UsersController(
UserManager <User> userManager,
IAdminUserService users,
SignInManager <User> signInManager)
{
this.userManager = userManager;
this.users = users;
this.signInManager = signInManager;
}
//public IAdminUserService AdminUserService { get; set; }
public void OnAuthorization(AuthorizationContext filterContext)
{
IAdminUserService AdminUserService = DependencyResolver.Current.GetService <IAdminUserService>();
CustomPermissionAttribute[] permAttr = (CustomPermissionAttribute[])filterContext.ActionDescriptor.GetCustomAttributes(typeof(CustomPermissionAttribute), false);
if (permAttr.Length == 0)
{
return;
}
long?userId = (long?)filterContext.HttpContext.Session["LoginUserId"];
if (userId == null)
{
//filterContext.Result = new ContentResult() { Content = "没有登录" };
if (filterContext.HttpContext.Request.IsAjaxRequest())
{
AjaxResult ajaxResult = new AjaxResult();
ajaxResult.Status = "redirect";
ajaxResult.Data = "/Main/Login";
ajaxResult.ErrorMsg = "没有登录";
filterContext.Result = new JsonNetResult()
{
Data = ajaxResult
};
}
else
{
filterContext.Result = new RedirectResult("/Main/Login");
}
return;
}
foreach (var attr in permAttr)
{
if (!AdminUserService.HasPermission(userId.Value, attr.Permission))
{
if (filterContext.HttpContext.Request.IsAjaxRequest())
{
AjaxResult ajaxResult = new AjaxResult();
ajaxResult.Status = "error";
ajaxResult.ErrorMsg = "没有权限" + attr.Permission;
filterContext.Result = new JsonNetResult()
{
Data = ajaxResult
};
}
else
{
filterContext.Result = new ContentResult()
{
Content = "对不起，你没有权限"
};
}
return;
}
}
}
public ExampleProjectService(
IProjectService projectService,
IAdminUserService adminUserService,
IFileSystem fileSystem,
IFileUriProvider uriProvider,
ICommentRepository commentRepository,
IUserRepository userRepository,
IUserAvatarProvider userAvatarProvider,
IMapper mapper)
{
_projectService = projectService;
_adminUserService = adminUserService;
_fileSystem = fileSystem;
_uriProvider = uriProvider;
_commentRepository = commentRepository;
_userRepository = userRepository;
_userAvatarProvider = userAvatarProvider;
_mapper = mapper;
}
public CartController(IAdminCartService service, IAdminUserService userService)
{
this.cartService = service;
this.userService = userService;
}
public UsersController(IUserService userService, IAdminUserService adminUserService, IUserAvatarProvider avatarProvider)
{
_userService = userService;
_adminUserService = adminUserService;
_avatarProvider = avatarProvider;
}
public RoleUsersController(IAdminUserService adminUserService)
{
_adminUserService = adminUserService;
}
public UserController(IAdminUserService service)
{
this.userService = service;
}
