public CspMiddleware(AppFunc next, ICspConfiguration options, bool reportOnly)
{
_next = next;
_config = options;
_reportOnly = reportOnly;
var headerGenerator = new HeaderGenerator();
_headerResult = headerGenerator.CreateCspResult(_config, reportOnly);
}
public XContentTypeOptionsMiddleware(RequestDelegate next)
: base(next)
{
_config = new SimpleBooleanConfiguration {
Enabled = true
};
var headerGenerator = new HeaderGenerator();
_headerResult = headerGenerator.CreateXContentTypeOptionsResult(_config);
}
public XDownloadOptionsMiddleware(AppFunc next)
: base(next)
{
_config = new SimpleBooleanConfiguration {
Enabled = true
};
var headerGenerator = new HeaderGenerator();
_headerResult = headerGenerator.CreateXDownloadOptionsResult(_config);
}
public void HandleHeaderResult_SetHeaderResult_SetsHeader()
{
var headerResult = new HeaderResult(HeaderResult.ResponseAction.Set, "NinjaHeader", "value");
_resultHandler.HandleHeaderResult(_httpResponse, headerResult);
Assert.AreEqual(1, _responseHeaders.Count);
var headerValue = _responseHeaders.Get("NinjaHeader");
Assert.IsNotNull(headerValue);
Assert.AreEqual("value", headerValue);
}
/// <summary>
/// 根据角色Id查询出已经分配的用户组
/// </summary>
/// <param name="roleId"></param>
/// <returns></returns>
public async Task <HeaderResult <List <Guid> > > GetUserGroupUnRoleList(Guid roleId)
{
var roleList = await _userGroupUnRoleRepository.WhereLoadEntityListAsNoTrackingAsync(e => e.RoleId == roleId);
HeaderResult <List <Guid> > result = new HeaderResult <List <Guid> >
{
IsSucceed = true,
Result = roleList.Select(e => e.UserGroupId).ToList()
};
return(result);
}
public void HandleHeaderResult_SetHeaderResult_SetsHeader()
{
var headerResult = new HeaderResult(HeaderResult.ResponseAction.Set, "NinjaHeader", "value");
_resultHandler.HandleHeaderResult(_httpResponse, headerResult);
Assert.Equal(1, _responseHeaders.Count);
var headerValue = _responseHeaders["NinjaHeader"].SingleOrDefault();
Assert.NotNull(headerValue);
Assert.Equal("value", headerValue);
}
/// <summary>
/// 根据角色Id查询角色信息
/// </summary>
/// <returns></returns>
public async Task <HeaderResult <RoleDto> > GetRole(Guid roleId)
{
var roleInfo = await _roleRepository.WhereLoadEntityAsNoTrackingAsync(e => e.Id == roleId);
var roleDto = roleInfo.MapTo <RoleInfo, RoleDto>();
HeaderResult <RoleDto> result = new HeaderResult <RoleDto>
{
IsSucceed = true,
Result = roleDto
};
return(result);
}
/// <summary>
/// 删除用户组
/// </summary>
/// <param name="userGroupId"></param>
/// <returns></returns>
public async Task <HeaderResult <string> > DelUserGroup(string userGroupId)
{
var userGroup = await _userGroupRepository.WhereLoadEntityAsync(e => e.Id == Guid.Parse(userGroupId));
userGroup?.DelUserGroup();
_userGroupRepository.UpdateEntity(userGroup);
_userGroupRepository.Commit();
HeaderResult <string> result = new HeaderResult <string>
{
IsSucceed = true,
Message = "删除成功!"
};
return(result);
}
/// <summary>
/// 删除用户组
/// </summary>
/// <param name="roleId"></param>
/// <returns></returns>
public async Task <HeaderResult <string> > DelRole(Guid roleId)
{
var role = await _roleRepository.WhereLoadEntityAsync(e => e.Id == roleId);
role?.DelRole();
_roleRepository.UpdateEntity(role);
_roleRepository.Commit();
HeaderResult <string> result = new HeaderResult <string>
{
IsSucceed = true,
Message = "删除成功!"
};
return(result);
}
/// <summary>
/// 添加用户组
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public async Task <HeaderResult <string> > AddUserGroup(UserGroupDto input)
{
var userGroupEntity = new UserGroupInfo().CreateUserGroup(input.UserGroupName, input.CreateUserId, input.CreateUserName);
await _userGroupRepository.AddEntityAsync(userGroupEntity);
await _userGroupRepository.CommitAsync();
HeaderResult <string> result = new HeaderResult <string>
{
IsSucceed = true,
Message = "添加成功!"
};
return(result);
}
/// <summary>
/// 根据条件查询用户组信息
/// </summary>
/// <param name="groupId"></param>
/// <returns></returns>
public async Task <HeaderResult <UserGroupDto> > GetUserGroup(Guid groupId)
{
var userGroup =
await _userGroupRepository.WhereLoadEntityAsNoTrackingAsync(e => e.Id == groupId);
var userGroupDto = userGroup.MapTo <UserGroupInfo, UserGroupDto>();
HeaderResult <UserGroupDto> result = new HeaderResult <UserGroupDto>
{
IsSucceed = true,
Result = userGroupDto
};
return(result);
}
/// <summary>
/// 修改角色
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public async Task <HeaderResult <string> > EditRole(AddRoleDto input)
{
var role = await _roleRepository.WhereLoadEntityAsync(e => e.Id == input.RoleId);
role?.EditRole(input.RoleName, input.RoleType, input.RoleDescription);
_roleRepository.UpdateEntity(role);
await _roleRepository.CommitAsync();
HeaderResult <string> result = new HeaderResult <string>
{
IsSucceed = true,
Message = "修改成功!"
};
return(result);
}
/// <summary>
/// 修改用户
/// </summary>
/// <returns></returns>
public HeaderResult <string> EditUser()
{
var user = _userRepository.WhereLoadEntity(e =>
e.Id == Guid.Parse("89BFD2F5-F2E2-4182-BA70-3431022C65D6"));
user.ModifyUser("测试并发修改");
_userRepository.Commit();
var result = new HeaderResult <string>
{
IsSucceed = true,
Message = "添加成功!"
};
return(result);
}
/// <summary>
/// 添加用户
/// </summary>
/// <returns></returns>
public async Task <HeaderResult <string> > AddUser(AddUserDto input)
{
Address address = new Address(input.Province, input.City, input.County, input.AddressDetails);
UserInfo user = new UserInfo().CreateUser(input.UserName, input.UserPassword, input.UserPhone, address, new Guid(), "管理员");
await _userRepository.AddEntityAsync(user);
await _userRepository.CommitAsync();
var result = new HeaderResult <string>
{
IsSucceed = true,
Message = "添加成功!"
};
return(result);
}
/// <summary>
/// 修改用户组
/// </summary>
/// <param name="userGroupName"></param>
/// <param name="groupId"></param>
/// <returns></returns>
public async Task <HeaderResult <string> > EditUserGroup(string userGroupName, Guid groupId)
{
var userGroup = await _userGroupRepository.WhereLoadEntityAsync(e => e.Id == groupId);
userGroup?.EditUserGroup(userGroupName);
_userGroupRepository.UpdateEntity(userGroup);
await _userGroupRepository.CommitAsync();
HeaderResult <string> result = new HeaderResult <string>
{
IsSucceed = true,
Message = "修改成功!"
};
return(result);
}
public void HandleHeaderResult(HttpResponse response, HeaderResult result)
{
if (result == null)
{
return;
}
switch (result.Action)
{
case HeaderResult.ResponseAction.Set:
response.Headers[result.Name] = result.Value;
return;
case HeaderResult.ResponseAction.Remove:
response.Headers.Remove(result.Name);
return;
}
}
public HeaderResult Get(string name, string build)
{
Console.WriteLine("Handling headers for " + name + " (" + build + ")");
var result = new HeaderResult();
var storage = DBCManager.LoadDBC(name, build);
if (storage.Values.Count == 0)
{
throw new Exception("No rows found!");
}
if (!DefinitionManager.definitionLookup.ContainsKey(name))
{
throw new KeyNotFoundException("Definition for " + name);
}
var definition = DefinitionManager.definitionLookup[name];
var fields = DefinitionManager.definitionCache[(name, build)].GetFields();
public void HandleHeaderResult(IHttpContextWrapper httpContext, HeaderResult result)
{
if (result == null)
{
return;
}
switch (result.Action)
{
case HeaderResult.ResponseAction.Set:
httpContext.SetHttpHeader(result.Name, result.Value);
return;
case HeaderResult.ResponseAction.Remove:
httpContext.RemoveHttpHeader(result.Name);
return;
default:
throw new ArgumentOutOfRangeException();
}
}
public void Setup()
{
_contextHelper = new Mock <IContextConfigurationHelper>(MockBehavior.Strict);
_configurationOverrideHelper = new Mock <IHeaderConfigurationOverrideHelper>(MockBehavior.Strict);
_headerGenerator = new Mock <IHeaderGenerator>(MockBehavior.Strict);
_expectedHeaderResult = new HeaderResult(HeaderResult.ResponseAction.Set, "ExpectedHeader", "ninjavalue");
_headerResultHandler = new Mock <IHeaderResultHandler>(MockBehavior.Strict);
_headerResultHandler.Setup(h => h.HandleHeaderResult(It.IsAny <HttpResponseBase>(), _expectedHeaderResult));
_cspConfigurationOverrideHelper = new Mock <ICspConfigurationOverrideHelper>(MockBehavior.Strict);
_reportHelper = new Mock <ICspReportHelper>(MockBehavior.Strict);
_overrideHelper = new HeaderOverrideHelper(_contextHelper.Object,
_configurationOverrideHelper.Object,
_headerGenerator.Object,
_headerResultHandler.Object,
_cspConfigurationOverrideHelper.Object,
_reportHelper.Object);
_mockContext = new Mock <HttpContextBase>().Object;
}
/// <summary>
/// 获取角色的信息
/// </summary>
/// <returns></returns>
public async Task <HeaderResult <List <RoleDto> > > GetRoleList(SearchRoleDto input)
{
Expression <Func <RoleInfo, bool> > where = e => true;
if (!string.IsNullOrEmpty(input.SearchRoleName))
{
where = where.And(e => e.RoleName.Contains(input.SearchRoleName));
}
var roleList = await _roleRepository.LoadEntityListAsync(where, e => e.RoleName, "asc", input.PageIndex, input.Pagesize);
var total = await _roleRepository.GetEntitiesCountAsync(where);
var roleDtoList = roleList.MapToList <RoleInfo, RoleDto>();
HeaderResult <List <RoleDto> > result = new HeaderResult <List <RoleDto> >
{
IsSucceed = true,
Result = roleDtoList,
Total = total
};
return(result);
}
/// <summary>
/// 添加角色
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public async Task <HeaderResult <string> > AddRole(AddRoleDto input)
{
var roleInfo = await _roleRepository.LoadEntityMaxSortAsync(e => e.RoleShot);
var shotIndex = 1;
if (roleInfo != null)
{
shotIndex = roleInfo.RoleShot + 1;
}
var userRoleEntity = new RoleInfo().CreateRole(input.RoleName, input.RoleType, input.RoleDescription, shotIndex);
await _roleRepository.AddEntityAsync(userRoleEntity);
await _roleRepository.CommitAsync();
HeaderResult <string> result = new HeaderResult <string>
{
IsSucceed = true,
Message = "添加成功!"
};
return(result);
}
/// <summary>
/// 分配用户组
/// </summary>
/// <param name="groupId"></param>
/// <param name="userIdStr"></param>
/// <returns></returns>
public async Task <HeaderResult <string> > AssignUserGroup(Guid groupId, string userIdStr)
{
await _userUnGroupRepository.DelEntityAsync(e => e.UserGroupId == groupId);
List <UserUnGroup> userUnGroupList = new List <UserUnGroup>();
var userArry = userIdStr.Split(",");
foreach (var item in userArry)
{
var userUnGroup = new UserUnGroup().CreateUserUnGroup(groupId, Guid.Parse(item));
userUnGroupList.Add(userUnGroup);
}
await _userUnGroupRepository.AddRangeAsync(userUnGroupList);
await _userUnGroupRepository.CommitAsync();
HeaderResult <string> result = new HeaderResult <string>
{
IsSucceed = true,
Message = "分配成功!"
};
return(result);
}
/// <summary>
/// 分配用户组角色
/// </summary>
/// <param name="roleId"></param>
/// <param name="userGroupIdStr"></param>
/// <returns></returns>
public async Task <HeaderResult <string> > AssignGroupRole(Guid roleId, string userGroupIdStr)
{
await _userGroupUnRoleRepository.DelEntityAsync(e => e.RoleId == roleId);
List <UserGroupUnRole> userGroupRoleList = new List <UserGroupUnRole>();
var userGroupArry = userGroupIdStr.Split(",");
foreach (var item in userGroupArry)
{
var userGroupRole = new UserGroupUnRole().CreateUserGroupUnRole(Guid.Parse(item), roleId);
userGroupRoleList.Add(userGroupRole);
}
await _userGroupUnRoleRepository.AddRangeAsync(userGroupRoleList);
await _userGroupUnRoleRepository.CommitAsync();
HeaderResult <string> result = new HeaderResult <string>
{
IsSucceed = true,
Message = "分配成功!"
};
return(result);
}
private static Message FailureMessage(HeaderResult<string> topic, HeaderResult<Guid> messageId)
{
var header = new MessageHeader(
messageId.Success ? messageId.Result : Guid.Empty,
topic.Success ? topic.Result : string.Empty,
MessageType.MT_UNACCEPTABLE);
var message = new Message(header, new MessageBody(string.Empty));
return message;
}
public ApiControllerBase()
{
Result = new HeaderResult <object>();
}
public async Task <HeaderResult> Get(string name, string build)
{
Logger.WriteLine("Serving headers for " + name + " (" + build + ")");
var result = new HeaderResult();
try
{
var storage = await dbcManager.GetOrLoad(name, build);
if (!dbdProvider.TryGetDefinition(name, out var definition))
{
throw new KeyNotFoundException("Definition for " + name);
}
result.headers = new List <string>();
result.fks = new Dictionary <string, string>();
result.comments = new Dictionary <string, string>();
result.unverifieds = new List <string>();
if (!storage.Values.Any())
{
for (var j = 0; j < storage.AvailableColumns.Length; ++j)
{
var fieldName = storage.AvailableColumns[j];
result.headers.Add(fieldName);
if (definition.columnDefinitions.TryGetValue(fieldName, out var columnDef))
{
if (columnDef.foreignTable != null)
{
result.fks.Add(fieldName, columnDef.foreignTable + "::" + columnDef.foreignColumn);
}
if (columnDef.comment != null)
{
result.comments.Add(fieldName, columnDef.comment);
}
if (!columnDef.verified)
{
result.unverifieds.Add(fieldName);
}
}
}
}
else
{
foreach (DBCDRow item in storage.Values)
{
for (var j = 0; j < storage.AvailableColumns.Length; ++j)
{
string fieldName = storage.AvailableColumns[j];
var field = item[fieldName];
if (field is Array a)
{
for (var i = 0; i < a.Length; i++)
{
result.headers.Add($"{fieldName}[{i}]");
if (definition.columnDefinitions.TryGetValue(fieldName, out var columnDef))
{
if (columnDef.foreignTable != null)
{
result.fks.Add($"{fieldName}[{i}]", columnDef.foreignTable + "::" + columnDef.foreignColumn);
}
if (columnDef.comment != null)
{
result.comments.Add($"{fieldName}[{i}]", columnDef.comment);
}
if (!columnDef.verified)
{
result.unverifieds.Add($"{fieldName}[{i}]");
}
}
}
}
else
{
result.headers.Add(fieldName);
if (definition.columnDefinitions.TryGetValue(fieldName, out var columnDef))
{
if (columnDef.foreignTable != null)
{
result.fks.Add(fieldName, columnDef.foreignTable + "::" + columnDef.foreignColumn);
}
if (columnDef.comment != null)
{
result.comments.Add(fieldName, columnDef.comment);
}
if (!columnDef.verified)
{
result.unverifieds.Add(fieldName);
}
}
}
}
break;
}
}
result.relationsToColumns = new Dictionary <string, List <string> >();
foreach (var column in result.headers)
{
var relationsToCol = dbdProvider.GetRelationsToColumn(name + "::" + column, true);
if (relationsToCol.Count > 0)
{
result.relationsToColumns.Add(column, relationsToCol);
}
}
}
catch (Exception e)
{
Logger.WriteLine("Error occured during serving data: " + e.Message);
result.error = e.Message.Replace(SettingManager.dbcDir, "");
}
return(result);
}
