/// <summary>
/// Update the already existing resource access claim
/// </summary>
/// <param name="id">Resource Access Claim Id</param>
/// <param name="access">Client Resource Claims Access</param>
/// <returns><![CDATA[ (bool IsSuccess, String Message) ]]></returns>
public (bool IsSuccess, String Message) UpdateClaimAccess(int id, ClientResourceClaimsAccess access)
{
try
{
var dbClaim = ClientDataAccess.ClientResourceAccessClaim.GetById(id);
if (dbClaim == null)
{
return(false, ResourceManagerMessages.Error.CLAIM_UPDATE_NOT_FOUND);
}
dbClaim.Access = access;
ClientDataAccess.ClientResourceAccessClaim.Update(dbClaim);
ClientDataAccess.Save();
return(true, ResourceManagerMessages.Success.CLAIM_UPDATED);
}
catch (DbEntityValidationException ex)
{
#if (DEBUG)
// for debuging entity framework
foreach (var error in ex.EntityValidationErrors.SelectMany(valError => valError.ValidationErrors))
{
Console.WriteLine(error.ErrorMessage);
}
#endif
throw;
}
catch
{
throw;
}
}
/// <summary>
/// Delete a specific resource access claim out of the database.
/// </summary>
/// <param name="id">Client Id</param>
/// <returns></returns>
public (bool IsSuccess, String Message) DeleteClaim(int id)
{
var dbView = ClientDataAccess.ClientResourceAccessClaim.GetById(id);
if (dbView == null)
{
return(false, ResourceManagerMessages.Error.CLAIM_NOT_FOUND);
}
ClientDataAccess.ClientResourceAccessClaim.Delete(dbView);
ClientDataAccess.Save();
return(true, ResourceManagerMessages.Success.CLAIM_DELETED);
}
/*TODO : MAKE SURE THAT ALL THE TRANSACTION ON SET ARE LOGGED IN A TABLE*/
/// <summary>
/// Create a new client record.
/// </summary>
/// <param name="ownerId">Owner Id</param>
/// <param name="name">Client Name</param>
/// <param name="status">Client Status</param>
/// <returns><![CDATA[ (ClientVm Client, ClientKeyVm Key, bool IsSuccess, String Message) ]]></returns>
public (ClientVm Client, ClientKeyVm Key, bool IsSuccess, String Message) CreateClient(int ownerId, string name, ClientKeyStatus status)
{
try
{
var dbCheck = ClientDataAccess.Client.Find(f => f.OwnerId == ownerId &&
f.Name.ToLower() == name.ToLower());
if (dbCheck != null)
{
return(null, null, false, ResourceManagerMessages.Error.CLIENT_ADD_ALREADY_EXISTS);
}
// Create the Client Resource
var dbView = (new ClientVm()
{
Name = name
}).ToEntityCreate(ownerId);
dbView = ClientDataAccess.Client.Create(dbView);
// Generate a new Client Key
var dbKey = (new ClientKeyVm()
{
Status = status
}).ToEntityCreate(dbView.Id);
dbKey = ClientDataAccess.ClientKey.Create(dbKey);
ClientDataAccess.Save();
var client = new ClientVm(dbView);
var key = new ClientKeyVm(dbKey);
return(client, key, true, ResourceManagerMessages.Success.CLAIM_CREATED);
}
catch (DbEntityValidationException ex)
{
#if (DEBUG)
// for debuging entity framework
foreach (var error in ex.EntityValidationErrors.SelectMany(valError => valError.ValidationErrors))
{
Console.WriteLine(error.ErrorMessage);
}
#endif
throw;
}
catch
{
throw;
}
}
/// <summary>
/// Add new claim the an existing client resource access
/// </summary>
/// <param name="resourceId">Client Resource Acces Id</param>
/// <param name="claimId">Resource Claim Id</param>
/// <param name="access">Client Resource Claims Access</param>
/// <returns><![CDATA[ (ClientResourceAccessClaimVm Claim, bool IsSuccess, string Message) ]]></returns>
public (ClientResourceAccessClaimVm Claim, bool IsSuccess, string Message) AddClaim(int resourceId, int claimId, ClientResourceClaimsAccess access)
{
try
{
// check to make sure that the client resource does exists inside the client.
var dbResAccess = ClientDataAccess.ClientResourceAccess.GetById(resourceId);
if (dbResAccess == null)
{
return(null, false, ResourceManagerMessages.Error.RESOURCE_NOT_FOUND);
}
var dbClaimCheck = ClientDataAccess.ClientResourceAccessClaim.Find(f => f.ClientResourceAccessId == resourceId && f.ResourceClaimId == claimId);
if (dbClaimCheck != null)
{
return(null, false, ResourceManagerMessages.Error.CLAIM_ADD_ALREADY_EXISTS);
}
var dbClaim = new ClientResourceAccessClaim()
{
ResourceClaimId = claimId,
ClientResourceAccessId = dbResAccess.Id,
Access = access,
};
ClientDataAccess.ClientResourceAccessClaim.Create(dbClaim);
ClientDataAccess.Save();
return(new ClientResourceAccessClaimVm(dbClaim), true, ResourceManagerMessages.Success.CLAIM_CREATED);
}
catch (DbEntityValidationException ex)
{
#if (DEBUG)
// for debuging entity framework
foreach (var error in ex.EntityValidationErrors.SelectMany(valError => valError.ValidationErrors))
{
Console.WriteLine(error.ErrorMessage);
}
#endif
throw;
}
catch
{
throw;
}
}
/// <summary>
/// Create a new key for the already existing client
/// </summary>
/// <param name="id">Client Id</param>
/// <param name="status">Client Key Status</param>
/// <returns><![CDATA[ (ClientKeyVm key, bool IsSuccess, String Message) ]]></returns>
public (ClientKeyVm key, bool IsSuccess, String Message) CreateKey(int id, ClientKeyStatus status)
{
try
{
var dbCheck = ClientDataAccess.Client.Find(f => f.Id == id);
if (dbCheck == null)
{
return(null, false, ResourceManagerMessages.Error.CLIENT_NOT_FOUND);
}
// Generate a new Client Key
var dbKey = (new ClientKeyVm()
{
Status = status
}).ToEntityCreate(id);
dbKey = ClientDataAccess.ClientKey.Create(dbKey);
ClientDataAccess.Save();
var key = new ClientKeyVm(dbKey);
return(key, true, ResourceManagerMessages.Success.CLAIM_KEY_CREATED);
}
catch (DbEntityValidationException ex)
{
#if (DEBUG)
// for debugging entity framework
foreach (var error in ex.EntityValidationErrors.SelectMany(valError => valError.ValidationErrors))
{
Console.WriteLine(error.ErrorMessage);
}
#endif
throw;
}
catch
{
throw;
}
}
/// <summary>
/// Update the already existing key
/// </summary>
/// <param name="id">Client Key Id</param>
/// <param name="status">Client Key Status</param>
/// <returns><![CDATA[ (bool IsSuccess, String Message) ]]></returns>
public (bool IsSuccess, String Message) UpdateKeyStatus(int id, ClientKeyStatus status)
{
try
{
// Check if the record exist in the database.
var dbView = ClientDataAccess.ClientKey.Find(f => f.Id == id);
if (dbView == null)
{
return(false, ResourceManagerMessages.Error.CLIENT_KEY_NOT_FOUND);
}
// Update the existing record from the database.
dbView.Status = status;
dbView.UpdateDate = DateTime.UtcNow;
ClientDataAccess.ClientKey.Update(dbView);
ClientDataAccess.Save();
return(true, ResourceManagerMessages.Success.CLAIM_KEY_UPDATED);
}
catch (DbEntityValidationException ex)
{
#if (DEBUG)
// for debuging entity framework
foreach (var error in ex.EntityValidationErrors.SelectMany(valError => valError.ValidationErrors))
{
Console.WriteLine(error.ErrorMessage);
}
#endif
throw;
}
catch
{
throw;
}
}
/// <summary>
/// Create a new resource access for the client.
/// </summary>
/// <param name="clientId">Client Id</param>
/// <param name="resourceId">Resouce Id</param>
/// <param name="resourceValue">Resource Value</param>
/// <param name="status">Client Resource Access Status</param>
/// <param name="claims">List of Claim Ids</param>
/// <returns><![CDATA[ (ClientResourceAccessVm Resource, bool IsSuccess, String Message) ]]></returns>
public (ClientResourceAccessVm Resource, bool IsSuccess, String Message) CreateResourceAccess(int clientId, int resourceId, int resourceValue, ClientResourceAccessStatus status, int[] claims = null)
{
try
{
// Check to make sure that the client does exists in the database.
var dbClient = ClientDataAccess.Client.Find(f => f.Id == clientId);
if (dbClient == null)
{
return(null, false, ResourceManagerMessages.Error.CLIENT_NOT_FOUND);
}
// Check to make sure that the resource manager does exists in the database.
var dbRes = ResourceDataAccess.ResourceManager.Find(f => f.Id == resourceId);
if (dbRes == null)
{
return(null, false, ResourceManagerMessages.Error.RESOURCE_NOT_FOUND);
}
// Check to make sure that the resource access with the same resource value does not exists.
var dbResVal = ClientDataAccess.ClientResourceAccess.Find(f => f.ResourceId == resourceId && f.ResourceValue == resourceValue);
if (dbResVal != null)
{
return(null, false, ResourceManagerMessages.Error.RESOURCE_ALREADY_EXISTS);
}
/* --------------------------------------------------------
* If the caller passesa list of claim Ids
* check to see if all the claim ids exists in the database
* before creating a new record in the database.
* --------------------------------------------------------- */
if (claims != null && claims.Length != 0)
{
var hasInvalidClaim = ResourceDataAccess.ResourceClaim.Any(f => f.ResourceId == resourceId && !claims.Contains(f.Id));
if (hasInvalidClaim)
{
return(null, false, ResourceManagerMessages.Error.CLAIM_UPDATE_NOT_FOUND);
}
}
var dbResAccess = (new ClientResourceAccessVm()
{
Status = status
}).ToEntityCreate(clientId, resourceId, resourceValue);
dbResAccess = ClientDataAccess.ClientResourceAccess.Create(dbResAccess);
if (claims != null)
{
foreach (var id in claims)
{
ClientDataAccess.ClientResourceAccessClaim.Create(
new ClientResourceAccessClaim()
{
ResourceClaimId = id,
ClientResourceAccessId = dbResAccess.Id,
Access = ClientResourceClaimsAccess.Allow
}
);
}
}
ClientDataAccess.Save();
var resAccess = new ClientResourceAccessVm(dbResAccess);
return(resAccess, true, ResourceManagerMessages.Success.ACCESS_CREATED);
}
catch (DbEntityValidationException ex)
{
#if (DEBUG)
// for debuging entity framework
foreach (var error in ex.EntityValidationErrors.SelectMany(valError => valError.ValidationErrors))
{
Console.WriteLine(error.ErrorMessage);
}
#endif
throw;
}
catch
{
throw;
}
}
