internal async Task <TResult> CreateCredentialMappingAsync <TResult>(Guid credentialMappingId,
CredentialValidationMethodTypes method, string subjectId, Guid actorId,
Func <TResult> onSuccess,
Func <TResult> onAlreadyExists,
Func <TResult> onTokenAlreadyInUse)
{
var rollback = new RollbackAsync <TResult>();
var methodName = Enum.GetName(typeof(CredentialValidationMethodTypes), method);
var credentialMappingDoc = new Documents.CredentialMappingDocument()
{
Method = methodName,
Subject = subjectId,
ActorId = actorId,
};
rollback.AddTaskCreate(credentialMappingId, credentialMappingDoc, onAlreadyExists, this.repository);
var lookupDocument = new Azure.Documents.CredentialMappingLookupDocument()
{
CredentialMappingId = credentialMappingId,
Method = methodName,
Subject = subjectId,
};
rollback.AddTaskCreate(subjectId, methodName, lookupDocument, onTokenAlreadyInUse, this.repository);
rollback.AddTaskCreateOrUpdate(actorId,
(Documents.ActorMappingsDocument authDoc) => authDoc.AddInviteId(credentialMappingId),
(authDoc) => authDoc.RemoveInviteId(credentialMappingId),
onAlreadyExists, // This should fail on the action above as well
this.repository);
return(await rollback.ExecuteAsync(onSuccess));
}
public async Task <TResult> CreatePasswordCredentialAsync <TResult>(Guid passwordCredentialId,
Guid actorId, Guid loginId, DateTime?emailLastSent,
Func <TResult> onSuccess,
Func <TResult> onAlreadyExists,
Func <TResult> onRelationshipAlreadyExists,
Func <TResult> onLoginAlreadyUsed)
{
var rollback = new RollbackAsync <TResult>();
var lookupDoc = new Documents.LoginActorLookupDocument
{
ActorId = actorId,
};
rollback.AddTaskCreate(loginId, lookupDoc,
onLoginAlreadyUsed, this.repository);
rollback.AddTaskCreateOrUpdate(actorId,
(Documents.ActorMappingsDocument actorDoc) =>
actorDoc.AddPasswordCredential(passwordCredentialId),
actorDoc => actorDoc.RemovePasswordCredential(passwordCredentialId),
onRelationshipAlreadyExists,
this.repository);
var passwordCredentialDoc = new Documents.PasswordCredentialDocument
{
LoginId = loginId,
EmailLastSent = emailLastSent,
};
rollback.AddTaskCreate(passwordCredentialId, passwordCredentialDoc,
onAlreadyExists, this.repository);
return(await rollback.ExecuteAsync(onSuccess));
}
internal static Task <TResult> CreateAsync <TResult>(Guid processStageId, Guid actorId,
Guid processStageTypeId, string title,
KeyValuePair <Guid[], Guid>[] confirmableActorIds, Guid[] editableActorIds, Guid[] viewableActorIds,
Func <TResult> onSuccess,
Func <TResult> onAlreadyExists)
{
return(AzureStorageRepository.Connection(
azureStorageRepository =>
{
var rollback = new RollbackAsync <TResult>();
var procStageDoc = new ProcessStageDocument()
{
Owner = actorId,
ProcessStageType = processStageTypeId,
Title = title,
};
procStageDoc.SetConfirmables(confirmableActorIds);
procStageDoc.SetEditables(editableActorIds);
procStageDoc.SetViewables(viewableActorIds);
rollback.AddTaskCreate(processStageId, procStageDoc,
onAlreadyExists, azureStorageRepository);
rollback.AddTaskCreateOrUpdate <TResult, Documents.ProcessStageActorLookupDocument>(actorId,
(created, lookupDoc) => lookupDoc.AddLookupDocumentId(processStageId),
lookupDoc => lookupDoc.RemoveLookupDocumentId(processStageId),
azureStorageRepository);
return rollback.ExecuteAsync(onSuccess);
}));
}
public async Task <TResult> CreateAsync <TResult>(
Guid id, Guid actorId, string name,
Func <TResult> onSuccess,
Func <TResult> onAlreadyExists,
Func <TResult> onActorNotFound)
{
var rollback = new RollbackAsync <TResult>();
var document = new Documents.RoleDocument()
{
Name = name,
ActorId = actorId,
};
rollback.AddTaskCreate(id, document, onAlreadyExists, this.azureStorageRepository);
rollback.AddTaskCreateOrUpdate(actorId,
(Documents.ActorMappingsDocument actorDoc) =>
{
actorDoc.AddRole(id);
return(true);
},
(actorDoc) => actorDoc.RemoveRole(id),
onActorNotFound,
this.azureStorageRepository);
return(await rollback.ExecuteAsync(onSuccess));
}
internal async Task <TResult> CreateCredentialMappingAsync <TResult>(Guid credentialMappingId,
Guid loginId, Guid actorId, string email, Guid token, DateTime lastSent, bool isToken, bool overrideLoginId,
Func <TResult> onSuccess,
Func <TResult> onAlreadyExists,
Func <TResult> onTokenAlreadyInUse,
Func <TResult> onLoginAlreadyInUse)
{
var rollback = new RollbackAsync <TResult>();
var inviteDocument = new Documents.InviteDocument()
{
ActorId = actorId,
Email = email,
IsToken = isToken,
LastSent = lastSent,
Token = token,
LoginId = loginId,
};
rollback.AddTaskCreate(credentialMappingId, inviteDocument, onAlreadyExists, this.repository);
var inviteTokenDocument = new Documents.InviteTokenDocument()
{
ActorId = actorId,
InviteId = credentialMappingId,
};
rollback.AddTaskCreate(token, inviteTokenDocument, onTokenAlreadyInUse, this.repository);
if (overrideLoginId)
{
var oldActorId = default(Guid);
rollback.AddTaskCreateOrUpdate(loginId,
(Documents.LoginActorLookupDocument loginActorDocument) =>
{
oldActorId = loginActorDocument.ActorId;
loginActorDocument.ActorId = actorId;
return(true);
},
(loginActorDocument) =>
{
loginActorDocument.ActorId = oldActorId;
return(true);
},
() => { throw new Exception("Login override failed"); }, // Should never happend because always return true on mutate
this.repository);
}
else
{
var loginActorDocument = new Documents.LoginActorLookupDocument()
{
ActorId = actorId,
};
rollback.AddTaskCreate(loginId, loginActorDocument, onLoginAlreadyInUse, this.repository);
}
rollback.AddTaskCreateOrUpdate(actorId,
(Documents.ActorMappingsDocument authDoc) => authDoc.AddInviteId(credentialMappingId),
(authDoc) => authDoc.RemoveInviteId(credentialMappingId),
onAlreadyExists, // This should fail on the action above as well
this.repository);
return(await rollback.ExecuteAsync(onSuccess));
}
internal static Task <TResult> CreateAsync <TResult>(Guid processId,
Guid processStageId,
Guid actorId, Guid resourceId, Type resourceType, DateTime createdOn,
Process.ProcessStageResource[] resources,
Guid?previousStepId, DateTime?confirmedWhen, Guid?confirmedBy,
Guid [] lookupActorIds,
Func <TResult> onSuccess,
Func <TResult> onAlreadyExists)
{
return(AzureStorageRepository.Connection(
azureStorageRepository =>
{
var rollback = new RollbackAsync <TResult>();
var resourceTypeString = resourceType.AssemblyQualifiedName;
var processDocument = new ProcessDocument()
{
ProcessStage = processStageId,
Resource = resourceId,
ResourceType = resourceTypeString,
CreatedOn = createdOn,
Owner = actorId,
ConfirmedBy = confirmedBy,
PreviousStep = previousStepId,
ConfirmedWhen = confirmedWhen,
};
processDocument.SetResources(resources);
rollback.AddTaskCreate(processId, processDocument,
onAlreadyExists, azureStorageRepository);
foreach (var lookupActorId in lookupActorIds.Distinct())
{
rollback.AddTaskCreateOrUpdate <TResult, Documents.ProcessStepActorLookupDocument>(lookupActorId, resourceTypeString,
(created, lookupDoc) => lookupDoc.AddLookupDocumentId(processId),
actorDoc => actorDoc.RemoveLookupDocumentId(processId),
azureStorageRepository);
}
rollback.AddTaskCreateOrUpdate <TResult, Documents.ProcessStepResourceLookupDocument>(resourceId, resourceTypeString,
(created, lookupDoc) => lookupDoc.AddLookupDocumentId(processId),
actorDoc => actorDoc.RemoveLookupDocumentId(processId),
azureStorageRepository);
bool[] updates = resources
.Select(
resource =>
{
if (!resource.resourceId.HasValue)
{
return true;
}
rollback.AddTaskCreateOrUpdate <TResult, Documents.ProcessStepResourceKeyLookupDocument>(
resource.resourceId.Value, resource.type.AssemblyQualifiedName,
(created, lookupDoc) => lookupDoc.AddLookupDocumentId(processId),
lookupDoc => lookupDoc.RemoveLookupDocumentId(processId),
azureStorageRepository);
return true;
})
.ToArray();
return rollback.ExecuteAsync(onSuccess);
}));
}
