private void UpdateFile(ScribsDbContext db, TreeNodeModel model, Project project, Dictionary <string, TreeNodeModel> models)
{
models.Add(model.Key, model);
Directory parent = model.ParentKey == project.Key ? project : project.GetDirectory(model.ParentKey);
if (!project.TryGetFile(model.Key, out File file))
{
FileSystemItem.Create(parent, File.Type, model.label, model.Key, model.Index);
}
else
{
if (file.Parent != parent)
{
file.Move(parent);
}
if (file.Index != model.Index)
{
file.Index = model.Index;
}
if (file.Name.StartsWith(".") && file.Name != model.label)
{
file.Rename(model.label);
}
}
}
public async Task <SheetModel> Update(SheetModel model)
{
using (var db = new ScribsDbContext()) {
var user = GetUser(db);
var sheet = await Sheet.Factory.GetInstanceAsync(db, model.Id);
if (sheet.Name != model.Name)
{
sheet.Name = model.Name;
}
var kept = new HashSet <int>();
foreach (var fieldModel in model.Fields.Where(o => o.Id > 0))
{
kept.Add(fieldModel.Id);
var field = sheet.SheetFields.Single(o => o.Id == fieldModel.Id);
field.Value = fieldModel.Value;
}
foreach (var fieldModel in model.Fields.Where(o => o.Id == 0))
{
CreateField(db, sheet, fieldModel);
}
foreach (var field in sheet.SheetFields.Where(o => !kept.Contains(o.Id)))
{
sheet.SheetFields.Remove(field);
SheetField.Factory.Delete(db, field);
}
await db.SaveChangesAsync();
return(SheetModelUtils.GetModel(sheet));
}
}
private void CreateField(ScribsDbContext db, SheetTemplate template, SheetTemplateFieldModel fieldModel)
{
var field = SheetTemplateField.Factory.CreateInstance(db);
field.Label = fieldModel.Label;
field.Index = fieldModel.Index;
template.SheetTemplateFields.Add(field);
}
public Task <ItemModel> Get(DirectoryModel model)
{
using (var db = new ScribsDbContext()) {
var user = GetUser(db);
var directory = GetItem(user, model.Project, model.Key) as Directory;
return(DirectoryModelUtils.CreateDirectoryModelAsync(directory, model.Read ?? false));
}
}
public Task <string> Read(FileModel model)
{
using (var db = new ScribsDbContext()) {
var user = GetUser(db);
var file = GetItem(user, model.Project, model.Key) as File;
return(file.DownloadTextAsync());
}
}
private void CreateField(ScribsDbContext db, Sheet sheet, SheetFieldModel fieldModel)
{
var field = SheetField.Factory.CreateInstance(db);
field.Value = field.Value;
field.SheetTemplateFieldId = fieldModel.SheetTemplateFieldId;
sheet.SheetFields.Add(field);
}
public Task <ItemModel> Get(FileModel model)
{
using (var db = new ScribsDbContext()) {
var user = GetUser(db);
var file = GetItem(user, model.Project, model.Key) as File;
return(FileModelUtils.CreateFileModelAsync(file, model.Read ?? false));
}
}
public Task Write(FileModel model)
{
using (var db = new ScribsDbContext()) {
var user = GetUser(db);
var file = GetItem(user, model.Project, model.Key) as File;
var time = Utils.DateFromJs(model.Time);
return(time > file.Time ? file.UploadTextAsync(model.Text, time) : null);
}
}
//[HttpGet]
//public bool ValidateToken() {
// return true;
//}
//[HttpGet]
//public UserModel GetUserModel(ScribsDbContext db) {
// var user = GetUser(db);
// return new UserModel {
// Id = user.Id,
// Name = user.Name
// };
//}
public User GetUser(ScribsDbContext db)
{
try {
var principal = RequestContext.Principal as ClaimsPrincipal;
var userId = int.Parse(principal.Claims.First(o => o.Type == ClaimTypes.NameIdentifier).Value);
return(Scribs.User.Factory.GetInstance(db, userId));
} catch {
throw new HttpResponseException(HttpStatusCode.ExpectationFailed);
}
}
private static bool ValidateToken(string token, out int?userId)
{
using (var db = new ScribsDbContext()) {
userId = null;
try {
var success = true;
var jwtToken = JwtManager.GetJwtToken(token);
ClaimsPrincipal simplePrinciple = JwtManager.GetPrincipal(db, jwtToken, out Access access);
if (simplePrinciple == null)
{
success = false;
}
else
{
var identity = simplePrinciple.Identity as ClaimsIdentity;
if (identity == null || !identity.IsAuthenticated)
{
success = false;
}
else
{
var agentIdClaim = identity.FindFirst(ClaimTypes.NameIdentifier);
if (agentIdClaim != null)
{
userId = int.Parse(agentIdClaim.Value);
}
if (!userId.HasValue)
{
success = false;
}
}
}
if (access != null)
{
if (success)
{
access.CTime = DateTime.Now;
}
else
{
access.Status = Status.Expired;
}
access.MTime = DateTime.Now;
db.SaveChanges();
}
else
{
success = false;
}
return(success);
} catch (Exception) {
return(false);
}
}
}
public IEnumerable <ProjectModel> GetAll()
{
using (var db = new ScribsDbContext()) {
var user = GetUser(db);
var projects = user.GetProjects();
return(projects.Select(o => new ProjectModel {
Name = o.Name,
Key = o.Key
}));
}
}
public async Task <SheetTemplateModel> Post(SheetTemplateModel model)
{
using (var db = new ScribsDbContext()) {
var user = GetUser(db);
var template = SheetTemplate.Factory.CreateInstance(db);
template.ProjectKey = model.ProjectKey;
template.Name = model.Name;
foreach (var fieldModel in model.Fields.Values)
{
CreateField(db, template, fieldModel);
}
await db.SaveChangesAsync();
return(SheetModelUtils.GetModel(template, true));
}
}
public async Task <SheetModel> Post(SheetModel model)
{
using (var db = new ScribsDbContext()) {
var user = GetUser(db);
var sheet = Sheet.Factory.CreateInstance(db);
sheet.ProjectKey = model.ProjectKey;
sheet.Name = model.Name;
sheet.SheetTemplateId = model.SheetTemplateId;
foreach (var fieldModel in model.Fields)
{
CreateField(db, sheet, fieldModel);
}
await db.SaveChangesAsync();
return(SheetModelUtils.GetModel(sheet));
}
}
public async Task <TreeNodeModel> Get(ProjectModel model)
{
using (var db = new ScribsDbContext()) {
var user = GetUser(db);
var project = user.GetProject(model.Name);
List <SheetTemplate> templates = null;
if (model.Read.HasValue && model.Read.Value)
{
templates = db.SheetTemplates.Where(o => o.ProjectKey == project.Key).ToList();
}
var result = await ProjectModelUtils.CreateProjectModelAsync(project, model.Read ?? false);
var tree = ProjectModelUtils.ProjectToTreeItemModel(result);
tree.draggable = false;
tree.Intern = true;
return(tree);
}
}
private void UpdateDirectory(ScribsDbContext db, TreeNodeModel model, Project project, Dictionary <string, TreeNodeModel> models)
{
models.Add(model.Key, model);
Directory directory = project;
Directory parent = null;
if (model.ParentKey != null)
{
project.TryGetDirectory(model.ParentKey, out parent);
}
if (model.Key != project.Key)
{
if (!project.TryGetDirectory(model.Key, out directory))
{
FileSystemItem.Create(parent, Directory.Type, model.label, model.Key, model.Index);
}
else
{
if (directory.Parent != parent)
{
directory.Move(parent);
}
if (directory.Index != model.Index)
{
directory.Index = model.Index;
}
if (!directory.Name.StartsWith(".") && directory.Name != model.label)
{
directory.Rename(model.label);
}
}
}
foreach (var child in model.children.Where(o => !o.IsLeaf))
{
UpdateDirectory(db, child, project, models);
}
foreach (var child in model.children.Where(o => o.IsLeaf))
{
UpdateFile(db, child, project, models);
}
}
public void Put(TreeNodeModel model)
{
using (var db = new ScribsDbContext()) {
var user = GetUser(db);
var project = user.GetProject(model.label);
var time = Utils.DateFromJs(model.Time);
if (time <= project.Time)
{
return;
}
var models = new Dictionary <string, TreeNodeModel>();
// Creations/Modifications
UpdateDirectory(db, model, project, models);
// Deletions
var keys = project.GetAllItems().Select(o => o.Key).ToList();
var deleted = new HashSet <string>();
foreach (var key in keys)
{
if (!deleted.Contains(key) && project.TryGetItem(key, null, out FileSystemItem item))
{
if (item != null && !models.ContainsKey(key))
{
item.Delete();
var directory = item as Directory;
if (directory != null)
{
foreach (var node in directory.Node.Descendants())
{
deleted.Add((string)node.Attribute("key"));
}
}
deleted.Add(item.Key);
}
}
}
project.Time = time;
project.Save();
}
}
public TokenModel SignUp(UserModel model)
{
using (var db = new ScribsDbContext()) {
if (String.IsNullOrEmpty(model.Username) || String.IsNullOrEmpty(model.Password) || String.IsNullOrEmpty(model.Mail))
{
throw new Exception("Some fields are missing");
}
if (model.Username.Length > 40)
{
throw new Exception("This username is too long");
}
var user = db.Users.SingleOrDefault(o => o.Name == model.Username);
if (user != null)
{
throw new Exception("This username is already taken");
}
user = db.Users.SingleOrDefault(o => o.Mail == model.Mail);
if (user != null)
{
throw new Exception("This email is already used");
}
user = Scribs.User.Factory.CreateInstance(db);
user.Name = model.Username;
user.Password = model.Password;
user.Mail = model.Mail;
try {
user.CreateDirectory();
} catch {
throw new Exception("Some special characters in your username are not supported");
}
db.Users.Add(user);
db.SaveChanges();
var result = new TokenModel();
var access = db.Accesses.FirstOrDefault(o => o.UserId == user.Id && o.Status == Status.Active);
result.Token = access != null ? access.Token : JwtManager.GenerateToken(db, user, model);
return(result);
}
throw new HttpResponseException(HttpStatusCode.Unauthorized);
}
public async Task <SheetTemplateModel> Update(SheetTemplateModel model)
{
using (var db = new ScribsDbContext()) {
var user = GetUser(db);
var template = await SheetTemplate.Factory.GetInstanceAsync(db, model.Id);
if (template.Name != model.Name)
{
template.Name = model.Name;
}
var kept = new HashSet <int>();
foreach (var kvp in model.Fields.Where(o => o.Key > 0))
{
kept.Add(kvp.Key);
var field = template.SheetTemplateFields.Single(o => o.Id == kvp.Key);
field.Label = kvp.Value.Label;
field.Index = kvp.Value.Index;
}
foreach (var fieldModel in model.Fields.Where(o => o.Key == 0).Select(o => o.Value))
{
CreateField(db, template, fieldModel);
}
foreach (var field in template.SheetTemplateFields.Where(o => !kept.Contains(o.Id)))
{
foreach (var sheet in template.Sheets)
{
var sheetField = sheet.SheetFields.SingleOrDefault(o => o.SheetTemplateFieldId == field.Id);
sheet.SheetFields.Remove(sheetField);
SheetField.Factory.Delete(db, sheetField);
}
template.SheetTemplateFields.Remove(field);
SheetTemplateField.Factory.Delete(db, field);
}
await db.SaveChangesAsync();
return(SheetModelUtils.GetModel(template, true));
}
}
public TokenModel SignIn(UserModel model)
{
using (var db = new ScribsDbContext()) {
if (String.IsNullOrEmpty(model.Username) || String.IsNullOrEmpty(model.Password))
{
throw new Exception("Wrong username and/or password");
}
var user = db.Users.SingleOrDefault(o => o.Name == model.Username);
if (user == null)
{
throw new Exception("This username does not exist");
}
if (user.Password != model.Password)
{
throw new Exception("Wrong password");
}
var result = new TokenModel();
var access = db.Accesses.FirstOrDefault(o => o.UserId == user.Id && o.Status == Status.Active);
result.Token = access != null ? access.Token : JwtManager.GenerateToken(db, user, model);
return(result);
}
throw new HttpResponseException(HttpStatusCode.Unauthorized);
}
public async Task <ProjectModel> Post(ProjectModel model)
{
using (var db = new ScribsDbContext()) {
var user = GetUser(db);
int index = user.GetProjects().Count();
var project = new Project(user, model.Name, false);
if (project.ExistsItem())
{
throw new System.Exception("This project already exists");
}
project.CreateItem();
project.Load();
project.Type = (Project.ProjectTypes)model.Type;
project.Description = model.Description;
project.Structure = model.Structure.Aggregate((a, b) => a + ";" + b);
project.Index = 0;
project.Key = Guid.NewGuid().ToString();
// Basic sheet templates
var charTemplate = SheetTemplate.Factory.CreateInstance(db);
charTemplate.User = user;
charTemplate.ProjectKey = project.Key;
charTemplate.Name = "Characters";
int i = 0;
foreach (string label in new List <string> {
"Name",
"Description",
"Personality",
"Occupation",
"Objective",
"Habits",
"Conflicts",
"Relatives",
"Notes"
})
{
var field = SheetTemplateField.Factory.CreateInstance(db);
field.Index = i++;
field.Label = label;
field.SheetTemplate = charTemplate;
charTemplate.SheetTemplateFields.Add(field);
}
var setTemplate = SheetTemplate.Factory.CreateInstance(db);
setTemplate.User = user;
setTemplate.ProjectKey = project.Key;
setTemplate.Name = "Settings";
i = 0;
foreach (string label in new List <string> {
"Name",
"Description",
"Sights",
"Sounds",
"Smells",
"Notes"
})
{
var field = SheetTemplateField.Factory.CreateInstance(db);
field.Index = i++;
field.Label = label;
field.SheetTemplate = setTemplate;
setTemplate.SheetTemplateFields.Add(field);
}
await db.SaveChangesAsync();
// Drafts
var draftDirectory = FileSystemItem.Create(project, Directory.Type, ".Drafts", Guid.NewGuid().ToString(), 0) as Directory;
FileSystemItem.Create(draftDirectory, File.Type, "Draft 1", Guid.NewGuid().ToString(), 0);
// Structure generation
var folders = model.Structure.Length > 1 ? model.Structure.Take(model.Structure.Length - 1) :
new List <string> {
"folder"
};
var file = model.Structure.Length > 0 ? model.Structure.Last() : "file";
var directory = project as Directory;
foreach (string folder in folders)
{
string directoryName = folder.Substring(0, 1).ToUpper() + folder.Substring(1, folder.Length - 1) + " 1";
directory = FileSystemItem.Create(directory, Directory.Type, directoryName, Guid.NewGuid().ToString(), 0) as Directory;
}
string fileName = file.Substring(0, 1).ToUpper() + file.Substring(1, file.Length - 1) + " 1";
FileSystemItem.Create(directory, File.Type, fileName, Guid.NewGuid().ToString(), 0);
project.Save();
return(new ProjectModel {
Name = model.Name,
Discriminator = Discriminator.Directory,
Key = project.Key
});
}
}
