public async Task <IActionResult> Create([FromBody] DocumentCreateDto document)
{
if (document == null)
{
return(BadRequest());
}
int attemptsCount = 0;
int maxAttemptsCount = 100;
string slug;
bool isSlugUnique = false;
do
{
slug = document.Title.GenerateSlug();
isSlugUnique = (await _db.Documents.SingleOrDefaultAsync(d => d.Slug == slug)) == null;
} while (!isSlugUnique && attemptsCount < maxAttemptsCount);
if (!isSlugUnique)
{
return(BadRequest(new { message = "Cannot generate unique slug" }));
}
var newDocument = new Documents
{
ParentDocumentId = document.ParentDocumentId,
ProjectId = document.ProjectId,
CreatorId = UserId,
Slug = slug,
Title = document.Title,
Subtitle = document.Subtitle,
DateCreated = DateTime.UtcNow,
IsDraft = document.IsDraft
};
_db.Documents.Add(newDocument);
await _db.SaveChangesAsync();
await _db.Entry(newDocument).Reference(d => d.Creator).LoadAsync();
var newDocumentText = new DocumentText
{
DocumentId = newDocument.DocumentId,
EditorId = UserId,
Content = document.Content,
QuillDelta = document.QuillDelta,
TimeUpdated = DateTime.UtcNow
};
_db.DocumentText.Add(newDocumentText);
await _db.SaveChangesAsync();
await this.SaveActivity(newDocument.DocumentId, @"Document created: " + newDocument.Title, new {
document_id = newDocument.DocumentId,
type = "create"
});
return(Ok(await PrepareDocument(newDocument)));
}
public async Task <IActionResult> MarkSeen([FromBody] LastSeenCreateDto document)
{
if (document == null)
{
return(BadRequest());
}
var dbDocument = await _db.Documents.SingleOrDefaultAsync(d => d.DocumentId == document.DocumentId);
if (dbDocument == null)
{
return(NotFound());
}
var newLastSeen = new LastSeenDocuments {
UserId = UserId, DocumentId = document.DocumentId, TimeCreated = DateTime.UtcNow
};
_db.LastSeenDocuments.Add(newLastSeen);
await _db.SaveChangesAsync();
await _db.Entry(newLastSeen).Reference(l => l.Document).LoadAsync();
return(Ok(new LastSeenDto(newLastSeen)));
}
public async Task <IActionResult> Follow([FromBody] FollowingCreateDto following)
{
if (following == null)
{
return(BadRequest());
}
var project = await _db.Projects.SingleOrDefaultAsync(p => p.ProjectId == following.ProjectId);
if (project == null)
{
return(NotFound());
}
var existingFollowing = await _db.FollowedProjects.Include(f => f.Project).SingleOrDefaultAsync(f => f.ProjectId == following.ProjectId && f.UserId == UserId);
if (existingFollowing != null)
{
return(Ok(new FollowingDto(existingFollowing)));
}
var newFollowing = new FollowedProjects {
UserId = UserId, ProjectId = following.ProjectId, TimeCreated = DateTime.UtcNow
};
_db.FollowedProjects.Add(newFollowing);
await _db.SaveChangesAsync();
await _db.Entry(newFollowing).Reference(f => f.Project).LoadAsync();
return(Ok(new FollowingDto(newFollowing)));
}
public async Task <IActionResult> Create([FromBody] BookmarkCreateDto bookmark)
{
if (bookmark == null)
{
return(BadRequest());
}
var document = await _db.Documents.SingleOrDefaultAsync(d => d.DocumentId == bookmark.DocumentId);
if (document == null)
{
return(NotFound());
}
var existingBookmark = await _db.Bookmarks.Include(b => b.Document).SingleOrDefaultAsync(b => b.DocumentId == bookmark.DocumentId && b.UserId == UserId);
if (existingBookmark != null)
{
return(Ok(new BookmarkDto(existingBookmark)));
}
var newBookmark = new Bookmarks {
UserId = UserId, DocumentId = bookmark.DocumentId, TimeCreated = DateTime.UtcNow
};
_db.Bookmarks.Add(newBookmark);
await _db.SaveChangesAsync();
await _db.Entry(newBookmark).Reference(b => b.Document).LoadAsync();
return(Ok(new BookmarkDto(newBookmark)));
}
public async Task <IActionResult> Create([FromBody] TemplateCreateDto template)
{
if (template == null)
{
return(BadRequest());
}
int attemptsCount = 0;
int maxAttemptsCount = 100;
string slug;
bool isSlugUnique = false;
do
{
slug = template.Title.GenerateSlug();
isSlugUnique = (await _db.Templates.SingleOrDefaultAsync(d => d.Slug == slug)) == null;
} while (!isSlugUnique && attemptsCount < maxAttemptsCount);
if (!isSlugUnique)
{
return(BadRequest(new { message = "Cannot generate unique slug" }));
}
var newTemplate = new Templates
{
ProjectId = template.ProjectId,
TemplateTypeSlug = template.TemplateType,
CreatorId = UserId,
Slug = slug,
Title = template.Title,
Description = template.Description,
DateCreated = DateTime.UtcNow
};
_db.Templates.Add(newTemplate);
await _db.SaveChangesAsync();
await _db.Entry(newTemplate).Reference(d => d.Creator).LoadAsync();
var newTemplateText = new TemplateText
{
TemplateId = newTemplate.TemplateId,
EditorId = UserId,
Content = template.Content,
QuillDelta = template.QuillDelta,
TimeUpdated = DateTime.UtcNow
};
_db.TemplateText.Add(newTemplateText);
await _db.SaveChangesAsync();
return(Ok(new TemplateDto(newTemplate, template.Content)));
}
public async Task <IActionResult> Create([FromBody] ProjectCreateDto project)
{
if (project == null)
{
return(BadRequest());
}
int attemptsCount = 0;
int maxAttemptsCount = 100;
string slug;
bool isSlugUnique = false;
do
{
slug = project.Name.GenerateSlug();
isSlugUnique = (await _db.Projects.SingleOrDefaultAsync(p => p.Slug == slug)) == null;
} while (!isSlugUnique && attemptsCount < maxAttemptsCount);
if (!isSlugUnique)
{
return(BadRequest(new { message = "Cannot generate unique slug" }));
}
// Creating new project
var newProject = new Projects
{
Slug = slug,
Name = project.Name,
Description = project.Description,
Goal = project.Goal,
DateStart = project.DateStart,
DateEnd = project.DateEnd,
Avatar = project.Avatar,
IsOpen = project.IsOpen,
IsActive = project.IsActive
};
_db.Projects.Add(newProject);
await _db.SaveChangesAsync();
// Assigning team to project
foreach (var member in project.Team)
{
if (member == null)
{
continue;
}
if (member.ProjectRole == null)
{
continue;
}
var role = await _db.ProjectRoles.SingleOrDefaultAsync(r => r.ProjectRoleId == member.ProjectRole.ProjectRoleId);
if (role == null)
{
continue;
}
var existingMember = await _db.ProjectTeam.SingleOrDefaultAsync(t => t.UserId == member.UserId && t.ProjectId == newProject.ProjectId);
if (existingMember != null)
{
continue;
}
var newMember = new ProjectTeam
{
UserId = member.UserId,
ProjectId = newProject.ProjectId,
ProjectRoleId = member.ProjectRole.ProjectRoleId,
DateJoined = DateTime.UtcNow,
Position = member.Position
};
_db.ProjectTeam.Add(newMember);
}
await _db.SaveChangesAsync();
// Copying template for project
var projectIntroTemplate = await _db.Templates.SingleOrDefaultAsync(t => t.TemplateTypeSlug == "project_intro" && t.ProjectId == null);
if (projectIntroTemplate != null)
{
var newTemplate = new Templates {
TemplateTypeSlug = projectIntroTemplate.TemplateTypeSlug,
ProjectId = newProject.ProjectId,
CreatorId = UserId,
Slug = newProject.Name.GenerateSlug(),
Title = projectIntroTemplate.Title,
Description = projectIntroTemplate.Description,
DateCreated = DateTime.UtcNow
};
_db.Templates.Add(newTemplate);
await _db.SaveChangesAsync();
var templateText = await _db.TemplateText.SingleOrDefaultAsync(t => t.TemplateId == projectIntroTemplate.TemplateId && t.IsActual);
if (templateText != null)
{
var newTemplateText = new TemplateText {
TemplateId = newTemplate.TemplateId,
EditorId = UserId,
Content = templateText.Content,
QuillDelta = templateText.QuillDelta,
TimeUpdated = DateTime.UtcNow
};
_db.TemplateText.Add(newTemplateText);
await _db.SaveChangesAsync();
}
}
await _db.Entry(newProject).Collection(b => b.QuickLinksHousingProject).LoadAsync();
var membersCount = await _db.ProjectTeam.Where(pt => pt.ProjectId == newProject.ProjectId).CountAsync();
var permissions = await _dbconnection.QueryAsync <string>(
@"select pp.project_permission_slug from project_permissions as pp
left join project_role_permissions as prp on prp.project_permission_slug = pp.project_permission_slug
left join project_team as pt on pt.project_role_id = prp.project_role_id
where pt.user_id = @user_id and pt.project_id = @project_id
group by pp.project_permission_slug", new { user_id = UserId, project_id = newProject.ProjectId });
return(Ok(new ProjectDto(newProject, membersCount, permissions)));
}
