/// <summary>
/// 显示权限点明细信息
/// </summary>
/// <returns></returns>
public IActionResult Detail(Author author)
{
var accessService = new AccessService();
var model = accessService.GetAccessById(author.Aid);
return(View(model));
}
public ActionResult AEdit(int id)
{
AccessService objService = new AccessService();
AccessModel objModel = new AccessModel();
objModel = objService.getByID(id);
QuotationService objService1 = new QuotationService();
List <DataCenterModel> ListDC = new List <DataCenterModel>();
ListDC = objService1.getDataCenter();
objModel.ListDC = new List <DataCenterModel>();
objModel.ListDC.AddRange(ListDC);
QuotationService objCompUSerService = new QuotationService();
List <CompanyModel> objCompList = new List <CompanyModel>();
objCompList = objCompUSerService.getActiveComp();
objModel.ListComp = new List <CompanyModel>();
objModel.ListComp.AddRange(objCompList);
List <UserModel> objUserList = new List <UserModel>();
objUserList = objCompUSerService.getActiveUser();
objModel.UserList = new List <UserModel>();
objModel.UserList.AddRange(objUserList);
var comp = Dbcontext.UserMasters.Where(m => m.UID == objModel.CreatedBy).SingleOrDefault();
int?cid = comp.CompID;
objModel.comp = cid;
return(View(objModel));
}
public IActionResult Apoint(Role role)
{
var roleService = new RoleService();
var model = roleService.GetRoleById(role.Rid);
var roleaccService = new RoleAccService();
var roacs = roleaccService.GetAIdByRId(role.Rid);
List <Author> accesslist = new List <Author>();
var accessService = new AccessService();
for (int i = 0; i < roacs.Count; i++)
{
var alist = accessService.GetAccessById(roacs[i].Aid.Value);
accesslist.Add(alist);
}
ViewData["Authors"] = accesslist;
var allAccessList = accessService.GetAll();
var unAuthorList = new List <Author>();
foreach (var author in allAccessList)
{
var isAdd = !accesslist.Exists(x => x.Aid == author.Aid);
if (isAdd)
{
unAuthorList.Add(author);
}
}
ViewData["UnAuthorList"] = unAuthorList;
return(View(model));
}
public DocumentsController(ApplicationDbContext context, PdfService pdf, UserManager <ApplicationUser> user, AccessService access)
{
_context = context;
_pdf = pdf;
_user = user;
_access = access;
}
public void DeleteProjectTest()
{
AccessService dbService = new AccessService();
//var projectUpdates = dbService.GetProjectUpdates("6a8a7e56-e9ac-4385-a8be-5be702c1f2e6");
UpdatePackage package = new UpdatePackage();
package.ProjectName = "Test Project";
package.Subject = "Deployment";
package.Body = "Environment:br549|Jimmy, toloose";
package.Updates.Add("verticalID", "3");
package.Updates.Add("Environment", "br549");
package.Updates.Add("Author", "Samantha");
package.Updates.Add("Manager", "Bocephus");
//__Adding this package should create a new Project and return the ProjectID as string
string stId = dbService.RecordUpdatePackage(package);
Assert.IsFalse(string.IsNullOrEmpty(stId));
Guid projectID = Guid.Parse(stId);
Assert.IsFalse(projectID == Guid.Empty);
Guid recordedId = dbService.GetProjectIDbyName(package.ProjectName);
Assert.AreEqual(projectID, recordedId);
// This is the actual test - let's see if it actually deletes the project
dbService.DeleteProject(projectID);
// When we look for updates, it should be null or empty.
// We will not test this part because the code crashes if you try and
// delete a project that does not exist and we are in code freeze.
// Assert.IsNull(dbService.GetAllUpdatesForProject(projectID.ToString()));
}
public TwitchBot(string _channelName)
{
//Init Client
twitchClient = new TwitchClient();
twitchPubSub = new TwitchPubSub();
//Init Database
this.db = new AppDbContextFactory().Create();
//Init access
accessService = new AccessService();
//Init Twitch API
api = new TwitchAPI();
api.Settings.ClientId = accessService.GetTwitchClientID();
api.Settings.AccessToken = accessService.GetTwitchAccessToken();
//Init services
this.achievementService = new AchievementService(db);
this.settingsService = new SettingsService(db);
this.pokemonService = new PokemonService(db);
userService = new UserService(db, api);
chatOutputService = new ChatOutputService(twitchClient, _channelName);
bossService = new BossService(userService, pokemonService, chatOutputService, settingsService);
userfightService = new UserfightService(userService, chatOutputService);
chatService = new ChatInputService(userService, chatOutputService, bossService, userfightService, achievementService);
destinationChannelName = _channelName;
Connect();
}
public void Can_Get_Only_CreatedByMe_Projects()
{
//Arrange
var projDbSet = new TestProjectDbSet();
var mockContext = new Mock <ISmartPlannerContext>();
string targetUserId = "123";
projDbSet.Add(new Project {
Id = 1, CreatorId = targetUserId
});
projDbSet.Add(new Project {
Id = 2, CreatorId = "124"
});
projDbSet.Add(new Project {
Id = 3, CreatorId = "125"
});
mockContext.Setup(m => m.Projects).Returns(projDbSet);
var accessService = new AccessService(mockContext.Object);
var projectService = new ProjectService(mockContext.Object, accessService);
//Act
var result = projectService.GetProjectsPaged(targetUserId, ProjectFilter.CreatedByMe);
//Assert
Assert.IsFalse(result.ErrorHandled);
Assert.AreEqual(result.TargetCollection.Count(), 1);
Assert.AreEqual(projDbSet.Count(), 3);
}
public void RecordUpdatePackageTest()
{
AccessService dbService = new AccessService();
//var projectUpdates = dbService.GetProjectUpdates("6a8a7e56-e9ac-4385-a8be-5be702c1f2e6");
UpdatePackage package = new UpdatePackage();
package.ProjectName = "Test Project";
package.Subject = "Deployment";
package.Body = "Environment:br549|Jimmy, toloose";
package.Updates.Add("verticalID", "3");
package.Updates.Add("Environment", "br549");
package.Updates.Add("Author", "Samantha");
package.Updates.Add("Manager", "Bocephus");
//__Adding this package should create a new Project and return the ProjectID as string
string stId = dbService.RecordUpdatePackage(package);
Assert.IsFalse(string.IsNullOrEmpty(stId));
Guid projectID = Guid.Parse(stId);
Assert.IsFalse(projectID == Guid.Empty);
Guid recordedId = dbService.GetProjectIDbyName(package.ProjectName);
Assert.AreEqual(projectID, recordedId);
dbService.DeleteProject(projectID);
}
public void GetAllVerticalsTest()
{
var dataAccess = new AccessService();
List <KeyValuePair <int, string> > verticalsList = dataAccess.GetAllVerticals();
// We can hardcode this because the verticals should never change. If it does,
// it shouldn't be very frequent and is reasonable to change this relatively unimportant unit test.
Assert.IsTrue(verticalsList[0].Key == 0);
Assert.IsTrue(verticalsList[0].Value == "Warehouse_Solutions");
Assert.IsTrue(verticalsList[1].Key == 1);
Assert.IsTrue(verticalsList[1].Value == "Merchandising_Solutions");
Assert.IsTrue(verticalsList[2].Key == 2);
Assert.IsTrue(verticalsList[2].Value == "Membership_Solutions");
Assert.IsTrue(verticalsList[3].Key == 3);
Assert.IsTrue(verticalsList[3].Value == "Distribution_Solutions");
Assert.IsTrue(verticalsList[4].Key == 4);
Assert.IsTrue(verticalsList[4].Value == "International_Solutions");
Assert.IsTrue(verticalsList[5].Key == 5);
Assert.IsTrue(verticalsList[5].Value == "Ancillary_Solutions");
Assert.IsTrue(verticalsList[6].Key == 6);
Assert.IsTrue(verticalsList[6].Value == "eBusiness_Solutions");
Assert.IsTrue(verticalsList[7].Key == 7);
Assert.IsTrue(verticalsList[7].Value == "Corporate_Solutions");
Assert.IsTrue(verticalsList[8].Key == -1);
Assert.IsTrue(verticalsList[8].Value == "Not_Assigned");
}
public void GetUserRoleTest()
{//__this covers AddUser, GetUserRole, DeleteUser, UpdateUserRole
string emailAddy = "*****@*****.**";
//string emailAddy2 = "*****@*****.**";
int userRole = 1;
AccessService dataAccess = new AccessService();
try//__make sure we can back out in case of errors
{
bool userAdded = dataAccess.AddUser(emailAddy, userRole);
//__test adding new user
Assert.IsTrue(userAdded, "AddUser returned false for email " + emailAddy + ", UserRole=" + userRole);
int recordedRole = dataAccess.GetUserRole(emailAddy);
Assert.AreEqual(userRole, recordedRole);
int newRole = 0;
dataAccess.UpdateUserRole(emailAddy, newRole);
recordedRole = dataAccess.GetUserRole(emailAddy);
Assert.AreEqual(newRole, recordedRole, "User Role not properly Modified");
bool userRemoved = dataAccess.DeleteUser(emailAddy);
Assert.IsTrue(userRemoved, "userRemoved returned false");
}
finally
{//__make sure to clean out our test data
if (dataAccess.IsUserAuthorized(emailAddy))
{
dataAccess.DeleteUser(emailAddy);
}
}
}
public void UpdateUserEmailTest2()
{
var dataAccess = new AccessService();
// Make sure that these domains are not there
Assert.IsFalse(dataAccess.IsUserAuthorized("*****@*****.**"));
Assert.IsFalse(dataAccess.IsUserAuthorized("*****@*****.**"));
Assert.IsFalse(dataAccess.IsUserAuthorized("*****@*****.**"));
// Make sure these updated email addresses do not exist
Assert.IsFalse(dataAccess.IsUserAuthorized("*****@*****.**"));
Assert.IsFalse(dataAccess.IsUserAuthorized("*****@*****.**"));
Assert.IsFalse(dataAccess.IsUserAuthorized("*****@*****.**"));
Guid userId = dataAccess.GetUserID("*****@*****.**");
Assert.IsTrue(userId == Guid.Empty);
// Make sure that you can add users
Assert.IsTrue(dataAccess.AddUser("*****@*****.**", 0));
Assert.IsTrue(dataAccess.AddUser("*****@*****.**", 1));
Assert.IsTrue(dataAccess.AddUser("*****@*****.**", 2));
// Check that the users are actually in the DB
Assert.IsTrue(dataAccess.IsUserAuthorized("*****@*****.**"));
Assert.IsTrue(dataAccess.IsUserAuthorized("*****@*****.**"));
Assert.IsTrue(dataAccess.IsUserAuthorized("*****@*****.**"));
Guid userIdCheck2 = dataAccess.GetUserID("*****@*****.**");
Assert.IsFalse(userIdCheck2 == Guid.Empty);
// Make sure these updated email addresses do not exist
Assert.IsFalse(dataAccess.IsUserAuthorized("*****@*****.**"));
Assert.IsFalse(dataAccess.IsUserAuthorized("*****@*****.**"));
Assert.IsFalse(dataAccess.IsUserAuthorized("*****@*****.**"));
// Now we are going to update these users - this is the main part
Assert.IsTrue(dataAccess.UpdateUserEmail("*****@*****.**", "*****@*****.**"));
Assert.IsTrue(dataAccess.UpdateUserEmail("*****@*****.**", "*****@*****.**"));
// Update it in the overloaded way
Guid userId3 = dataAccess.GetUserID("*****@*****.**");
Assert.IsTrue(dataAccess.UpdateUserEmail(userId3, "*****@*****.**"));
// Make sure that these domains are not there anymore
Assert.IsFalse(dataAccess.IsUserAuthorized("*****@*****.**"));
Assert.IsFalse(dataAccess.IsUserAuthorized("*****@*****.**"));
Assert.IsFalse(dataAccess.IsUserAuthorized("*****@*****.**"));
// Make sure these updated email addresses exist
Assert.IsTrue(dataAccess.IsUserAuthorized("*****@*****.**"));
Assert.IsTrue(dataAccess.IsUserAuthorized("*****@*****.**"));
Assert.IsTrue(dataAccess.IsUserAuthorized("*****@*****.**"));
// Clean up users
Assert.IsTrue(dataAccess.DeleteUser("*****@*****.**"));
Assert.IsTrue(dataAccess.DeleteUser("*****@*****.**"));
Assert.IsTrue(dataAccess.DeleteUser("*****@*****.**"));
}
public IActionResult UpdateAccess(Author author)
{
var accessService = new AccessService();
var ab = accessService.UpdateAccess(author.Aid, author.Aname, (int)author.Enabled);
return(Redirect(Url.Action("Index", "Access")));
}
public IActionResult DeleteAccess(Author author)
{
var accessService = new AccessService();
var authors = accessService.AccessDelete(author.Aid);
return(Redirect(Url.Action("Index", "Access")));
}
public IActionResult AddAccess(Author author)
{
var accessService = new AccessService();
var count = accessService.AccessAdd(author.Aname, (int)author.Enabled);
return(Redirect(Url.Action("Index", "Access")));
}
protected SearchModule(
string path,
ILogger logger,
AbstractValidator <T> abstractValidator,
AccessService accessService) : base(path, logger, abstractValidator, accessService)
{
}
public void ChangeProjectUpdatePhaseTest1()
{
AccessService dbService = new AccessService();
//var projectUpdates = dbService.GetProjectUpdates("6a8a7e56-e9ac-4385-a8be-5be702c1f2e6");
UpdatePackage package = new UpdatePackage();
package.ProjectName = "Test Getting Project Updates";
package.Subject = "Deployment";
package.Body = "Environment:br549|Jimmy, toloose";
package.Updates.Add("verticalID", "3");
package.Updates.Add("Environment", "br549");
package.Updates.Add("Author", "Samantha");
package.Updates.Add("Manager", "Bocephus");
//__Adding this package should create a new Project and return the ProjectID as string
string stId = dbService.RecordUpdatePackage(package);
Guid projectID = Guid.Parse(stId);
// Gotta convert this to a Project Update as opposed to a plain Update Project
List <ProjectUpdate> pjUpdates = dbService.GetProjectUpdates(stId);
pjUpdates[0].PhaseID = 4;
pjUpdates[0].Phase = "Build_and_Test"; // Don't think this needs to be done
dbService.ChangeProjectUpdatePhase(pjUpdates[0]);
List <ProjectUpdate> pjUpdateChanges = dbService.GetProjectUpdates(stId);
Assert.IsTrue(pjUpdateChanges[0].PhaseID == 4);
pjUpdateChanges[0].PhaseID = 5;
dbService.ChangeProjectUpdatePhase(pjUpdateChanges[0]);
List <ProjectUpdate> pjUpdateChangesMore = dbService.GetProjectUpdates(stId);
Assert.IsTrue(pjUpdateChangesMore[0].PhaseID == 5);
dbService.DeleteProject(projectID);
}
private static bool writeSampleData()
{
try
{
int totalRecords = 0;
DateTime start = DateTime.Now;
AccessService dataAccess = new AccessService();
List <ProjectUpdate> projects = UpdateGenerator.GenerateUpdates(numberOfProjectsToGenerate);
int numberOfProjects = projects.Count;
foreach (ProjectUpdate project in projects)
{
List <StatusUpdate> updates = project.StatusUpdates.ToList();
totalRecords += updates.Count;
dataAccess.RecordStatusUpdate(updates);
Console.WriteLine("Recorded " + updates.Count + " updates for Project ");
}
int durationInMinutes = (DateTime.Now - start).Minutes;
Console.WriteLine("Recorded " + totalRecords + " for " + numberOfProjects + " projects in " + durationInMinutes + "m");
}
catch (Exception e)
{
errorMessage = e.Message;
Console.Write("*******Error: " + errorMessage + "\n");
Console.Write("*******InnerException: " + e.InnerException + "\n");
Console.WriteLine("*********Detail: " + e.InnerException.Message + "\n");
return(false);
}
return(true);
}
public void IsUserAuthorizedTest()
{
var dataAccess = new AccessService();
// Make sure that these domains are not there
Assert.IsFalse(dataAccess.IsUserAuthorized("*****@*****.**"));
Assert.IsFalse(dataAccess.IsUserAuthorized("*****@*****.**"));
Assert.IsFalse(dataAccess.IsUserAuthorized("*****@*****.**"));
Guid userId = dataAccess.GetUserID("*****@*****.**");
Assert.IsTrue(userId == Guid.Empty);
// Make sure that you can add users
Assert.IsTrue(dataAccess.AddUser("*****@*****.**", 0));
Assert.IsTrue(dataAccess.AddUser("*****@*****.**", 1));
Assert.IsTrue(dataAccess.AddUser("*****@*****.**", 2));
// Check that the users are actually in the DB
Assert.IsTrue(dataAccess.IsUserAuthorized("*****@*****.**"));
Assert.IsTrue(dataAccess.IsUserAuthorized("*****@*****.**"));
Assert.IsTrue(dataAccess.IsUserAuthorized("*****@*****.**"));
Guid userIdCheck2 = dataAccess.GetUserID("*****@*****.**");
Assert.IsFalse(userIdCheck2 == Guid.Empty);
// Delete users
Assert.IsTrue(dataAccess.DeleteUser("*****@*****.**"));
Assert.IsTrue(dataAccess.DeleteUser("*****@*****.**"));
Assert.IsTrue(dataAccess.DeleteUser("*****@*****.**"));
}
public void Can_Get_All_Accessible_Projects()
{
//Arrange
var projUsersDbSet = new TestProjectUserAccessDbSet();
var mockContext = new Mock <ISmartPlannerContext>();
string targetUserId = "123";
projUsersDbSet.Add(new ProjectUserAccess {
UserId = targetUserId, Project = new Project {
Id = 1, CreatorId = targetUserId
}
});
projUsersDbSet.Add(new ProjectUserAccess {
UserId = targetUserId, Project = new Project {
Id = 2
}
});
projUsersDbSet.Add(new ProjectUserAccess {
UserId = "124", Project = new Project {
Id = 3
}
});
mockContext.Setup(m => m.ProjectUserAccesses).Returns(projUsersDbSet);
var accessService = new AccessService(mockContext.Object);
var projectService = new ProjectService(mockContext.Object, accessService);
//Act
var result = projectService.GetProjectsPaged(targetUserId);
//Assert
Assert.IsFalse(result.ErrorHandled);
Assert.AreEqual(result.TargetCollection.Count(), 2);
Assert.AreEqual(projUsersDbSet.Count(), 3);
}
public void GetProjectNameForIDTest()
{
var dataAccess = new AccessService();
// Grab a list of all the projects in the database
List <Project> allProjects = dataAccess.GetAllProjectNames();
// In case the database has just been wiped out...
if (allProjects.Count != 0)
{
// Pick a random project and get the ID and the (correct) project name
Random random = new Random();
int randomNumber = random.Next(0, allProjects.Count);
Guid randomProjectID = allProjects[randomNumber].ProjectID;
string randomProjectName = allProjects[randomNumber].ProjectName;
// Using the ID, use the function that we are testing to retrieve the projectname
string checkThisName = dataAccess.GetProjectNameForID(randomProjectID);
// Check if it is correct. boom.
Assert.AreEqual(checkThisName, randomProjectName);
}
else
{
Assert.Inconclusive("Database might be empty, try rerunning with data");
}
}
/// <summary>
/// Get function ,to get all the projects for specific vertical from data access layer.
/// It been used in project-list.js to show the project names on a ProjectList.html.
/// </summary>
/// <param name="VerticalId">VerticalId (int)index defined in the Verticals enum</param>
/// <returns>List of Project objects in format of json</returns>
public string GetVerticalProjects(int VerticalId)
{
AccessService DataAccess = new AccessService();
var passProjectList = new List <StatusUpdatesModel.Project>();
try {
if (this.Session["username"].ToString() != null && DataAccess.IsUserAuthorized(this.Session["username"].ToString()))
{
// AccessService DataAccess = new AccessService();
var VerticalProjects = DataAccess.GetAllProjectsForVertical(VerticalId);
foreach (StatusUpdatesModel.Project project in VerticalProjects)
{
StatusUpdatesModel.Project tempProject = new StatusUpdatesModel.Project();
tempProject.LatestUpdate = project.LatestUpdate;
tempProject.ProjectID = project.ProjectID;
tempProject.ProjectName = project.ProjectName;
passProjectList.Add(tempProject);
}
}
}
catch (Exception)
{
// Probably not the best way to handle this
string empty = JsonConvert.SerializeObject(passProjectList);
return(empty);
}
string result = JsonConvert.SerializeObject(passProjectList);
return(result);
}
public RemoteFileController(AttachService attachService
, TokenSerivce tokenSerivce
, NoteFileService noteFileService
, UserService userService
, ConfigFileService configFileService
, IHttpContextAccessor accessor
, AccessService accessService
, ConfigService configService
, TagService tagService
, NoteService noteService
, NotebookService notebookService
, IWebHostEnvironment webHostEnvironment
, ISevenZipCompressor sevenZipCompressor
, BlogService blogService
) :
base(attachService, tokenSerivce, noteFileService, userService, configFileService, accessor)
{
this.accessService = accessService;
this.blogService = blogService;
this.configService = configService;
this.tagService = tagService;
this.notebookService = notebookService;
this.noteService = noteService;
this.HostEnvironment = webHostEnvironment;
this.SevenZipCompressor = sevenZipCompressor;
if (RuntimeEnvironment.IsWindows)
{
PathRoot = @"C:\";
}
}
public IActionResult Apoint(Team team)
{
var groupService = new GroupService();
var model = groupService.GetGroupById(team.Gid);
var gracService = new GracService();
var gracs = gracService.GetAIdByGId(team.Gid);
List <Author> accesslist = new List <Author>();
var accessService = new AccessService();
for (int i = 0; i < gracs.Count; i++)
{
var alist = accessService.GetAccessById(gracs[i].Aid.Value);
accesslist.Add(alist);
}
ViewData["Authors"] = accesslist;
var allAccessList = accessService.GetAll();
var unAuthorList = new List <Author>();
foreach (var author in allAccessList)
{
var isAdd = !accesslist.Exists(x => x.Aid == author.Aid);
if (isAdd)
{
unAuthorList.Add(author);
}
}
ViewData["UnAuthorList"] = unAuthorList;
return(View(model));
}
/// <summary>
/// 分配权限点
/// </summary>
/// <param name="user"></param>
/// <returns></returns>
public IActionResult Apoint(User user)
{
var userService = new UserService();
var model = userService.GetUserById(user.Uid);
var useraccService = new UserAccService();
var useraccs = useraccService.GetAIdByUId(user.Uid);
List <Author> accesslist = new List <Author>();
var accessService = new AccessService();
for (int i = 0; i < useraccs.Count; i++)
{
var alist = accessService.GetAccessById(useraccs[i].Aid.Value);
accesslist.Add(alist);
}
ViewData["Authors"] = accesslist;
var allAccessList = accessService.GetAll();
var unAuthorList = new List <Author>();
foreach (var author in allAccessList)
{
var isAdd = !accesslist.Exists(x => x.Aid == author.Aid);
if (isAdd)
{
unAuthorList.Add(author);
}
}
ViewData["UnAuthorList"] = unAuthorList;
return(View(model));
}
public ActionResult postLogin(String username, String password)
{
if (Session["username"] == null)
{
UsrService service = new UsrService();
USR user = service.findById(username);
if (user == null)
{
return(RedirectToAction("Login", "Home"));
}
AccessService loginService = new AccessService();
String role = loginService.Login(username, password);
FormsAuthentication.SetAuthCookie(username, true);
Session["username"] = username;
if (role == "CANDIDATE")
{
return(RedirectToAction("Index", "Test"));
}
else if (role == "MANAGER")
{
return(RedirectToAction("Index", "Manager"));
}
else
{
return(RedirectToAction("Login", "Home"));
}
}
else
{
return(RedirectToAction("Index", "Home"));
}
}
private async Task <dynamic> GetCurrentUserPermissions()
{
var userPermissionRequest = this.Bind <UserInfoRequest>();
var isGrainEmpty = string.IsNullOrEmpty(userPermissionRequest.Grain);
await SetDefaultRequest(userPermissionRequest);
CheckReadAccess();
var permissionResolutionResult = await _permissionResolverService.Resolve(new PermissionResolutionRequest
{
SubjectId = SubjectId,
IdentityProvider = IdentityProvider,
Grain = userPermissionRequest.Grain,
SecurableItem = userPermissionRequest.SecurableItem,
IncludeSharedPermissions = isGrainEmpty,
UserGroups = await AccessService.GetGroupsForAuthenticatedUser(SubjectId, IdentityProvider, Context.CurrentUser)
});
var permissionRequestContexts = permissionResolutionResult.AllowedPermissions.Select(
p => new PermissionRequestContext
{
RequestedGrain = p.Grain,
RequestedSecurableItem = p.SecurableItem
}).Distinct(new PermissionRequestContextComparer());
return(new UserPermissionsApiModel
{
PermissionRequestContexts = permissionRequestContexts,
Permissions = permissionResolutionResult.AllowedPermissions
.Except(permissionResolutionResult.DeniedPermissions)
.Select(p => p.ToString())
});
}
private async Task InsertLogAsync(string url)
{
var headers = Request.Headers;
StringBuilder stringBuilder = new StringBuilder();
foreach (var item in headers)
{
stringBuilder.Append(item.Key + "---" + item.Value + "\r\n");
}
string RealIP = headers["X-Forwarded-For"].ToString().Split(",")[0];
AccessRecords accessRecords = new AccessRecords()
{
AccessId = SnowFlake_Net.GenerateSnowFlakeID(),
IP = RealIP,
X_Real_IP = headers["X-Real-IP"],
X_Forwarded_For = headers["X-Forwarded-For"],
Referrer = headers["Referer"],
RequestHeader = stringBuilder.ToString(),
AccessTime = DateTime.Now,
UnixTime = (long)(DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1))).TotalSeconds,
TimeInterval = -1,
url = url
};
await AccessService.InsertAccessAsync(accessRecords).ConfigureAwait(false);
}
public SecurableItemsModule(SecurableItemService securableItemService,
SecurableItemValidator validator,
AccessService accessService,
ClientService clientService,
GrainService grainService,
ILogger logger) : base("/v1/securableitems", logger, validator, accessService)
{
_clientService = clientService ??
throw new ArgumentNullException(nameof(clientService));
_grainService = grainService ??
throw new ArgumentNullException(nameof(grainService));
_securableItemService = securableItemService ??
throw new ArgumentNullException(nameof(securableItemService));
Get("/",
async _ => await GetSecurableItem().ConfigureAwait(false),
null,
"GetSecurableItem");
Get("/{securableItemId}",
async parameters => await this.GetSecurableItem(parameters).ConfigureAwait(false),
null,
"GetSecurableItemById");
Post("/{securableItemId}",
async parameters => await this.AddSecurableItem(parameters).ConfigureAwait(false),
null,
"AddSecurableItemById");
}
/// <summary>
/// 检查一般权限
/// </summary>
/// <param name="objName">对象名</param>
/// <param name="toCheckImpower">要检查的权限</param>
/// <returns></returns>
public static AuthType CheckNormalAuth(string objName, string toCheckImpower)
{
string denyParams = "";
string allowParams = "";
AuthType ret = AccessService.CheckPermissible(CurrentRoles, objName, toCheckImpower, out denyParams, out allowParams);
return(ret);
}
public void BeforeTest()
{
mockStorageManager = new Mock <InMemoryStorageManager>();
accessService = new AccessService(mockStorageManager.Object);
controller = new ValuesController(accessService);
InitializeApiController(controller);
}
public AccessServiceTests()
{
Repository = MockRepository.GenerateStub<IRepository>();
CallForProposalRepository = MockRepository.GenerateStub<IRepository<CallForProposal>>();
Repository.Expect(a => a.OfType<CallForProposal>()).Return(CallForProposalRepository);
TemplateRepository = MockRepository.GenerateStub<IRepository<Template>>();
Repository.Expect(a => a.OfType<Template>()).Return(TemplateRepository);
AccessService = new AccessService(Repository);
}
