public async Task <IActionResult> Create(ApiResourceViewModel vm)
{
if (vm == null)
{
return(BadRequest());
}
if (ModelState.IsValid)
{
var obj = GetApiResource(vm);
_dbContext.ApiResources.Add(obj);
try
{
await _dbContext.SaveChangesAsync();
_logger.LogInformation($"API resource Id {obj.Id} created by {User?.Identity?.Name}.");
return(RedirectToAction("Index"));
}
catch (DbException ex)
{
_logger.LogError(ex.GetBaseException()?.Message ?? ex.Message);
throw;
}
}
return(View(vm));
}
public async Task <IActionResult> Edit([FromBody] ApiResourceViewModel apiResourceVM)
{
_context.Update(apiResourceVM.MapTo <ApiResource>());
await _context.SaveChangesAsync();
return(Ok());
}
private async Task <Response <string> > UpdateAsync(int id, ApiResourceViewModel viewModel)
{
//判断
var identityResource = await _configurationDbContext.ApiResources.FirstOrDefaultAsync(d => d.Name == viewModel.Name && d.Id != id);
if (identityResource != null)
{
return(new Response <string>(success: false, msg: "Api资源名称已存在!")
{
Data = "Api资源名称已存在!"
});
}
identityResource = viewModel;
_configurationDbContext.ApiResources.Update(identityResource);
var result = await _configurationDbContext.SaveChangesAsync();
if (result < 1)
{
return(new Response <string>(success: false, msg: "修改失败,请重试!")
{
Data = "修改失败,请重试!"
});
}
return(new Response <string>(msg: "修改成功!")
{
Data = "修改成功!"
});
}
public async Task <IActionResult> Edit(int id, ApiResourceViewModel apiResourceVM)
{
if (id != apiResourceVM.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(apiResourceVM.MapTo <ApiResource>());
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ApiResourceExists(apiResourceVM.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index), new { SuccessMessage = "Api Resource successfully edited." }));
}
return(View(apiResourceVM));
}
public async Task <IActionResult> Delete(ApiResourceViewModel vm)
{
if (vm == null)
{
return(BadRequest());
}
var apiResource = await _dbContext.ApiResources.FindAsync(vm.Id);
if (apiResource == null)
{
return(NotFound());
}
_dbContext.ApiResources.Remove(apiResource);
try
{
await _dbContext.SaveChangesAsync();
_logger.LogInformation($"API resource Id {vm.Id} removed by {User?.Identity?.Name}.");
return(RedirectToAction("Index"));
}
catch (DbException ex)
{
_logger.LogError(ex.GetBaseException()?.Message ?? ex.Message);
throw;
}
}
private async Task <Response <string> > AddAsync(ApiResourceViewModel viewModel)
{
//判断
var identityResource = await _configurationDbContext.ApiResources.FirstOrDefaultAsync(d => d.Name == viewModel.Name);
if (identityResource != null)
{
return(new Response <string>(success: false, msg: "Api资源名称已存在!")
{
Data = "Api资源名称已存在!"
});
}
identityResource = new IdentityServer4.EntityFramework.Entities.ApiResource
{
Name = viewModel.Name,
DisplayName = viewModel.DisplayName,
Description = viewModel.Description,
};
await _configurationDbContext.ApiResources.AddAsync(identityResource);
var result = await _configurationDbContext.SaveChangesAsync();
if (result < 1)
{
return(new Response <string>(success: false, msg: "注册失败,请重试!")
{
Data = "注册失败,请重试!"
});
}
return(new Response <string>(msg: "注册成功!")
{
Data = "注册成功!"
});
}
public ActionResult Edit(ApiResourceViewModel collection)
{
try
{
if (ModelState.IsValid)
{
ApiResourceEntity resource = new ApiResourceEntity()
{
//ApiSecrets = collection.ApiSecrets,
//Scopes = collection.Scopes,
Name = collection.Name,
//Enabled = collection.Enabled,
Description = collection.Description,
DisplayName = collection.DisplayName,
//UserClaims = collection.UserClaims
};
_resourceStoreExtended.EditApiResource(resource);
return(RedirectToAction(nameof(Index)));
}
return(View(collection));
}
catch
{
return(View());
}
}
public ActionResult Create(ApiResourceViewModel collection)
{
try
{
if (ModelState.IsValid)
{
ApiResourceEntity resource = new ApiResourceEntity()
{
//ApiSecrets = collection.ApiSecrets,
//Scopes = collection.Scopes,
Name = collection.Name,
Enabled = collection.Enabled,
Description = collection.Description,
DisplayName = collection.DisplayName,
//UserClaims = collection.UserClaims
};
// TODO: Add update logic here
_resourceStoreExtended.CreateApiResource(resource);
return(RedirectToAction(nameof(Index)));
}
else
{
return(View(collection));
}
}
catch
{
return(View());
}
}
public async Task <IActionResult> ViewAsync(int id, string returnUrl)
{
ViewData["ReturnUrl"] = returnUrl;
var resource = await _dbContext.ApiResources.FirstOrDefaultAsync(x => x.Id == id);
if (resource == null)
{
return(NotFound());
}
var claims = await _dbContext.ApiResourceClaims.Where(x => x.ApiResourceId == resource.Id)
.Select(x => x.Type)
.ToListAsync();
var viewModel = new ApiResourceViewModel
{
Name = resource.Name,
Enabled = resource.Enabled,
Description = resource.Description,
DisplayName = resource.DisplayName,
UserClaims = string.Join(" ", claims)
};
return(View("View", viewModel));
}
public IActionResult InsertApi(ApiResourceViewModel model)
{
if (ModelState.IsValid)
{
_contextConfig.Database.Migrate();
var api = _contextConfig.ApiResources.Count(m => m.Name == model.Name);
if (api == 0)
{
foreach (var resource in ClientMethod.GetApiResources(model))
{
_contextConfig.ApiResources.Add(resource.ToEntity());
}
try
{
_contextConfig.SaveChanges();
ViewData["Error"] = "服务端注册成功";
}
catch (Exception ex)
{
ViewData["Error"] = "服务端注册失败!错误:" + ex.ToString();
}
}
else;
{
ViewData["Error"] = "服务已存在！";
}
}
return View();
}
public static IEnumerable <ApiResource> GetApiResources(ApiResourceViewModel model)
{
return(new List <ApiResource>
{
new ApiResource(model.Name, model.DisplayName)
});
}
public async Task <IActionResult> Edit(ApiResourceViewModel vm)
{
if (vm == null)
{
return(BadRequest());
}
if (ModelState.IsValid)
{
var apiResource = await _dbContext.IdentityResources.FindAsync(vm.Id);
apiResource.Enabled = vm.Enabled;
apiResource.Name = vm.Name;
apiResource.DisplayName = vm.DisplayName;
apiResource.Description = vm.Description;
try
{
await _dbContext.SaveChangesAsync();
_logger.LogInformation($"API resource Id {apiResource.Id} updated by {User?.Identity?.Name}.");
return(RedirectToAction("Index"));
}
catch (DbException ex)
{
_logger.LogError(ex.GetBaseException()?.Message ?? ex.Message);
throw;
}
}
return(View(vm));
}
public async Task <IActionResult> Create(ApiResourceViewModel apiResourceVM)
{
if (ModelState.IsValid)
{
_context.Add(apiResourceVM.MapTo <ApiResource>());
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index), new { SuccessMessage = "Api Resource successfully created." }));
}
return(View(apiResourceVM));
}
private ApiResource GetApiResource(ApiResourceViewModel vm)
{
if (vm != null)
{
return(new ApiResource
{
Enabled = vm.Enabled,
Name = vm.Name,
DisplayName = vm.DisplayName,
Description = vm.Description,
});
}
return(null);
}
public async Task <Response <string> > Save([FromBody] ApiResourceViewModel viewModel)
{
var result = new Response <string>();
if (viewModel.Id > 0)
{
result = await UpdateAsync(viewModel.Id, viewModel);
}
else
{
result = await AddAsync(viewModel);
}
return(result);
}
public EditableApiResourceViewModel BuildEditableApiResourceViewModel(ModelStateDictionary modelState,
ApiResourceViewModel viewModel = null)
{
var claimTypesResult = m_claimTypeManager.GetAllClaimTypes();
if (claimTypesResult.HasError)
{
modelState.AddModelError(claimTypesResult.Error.Message);
}
var claimTypeViewModels = m_mapper.Map <IList <ClaimTypeViewModel> >(claimTypesResult.Result);
return(m_viewModelFactory.GetEditableApiResourceViewModel(claimTypeViewModels, viewModel));
}
public IActionResult AddApiResource(ApiResourceViewModel apiResourceViewModel)
{
if (!ModelState.IsValid)
{
return(View());
}
var apiResource = new ApiResourceModel(apiResourceViewModel.Name, apiResourceViewModel.DisplayName);
_configurationDbContext.ApiResources.Add(apiResource.ToEntity());
_configurationDbContext.SaveChanges();
_trackTelemetry.TrackEvent(EventName.AddApiResource, EventType.Action, EventStatus.Success);
return(RedirectToAction(nameof(Index)));
}
public async Task <IActionResult> Edit(string id)
{
ApiResource resource = await _resourceStoreExtended.FindApiResourcesByNameAsync(id);
ApiResourceViewModel vm = new ApiResourceViewModel()
{
ApiSecrets = resource.ApiSecrets,
UserClaims = resource.UserClaims,
Description = resource.Description,
DisplayName = resource.DisplayName,
Enabled = resource.Enabled,
Name = resource.Name,
Scopes = resource.Scopes
};
return(View(vm));
}
private async Task <ApiResourceViewModel> GetByIdAsync(int id)
{
var viewModel = new ApiResourceViewModel();
var model = await _configurationDbContext.ApiResources.FirstOrDefaultAsync(d => d.Id == id);
if (model != null)
{
viewModel = new ApiResourceViewModel
{
Id = model.Id,
Name = model.Name,
DisplayName = model.DisplayName,
Description = model.Description,
};
}
return(viewModel);
}
public async Task <ActionResult> RegisterApiResouce(ApiResourceViewModel resourceViewModel)
{
ActionResult Result = Ok();
IdentityServer4.Models.ApiResource Resource = new ApiResource
(resourceViewModel.Name, resourceViewModel.DisplayName);
if (!string.IsNullOrEmpty(resourceViewModel.Claim))
{
Resource.UserClaims = new[] { resourceViewModel.Claim };
}
Resource.Scopes = resourceViewModel.Scopes;
bool IsSuccess = await Repository.AddApiResource(Resource);
if (!IsSuccess)
{
Result = Problem("Error to add ApiResource", null, 500, "", null);
}
return(Result);
}
public IActionResult UpdateApiResource(ApiResourceViewModel apiResourceViewModel)
{
if (!ModelState.IsValid)
{
_trackTelemetry.TrackEvent(EventName.UpdateApiResource, EventType.Action, EventStatus.Fail);
return(View());
}
var apiResource = _configurationDbContext.ApiResources.Single(c => c.Name == apiResourceViewModel.Name);
apiResource.DisplayName = apiResourceViewModel.DisplayName;
_configurationDbContext.ApiResources.Update(apiResource);
_configurationDbContext.SaveChanges();
_trackTelemetry.TrackEvent(EventName.UpdateApiResource, EventType.Action, EventStatus.Success);
return(RedirectToAction(nameof(Index)));
}
public EditableApiResourceViewModel GetEditableApiResourceViewModel(IList <ClaimTypeViewModel> claimTypes,
ApiResourceViewModel apiResourceViewModel = null)
{
var selectableClaimTypes = m_genericViewModelFactory.GetSelectableViewmodelList(claimTypes);
if (apiResourceViewModel != null)
{
selectableClaimTypes.ForEach(claim =>
claim.IsSelected =
apiResourceViewModel.Claims?.FirstOrDefault(userClaim => userClaim.Id == claim.Item.Id) !=
null);
}
return(new EditableApiResourceViewModel
{
ApiResourceViewModel = apiResourceViewModel ?? new ApiResourceViewModel(),
SelectableClaimTypes = selectableClaimTypes,
});
}
public IActionResult Index(ApiResourceViewModel model)
{
if (model != null)
{
List <String> apiSecrets = new List <string>();
String[] arrapiSecrets = model.Secrets.Split(new char[] { ',' });
apiSecrets = arrapiSecrets.ToList <String>();
var _ApiSecrets = new List <global::IdentityServer4.EntityFramework.Entities.ApiSecret>();
foreach (var secret in apiSecrets)
{
_ApiSecrets.Add(new global::IdentityServer4.EntityFramework.Entities.ApiSecret()
{
Value = secret.Sha256()
});
}
List <String> claims = new List <string>();
String[] arrClaims = model.Claims.Split(new char[] { ',' });
claims = arrClaims.ToList <String>();
var _Claims = new List <global::IdentityServer4.EntityFramework.Entities.ApiResourceClaim>();
foreach (var claim in claims)
{
switch (claim.ToLower())
{
case "name":
_Claims.Add(new global::IdentityServer4.EntityFramework.Entities.ApiResourceClaim()
{
Type = JwtClaimTypes.Name
});
break;
case "email":
_Claims.Add(new global::IdentityServer4.EntityFramework.Entities.ApiResourceClaim()
{
Type = JwtClaimTypes.Email
});
break;
case "role":
_Claims.Add(new global::IdentityServer4.EntityFramework.Entities.ApiResourceClaim()
{
Type = JwtClaimTypes.Role
});
break;
case "id":
_Claims.Add(new global::IdentityServer4.EntityFramework.Entities.ApiResourceClaim()
{
Type = JwtClaimTypes.Id
});
break;
default:
break;
}
}
List <String> allowedScopes = new List <string>();
String[] arrAllowedScopes = model.Scopes.Split(new char[] { ',' });
allowedScopes = arrAllowedScopes.ToList <String>();
var _AllowedScopes = new List <global::IdentityServer4.EntityFramework.Entities.ApiScope>();
foreach (var scope in allowedScopes)
{
_AllowedScopes.Add(new global::IdentityServer4.EntityFramework.Entities.ApiScope()
{
Name = scope, DisplayName = scope
});
}
using (var scope = _serviceProvider.GetRequiredService <IServiceScopeFactory>().CreateScope())
{
var cfg_context = scope.ServiceProvider.GetRequiredService <ConfigurationDbContext>();
var resource = new global::IdentityServer4.EntityFramework.Entities.ApiResource();
resource.Name = model.Name;
resource.DisplayName = model.Name;
resource.UserClaims = _Claims;
resource.Scopes = _AllowedScopes;
resource.Secrets = _ApiSecrets;
cfg_context.ApiResources.Add(resource);
cfg_context.SaveChanges();
}
}
return(View());
}
public EditableApiResourceViewModel GetEditableApiResourceViewModel(IList <ClaimTypeViewModel> claimTypes,
ApiResourceViewModel apiResourceViewModel = null)
{
return(m_editableViewModelFactory.GetEditableApiResourceViewModel(claimTypes, apiResourceViewModel));
}
public async Task <IActionResult> CreateAsync(string returnUrl, ApiResourceViewModel dto)
{
if (!ModelState.IsValid)
{
return(View("Create", dto));
}
dto.Name = dto.Name.Trim();
if (await _dbContext.ApiResources.AnyAsync(x => x.Name == dto.Name))
{
ModelState.AddModelError("Name", "Name already exists");
return(View("Create", dto));
}
var identityResource = new ApiResource
{
Name = dto.Name,
Description = dto.Description?.Trim(),
DisplayName = string.IsNullOrWhiteSpace(dto.DisplayName) ? dto.Name : dto.DisplayName?.Trim(),
Enabled = dto.Enabled,
Scopes = new List <ApiScope>
{
new ApiScope
{
Name = dto.Name,
DisplayName = string.IsNullOrWhiteSpace(dto.DisplayName) ? dto.Name : dto.DisplayName?.Trim(),
}
}
};
var context = (DbContext)_dbContext;
var transaction = context.Database.BeginTransaction();
try
{
var claims = dto.UserClaims?.Split(" ", StringSplitOptions.RemoveEmptyEntries);
var identityClaims = new List <ApiResourceClaim>();
if (claims != null)
{
foreach (var identityClaim in claims)
{
identityClaims.Add(new ApiResourceClaim
{
Type = identityClaim,
ApiResource = identityResource
});
}
}
identityResource.UserClaims = identityClaims;
await _dbContext.ApiResources.AddAsync(identityResource);
await _dbContext.SaveChangesAsync();
transaction.Commit();
if (string.IsNullOrEmpty(returnUrl))
{
return(RedirectToAction("Index"));
}
return(Redirect(returnUrl));
}
catch (Exception e)
{
Logger.LogError($"Create api resource failed: {e}");
try
{
transaction.Rollback();
}
catch (Exception te)
{
Logger.LogError($"Rollback api resource failed: {te}");
}
ModelState.AddModelError(string.Empty, "Create api resource failed");
return(View("Create", dto));
}
}
public async Task <IActionResult> UpdateAsync(int id, string returnUrl, ApiResourceViewModel dto)
{
if (!ModelState.IsValid)
{
return(View("View", dto));
}
var resource = await _dbContext.ApiResources.FirstOrDefaultAsync(x => x.Id == id);
if (resource == null)
{
return(NotFound());
}
dto.Name = dto.Name.Trim();
var nameExits = await _dbContext.ApiResources.AnyAsync(x => x.Id != id && x.Name == dto.Name);
if (nameExits)
{
ModelState.AddModelError(string.Empty, $"Resource name {dto.Name} already exists");
return(View("View", dto));
}
resource.Name = dto.Name;
resource.Description = dto.Description?.Trim();
resource.DisplayName =
string.IsNullOrWhiteSpace(dto.DisplayName) ? dto.Name : dto.DisplayName?.Trim();
resource.Enabled = dto.Enabled;
var oldClaims = await _dbContext.ApiResourceClaims.Where(x => x.ApiResourceId == resource.Id)
.ToListAsync();
var context = (DbContext)_dbContext;
var transaction = context.Database.BeginTransaction();
try
{
_dbContext.ApiResourceClaims.RemoveRange(oldClaims);
var newClaims = dto.UserClaims?.Split(" ", StringSplitOptions.RemoveEmptyEntries);
var claims = new List <ApiResourceClaim>();
if (newClaims != null)
{
var list = newClaims.ToList();
list.Sort();
foreach (var identityClaim in list)
{
claims.Add(new ApiResourceClaim
{
Type = identityClaim,
ApiResource = resource
});
}
}
resource.UserClaims = claims;
_dbContext.ApiResources.Update(resource);
await _dbContext.SaveChangesAsync();
transaction.Commit();
if (string.IsNullOrEmpty(returnUrl))
{
return(RedirectToAction("Index"));
}
return(Redirect(returnUrl));
}
catch (Exception e)
{
Logger.LogError($"Update api resource failed: {e}");
try
{
transaction.Rollback();
}
catch (Exception te)
{
Logger.LogError($"Rollback update api resource failed: {te}");
}
ModelState.AddModelError(string.Empty, "Update api resource failed");
return(View("View", dto));
}
}
