public EntityTypesController(
EntityTypeLoader assemblyLoader,
DatabaseAccessService database)
{
_typeLoader = assemblyLoader;
_database = database;
}
public static async Task <ShrunkUrl> ShrinkUrlAsync(ShrinkRequest req)
{
var db = DatabaseAccessService.OpenOrCreateDefault();
// Return existing URL if it exists
var existingUrl = await RetrieveShrunkUrlByTargetAsync(req.Url);
if (existingUrl != null)
{
return(existingUrl);
}
var storedUrls = db.GetCollection <ShrunkUrl>(DatabaseAccessService.ShrunkUrlCollectionDatabaseKey);
var newShrunkUrl = new ShrunkUrl
{
Target = req.Url,
ShrunkPath = StringUtils.SecureRandomString(7),
CreatedTimestamp = DateTime.Now
};
await Task.Run(() =>
{
using (var trans = db.BeginTrans())
{
// save new url
storedUrls.Insert(newShrunkUrl);
storedUrls.EnsureIndex(x => x.ShrunkPath);
storedUrls.EnsureIndex(x => x.Target);
trans.Commit();
}
});
return(newShrunkUrl);
}
public async Task GetLayersAsync_ReturnLayerListCorrectly()
{
await DatabaseAccessService.DeleteDatabase();
await DatabaseAccessService.CreateDatabaseAsync();
var insertedLayer = new MapLayerItem()
{
Id = 1234124, Name = "Test Layer"
};
await DatabaseAccessService.InsertLayerAsync(insertedLayer);
var returnedList = await DatabaseAccessService.GetLayersAsync();
Assert.IsNotNull(returnedList, "Returned object is null");
Assert.AreEqual(1, returnedList.Count, $@"Returned list count is wrong.
Expected: {1},
Actual: {returnedList.Count}.");
var returnedLayer = returnedList.First();
Assert.IsNotNull(returnedLayer, "Database query for inserted layer returned null.");
Assert.AreEqual(insertedLayer.Id, returnedLayer.Id, $@"Database query for inserted layer returned layer with differrent Id.
Expected: {insertedLayer.Id},
Actual: {returnedLayer.Id}.");
Assert.AreEqual(insertedLayer.Name, returnedLayer.Name, $@"Database query for inserted layer returned layer with different Name.
Expected: {insertedLayer.Name},
Actual: {returnedLayer.Name}.");
}
public async Task UpdateQueryAsync()
{
var raw = await DatabaseAccessService.GetVirtualfolderImagesWithGroupsAndTags(DatabaseId);
var currentIds = AllImages.Select(i => i.DatabaseId).ToList();
var rawCount = raw.Count;
for (int i = rawCount - 1; i >= 0; i--)
{
for (int j = currentIds.Count - 1; j >= 0; j--)
{
if (raw[i].Id == currentIds[j])
{
raw.RemoveAt(i);
currentIds.RemoveAt(j);
break;
}
}
}
AllImages.RemoveAll(i => currentIds.Contains(i.DatabaseId));
foreach (var item in raw)
{
AllImages.Add(await ImageItem.FromDatabaseImage(item, viewMode: ImageItem.Options.None));
}
ReorderImages();
}
/// <summary>
/// Initializes the map page, populates it with data from the database.
/// </summary>
/// <returns></returns>
public async Task InitializeAsync()
{
MapLayers = new ObservableCollection <MapLayerItem>(await DatabaseAccessService.GetLayersAsync());
var elements = await DatabaseAccessService.GetMapElementItemsAsync();
foreach (var item in elements)
{
AddMapElementItem(item);
}
if (_locationService != null)
{
_locationService.PositionChanged += LocationService_PositionChanged;
var initializationSuccessful = await _locationService.InitializeAsync();
if (initializationSuccessful)
{
await _locationService.StartListeningAsync();
}
if (initializationSuccessful && _locationService.CurrentPosition != null)
{
Center = _locationService.CurrentPosition.Coordinate.Point;
}
else
{
Center = new Geopoint(_defaultPosition);
}
}
}
public async Task InsertLayerAsync_InsertsLayerCorrectly()
{
await DatabaseAccessService.DeleteDatabase();
await DatabaseAccessService.CreateDatabaseAsync();
var insertedLayer = new MapLayerItem()
{
Id = 1234124, Name = "Test Layer"
};
await DatabaseAccessService.InsertLayerAsync(insertedLayer);
using (var cnn = await DatabaseAccessService.GetDbConnectionAsync())
{
cnn.Open();
var queriedLayerList = (cnn.Query <MapLayerItem>($"SELECT * FROM Layer WHERE Id={insertedLayer.Id}")).ToList();
Assert.AreEqual(1, queriedLayerList.Count, $@"Database query for inserted layer returned list with number of entries
different than one.
Expected: 1,
Actual: {queriedLayerList.Count}.");
var queriedLayer = queriedLayerList.First();
Assert.IsNotNull(queriedLayer, "Database query for inserted layer returned null.");
Assert.AreEqual(insertedLayer.Id, queriedLayer.Id, $@"Database query for inserted layer returned layer with differrent Id.
Expected: {insertedLayer.Id},
Actual: {queriedLayer.Id}.");
Assert.AreEqual(insertedLayer.Name, queriedLayer.Name, $@"Database query for inserted layer returned layer with different Name.
Expected: {insertedLayer.Name},
Actual: {queriedLayer.Name}.");
}
}
private static async Task <DatabaseVirtualFolder> AddToDatabase(StorageFolder folder, int parentId = -1)
{
var dbvf = await DatabaseAccessService.InsertVirtualFolderAsync(folder.Name, parentId);
var subs = await folder.GetFoldersAsync();
foreach (var item in subs)
{
await AddToDatabase(item, dbvf.Id);
}
List <string> fileTypeFilter = new List <string>();
fileTypeFilter.Add(".jpg");
fileTypeFilter.Add(".png");
fileTypeFilter.Add(".bmp");
fileTypeFilter.Add(".gif");
var queryOptions = new QueryOptions(CommonFileQuery.OrderByName, fileTypeFilter);
queryOptions.FolderDepth = FolderDepth.Shallow;
var files = await folder.CreateFileQueryWithOptions(queryOptions).GetFilesAsync();
foreach (var file in files)
{
await DatabaseAccessService.InsertImageAsync(file.Path, false, dbvf.Id);
}
return(dbvf);
}
/// <summary>
/// Registers a stored file
/// </summary>
/// <param name="ownerName"></param>
/// <param name="fileName"></param>
/// <param name="identifier"></param>
/// <param name="fileSize"></param>
/// <returns></returns>
public async Task <StoredFile> RegisterStoredFileAsync(string ownerName, string fileName, string userPath, string identifier,
long fileSize)
{
return(await Task.Run(() =>
{
var userDatabaseLock = ServerContext.ServiceTable.GetOrCreate(ownerName).UserLock;
userDatabaseLock.ObtainExclusiveWrite();
var db = new DatabaseAccessService().OpenOrCreateDefault();
var storedFiles = db.GetCollection <StoredFile>(DatabaseAccessService.StoredFilesCollectionDatabaseKey);
var result = new StoredFile
{
Name = fileName,
Identifier = identifier,
FileSize = fileSize,
OwnerUsername = ownerName,
ParentDirPath = userPath
};
using (var trans = db.BeginTrans())
{
storedFiles.Insert(result);
trans.Commit();
}
userDatabaseLock.ReleaseExclusiveWrite();
// Index the database
storedFiles.EnsureIndex(x => x.Identifier);
return result;
}));
}
private async Task CreateAndAddMapPolygonAsync(IReadOnlyList <BasicGeoposition> path, Color fillColor, Color strokeColor, string name, MapLayerItem layer)
{
var newItem = MapElementItemFactoryService.GetMapPolygonItem(name, path, layer, strokeColor, fillColor);
AddMapElementItem(newItem);
await DatabaseAccessService.InsertMapPolygonItemAsync(newItem);
}
public async void InitializeThings()
{
if (!DatabaseAccessService.Initialized)
{
await DatabaseAccessService.InitializeDatabaseAsync();
}
}
/// <summary>
/// Attempts to register a new user. Only the username is validated, it is expected that other fields have already been validated!
/// </summary>
/// <param name="signupParams"></param>
/// <returns></returns>
public RegisteredUser RegisterUser(WebSignupParameters signupParams)
{
RegisteredUser newUserRecord = null;
if (FindUserByUsername(signupParams.Username) != null)
{
//BAD! Another conflicting user exists!
throw new SecurityException("A user with the same username already exists!");
}
using (var db = new DatabaseAccessService().OpenOrCreateDefault())
{
var registeredUsers = db.GetCollection <RegisteredUser>(DatabaseAccessService.UsersCollectionDatabaseKey);
//Calculate cryptographic info
var cryptoConf = PasswordCryptoConfiguration.CreateDefault();
var pwSalt = AuthCryptoHelper.GetRandomSalt(64);
var encryptedPassword = AuthCryptoHelper.CalculateUserPasswordHash(signupParams.Password, pwSalt, cryptoConf);
//Create user
newUserRecord = new RegisteredUser
{
Identifier = Guid.NewGuid(),
Username = signupParams.Username,
CryptoSalt = pwSalt,
PasswordCryptoConfiguration = cryptoConf,
PasswordKey = encryptedPassword,
};
//Add the user to the database
registeredUsers.Insert(newUserRecord);
//Index database
registeredUsers.EnsureIndex(x => x.Identifier);
}
return(newUserRecord);
}
public async Task DeleteMapElementAsync_DeletesMapElementCorrectly()
{
var taskSource = new TaskCompletionSource <object>();
await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(
CoreDispatcherPriority.Normal, async() =>
{
try
{
await DatabaseAccessService.DeleteDatabase();
await DatabaseAccessService.CreateDatabaseAsync();
var insertedLayer = new MapLayerItem()
{
Id = 1234124, Name = "Test Layer"
};
var path = new List <BasicGeoposition>()
{
new BasicGeoposition()
{
Latitude = 1, Longitude = 2
},
new BasicGeoposition()
{
Latitude = 3, Longitude = 4
},
new BasicGeoposition()
{
Latitude = 6, Longitude = 2
}
};
var insertedPolygon = MapElementItemFactoryService.GetMapPolygonItem("Test polygon", path,
insertedLayer, Color.FromArgb(0, 0, 0, 0), Color.FromArgb(0, 0, 0, 0));
await DatabaseAccessService.InsertLayerAsync(insertedLayer);
await DatabaseAccessService.InsertMapPolygonItemAsync(insertedPolygon);
await DatabaseAccessService.DeleteMapElementAsync(insertedPolygon.Id);
using (var cnn = await DatabaseAccessService.GetDbConnectionAsync())
{
cnn.Open();
var queriedMapElementList = await DatabaseAccessService.GetMapElementItemsAsync();
Assert.AreEqual(0, queriedMapElementList.Count, $@"Database query for inserted MapElement
returned list with number of entries different than zero.
Expected: 0,
Actual: {queriedMapElementList.Count}.");
}
taskSource.SetResult(null);
}
catch (Exception e)
{
taskSource.SetException(e);
}
});
await taskSource.Task;
}
static void showCarTypes()
{
using (var service = new DatabaseAccessService())
{
var carTypes = service.getCarTypes().Result;
carTypes.ToList().ForEach(c => Console.WriteLine("carType: " + c.carTypeName + ", basePriceModifier: " + c.basePriceModifier + ", kmPriceModifier: " + c.kmPriceModifier));
}
}
static void showActivatedReservations()
{
using (var service = new DatabaseAccessService())
{
var ares = service.getActivatedReservations().Result;
ares.ToList().ForEach(ar => Console.WriteLine("id: " + ar.id + ", car: " + ar.rentedCar + ", isCurrentlyActive: " + ar.isCurrentlyActive));
}
}
static void showReservations()
{
using (var service = new DatabaseAccessService())
{
var res = service.getReservations().Result;
res.ToList().ForEach(r => Console.WriteLine("id: " + r.id + ", carType: " + r.carType.carTypeName));
}
}
static void showCars()
{
using (var service = new DatabaseAccessService())
{
var cars = service.getRentalCars().Result;
cars.ToList().ForEach(c => Console.WriteLine("carPlate: " + c.carNumber + ", carType: " + c.rentalCarType.carTypeName + ", currentMileage: " + c.currentMileage));
}
}
static void showCustomers()
{
using (var service = new DatabaseAccessService())
{
var customers = service.getCustomers().Result;
customers.ToList().ForEach(c => Console.WriteLine("id: " + c.id + ", name: " + c.name));
}
}
public static async Task <IEnumerable <UrlRedirectEvent> > GetRedirectHistory(ShrunkUrl shrunkUrl, DateTime earliestDate)
{
return(await Task.Run(() =>
{
var db = DatabaseAccessService.OpenOrCreateDefault();
var storedUrls = db.GetCollection <UrlRedirectEvent>(DatabaseAccessService.ShrunkUrlCollectionDatabaseKey);
return storedUrls.Find(Query.Where(nameof(UrlRedirectEvent.Timestamp), x => x.AsDateTime > earliestDate));
}));
}
public static async Task <ShrunkUrl> RetrieveShrunkUrlAsync(string shrunkPath)
{
return(await Task.Run(() =>
{
var db = DatabaseAccessService.OpenOrCreateDefault();
var storedUrls = db.GetCollection <ShrunkUrl>(DatabaseAccessService.ShrunkUrlCollectionDatabaseKey);
return storedUrls.FindOne(x => x.ShrunkPath == shrunkPath);
}));
}
private async Task AddMapLayer(string name)
{
int newId = (MapLayers.Count == 0) ? 0 : MapLayers.Last().Id + 1;
MapLayers.Add(new MapLayerItem()
{
Id = newId, Name = name
});
await DatabaseAccessService.InsertLayerAsync(MapLayers.Last());
}
public async Task <StoredFile> GetStoredFileByIdentifierAsync(string id)
{
return(await Task.Run(() =>
{
var db = new DatabaseAccessService().OpenOrCreateDefault();
var storedFiles = db.GetCollection <StoredFile>(DatabaseAccessService.StoredFilesCollectionDatabaseKey);
return storedFiles
.FindOne(x => x.Identifier == id);
}));
}
public async Task RenameAsync(string newName)
{
if (newName.IndexOfAny(NameInvalidCharacters.ToCharArray()) != -1)
{
throw new FormatException();
}
await DatabaseAccessService.RenameVirtualFolderAsync(DatabaseId, newName);
Name = newName;
}
public async Task <IEnumerable <RegisteredUser> > GetAllUsersAsync()
{
return(await Task.Run(() =>
{
var db = new DatabaseAccessService().OpenOrCreateDefault();
var registeredUsers =
db.GetCollection <RegisteredUser>(DatabaseAccessService.UsersCollectionDatabaseKey);
return registeredUsers.FindAll();
}));
}
public async Task SetParentAsync(FolderItem folder)
{
if (folder is FolderItem)
{
await DatabaseAccessService.SetParentOfFolderAsync(DatabaseId, (folder as FolderItem).DatabaseId);
ParentFolder?.Subfolders?.Remove(this);
ParentFolder = folder;
folder.Subfolders.Add(this);
}
}
private async void TreeViewItem_Drop(object sender, DragEventArgs e)
{
foreach (var item in DragAndDropHelper.DraggedItems)
{
if (item is ImageItem imageItem)
{
await DatabaseAccessService.MoveImageToVirtualfolderAsync(imageItem.DatabaseId, ((sender as WinUI.TreeViewItem).DataContext as FolderItem).DatabaseId);
}
}
DragAndDropHelper.DropSuccessful = true;
}
public bool UpdateUserInDatabase(RegisteredUser currentUser)
{
bool result;
using (var db = new DatabaseAccessService().OpenOrCreateDefault())
{
var registeredUsers = db.GetCollection <RegisteredUser>(DatabaseAccessService.UsersCollectionDatabaseKey);
result = registeredUsers.Update(currentUser);
}
return(result);
}
public RegisteredUser FindUserByApiKey(string apiKey)
{
RegisteredUser storedUserRecord = null;
var db = new DatabaseAccessService().OpenOrCreateDefault();
var registeredUsers = db.GetCollection <RegisteredUser>(DatabaseAccessService.UsersCollectionDatabaseKey);
var userRecord = registeredUsers.FindOne(u => u.ApiKey == apiKey);
storedUserRecord = userRecord;
return(storedUserRecord ?? null);
}
public async Task <IEnumerable <StoredFile> > GetStoredFilesByUserAsync(RegisteredUser user)
{
return(await Task.Run(() =>
{
var db = new DatabaseAccessService().OpenOrCreateDefault();
var storedFiles = db.GetCollection <StoredFile>(DatabaseAccessService.StoredFilesCollectionDatabaseKey);
return storedFiles
.Find(x => x.OwnerUsername == user.Username)
.OrderByDescending(x => x.UploadedDate);
}));
}
private async Task CreateAndAddMapIconAsync(BasicGeoposition position, string title, MapLayerItem layer)
{
var pos = new BasicGeoposition()
{
Longitude = position.Longitude, Latitude = position.Latitude
};
var newItem = MapElementItemFactoryService.GetMapIconItem(title, pos, layer);
AddMapElementItem(newItem);
await DatabaseAccessService.InsertMapIconItemAsync(newItem);
}
public async Task GetDbConnectionAsync_ReturnsValidSQLiteConnection()
{
using (var connection = await DatabaseAccessService.GetDbConnectionAsync())
{
Assert.IsNotNull(connection, "Returned connection is null.");
connection.Open();
Assert.AreEqual(DatabaseAccessService.DbFile, connection.FileName, $@"Connection to a wrong DB file.\n
Expected: {DatabaseAccessService.DbFile},\n
Actual: {connection.FileName}");
}
}
