public void UpdateUserGroup(Guid id, UpdateUserGroupRequest request)
{
request.Id = id;
IUserGroupService roleService = IoC.Container.Resolve <IUserGroupService>();
roleService.Update(request);
}
public IList <UserGroupListItemSummary> GetUserGroups()
{
IUserGroupService userGroupService = IoC.Container.Resolve <IUserGroupService>();
IList <UserGroupListItemSummary> userGroups = userGroupService.GetUserGroups();
return(userGroups);
}
protected void Page_Load(object sender, EventArgs e)
{
IUnityContainer container =
(IUnityContainer)HttpContext.Current.
Application["unityContainer"];
groupService = container.Resolve<IUserGroupService>();
}
private string _imuid = ""; //用户标识
#region ctor
/// <summary>
///
/// </summary>
/// <param name="imUserInfoService"></param>
public UserGroupController(IImUserInfoService imUserInfoService, IUserGroupService userGroupService, IChannelInfoService channelInfoService, IGroupInfoService groupInfoService)
{
_imUserInfoService = imUserInfoService;
_userGroupService = userGroupService;
_channelInfoService = channelInfoService;
_groupInfoService = groupInfoService;
}
public UserController(SecurityDbContext dbContext, UserManager <ApplicationUser> userManager, IUserGroupService userGroupService, IUserService userService)
{
_dbContext = dbContext;
_userManager = userManager;
_userGroupService = userGroupService;
_userService = userService;
}
public CatalogController(ICatalogService catalogService, IUserGroupService userGroupService, UserManager <ApplicationUser> userManager, ResourceManagementStrategy resourceManagementStrategy)
{
_catalogService = catalogService;
_userGroupService = userGroupService;
_userManager = userManager;
_resourceManagementStrategy = resourceManagementStrategy;
}
/// <summary>
///
/// </summary>
/// <param name="groupInfoService"></param>
/// <param name="imUserInfoService"></param>
/// <param name="userGroupService"></param>
public TempGroupController(IGroupInfoService groupInfoService, IImUserInfoService imUserInfoService,
IUserGroupService userGroupService)
{
_groupInfoService = groupInfoService;
_imUserInfoService = imUserInfoService;
_userGroupService = userGroupService;
}
public UserController(ILogger <ServiceController> logger, IUserService userService, IUserGroupService userGroupService, JwtHelper <DefaultJwtTokenModel> jwtHelper)
{
_logger = logger;
_userService = userService;
_userGroupService = userGroupService;
_jwtHelper = jwtHelper;
}
public UserGroupController(
IUserGroupService userGroupService,
IRoleService roleService)
{
this._userGroupService = userGroupService;
this._roleService = roleService;
}
public UserService(IUserRepository userRepository, IRoleService roleService, IUserGroupService userGroupService, IUnitOfWork unitOfWork)
: base(unitOfWork)
{
this._userRepository = userRepository;
this._roleService = roleService;
this._userGroupService = userGroupService;
}
public RbacController(
IDashboardService IDashboardService,
IRegisterService IRegisterService,
ITokenKeyService ITokenKeyService,
IUserGroupService IUserGroupService,
IUserService IUserService,
ISectionService ISectionService,
IRoleService IRoleService,
IFuncMenuService IFuncMenuService,
IPermissionGroupService IPermissionGroupService,
IPermissionRoleService IPermissionRoleService,
IPermissionFuncService IPermissionFuncService)
{
_IDashboardService = IDashboardService;
_IRegisterService = IRegisterService;
_ITokenKeyService = ITokenKeyService;
_IUserGroupService = IUserGroupService;
_IUserService = IUserService;
_IRoleService = IRoleService;
_ISectionService = ISectionService;
_IFuncMenuService = IFuncMenuService;
_IPermissionGroupService = IPermissionGroupService;
_IPermissionRoleService = IPermissionRoleService;
_IPermissionFuncService = IPermissionFuncService;
}
public LoginController(
IUserService userService,
IUserGroupService userGroupService
)
{
_userService = userService;
_userGroupService = userGroupService;
}
public ExerciseController(IHttpContextAccessor httpContextAccessor, IExerciseService exerciseService, IUserExerciseService userExerciseService, IUserGroupService roleService, IJwtHandler jwtHandler)
{
_httpContextAccessor = httpContextAccessor;
_exerciseService = exerciseService;
_userExerciseService = userExerciseService;
_roleService = roleService;
_jwtHandler = jwtHandler;
}
public ChatController(IUserGroupService userGroupService, IMessageService messageService, UserManager <IdentityUser> userManager, IHubContext <GroupHub> hub, IUserVsgroupService userVsgroupService)
{
this.userGroupService = userGroupService;
this.messageService = messageService;
this.userManager = userManager;
this.hub = hub;
this.userVsgroupService = userVsgroupService;
}
private void UserGroupsEndPoint(IUserGroupService userGroupService)
{
//*** "UserGroups" Graphql Route (endpoint) **//
// Tüm Kullanıcı Grupları - (Not : Kullanıcı gruplarının, ilişkili oldugu, tüm bölümler (alanlar, ilişki tablolar) UsersType Tanımlanıyor.)
//query { UserGroups { Id, Name } } -- Graphql Query
Field <ListGraphType <UserGroupType> >("UserGroups", resolve: ctx => userGroupService.All()).AddPermissions("user");;
}
public UserGroupController(IUserGroupService service, IMapper mapper, ILogger <UserGroupController> logger,
IHubContext <GroupHub, IGroupHubClient> hubContext)
{
_service = service;
_mapper = mapper;
_logger = logger;
_hubContext = hubContext;
}
public AccountController(ApplicationUserManager userManager,
ISecureDataFormat <AuthenticationTicket> accessTokenFormat, IUserGroupService userGroupService, IUserEventService userEventService)
{
UserManager = userManager;
AccessTokenFormat = accessTokenFormat;
_userGroupService = userGroupService;
_userEventService = userEventService;
}
public UserGroupQuery(IUserGroupService userGroupService)
{
Name = "UserGroupQuery";
Field <ListGraphType <UserGroupType> >("UserGroups", resolve: ctx => userGroupService.All());
Field <UserGroupType>(
"UserGroupID",
arguments: new QueryArguments(new QueryArgument <NonNullGraphType <IdGraphType> >
{
Name = "Id", Description = "UserGroup Id"
}),
resolve: context =>
{
var id = context.GetArgument <int>("Id");
if (id == 0)
{
context.Errors.Add(new ExecutionError("aaaa must be greater than zero!"));
return(new List <UserGroup>());
}
return(userGroupService.GetId(id));
}
);
/*
* FieldAsync<ListGraphType<GenericObjectGraphType<T>>>("query",
* arguments: new QueryArguments {
* new QueryArgument<IntGraphType> { Name = "skip", DefaultValue = 0 },
* new QueryArgument<IntGraphType> { Name = "take", DefaultValue = 10 },
* },
* resolve: async context =>
* {
* var skip = context.GetArgument<int>("skip");
* var take = context.GetArgument<int>("take");
* return await repository.Get().Skip(skip).Take(take).ToListAsync();
* });
* /
*
* /*
* FieldAsync<ListGraphType<AuthorType>>(
* name: "authors",
* resolve: async context => await authorService.GetAuthorsAsync()
* );
*
* var args = new QueryArguments(
* new QueryArgument<IdGraphType> { Name = "id" });
*
* FieldAsync<AuthorType>(
* name: "authorById",
* arguments: args,
* resolve: async context =>
* {
* var id = context.GetArgument<int>("id");
* return await authorService.GetAuthorByIdAsync(id);
* });
*/
}
public SimpleUserManageModel()
{
_userGroupService = HostContainer.GetInstance <IUserGroupService>();
UserGroups = _userGroupService.GetUserGroups();
UserGroupIds = new List <int>();
StatusList = EnumUtilities.GenerateSelectListItems <UserEnums.UserStatus>();
}
public CriteriaController(ICertificateService certificateService, IProductionEquipmentService productionEquipmentService, ISystemUserService systemUserService, IUnitService unitService, IUserGroupService userGroupService, ICriterionService criterionService)
{
this.certificateService = certificateService;
this.productionEquipmentService = productionEquipmentService;
this.systemUserService = systemUserService;
this.unitService = unitService;
this.userGroupService = userGroupService;
this.criterionService = criterionService;
}
public UserManageModel()
{
_userGroupService = HostContainer.GetInstance <IUserGroupService>();
UserGroups = _userGroupService.GetUserGroups();
Genders = EnumUtilities.GetAllItems <UserEnums.Gender>();
StatusList = EnumUtilities.GenerateSelectListItems <UserEnums.UserStatus>();
ManageSettingModel = new ManageSettingModel();
}
public static void MyClassInitialize(TestContext testContext)
{
Console.WriteLine(Assembly.GetExecutingAssembly().ToString());
container = TestManager.ConfigureUnityContainer("unity");
userProfileDao = container.Resolve<IUserProfileDao>();
userService = container.Resolve<IUserService>();
userGroupDao = container.Resolve<IUserGroupDao>();
userGroupService = container.Resolve<IUserGroupService>();
}
public TestAllocationController(ISampleReceivingService SampleReceivingService, ITestAllocationService TestAllocationService, IDropDownListService DropDownListService, IUOMService UOMService, IUserService UserService, IUserGroupService UserGroupService)
{
this.SampleReceivingService = SampleReceivingService;
this.TestAllocationService = TestAllocationService;
this.DropDownListService = DropDownListService;
this.UOMService = UOMService;
this.UserService = UserService;
this.userGroupService = UserGroupService;
}
/// <summary>
/// 用户管理初始化
/// </summary>
/// <param name="_userService"></param>
/// <param name="_userGroupService"></param>
public static void UserDataInitial(IUserService _userService, IUserGroupService _userGroupService)
{
long opId = 0, managerId = 1, adminId = 2;
UserGroup userGroup = _userGroupService.QueryableToEntity(x => x.group_code == "Operator");
if (userGroup == null)
{
userGroup = new UserGroup()
{
group_code = "Operator", group_name = "操作员", group_description = ""
};
opId = _userGroupService.InsertBigIdentity(userGroup);
}
userGroup = _userGroupService.QueryableToEntity(x => x.group_code == "Manager");
if (userGroup == null)
{
userGroup = new UserGroup()
{
group_code = "Manager", group_name = "管理员", group_description = ""
};
managerId = _userGroupService.InsertBigIdentity(userGroup);
}
userGroup = _userGroupService.QueryableToEntity(x => x.group_code == "Administrator");
if (userGroup == null)
{
userGroup = new UserGroup()
{
group_code = "Administrator", group_name = "系统管理员", group_description = ""
};
adminId = _userGroupService.InsertBigIdentity(userGroup);
}
SystemUser user = _userService.QueryableToEntity(x => x.user_name == "admin");
if (user == null)
{
user = new SystemUser()
{
user_name = "admin", user_password = "******", user_type = (int)adminId, create_time = DateTime.Now
};
_userService.Insert(user);
}
user = _userService.QueryableToEntity(x => x.user_name == "op");
if (user == null)
{
user = new SystemUser()
{
user_name = "op", user_password = "******", user_type = (int)opId, create_time = DateTime.Now
};
_userService.Insert(user);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="RoleController"/> class.
/// </summary>
public RoleController()
{
roleService = ServiceLocator.Current.GetInstance <IRoleService>();
roleLocaleService = ServiceLocator.Current.GetInstance <IRoleLocaleService>();
userService = ServiceLocator.Current.GetInstance <IUserService>();
userGroupService = ServiceLocator.Current.GetInstance <IUserGroupService>();
}
public UserController(IUserGroupService userGroupService,
IHttpRequest httpRequest,
IHttpContextAccessor httpContextAccessor,
HttpClientFactoryHelper httpClientFactory)
{
_userGroupService = userGroupService;
_httpRequest = httpRequest;
_httpContextAccessor = httpContextAccessor;
_httpClient = httpClientFactory;
}
public UserController(IUserService userService,
IDepartmentService departmentService,
IUserGroupService userGroupService,
IRoleService roleService)
{
this._userService = userService;
this._departmentService = departmentService;
this._userGroupService = userGroupService;
this._roleService = roleService;
}
/// <summary>
/// Initializes a new instance of the <see cref="RoleController"/> class.
/// </summary>
public RoleController()
{
roleService = ServiceLocator.Current.GetInstance<IRoleService>();
roleLocaleService = ServiceLocator.Current.GetInstance<IRoleLocaleService>();
userService = ServiceLocator.Current.GetInstance<IUserService>();
userGroupService = ServiceLocator.Current.GetInstance<IUserGroupService>();
}
public MembershipManager(IUserRepository userRepository, IUserGroupRepository userGroupRepository, IUserGroupService userGroupService, IRoleRepository roleRepository, IUserGroupRoleRepository userGroupRoleRepository, ICompanyService companyService, ICompanyRepository companyRepository)
{
_userRepository = userRepository;
_userGroupRepository = userGroupRepository;
_userGroupService = userGroupService;
_roleRepository = roleRepository;
_userGroupRoleRepository = userGroupRoleRepository;
_companyService = companyService;
_companyRepository = companyRepository;
}
public UserGroupsController(
IMapper mapper,
IOptions <AppSettings> appSettings,
IUserGroupService userGroupService,
IItemListService itemListService)
{
_mapper = mapper;
_appSettings = appSettings.Value;
_userGroupService = userGroupService;
_itemListService = itemListService;
}
public DocumentPermissionManageModel()
{
_companyService = HostContainer.GetInstance <ICompanyService>();
_companyTypeService = HostContainer.GetInstance <ICompanyTypeService>();
_userGroupService = HostContainer.GetInstance <IUserGroupService>();
_documentService = HostContainer.GetInstance <IDocumentService>();
Groups = _userGroupService.GetUserGroups();
Companies = _companyService.GetCompanies();
CompanyTypes = _companyTypeService.GetCompanyTypes();
}
/// <summary>
/// Builds the assignment model.
/// </summary>
/// <param name="user">The user.</param>
/// <returns></returns>
public static UserGroupToUserAssignmentModel BuildAssignmentModel(User user)
{
IUserGroupService userGroupService = ServiceLocator.Current.GetInstance <IUserGroupService>();
var allUserGroups = userGroupService.GetAll();
return(new UserGroupToUserAssignmentModel
{
User = new UserViewModel().MapFrom(user),
UserGroups = allUserGroups.Select(userGroup => BuildRoleAssignmentModel(user, userGroup)).ToArray()
});
}
public UserController(IUserService userService,
IUserGroupService userGroupService,
IDistrictService districtService,
IProvinceService provinceService)
: base()
{
this._userService = userService;
this._userGroupService = userGroupService;
this._districtService = districtService;
this._provinceService = provinceService;
}
public UserController(
IUserService userService,
IUserGroupService userGroupService,
IRoleService roleService,
MapperConfiguration mapperConfiguration)
{
this._userService = userService;
this._userGroupService = userGroupService;
this._roleService = roleService;
this._mapperConfiguration = mapperConfiguration;
}
public GroupController(IGroupService groupService, IUserGroupService userGroupService)
{
this.groupService = groupService;
this.userGroupService = userGroupService;
}
public UserGroupServiceTest()
{
_userGroupService = new UserGroupService(AccountModel);
}
public UserGroupController(IUserGroupService userGroupService)
{
this.userGroupService = userGroupService;
}
protected void Page_Load(object sender, EventArgs e)
{
lblNoGroups.Visible = false;
int startIndex, count;
/* Get Start Index */
try
{
startIndex = Int32.Parse(Request.Params.Get("startIndex"));
}
catch (ArgumentNullException)
{
startIndex = 0;
}
/* Get Count */
try
{
count = Int32.Parse(Request.Params.Get("count"));
}
catch (ArgumentNullException)
{
count = Settings.Default.PracticaMaD_defaultCount;
}
/* Get the Service */
IUnityContainer container =
(IUnityContainer)HttpContext.Current.
Application["unityContainer"];
groupService =
container.Resolve<IUserGroupService>();
/* Get Events Info */
if (SessionManager.IsUserAuthenticated(Context))
{
userId = SessionManager.GetUserSession(Context).UserProfileId;
}
GroupBlock groupBlock =
groupService.GetAllGroups(startIndex, count);
if (groupBlock.Groups.Count == 0)
{
lblNoGroups.Visible = true;
return;
}
gvGroups.DataSource = groupBlock.Groups;
gvGroups.DataBind();
/* "Previous" link */
if ((startIndex - count) >= 0)
{
String url =
Settings.Default.PracticaMaD_applicationURL +
"Pages/Group/SeeGroups.aspx" +
"?startIndex=" + (startIndex - count) + "&count=" +
count;
this.lnkPrevious.NavigateUrl =
Response.ApplyAppPathModifier(url);
this.lnkPrevious.Visible = true;
}
/* "Next" link */
if (groupBlock.ExistMoreGroups)
{
String url =
Settings.Default.PracticaMaD_applicationURL +
"Pages/Group/SeeGroups.aspx" +
"?startIndex=" + (startIndex + count) + "&count=" +
count;
this.lnkNext.NavigateUrl =
Response.ApplyAppPathModifier(url);
this.lnkNext.Visible = true;
}
}
