private static ItemModel ConvertToItemModel(DbDocItem docItem)
{
return(new ItemModel
{
Id = docItem.Id,
Name = docItem.Name,
Type = ConvertToType(docItem.Type),
ParentId = docItem.ParentId,
Children = docItem.Children,
Size = docItem.Size,
AccessRole = docItem.AccessRole
});
}
private static DbDocItem GetItemById(DbMynaContext dbContext, DbUser user, long?id)
{
DbDocItem item = null;
if (id.HasValue)
{
return(dbContext.DbDocItems.SingleOrDefault(
item => item.OwnerId == user.Id && item.Id == id.Value));
}
else
{
item = dbContext.DbDocItems.SingleOrDefault(
item => item.OwnerId == user.Id && item.Type == DbDocItemType.Volume);
}
return(item);
}
public ItemModel CreateVolume(IPwdManService pwdManService, string authenticationToken, string name)
{
logger.LogDebug("Create volume '{name}'...", name);
name = name.Trim();
var user = pwdManService.GetUserFromToken(authenticationToken);
var dbContext = pwdManService.GetDbContext();
var docItem = GetVolume(dbContext, user);
if (docItem == null)
{
docItem = new DbDocItem {
Name = name,
Type = DbDocItemType.Volume,
OwnerId = user.Id
};
dbContext.DbDocItems.Add(docItem);
dbContext.SaveChanges();
}
return(ConvertToItemModel(docItem));
}
public ItemModel AddFolder(IPwdManService pwdManService, string authenticationToken, long parentId, string name)
{
logger.LogDebug("Add folder '{name}' into parent ID {parentId}...", name, parentId);
name = name.Trim();
var user = pwdManService.GetUserFromToken(authenticationToken);
var dbContext = pwdManService.GetDbContext();
var parentItem = GetItemById(dbContext, user, parentId);
if (parentItem != null)
{
var docItem = new DbDocItem
{
Name = name,
Type = DbDocItemType.Folder,
OwnerId = user.Id,
ParentId = parentId
};
dbContext.DbDocItems.Add(docItem);
parentItem.Children += 1;
dbContext.SaveChanges();
return(ConvertToItemModel(docItem));
}
return(null);
}
private static void MigrateDbContexts(ILogger logger, DbMynaContext srcContext, DbMynaContext destContext)
{
if (destContext.DbUsers.Any())
{
logger.LogWarning("Destination database already contains users. Migration aborted.");
return;
}
logger.LogInformation("Migrate Users...");
var users = srcContext.DbUsers.Include(u => u.Roles).Include(u => u.PasswordFile).OrderBy(u => u.Id);
foreach (var user in users)
{
var pgUser = new DbUser
{
Name = user.Name,
PasswordHash = user.PasswordHash,
Salt = user.Salt,
Email = user.Email,
Requires2FA = user.Requires2FA,
LoginTries = user.LoginTries,
LastLoginTryUtc = user.LastLoginTryUtc,
RegisteredUtc = user.RegisteredUtc,
LogoutUtc = user.LogoutUtc,
TOTPKey = user.TOTPKey,
PasswordFileId = null,
PasswordFile = null,
Roles = null,
UseLongLivedToken = user.UseLongLivedToken,
AllowResetPassword = user.AllowResetPassword,
Photo = user.Photo,
StorageQuota = user.StorageQuota
};
if (user.Roles != null)
{
pgUser.Roles = new List <DbRole>();
foreach (var role in user.Roles)
{
pgUser.Roles.Add(new DbRole {
Name = role.Name
});
}
}
if (user.PasswordFile != null)
{
pgUser.PasswordFile = new DbPasswordFile
{
Content = user.PasswordFile.Content,
LastWrittenUtc = user.PasswordFile.LastWrittenUtc
};
}
destContext.DbUsers.Add(pgUser);
}
destContext.SaveChanges();
logger.LogInformation("Migrate Chats...");
var chats = srcContext.DbChats.Include(c => c.DbUser).OrderBy(c => c.Id);
foreach (var chat in chats)
{
var pgUser = destContext.DbUsers.Single(u => u.Name == chat.DbUser.Name);
destContext.DbChats.Add(new DbChat
{
DbUser = pgUser,
Message = chat.Message,
CreatedUtc = chat.CreatedUtc
});
}
destContext.SaveChanges();
logger.LogInformation("Migrate Diaries...");
var diaries = srcContext.DbDiaries.Include(d => d.DbUser).OrderBy(d => d.Id);
foreach (var diary in diaries)
{
var pgUser = destContext.DbUsers.Single(u => u.Name == diary.DbUser.Name);
destContext.DbDiaries.Add(new DbDiary
{
DbUser = pgUser,
Entry = diary.Entry,
Date = diary.Date
});
}
destContext.SaveChanges();
logger.LogInformation("Migrate Notes...");
var notes = srcContext.DbNotes.Include(n => n.DbUser).OrderBy(n => n.Id);
foreach (var note in notes)
{
var pgUser = destContext.DbUsers.Single(u => u.Name == note.DbUser.Name);
destContext.DbNotes.Add(new DbNote
{
DbUser = pgUser,
Content = note.Content,
Title = note.Title,
ModifiedUtc = note.ModifiedUtc
});
}
destContext.SaveChanges();
logger.LogInformation("Migrate LoginIpAddresses...");
var loginIpAddresses = srcContext.DbLoginIpAddresses.Include(ip => ip.DbUser).OrderBy(ip => ip.Id);
foreach (var loginIpAddress in loginIpAddresses)
{
var pgUser = destContext.DbUsers.Single(u => u.Name == loginIpAddress.DbUser.Name);
destContext.DbLoginIpAddresses.Add(new DbLoginIpAddress
{
DbUser = pgUser,
IpAddress = loginIpAddress.IpAddress,
LastUsedUtc = loginIpAddress.LastUsedUtc,
Succeeded = loginIpAddress.Succeeded,
Failed = loginIpAddress.Failed
});
}
destContext.SaveChanges();
logger.LogInformation("Migrate Registrations...");
var registrations = srcContext.DbRegistrations.Include(r => r.ConfirmedBy).OrderBy(r => r.Id);
foreach (var registration in registrations)
{
DbUser pgUser = null;
if (registration.ConfirmedBy != null)
{
pgUser = destContext.DbUsers.Single(u => u.Name == registration.ConfirmedBy.Name);
}
destContext.DbRegistrations.Add(new DbRegistration
{
ConfirmedBy = pgUser,
ConfirmedUtc = registration.ConfirmedUtc,
Email = registration.Email,
IpAddress = registration.IpAddress,
RequestedUtc = registration.RequestedUtc,
Token = registration.Token
});
}
destContext.SaveChanges();
logger.LogInformation("Migrate ResetPasswords...");
var resetPasswords = srcContext.DbResetPasswords.OrderBy(r => r.Id);
foreach (var resetPassword in resetPasswords)
{
destContext.DbResetPasswords.Add(new DbResetPassword
{
Email = resetPassword.Email,
IpAddress = resetPassword.IpAddress,
RequestedUtc = resetPassword.RequestedUtc,
Token = resetPassword.Token
});
}
destContext.SaveChanges();
logger.LogInformation("Migrate Settings...");
var settings = srcContext.DbSettings.OrderBy(s => s.Id);
foreach (var setting in settings)
{
destContext.DbSettings.Add(new DbSetting
{
Key = setting.Key,
Value = setting.Value
});
}
destContext.SaveChanges();
logger.LogInformation("Migrate SkatResults...");
var idmap = new Dictionary <long, long>();
var skatResults = srcContext.DbSkatResults.OrderBy(r => r.Id);
foreach (var skatResult in skatResults)
{
var pgSkatResult = new DbSkatResult
{
StartedUtc = skatResult.StartedUtc,
EndedUtc = skatResult.EndedUtc,
Player1 = skatResult.Player1,
Player2 = skatResult.Player2,
Player3 = skatResult.Player3,
Player4 = skatResult.Player4
};
destContext.DbSkatResults.Add(pgSkatResult);
destContext.SaveChanges();
idmap[skatResult.Id] = pgSkatResult.Id;
}
logger.LogInformation("Migrate SkatGameHistories...");
var skatGameHistories = srcContext.DbSkatGameHistories.OrderBy(h => h.Id);
foreach (var skatGameHistory in skatGameHistories)
{
var pgSkatGameHistoy = new DbSkatGameHistory
{
DbSkatResultId = idmap[skatGameHistory.DbSkatResultId],
History = skatGameHistory.History
};
destContext.DbSkatGameHistories.Add(pgSkatGameHistoy);
destContext.SaveChanges();
}
logger.LogInformation("Migrate TetrisHighScores...");
var tetrisHighScores = srcContext.DbTetrisHighScore.OrderBy(h => h.Id);
foreach (var tetrisHighScore in tetrisHighScores)
{
destContext.DbTetrisHighScore.Add(new DbTetrisHighScore
{
Created = tetrisHighScore.Created,
Level = tetrisHighScore.Level,
Lines = tetrisHighScore.Lines,
Name = tetrisHighScore.Name,
Score = tetrisHighScore.Score
});
}
destContext.SaveChanges();
logger.LogInformation("Migrate UserSkatResults...");
var skatUsers = destContext.DbUsers.ToList();
foreach (var skatUser in skatUsers)
{
MigrateSkatUserResults(destContext, skatUser.Name, skatUser.Id);
}
logger.LogInformation("Migrate SkatReservations...");
var reservations = srcContext.DbSkatReservations.Include(r => r.ReservedBy).OrderBy(r => r.Id);
foreach (var reservation in reservations)
{
DbUser pgUser = null;
if (reservation.ReservedBy != null)
{
pgUser = destContext.DbUsers.Single(u => u.Name == reservation.ReservedBy.Name);
}
destContext.DbSkatReservations.Add(new DbSkatReservation
{
Duration = reservation.Duration,
Player1 = reservation.Player1,
Player2 = reservation.Player2,
Player3 = reservation.Player3,
Player4 = reservation.Player4,
ReservedBy = pgUser,
ReservedUtc = reservation.ReservedUtc,
EndUtc = reservation.EndUtc
});
}
destContext.SaveChanges();
logger.LogInformation("Migrate DocItems...");
var pgAllUsers = destContext.DbUsers.ToList();
foreach (var pgUser in pgAllUsers)
{
var sqliteUser = srcContext.DbUsers.SingleOrDefault(u => u.Name == pgUser.Name);
if (sqliteUser == null)
{
continue;
}
var docItems = new Queue <DbDocItem>();
var volume = DocumentService.GetVolume(srcContext, sqliteUser);
if (volume != null)
{
docItems.Enqueue(volume);
}
var idMap = new Dictionary <long, long>();
var ids = new List <long>();
while (docItems.Any())
{
var docItem = docItems.Dequeue();
ids.Add(docItem.Id);
foreach (var child in DocumentService.GetChildren(srcContext, sqliteUser, docItem))
{
docItems.Enqueue(child);
}
}
foreach (var id in ids)
{
var docItem = srcContext.DbDocItems
.Include(item => item.Content)
.Single(item => item.Id == id && item.OwnerId == sqliteUser.Id);
long?parentId = null;
if (docItem.ParentId.HasValue)
{
parentId = idMap[docItem.ParentId.Value];
}
var pgDocItem = new DbDocItem
{
Name = docItem.Name,
Type = docItem.Type,
OwnerId = pgUser.Id,
Size = docItem.Size,
Children = docItem.Children,
ParentId = parentId
};
if (docItem.Content != null)
{
pgDocItem.Content = new DbDocContent {
Data = docItem.Content.Data
};
}
destContext.DbDocItems.Add(pgDocItem);
destContext.SaveChanges();
idMap[docItem.Id] = pgDocItem.Id;
}
}
logger.LogInformation("Migration succeeded.");
}
public ItemModel UploadDocument(IPwdManService pwdManService, string authenticationToken, long parentId, string name, Stream stream, bool overwrite)
{
logger.LogDebug("Upload document with '{name}' into parent ID {parentId}...", name, parentId);
name = name.Trim();
var user = pwdManService.GetUserFromToken(authenticationToken);
var dbContext = pwdManService.GetDbContext();
var sum = dbContext.DbDocItems.Where(item => item.Type == DbDocItemType.Item && item.OwnerId == user.Id).Sum(item => item.Size);
var parentItem = GetItemById(dbContext, user, parentId);
if (parentItem != null)
{
DbDocItem docItem = null;
if (overwrite)
{
docItem = dbContext.DbDocItems.
Include(item => item.Content).
SingleOrDefault(item =>
item.Type == DbDocItemType.Item &&
item.ParentId == parentId &&
item.OwnerId == user.Id &&
item.Name == name);
if (docItem != null)
{
sum -= docItem.Size;
}
}
var ms = new MemoryStream();
stream.CopyTo(ms);
var size = ms.Length;
if (sum + size > user.StorageQuota)
{
throw new StorageQuotaExceededException();
}
if (docItem != null)
{
docItem.Size = size;
docItem.Content.Data = ms.ToArray();
docItem.AccessRole = parentItem.AccessRole;
}
else
{
docItem = new DbDocItem
{
Name = name,
Type = DbDocItemType.Item,
OwnerId = user.Id,
ParentId = parentId,
Size = size,
Content = new DbDocContent {
Data = ms.ToArray()
},
AccessRole = parentItem.AccessRole
};
dbContext.DbDocItems.Add(docItem);
parentItem.Children += 1;
}
dbContext.SaveChanges();
return(ConvertToItemModel(docItem));
}
return(null);
}
private static List <DbDocItem> GetAllChildren(DbMynaContext dbContext, DbUser user, DbDocItem docItem)
{
var ret = new List <DbDocItem>();
foreach (var child in GetChildren(dbContext, user, docItem))
{
ret.Add(child);
if (IsContainer(child))
{
ret.AddRange(GetAllChildren(dbContext, user, child));
}
}
return(ret);
}
private static List <DbDocItem> GetPath(DbMynaContext dbContext, DbUser user, DbDocItem item)
{
var ret = new List <DbDocItem>();
while (item != null && item.ParentId.HasValue)
{
item = GetItemById(dbContext, user, item.ParentId.Value);
if (item != null)
{
ret.Add(item);
}
}
return(ret);
}
public static List <DbDocItem> GetChildren(DbMynaContext dbContext, DbUser user, DbDocItem item)
{
return(dbContext.DbDocItems.Where(child => child.OwnerId == user.Id && child.ParentId == item.Id).ToList <DbDocItem>());
}
// ---- private methods
private static bool IsContainer(DbDocItem item) => item.Type == DbDocItemType.Folder || item.Type == DbDocItemType.Folder;
