/// <summary>
/// Performs an activation of the verification link.
/// </summary>
/// <returns>
/// If the link does not exist the method returns null.
/// If the link is already activated the method returns false.
/// If the link exists and was not activated the method returns true.
/// </returns>
public async Task <bool?> ActivateLinkAsync(string link)
{
try
{
var filter = new EqualityFilter <string>("link", link);
VerificationLink verificationLink = (await verificationLinksDatabase.Get(filter)).FirstOrDefault();
if (verificationLink == null)
{
return(null);
}
if (verificationLink.Used)
{
return(false);
}
verificationLink.Used = true;
await verificationLinksDatabase.Update(verificationLink, new[] { "Used" });
return(true);
}
catch (Exception ex)
{
exceptionLogger.Log(new ApplicationError(ex), LogLevel.Error, logConfiguration);
throw new DatabaseException("Error occured while working with the database");
}
}
private Filter <ITestDescriptor> GetNamespaceFilter(TestTreeNode namespaceNode)
{
var equalityFilter = new EqualityFilter <string>(namespaceNode.Id);
var namespaceFilter = new NamespaceFilter <ITestDescriptor>(equalityFilter);
if (optionsController.NamespaceHierarchy == NamespaceHierarchy.Flat)
{
return(namespaceFilter);
}
var filters = new List <Filter <ITestDescriptor> > {
namespaceFilter
};
foreach (var n in namespaceNode.Nodes)
{
var node = n as NamespaceNode;
if (node == null)
{
continue;
}
var filter = GetNamespaceFilter(node);
if (filter != null)
{
filters.Add(filter);
}
}
return(filters.Count > 1 ? new OrFilter <ITestDescriptor>(filters)
: filters[0]);
}
public async Task <WordDownloadLink> GetUnusedDownloadLink(ObjectId linkID)
{
try
{
await wordLinksDatabase.Connect().ConfigureAwait(false);
var filter = new EqualityFilter <ObjectId>("_id", linkID);
var wordDownloadLink = (await wordLinksDatabase.Get(filter).ConfigureAwait(false))
.FirstOrDefault();
if (wordDownloadLink is null)
{
throw new ArgumentException("No link was found for given ID");
}
if (wordDownloadLink.Used)
{
throw new ArgumentException("The link has already been used");
}
return(wordDownloadLink);
}
catch (Exception ex) when(ex.GetType() != typeof(ArgumentException))
{
exceptionLogger.Log(new ApplicationError(ex), LogLevel.Error, logConfiguration);
throw new DatabaseException("Error occured while working with the database");
}
}
public void CreateFilter(string key, Type filterType)
{
Filter <string> filterValue = new EqualityFilter <string>("");
Filter <ITestDescriptor> filter = (new TestDescriptorFilterFactory <ITestDescriptor>()).CreateFilter(key, filterValue);
Assert.AreEqual(filter.GetType(), filterType);
}
public async Task <TemplateDto> UpdateTemplate(TemplateUpdateDto dto)
{
try
{
await database.Connect().ConfigureAwait(false);
var idFilter = new EqualityFilter <ObjectId>("_id", dto.TemplateID);
Template template = (await database.Get(idFilter).ConfigureAwait(false)).FirstOrDefault();
if (template is null)
{
throw new ArgumentException("No template with such an ID");
}
var(newPublished, newName, newDesc, newOrg, newItems, newLogo) = dto;
template.Update(newPublished, newName, newDesc, newOrg, newItems, newLogo);
await database.Update(template).ConfigureAwait(false);
var templateAuthor = await userService.GetAsync(template.AuthorID).ConfigureAwait(false);
return(new TemplateDto(template, templateAuthor));
}
catch (Exception ex) when(ex.GetType() != typeof(ArgumentException))
{
exceptionLogger.Log(new ApplicationError(ex), LogLevel.Error, logConfiguration);
throw new DatabaseException("Error ocurred while updating the template");
}
}
public async Task <IEnumerable <TemplateDto> > SearchForUserTemplates(ObjectId userID, string query)
{
try
{
await database.Connect().ConfigureAwait(false);
var userFilter = new EqualityFilter <ObjectId>("authorID", userID);
var nameFilter = new RegexFilter("name", query);
var getFilter = userFilter & nameFilter;
var templates = await database.Get(getFilter).ConfigureAwait(false);
var author = await userService.GetAsync(userID);
if (author is null)
{
throw new ArgumentException("No user fot given ID");
}
return(templates.Select(template => new TemplateDto(template, author)));
}
catch (Exception ex) when(ex.GetType() != typeof(ArgumentException))
{
exceptionLogger.Log(new ApplicationError(ex), LogLevel.Error, logConfiguration);
throw new DatabaseException("Error ocurred while searching for templates");
}
}
public async Task <UserInfo> GetAsync(string email, string password)
{
try
{
await database.Connect();
FilterBase emailFilter = new EqualityFilter <string>(
typeof(UserInfo).GetBsonPropertyName("Email"), email);
FilterBase passwordFilter = new EqualityFilter <string>(
typeof(UserInfo).GetBsonPropertyName("Password"), password);
var users = (await database.Get(emailFilter & passwordFilter)).ToList();
if (users.Count != 1)
{
return(null);
}
return(users[0]);
}
catch (Exception ex) when(ex.GetType() != typeof(DatabaseException))
{
exceptionLogger.Log(new ApplicationError(ex), LogLevel.Error, logConfiguration);
throw new DatabaseException("Error occured while working with the database");
}
}
public async Task <DocumentElementDto> DeleteNodeAsync(ObjectId documentElementID, ObjectId branchNodeID,
ObjectId userID)
{
try
{
await database.Connect().ConfigureAwait(false);
FilterBase getFilter = new EqualityFilter <ObjectId>("_id", documentElementID);
var element = (await database.Get(getFilter).ConfigureAwait(false)).FirstOrDefault();
if (element is null)
{
throw new ArgumentException("No document element was found for id");
}
element.DeleteNode(branchNodeID);
await database.Update(element).ConfigureAwait(false);
var dto = new DocumentElementDto(element);
dto.SetBranches(element.Branches, userID);
return(dto);
}
catch (Exception ex) when(ex.GetType() != typeof(ArgumentException))
{
exceptionLogger.Log(new ApplicationError(ex), LogLevel.Error, logConfiguration);
throw new DatabaseException("Error occurred while deleting node");
}
}
public async Task <DocumentElementDto> CreateNewBranchAsync(ObjectId documentElementID, string branchName,
ObjectId userID)
{
try
{
await database.Connect().ConfigureAwait(false);
FilterBase getFilter = new EqualityFilter <ObjectId>("_id", documentElementID);
var element = (await database.Get(getFilter).ConfigureAwait(false)).FirstOrDefault();
if (element is null)
{
throw new ArgumentException("No document element was found for id");
}
element.Branches.Add(Branch.GetNewBranch(branchName, dateService, element.Type,
new List <BranchAccess>()
{
new BranchAccess(userID, BranchAccessType.ReadWrite)
}, userID));
await database.Update(element).ConfigureAwait(false);
var dto = new DocumentElementDto(element);
dto.SetBranches(element.Branches, userID);
return(dto);
}
catch (Exception ex) when(ex.GetType() != typeof(ArgumentException))
{
exceptionLogger.Log(new ApplicationError(ex), LogLevel.Error, logConfiguration);
throw new DatabaseException("Error occurred while creating new branch");
}
}
public async Task <TemplateDto> IncreaseDocumentCountForTemplate(ObjectId templateID)
{
try
{
await database.Connect().ConfigureAwait(false);
var idFilter = new EqualityFilter <ObjectId>("_id", templateID);
Template template = (await database.Get(idFilter).ConfigureAwait(false)).FirstOrDefault();
if (template is null)
{
throw new ArgumentException("No template with such an ID");
}
++template.DocumentCount;
await database.Update(template).ConfigureAwait(false);
var templateAuthor = await userService.GetAsync(template.AuthorID);
if (templateAuthor is null)
{
throw new ArgumentException("No user fot given ID");
}
return(new TemplateDto(template, templateAuthor));
}
catch (Exception ex) when(ex.GetType() != typeof(ArgumentException))
{
exceptionLogger.Log(new ApplicationError(ex), LogLevel.Error, logConfiguration);
throw new DatabaseException("Error ocurred while increasing documents count for templates");
}
}
public async Task ActivateCodeAsync(string code)
{
try
{
FilterBase codeFilter = new EqualityFilter <string>(typeof(ActivationCode)
.GetBsonPropertyName("Code"), code);
FilterBase usedFilter = new EqualityFilter <bool>(typeof(ActivationCode)
.GetBsonPropertyName("Used"), false);
await database.Connect().ConfigureAwait(false);
ActivationCode activationCode = (await database.Get(codeFilter & usedFilter)
.ConfigureAwait(false)).FirstOrDefault();
if (activationCode == null)
{
throw new DatabaseException("Such a code does not exist");
}
activationCode.Used = true;
activationCode.UsageDate = DateTime.UtcNow;
await database.Update(activationCode, new[] { "Used", "UsageDate" }).ConfigureAwait(false);
}
catch (Exception ex) when(ex.GetType() != typeof(DatabaseException))
{
exceptionLogger.Log(new ApplicationError(ex), LogLevel.Error, logConfiguration);
throw new DatabaseException("THe error happened while activating the code");
}
}
public async Task <DocumentElementDto> CreateNewNodeAsync(ObjectId documentElementID, ObjectId branchID,
ObjectId userID, string nodeName, string comment)
{
try
{
await database.Connect().ConfigureAwait(false);
FilterBase getFilter = new EqualityFilter <ObjectId>("_id", documentElementID);
var element = (await database.Get(getFilter).ConfigureAwait(false)).FirstOrDefault();
if (element is null)
{
throw new ArgumentException("No document element was found for id");
}
var branch = element.Branches.Find(b => b.BranchID == branchID);
if (branch is null)
{
throw new ArgumentException("No branch found for this id");
}
branch.BranchNodes.Add(BranchNode.GetEmptyNode(element.Type, dateService, userID, nodeName, comment));
await database.Update(element).ConfigureAwait(false);
var dto = new DocumentElementDto(element);
dto.SetBranches(element.Branches, userID);
return(dto);
}
catch (Exception ex) when(ex.GetType() != typeof(ArgumentException))
{
exceptionLogger.Log(new ApplicationError(ex), LogLevel.Error, logConfiguration);
throw new DatabaseException("Error occurred while creating new node");
}
}
public async Task <ProjectShortDto> UpdateProject(ProjectUpdateDto update)
{
try
{
await database.Connect().ConfigureAwait(false);
var getFilter = new EqualityFilter <ObjectId>("_id", update.ProjectID);
Project project = (await database.Get(getFilter).ConfigureAwait(false)).FirstOrDefault();
if (project is null)
{
throw new ArgumentException("No project was found for given ID");
}
UpdateProject(project, update);
await database.Update(project).ConfigureAwait(false);
return(new ProjectShortDto(project));
}
catch (Exception ex) when(ex.GetType() != typeof(ArgumentException))
{
exceptionLogger.Log(new ApplicationError(ex), LogLevel.Error, logConfiguration);
throw new DatabaseException("Error ocurred while updating project");
}
}
public async Task DeleteProject(ObjectId projectID)
{
try
{
await database.Connect().ConfigureAwait(false);
var getFilter = new EqualityFilter <ObjectId>("_id", projectID);
Project project = (await database.Get(getFilter).ConfigureAwait(false)).FirstOrDefault();
if (project is null)
{
throw new ArgumentException("Project was not found for given ID");
}
ObjectId authorID = project.Users.Where(u => u.Role == ProjectRole.Creator).First().UserID;
UserInfo author = await userService.GetAsync(authorID).ConfigureAwait(false);
if (author is null)
{
throw new ArgumentException("No author was found for project");
}
author.UserRelatedProjects.Remove(project.ID);
await userService.UpdateAsync(author).ConfigureAwait(false);
await database.Delete(getFilter).ConfigureAwait(false);
}
catch (Exception ex) when(ex.GetType() != typeof(ArgumentException))
{
exceptionLogger.Log(new ApplicationError(ex), LogLevel.Error, logConfiguration);
throw new DatabaseException("Error ocurred while deleting project");
}
}
public async Task AssociateFileWithDocumentAsync(ObjectId fileID, ObjectId documentID)
{
try
{
await database.Connect().ConfigureAwait(false);
FilterBase fileIDGetFilter = new EqualityFilter <ObjectId>("FileID", fileID);
var fileToDoc = (await database.Get(fileIDGetFilter).
ConfigureAwait(false)).FirstOrDefault();
if (fileToDoc is null)
{
fileToDoc = new Models.FileToDocument(fileID, documentID);
await database.Insert(fileToDoc).ConfigureAwait(false);
}
else
{
if (fileToDoc.DocumentID == documentID)
{
return;
}
fileToDoc.DocumentID = documentID;
await database.Update(fileToDoc).ConfigureAwait(false);
}
}
catch (Exception ex)
{
exceptionLogger.Log(new ApplicationError(ex), LogLevel.Error, logConfiguration);
throw new DatabaseException("The error occured while associating file with document", ex);
}
}
public async Task RenameFolder(ObjectId folderID, string newFolderName)
{
try
{
await database.Connect().ConfigureAwait(false);
var getFilter = new EqualityFilter <ObjectId>(typeof(DocumentFolder).GetBsonPropertyName("ID"), folderID);
DocumentFolder documentFolder = (await database.Get(getFilter).ConfigureAwait(false)).FirstOrDefault();
if (documentFolder == null)
{
throw new ArgumentException();
}
documentFolder.FolderName = newFolderName;
await database.Update(documentFolder).ConfigureAwait(false);
}
catch (Exception ex) when(ex.GetType() != typeof(ArgumentException))
{
exceptionLogger.Log(new ApplicationError(ex), LogLevel.Error, logConfiguration);
throw new DatabaseException("The error occured while renaming the folder");
}
}
public async Task <IEnumerable <ProjectShortDto> > GetUserShortProjectsAsync(ObjectId userID)
{
try
{
await database.Connect().ConfigureAwait(false);
UserInfo user = await userService.GetAsync(userID).ConfigureAwait(false);
List <ObjectId> projectsIDs = user.UserRelatedProjects;
if (projectsIDs is null || projectsIDs.Count == 0)
{
return(new List <ProjectShortDto>());
}
return(projectsIDs.Select(projectID =>
{
var filter = new EqualityFilter <ObjectId>("_id", projectID);
Project project = database.Get(filter).GetAwaiter().GetResult().FirstOrDefault();
if (project is null)
{
throw new ArgumentException("Project was not found for given id");
}
return project;
}).Select(project => new ProjectShortDto(project)));
}
catch (Exception ex) when(ex.GetType() != typeof(ArgumentException))
{
exceptionLogger.Log(new ApplicationError(ex), LogLevel.Error, logConfiguration);
throw new DatabaseException("Error ocurred while getting user projects");
}
}
public async Task <IEnumerable <TemplateDto> > GetUserTemplates(ObjectId userID)
{
try
{
await database.Connect().ConfigureAwait(false);
var getFilter = new EqualityFilter <ObjectId>("authorID", userID);
var templates = await database.Get(getFilter).ConfigureAwait(false);
var templatesAuthor = await userService.GetAsync(userID);
if (templatesAuthor is null)
{
throw new ArgumentException("No author for this template");
}
return(templates.Select(template => new TemplateDto(template, templatesAuthor)));
}
catch (Exception ex) when(ex.GetType() != typeof(ArgumentException))
{
exceptionLogger.Log(new ApplicationError(ex), LogLevel.Error, logConfiguration);
throw new DatabaseException("Error ocurred while getting user templates");
}
}
/// <summary>
/// Gets the collection of the single user's activities with a given userID.
/// </summary>
/// <returns>
/// Can return null if the user with a given ID does not exist.
/// </returns>
public async Task <IEnumerable <SingleUserActivity> > GetUserSingleActivitiesAsync(ObjectId userID)
{
await database.Connect();
var filter = new EqualityFilter <ObjectId>("userID", userID);
return((await database.Get(filter).ConfigureAwait(false)).FirstOrDefault()?.Activities);
}
/// <summary>
/// Gets the user activity for a user with a given ID.
/// </summary>
/// <returns>
/// Can return null if theere is no user with a given ID.
/// </returns>
public async Task <Domain.UserActivity.UserActivity> GetUserActivityAsync(ObjectId userID)
{
await database.Connect();
var filter = new EqualityFilter <ObjectId>("userID", userID);
return((await database.Get(filter).ConfigureAwait(false)).FirstOrDefault());
}
public async Task <DocumentElementDto> DeleteBranchAsync(ObjectId elementID, ObjectId branchID, ObjectId userID)
{
try
{
await database.Connect().ConfigureAwait(false);
FilterBase getFilter = new EqualityFilter <ObjectId>("_id", elementID);
var element = (await database.Get(getFilter).ConfigureAwait(false)).FirstOrDefault();
if (element is null)
{
throw new ArgumentException("No document element was found for id");
}
var branch = element.Branches.Find(branch => branch.BranchID == branchID);
if (branch is null)
{
throw new ArgumentException("There is no branch for given id");
}
element.Branches.Remove(branch);
if (element.Branches.Count == 0)
{
element.Branches.Add(Branch.GetNewBranch("New branch", dateService, element.Type,
new List <BranchAccess>()
{
new BranchAccess(userID, BranchAccessType.ReadWrite)
}, userID));
}
element.CurrentBranchID = element.Branches.First().BranchID;
if (element.Branches.First().BranchNodes.Count == 0)
{
element.Branches.First().BranchNodes.Add(BranchNode.GetEmptyNode(element.Type, dateService,
userID, "New node", "Comment"));
}
element.CurrentBranchNodeID = element.Branches.First().BranchNodes.First().BranchNodeID;
await database.Update(element).ConfigureAwait(false);
var dto = new DocumentElementDto(element);
dto.SetBranches(element.Branches, userID);
return(dto);
}
catch (Exception ex) when(ex.GetType() != typeof(ArgumentException))
{
exceptionLogger.Log(new ApplicationError(ex), LogLevel.Error, logConfiguration);
throw new DatabaseException("Error occurred while deleting branch");
}
}
public async Task DeleteDeskStateAsync(ObjectId userID)
{
try
{
await database.Connect().ConfigureAwait(false);
IFilter deletionFilter = new EqualityFilter <ObjectId>("userID", userID);
await database.Delete(deletionFilter).ConfigureAwait(false);
}
catch (Exception ex)
{
exceptionLogger.Log(new ApplicationError(ex), LogLevel.Error, logConfiguration);
throw new DatabaseException("The error occured while creating new document desk state");
}
}
public static void SafeAnd(this DomainCriteria value, EqualityFilter filter)
{
if (filter.IsNotNull())
{
if (filter.Value.IsNotNull())
{
if (filter.Value is string && filter.Value.AsString().IsNullOrEmpty())
{
return;
}
value.Filter &= filter;
}
}
}
public async Task <Domain.Workplace.DocumentsDeskState.DocumentDeskState> GetDeskStateAsync(ObjectId userID)
{
try
{
await database.Connect().ConfigureAwait(false);
var getFilter = new EqualityFilter <ObjectId>(typeof(Domain.Workplace.DocumentsDeskState.DocumentDeskState).GetBsonPropertyName("UserID"), userID);
return((await database.Get(getFilter).ConfigureAwait(false)).FirstOrDefault());
}
catch (Exception ex)
{
exceptionLogger.Log(new ApplicationError(ex), LogLevel.Error, logConfiguration);
throw new DatabaseException("The error occured while getting the desk state", ex);
}
}
public async Task <DocumentFolder> GetFolderData(ObjectId folderID)
{
try
{
await database.Connect().ConfigureAwait(false);
var getFilter = new EqualityFilter <ObjectId>(typeof(DocumentFolder).GetBsonPropertyName("ID"), folderID);
return((await database.Get(getFilter).ConfigureAwait(false)).FirstOrDefault());
}
catch (Exception ex)
{
exceptionLogger.Log(new ApplicationError(ex), LogLevel.Error, logConfiguration);
throw new DatabaseException("The error occured while getting the folder data");
}
}
public async Task <Models.FileToDocument> GetFileToDocumentModelAsync(ObjectId fileID)
{
try
{
await database.Connect().ConfigureAwait(false);
FilterBase getFilter = new EqualityFilter <ObjectId>("fileID", fileID);
return((await database.Get(getFilter).ConfigureAwait(false)).FirstOrDefault());
}
catch (Exception ex)
{
exceptionLogger.Log(new ApplicationError(ex), LogLevel.Error, logConfiguration);
throw new DatabaseException("Error ocured while getting the file-document info");
}
}
public async Task DeleteFolder(ObjectId folderID)
{
try
{
await database.Connect().ConfigureAwait(false);
var deletionFilter = new EqualityFilter <ObjectId>(typeof(DocumentFolder).GetBsonPropertyName("ID"),
folderID);
await database.Delete(deletionFilter).ConfigureAwait(false);
}
catch (Exception ex)
{
exceptionLogger.Log(new ApplicationError(ex), LogLevel.Error, logConfiguration);
throw new DatabaseException("The error occured while deleting the folder");
}
}
public async Task <IEnumerable <DocumentFolder> > GetFolders(ObjectId userID, string searchQuery)
{
try
{
await database.Connect().ConfigureAwait(false);
FilterBase idFilter = new EqualityFilter <ObjectId>(typeof(DocumentFolder).GetBsonPropertyName("ID"), userID);
FilterBase folderNameFilter = new RegexFilter(typeof(DocumentFolder).GetBsonPropertyName("FolderName"), $"/{searchQuery}/");
return(await database.Get(idFilter& folderNameFilter).ConfigureAwait(false));
}
catch (Exception ex)
{
exceptionLogger.Log(new ApplicationError(ex), LogLevel.Error, logConfiguration);
throw new DatabaseException("The error occured while searching for folders");
}
}
public async Task <IEnumerable <DocumentFolder> > GetFolders(ObjectId userID, ObjectId parentFolderID)
{
try
{
await database.Connect().ConfigureAwait(false);
FilterBase userIDFilter = new EqualityFilter <ObjectId>(typeof(DocumentFolder).GetBsonPropertyName("UserID"), userID);
FilterBase parentFolderFilter = new EqualityFilter <ObjectId>(typeof(DocumentFolder).GetBsonPropertyName("ParentFolderID"), parentFolderID);
return(await database.Get(userIDFilter& parentFolderFilter).ConfigureAwait(false));
}
catch (Exception ex)
{
exceptionLogger.Log(new ApplicationError(ex), LogLevel.Error, logConfiguration);
throw new DatabaseException("The error occured while getting your folders");
}
}
public async Task <UserInfo> GetAsync(string token)
{
try
{
JwtSecurityToken jwtSecurityToken = new JwtSecurityTokenHandler().ReadToken(token) as JwtSecurityToken;
string email = jwtSecurityToken.Claims.ToList().Find(c => c.Type == "Email").Value;
await database.Connect().ConfigureAwait(false);
var filter = new EqualityFilter <string>("email", email);
return((await database.Get(filter)).FirstOrDefault());
}
catch (Exception ex)
{
exceptionLogger.Log(new ApplicationError(ex), LogLevel.Error, logConfiguration);
throw new DatabaseException("Error occured while working with the database");
}
}
private Filter<ITestDescriptor> GetNamespaceFilter(TestTreeNode namespaceNode)
{
var equalityFilter = new EqualityFilter<string>(namespaceNode.Id);
var namespaceFilter = new NamespaceFilter<ITestDescriptor>(equalityFilter);
if (optionsController.NamespaceHierarchy == NamespaceHierarchy.Flat)
return namespaceFilter;
var filters = new List<Filter<ITestDescriptor>> { namespaceFilter };
foreach (var n in namespaceNode.Nodes)
{
var node = n as NamespaceNode;
if (node == null)
continue;
var filter = GetNamespaceFilter(node);
if (filter != null)
{
filters.Add(filter);
}
}
return filters.Count > 1 ? new OrFilter<ITestDescriptor>(filters)
: filters[0];
}
private Filter<ITestDescriptor> GenerateFilter(TestTreeNode node)
{
var equalityFilter = new EqualityFilter<string>(node.Id);
if (node is NamespaceNode)
{
return GetNamespaceFilter(node);
}
if (node is TestDataNode)
{
return new IdFilter<ITestDescriptor>(equalityFilter);
}
if (node is MetadataNode && node.Id != "None")
{
return new MetadataFilter<ITestDescriptor>(node.TestKind, equalityFilter);
}
return CreateFilter(node.Nodes);
}
public void CreateFilter(string key, Type filterType)
{
Filter<string> filterValue = new EqualityFilter<string>("");
Filter<ITestDescriptor> filter = (new TestDescriptorFilterFactory<ITestDescriptor>()).CreateFilter(key, filterValue);
Assert.AreEqual(filter.GetType(), filterType);
}
