public IActionResult Delete(int id)
{
var api = _configurationDbContext.ApiResources
.FirstOrDefault(x => x.Id == id);
return(View(ApiResourceModel.FromEntity(api)));
}
public async Task <IActionResult> Edit(ApiResourceModel model)
{
if (model.Id == 0)
{
return(RedirectToAction(nameof(Index)));
}
var apiResource = await _apiResourceService.GetApiResourceByIdAsync(model.Id);
if (apiResource == null)
{
return(RedirectToAction(nameof(Index)));
}
model.UserClaims = model.UserClaimsItems.Deserialize <List <string> >()?.Select(x => new ApiResourceClaimModel
{
Type = x
}).ToList();
apiResource = CommonMappers.Mapper.Map <ApiResource>(model);
var updatedResult = await _apiResourceService.UpdateApiResourceAsync(apiResource);
if (updatedResult)
{
SuccessNotification(await _localizationService.GetResourceAsync("ApiResource.Updated"));
return(RedirectToAction(nameof(Index)));
}
return(View(model));
}
public DataResult <bool> UpdateApiResource(int id, ApiResourceModel apiResourceModel, IEnumerable <int> claimsIds)
{
var apiResource = new ApiResourceEntity
{
Name = apiResourceModel.Name,
Description = apiResourceModel.Description,
Required = apiResourceModel.Required,
ShowInDiscoveryDocument = apiResourceModel.ShowInDiscoveryDocument
};
try
{
m_apiResourceUoW.UpdateApiResource(id, apiResource, claimsIds);
return(Success(true));
}
catch (NoResultException <ApiResourceEntity> e)
{
m_logger.LogWarning(e);
return(Error <bool>(m_translator.Translate("invalid-api-resource-id"), DataResultErrorCode.ApiResourceNotExistId));
}
catch (DatabaseException e)
{
m_logger.LogWarning(e);
return(Error <bool>(e.Message));
}
}
public DataResult <int> CreateApiResource(ApiResourceModel apiResourceModel, IEnumerable <int> claimsIds)
{
var defaultScope = new ScopeEntity
{
Name = apiResourceModel.Name,
Description = apiResourceModel.Description,
Required = apiResourceModel.Required,
ShowInDiscoveryDocument = apiResourceModel.ShowInDiscoveryDocument
};
var apiResourceEntity = new ApiResourceEntity
{
Name = apiResourceModel.Name,
Description = apiResourceModel.Description,
Required = apiResourceModel.Required,
ShowInDiscoveryDocument = apiResourceModel.ShowInDiscoveryDocument,
};
try
{
var result = m_apiResourceUoW.CreateApiResource(apiResourceEntity, claimsIds, defaultScope);
return(Success(result));
}
catch (DatabaseException e)
{
m_logger.LogWarning(e);
return(Error <int>(e.Message));
}
}
public async Task <ApiResourceModel> AddAsync(ApiResourceModel model)
{
var apiResource = _mapper.Map <ApiResource>(model);
var entry = _context.Add(apiResource.ToEntity());
await _context.SaveChangesAsync();
return(_mapper.Map <ApiResourceModel>(entry.Entity.ToModel()));
}
public IActionResult Edit(int id)
{
var identity = _configurationDbContext.ApiResources
.Include(x => x.UserClaims)
.FirstOrDefault(x => x.Id == id);
return(View(ApiResourceModel.FromEntity(identity)));
}
async public Task RemoveApiResourceAsync(ApiResourceModel apiResource)
{
var collection = GetApiResourceCollection();
string id = apiResource.Name.ApiNameToHexId(_cryptoService);
await collection
.DeleteOneAsync <ApiResourceDocument>(d => d.Id == id);
}
public void api_resource_model()
{
var model = NewApiResourceModel;
var model2 = new ApiResourceModel(model.ToApiResource());
var model3 = NewApiResourceModel;
model.ShouldBe(model2);
model.ShouldNotBe(model3);
}
public IActionResult Delete(ApiResourceModel model)
{
var api = _configurationDbContext.ApiResources
.FirstOrDefault(x => x.Id == model.Id);
_configurationDbContext.ApiResources.Remove(api);
_configurationDbContext.SaveChanges();
return(RedirectToAction(nameof(Index)));
}
async public Task UpdateApiResourceAsync(ApiResourceModel apiResource, IEnumerable <string> propertyNames = null)
{
FileInfo fi = new FileInfo($"{ _rootPath }/{ apiResource.Name.NameToHexId(_cryptoService) }.api");
if (fi.Exists)
{
fi.Delete();
}
await AddApiResourceAsync(apiResource);
}
public Task RemoveApiResourceAsync(ApiResourceModel apiResource)
{
FileInfo fi = new FileInfo($"{ _rootPath }/{ apiResource.Name.NameToHexId(_cryptoService) }.api");
if (fi.Exists)
{
fi.Delete();
}
return(Task.CompletedTask);
}
public Task AddApiResourceAsync(ApiResourceModel apiResource)
{
if (_apiResources.ContainsKey(apiResource.Name))
{
throw new Exception($"Api { apiResource.Name } already exists");
}
_apiResources[apiResource.Name] = apiResource;
return(Task.CompletedTask);
}
public Task UpdateApiResourceAsync(ApiResourceModel resource, IEnumerable <string> propertyNames = null)
{
if (!_apiResources.ContainsKey(resource.Name))
{
throw new Exception($"Api { resource.Name } not exists");
}
_apiResources[resource.Name] = resource;
return(Task.CompletedTask);
}
async public Task UpdateApiResourceAsync(ApiResourceModel apiResource, IEnumerable <string> propertyNames = null)
{
var collection = GetApiResourceCollection();
string id = apiResource.Name.ApiNameToHexId(_cryptoService);
UpdateDefinition <ApiResourceDocument> update = Builders <ApiResourceDocument>
.Update
.Set("BlobData", _cryptoService.EncryptText(_blobSerializer.SerializeObject(apiResource)));
await collection
.UpdateOneAsync <ApiResourceDocument>(d => d.Id == id, update);
}
async public Task RemoveApiResourceAsync(ApiResourceModel apiResource)
{
if (_tableStorage == null || apiResource == null)
{
return;
}
await _tableStorage.DeleteEntityAsync(_tablename,
new BlobTableEntity(TableStorageBlobResourceDb.ApiResourcePartitionKey,
apiResource.RowKey(),
apiResource,
_cryptoService,
_blobSerializer));
}
async public Task UpdateApiResourceAsync(ApiResourceModel apiResource, IEnumerable <string> propertyNames = null)
{
if (_tableStorage == null || apiResource == null)
{
return;
}
await _tableStorage.MergeEntity(_tablename,
new BlobTableEntity(TableStorageBlobResourceDb.ApiResourcePartitionKey,
apiResource.RowKey(),
apiResource,
_cryptoService,
_blobSerializer));
}
public Task RemoveApiResourceAsync(ApiResourceModel apiResource)
{
if (!_apiResources.ContainsKey(apiResource.Name))
{
throw new Exception($"Api with clientId { apiResource.Name } not exists");
}
if (!_apiResources.TryRemove(apiResource.Name, out apiResource))
{
throw new Exception($"Can't remove api");
}
return(Task.CompletedTask);
}
public async Task <IActionResult> Delete(ApiResourceModel model)
{
if (model.Id == 0)
{
return(RedirectToAction(nameof(Index)));
}
var result = await _apiResourceService.DeleteApiResourceAsync(CommonMappers.Mapper.Map <ApiResource>(model));
if (result)
{
SuccessNotification(await _localizationService.GetResourceAsync("ApiResource.Deleted"));
}
return(RedirectToAction(nameof(Index)));
}
public Task <IActionResult> Get(string name)
{
return(Task.Run <IActionResult>(() =>
{
var completeResource = _db.Single <ApiResource>(r => r.Name == name);
var resource = new ApiResourceModel
{
Name = completeResource.Name,
DisplayName = completeResource.DisplayName
};
return Ok(new
{
success = true,
resource
});
}));
}
async public Task AddApiResourceAsync(ApiResourceModel apiResource)
{
string id = apiResource.Name.NameToHexId(_cryptoService);
FileInfo fi = new FileInfo($"{ _rootPath }/{ id }.api");
if (fi.Exists)
{
throw new Exception("Api already exists");
}
byte[] buffer = Encoding.UTF8.GetBytes(
_cryptoService.EncryptText(_blobSerializer.SerializeObject(apiResource)));
using (var fs = new FileStream(fi.FullName, FileMode.OpenOrCreate,
FileAccess.Write, FileShare.None, buffer.Length, true))
{
await fs.WriteAsync(buffer, 0, buffer.Length);
}
}
public async Task <IActionResult> Create(ApiResourceModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
model.UserClaims = !string.IsNullOrEmpty(model.UserClaimsItems)
? JsonConvert.DeserializeObject <List <string> >(model.UserClaimsItems).Select(x =>
new ApiResourceClaimModel
{
Type = x
}).ToList()
: new List <ApiResourceClaimModel>();
await _apiResourceService.InsertApiResourceAsync(CommonMappers.Mapper.Map <ApiResource>(model));
SuccessNotification(await _localizationService.GetResourceAsync("ApiResource.Added"));
return(RedirectToAction(nameof(Index)));
}
public Task <IActionResult> Update(string name, [FromBody] ApiResourceModel input)
{
return(Task.Run <IActionResult>(() =>
{
if (!ModelState.IsValid)
{
return BadRequest();
}
var resourceExists = _db.Single <ApiResource>(r => r.Name == name) != null;
if (!resourceExists)
{
return new StatusCodeResult((int)HttpStatusCode.NotFound);
}
var resource = new ApiResource(input.Name, input.DisplayName);
_db.Replace(r => r.Name == name, resource);
return Ok(new { success = true });
}));
}
async public Task <IActionResult> OnPostAsync()
{
if (!ModelState.IsValid)
{
return(Page());
}
string apiName = Input.ApiResourceName.Trim().ToLower();
return(await SecureHandlerAsync(async() =>
{
if (_resourceDb != null)
{
var apiResource = new ApiResourceModel(apiName, Input.ApiResourceDisplayName);
await _resourceDb.AddApiResourceAsync(apiResource);
}
}
, onFinally : () => RedirectToPage("EditApi/Index", new { id = apiName })
, successMessage : "Api resource successfully created"
, onException : (ex) => RedirectToPage()));
}
public Task <IActionResult> Create([FromBody] ApiResourceModel input)
{
return(Task.Run <IActionResult>(() =>
{
if (!ModelState.IsValid)
{
return BadRequest();
}
var resourceExist = _db.Where <ApiResource>(r => r.Name == input.Name).Any();
if (resourceExist)
{
return new StatusCodeResult((int)HttpStatusCode.Conflict);
}
var resource = new ApiResource(input.Name, input.DisplayName);
_db.Add(resource);
return Ok(new { success = true });
}));
}
async public Task AddApiResourceAsync(ApiResourceModel apiResource)
{
if (apiResource == null)
{
return;
}
if (await FindApiResourceAsync(apiResource.Name) != null)
{
throw new Exception("Api resource alread exists");
}
string id = apiResource.Name.ApiNameToHexId(_cryptoService);
var collection = GetApiResourceCollection();
var document = new ApiResourceDocument()
{
Id = id,
BlobData = _cryptoService.EncryptText(_blobSerializer.SerializeObject(apiResource))
};
await collection.InsertOneAsync(document);
}
public IActionResult Edit(ApiResourceModel model)
{
ApiResource api;
if (model.Id == 0)
{
api = new ApiResource
{
UserClaims = new List <ApiResourceClaim>(),
};
_configurationDbContext.ApiResources.Add(api);
}
else
{
api = _configurationDbContext.ApiResources
.Include(x => x.UserClaims)
.FirstOrDefault(x => x.Id == model.Id);
api.UserClaims.Clear();
}
model.UpdateEntity(api);
if (!string.IsNullOrEmpty(model.UserClaimsItems))
{
var userClaims = JsonConvert.DeserializeObject <List <string> >(model.UserClaimsItems);
api.UserClaims.AddRange(userClaims.Select(x => new ApiResourceClaim
{
Type = x,
}));
}
_configurationDbContext.SaveChanges();
return(RedirectToAction(nameof(Edit), new { id = api.Id }));
}
public async Task <IActionResult> OnGetAsync(int?id)
{
Id = id;
if (!id.HasValue)
{
ApiResource = new ApiResourceModel();
}
else
{
var apiResource = await LoadApiResource(id);
if (apiResource == null)
{
return(NotFound());
}
ApiResource = apiResource.ToModel();
}
LoadLookups();
return(Page());
}
public async Task <IActionResult> Add([FromBody] ApiResourceModel model)
{
var newModel = await _service.AddAsync(model);
return(CreatedAtRoute("GetApiResourceById", new { id = newModel.Name }, newModel));
}
public static void ToEntity(this ApiResourceModel model, ApiResource apiResource)
{
Mapper.Map(model, apiResource);
}
public static ApiResource ToEntity(this ApiResourceModel model)
{
return(model == null ? null : Mapper.Map <ApiResource>(model));
}