/// <summary>
/// Deletes the user.
/// </summary>
/// <param name="user">The user.</param>
/// <param name="token">The token.</param>
/// <param name="context">The context.</param>
/// <returns>System.Boolean; true if successful, false otherwise.</returns>
private static bool DeleteUser(ZentityUser user, AuthenticatedToken token, ZentityContext context)
{
if (!DataAccess.IsAdmin(token.IdentityName, context))
{
throw new UnauthorizedAccessException(ConstantStrings.UnauthorizedAccessException);
}
Identity identity = GetIdentity(user.LogOnName, context);
if (identity == null)
{
throw new ArgumentException(string.Format(
CultureInfo.CurrentUICulture,
ConstantStrings.IdentityDoesNotExist,
identity.IdentityName));
}
// Remove relationships
identity.RelationshipsAsObject.Load();
identity.RelationshipsAsSubject.Load();
foreach (Relationship relationship in identity.RelationshipsAsObject.Union(
identity.RelationshipsAsSubject).ToList())
{
context.DeleteObject(relationship);
}
// Remove identity
context.DeleteObject(identity);
if (context.SaveChanges() == 0)
{
return(false);
}
if (!user.Unregister())
{
return(false);
}
return(true);
}
/// <summary>
/// Deletes the group.
/// </summary>
/// <param name="group">The group.</param>
/// <param name="token">The token.</param>
/// <param name="context">The context.</param>
/// <returns>System.Boolean; true if successful, false otherwise.</returns>
private static bool DeleteGroup(Group group, AuthenticatedToken token, ZentityContext context)
{
if (!DataAccess.IsAdmin(token.IdentityName, context))
{
throw new UnauthorizedAccessException(ConstantStrings.UnauthorizedAccessException);
}
Group existingGroup = GetGroup(group.Id, context);
if (existingGroup == null)
{
throw new ArgumentException(string.Format(
CultureInfo.CurrentUICulture,
ConstantStrings.IdentityDoesNotExist,
existingGroup.GroupName));
}
existingGroup.RelationshipsAsObject.Load();
existingGroup.RelationshipsAsSubject.Load();
List <Relationship> relationships = existingGroup.RelationshipsAsSubject.ToList();
foreach (Relationship relationship in relationships)
{
context.DeleteObject(relationship);
}
relationships = existingGroup.RelationshipsAsObject.ToList();
foreach (Relationship relationship in relationships)
{
context.DeleteObject(relationship);
}
context.DeleteObject(existingGroup);
return(context.SaveChanges() == 0 ? false : true);
}
/// <summary>
/// Deletes the specified resource.
/// </summary>
/// <param name="collectionName">The type of the resource.</param>
/// <param name="memberResourceId">The Guid of the resource.</param>
/// <returns>True if the operation succeeds, False otherwise.</returns>
/// <exception cref="ArgumentNullException">Throws exception if collectionName is null/empty.</exception>
/// <exception cref="ArgumentException">Throws exception if requested memberResourceId is not a unique identifier.</exception>
bool IAtomPubStoreWriter.DeleteMember(string collectionName, string memberResourceId)
{
using (ZentityContext context = CoreHelper.CreateZentityContext())
{
ScholarlyWork resource = (ScholarlyWork)AtomPubHelper.GetMember(context, collectionName, memberResourceId, "Delete");
// Load to delete all Core.File resource associated to requested scholarlywork.
if (!resource.Files.IsLoaded)
{
resource.Files.Load();
}
Zentity.Core.File[] resourceFiles = resource.Files.ToArray();
for (int i = 0; i < resourceFiles.Length; i++)
{
DeleteRelationships(context, resourceFiles[i]);
context.DeleteObject(resourceFiles[i]);
}
DeleteRelationships(context, resource);
// Delete associated Resource propertes
resource.ResourceProperties.Load();
List <ResourceProperty> resProperties = resource.ResourceProperties.ToList();
foreach (ResourceProperty property in resProperties)
{
resource.ResourceProperties.Remove(property);
context.DeleteObject(property);
}
context.DeleteObject(resource);
context.SaveChanges();
return(true);
}
}
/// <summary>
/// Revokes permission on resource for the current identity.
/// </summary>
/// <typeparam name="T">Zentity.Core.Resource or its derived type</typeparam>
/// <param name="authorizingPredicateUri">
/// Predicate corresponding to the permission.
/// </param>
/// <param name="resource">
/// Resource on which the permission is to be granted.
/// </param>
/// <param name="context">
/// Zentity Object Context.
/// </param>
/// <returns>
/// Boolean indicating whether the permission was successfully revoked or not.
/// </returns>
/// <exception cref="AuthorizationException">Exception to indicate invalid information or other general exception.</exception>
/// <example>
/// <code>
/// string authorizingPredicate = "urn:zentity/module/zentity-authorization/predicate/has-read-access";
/// using (ZentityContext context = new ZentityContext())
/// {
/// Identity identity = context.Resources.OfType<Identity>()
/// .Where(tuple => tuple.IdentityName.Equals("User1")).First();
/// Resource resource = context.Resources.Where(tuple => tuple.Title.Equals("Resource1")).First();
///
/// identity.RevokeAuthorization(authorizingPredicate, resource, context);
/// context.SaveChanges();
/// }
/// </code>
/// </example>
public bool RevokeAuthorization <T>(string authorizingPredicateUri, T resource, ZentityContext context) where T : Resource
{
#region Parameter Validation
ValidateParameters(authorizingPredicateUri, context);
if (resource == null)
{
throw new ArgumentNullException("resource");
}
#endregion
try
{
Relationship relationship =
context.Relationships.Where(rel => rel.Subject.Id == this.Id && rel.Object.Id == resource.Id &&
rel.Predicate.Uri == authorizingPredicateUri).FirstOrDefault();
if (relationship != null)
{
context.DeleteObject(relationship);
}
else
{
// Check if relationship is present in context in added, modified or deleted state
foreach (ObjectStateEntry objectStateEntry in
context.ObjectStateManager.GetObjectStateEntries(EntityState.Added))
{
Relationship existingRelationship = objectStateEntry.Entity as Relationship;
//// Check if relationship is same on which Grant is requested
if (existingRelationship != null &&
(existingRelationship.Subject.Id == this.Id &&
existingRelationship.Object.Id == resource.Id &&
existingRelationship.Predicate.Uri.Equals(authorizingPredicateUri, StringComparison.OrdinalIgnoreCase)))
{
objectStateEntry.Delete();
break;
}
}
}
return(true);
}
catch (Exception exception)
{
throw new AuthorizationException(Resources.RevokeAuthorizationException, exception);
}
}
/// <summary>
/// Deletes the relationships.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="resource">The resource.</param>
private static void DeleteRelationships(ZentityContext context, Resource resource)
{
if (!resource.RelationshipsAsObject.IsLoaded)
{
resource.RelationshipsAsObject.Load();
}
if (!resource.RelationshipsAsSubject.IsLoaded)
{
resource.RelationshipsAsSubject.Load();
}
Relationship[] relationships = resource.RelationshipsAsObject
.Union(resource.RelationshipsAsSubject)
.ToArray();
for (int i = 0; i < relationships.Length; i++)
{
context.DeleteObject(relationships[i]);
}
}
/// <summary>
/// Deletes the Resource.File for the specified resource.
/// </summary>
/// <param name="collectionName">The type of the resource.</param>
/// <param name="memberResourceId">The Guid of the resource.</param>
/// <returns>True if the operation succeeds, False otherwise.</returns>
/// <exception cref="ArgumentNullException">Throws exception if collectionName is null/empty.</exception>
/// <exception cref="ArgumentException">Throws exception if requested memberResourceId is not a unique identifier.</exception>
bool IAtomPubStoreWriter.DeleteMedia(string collectionName, string memberResourceId)
{
if (string.IsNullOrEmpty(collectionName))
{
throw new ArgumentNullException("collectionName");
}
if (!AtomPubHelper.IsValidGuid(memberResourceId))
{
throw new ArgumentException(Resources.ATOMPUB_INVALID_RESOURCE_ID, "memberResourceId");
}
using (ZentityContext context = CoreHelper.CreateZentityContext())
{
Type collectionType = CoreHelper.GetSystemResourceType(collectionName);
string commandText = string.Format(CultureInfo.InvariantCulture, AtomPubConstants.EsqlToGetFileContents,
collectionType.FullName);
ObjectQuery <Core.File> query = new ObjectQuery <Core.File>(commandText, context);
query.Parameters.Add(new ObjectParameter("Id", new Guid(memberResourceId)));
Core.File mediaFile = query.FirstOrDefault();
if (null == mediaFile)
{
throw new ResourceNotFoundException(Resources.ATOMPUB_RESOURCE_NOT_FOUND);
}
if (!mediaFile.Authorize("Delete", context, CoreHelper.GetAuthenticationToken()))
{
throw new UnauthorizedException(Resources.ATOMPUB_UNAUTHORIZED);
}
DeleteRelationships(context, mediaFile);
context.DeleteObject(mediaFile);
context.SaveChanges();
return(true);
}
}