378 lines
11 KiB
Dart
378 lines
11 KiB
Dart
import 'dart:io';
|
|
|
|
import 'package:logging/logging.dart';
|
|
import 'package:photos/models/file_type.dart';
|
|
import 'package:photos/models/location.dart';
|
|
import 'package:photos/models/file.dart';
|
|
import 'package:path/path.dart';
|
|
import 'package:sqflite/sqflite.dart';
|
|
import 'package:path_provider/path_provider.dart';
|
|
|
|
class FilesDB {
|
|
static final _databaseName = "ente.files.db";
|
|
static final _databaseVersion = 1;
|
|
|
|
static final Logger _logger = Logger("FilesDB");
|
|
|
|
static final table = 'files';
|
|
|
|
static final columnGeneratedId = '_id';
|
|
static final columnUploadedFileId = 'uploaded_file_id';
|
|
static final columnLocalId = 'local_id';
|
|
static final columnTitle = 'title';
|
|
static final columnDeviceFolder = 'device_folder';
|
|
static final columnLatitude = 'latitude';
|
|
static final columnLongitude = 'longitude';
|
|
static final columnFileType = 'file_type';
|
|
static final columnRemoteFolderId = 'remote_folder_id';
|
|
static final columnIsDeleted = 'is_deleted';
|
|
static final columnCreationTime = 'creation_time';
|
|
static final columnModificationTime = 'modification_time';
|
|
static final columnUpdationTime = 'updation_time';
|
|
|
|
// make this a singleton class
|
|
FilesDB._privateConstructor();
|
|
static final FilesDB instance = FilesDB._privateConstructor();
|
|
|
|
// only have a single app-wide reference to the database
|
|
static Database _database;
|
|
Future<Database> get database async {
|
|
if (_database != null) return _database;
|
|
// lazily instantiate the db the first time it is accessed
|
|
_database = await _initDatabase();
|
|
return _database;
|
|
}
|
|
|
|
// this opens the database (and creates it if it doesn't exist)
|
|
_initDatabase() async {
|
|
Directory documentsDirectory = await getApplicationDocumentsDirectory();
|
|
String path = join(documentsDirectory.path, _databaseName);
|
|
return await openDatabase(path,
|
|
version: _databaseVersion, onCreate: _onCreate);
|
|
}
|
|
|
|
// SQL code to create the database table
|
|
Future _onCreate(Database db, int version) async {
|
|
await db.execute('''
|
|
CREATE TABLE $table (
|
|
$columnGeneratedId INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
|
|
$columnLocalId TEXT,
|
|
$columnUploadedFileId INTEGER,
|
|
$columnTitle TEXT NOT NULL,
|
|
$columnDeviceFolder TEXT NOT NULL,
|
|
$columnLatitude REAL,
|
|
$columnLongitude REAL,
|
|
$columnFileType INTEGER,
|
|
$columnRemoteFolderId INTEGER,
|
|
$columnIsDeleted INTEGER DEFAULT 0,
|
|
$columnCreationTime TEXT NOT NULL,
|
|
$columnModificationTime TEXT NOT NULL,
|
|
$columnUpdationTime TEXT
|
|
)
|
|
''');
|
|
}
|
|
|
|
Future<int> insert(File file) async {
|
|
final db = await instance.database;
|
|
return await db.insert(table, _getRowForFile(file));
|
|
}
|
|
|
|
Future<List<dynamic>> insertMultiple(List<File> files) async {
|
|
final db = await instance.database;
|
|
var batch = db.batch();
|
|
int batchCounter = 0;
|
|
for (File file in files) {
|
|
if (batchCounter == 400) {
|
|
await batch.commit();
|
|
batch = db.batch();
|
|
}
|
|
batch.insert(table, _getRowForFile(file));
|
|
batchCounter++;
|
|
}
|
|
return await batch.commit();
|
|
}
|
|
|
|
Future<List<File>> getAllLocalFiles() async {
|
|
final db = await instance.database;
|
|
final results = await db.query(
|
|
table,
|
|
where: '$columnLocalId IS NOT NULL AND $columnIsDeleted = 0',
|
|
orderBy: '$columnCreationTime DESC',
|
|
);
|
|
return _convertToFiles(results);
|
|
}
|
|
|
|
Future<List<File>> getAllVideos() async {
|
|
final db = await instance.database;
|
|
final results = await db.query(
|
|
table,
|
|
where:
|
|
'$columnLocalId IS NOT NULL AND $columnFileType = 1 AND $columnIsDeleted = 0',
|
|
orderBy: '$columnCreationTime DESC',
|
|
);
|
|
return _convertToFiles(results);
|
|
}
|
|
|
|
Future<List<File>> getAllInFolder(
|
|
int folderId, int beforeCreationTime, int limit) async {
|
|
final db = await instance.database;
|
|
final results = await db.query(
|
|
table,
|
|
where:
|
|
'$columnRemoteFolderId = ? AND $columnIsDeleted = 0 AND $columnCreationTime < ?',
|
|
whereArgs: [folderId, beforeCreationTime],
|
|
orderBy: '$columnCreationTime DESC',
|
|
limit: limit,
|
|
);
|
|
return _convertToFiles(results);
|
|
}
|
|
|
|
Future<List<File>> getFilesCreatedWithinDuration(
|
|
int startCreationTime, int endCreationTime) async {
|
|
final db = await instance.database;
|
|
final results = await db.query(
|
|
table,
|
|
where:
|
|
'$columnCreationTime > ? AND $columnCreationTime < ? AND $columnIsDeleted = 0',
|
|
whereArgs: [startCreationTime, endCreationTime],
|
|
orderBy: '$columnCreationTime ASC',
|
|
);
|
|
return _convertToFiles(results);
|
|
}
|
|
|
|
Future<List<File>> getAllDeleted() async {
|
|
final db = await instance.database;
|
|
final results = await db.query(
|
|
table,
|
|
where: '$columnIsDeleted = 1',
|
|
orderBy: '$columnCreationTime DESC',
|
|
);
|
|
return _convertToFiles(results);
|
|
}
|
|
|
|
Future<List<File>> getFilesToBeUploaded() async {
|
|
final db = await instance.database;
|
|
final results = await db.query(
|
|
table,
|
|
where: '$columnUploadedFileId IS NULL',
|
|
orderBy: '$columnCreationTime DESC',
|
|
);
|
|
return _convertToFiles(results);
|
|
}
|
|
|
|
Future<File> getMatchingFile(String localId, String title,
|
|
String deviceFolder, int creationTime, int modificationTime,
|
|
{String alternateTitle}) async {
|
|
final db = await instance.database;
|
|
final rows = await db.query(
|
|
table,
|
|
where: '''$columnLocalId=? AND ($columnTitle=? OR $columnTitle=?) AND
|
|
$columnDeviceFolder=? AND $columnCreationTime=? AND $columnModificationTime=?''',
|
|
whereArgs: [
|
|
localId,
|
|
title,
|
|
alternateTitle,
|
|
deviceFolder,
|
|
creationTime,
|
|
modificationTime
|
|
],
|
|
);
|
|
if (rows.isNotEmpty) {
|
|
return _getFileFromRow(rows[0]);
|
|
} else {
|
|
throw ("No matching file found");
|
|
}
|
|
}
|
|
|
|
Future<File> getMatchingRemoteFile(int uploadedFileId) async {
|
|
final db = await instance.database;
|
|
final rows = await db.query(
|
|
table,
|
|
where: '$columnUploadedFileId=?',
|
|
whereArgs: [uploadedFileId],
|
|
);
|
|
if (rows.isNotEmpty) {
|
|
return _getFileFromRow(rows[0]);
|
|
} else {
|
|
throw ("No matching file found");
|
|
}
|
|
}
|
|
|
|
Future<int> update(int generatedId, int uploadedId, int updationTime) async {
|
|
final db = await instance.database;
|
|
final values = new Map<String, dynamic>();
|
|
values[columnUploadedFileId] = uploadedId;
|
|
values[columnUpdationTime] = updationTime;
|
|
return await db.update(
|
|
table,
|
|
values,
|
|
where: '$columnGeneratedId = ?',
|
|
whereArgs: [generatedId],
|
|
);
|
|
}
|
|
|
|
// TODO: Remove deleted files on remote
|
|
Future<int> markForDeletion(File file) async {
|
|
final db = await instance.database;
|
|
final values = new Map<String, dynamic>();
|
|
values[columnIsDeleted] = 1;
|
|
return db.update(
|
|
table,
|
|
values,
|
|
where: '$columnGeneratedId =?',
|
|
whereArgs: [file.generatedId],
|
|
);
|
|
}
|
|
|
|
Future<int> delete(File file) async {
|
|
final db = await instance.database;
|
|
return db.delete(
|
|
table,
|
|
where: '$columnGeneratedId =?',
|
|
whereArgs: [file.generatedId],
|
|
);
|
|
}
|
|
|
|
Future<int> deleteFilesInRemoteFolder(int folderId) async {
|
|
final db = await instance.database;
|
|
return db.delete(
|
|
table,
|
|
where: '$columnRemoteFolderId =?',
|
|
whereArgs: [folderId],
|
|
);
|
|
}
|
|
|
|
Future<List<String>> getLocalPaths() async {
|
|
final db = await instance.database;
|
|
final rows = await db.query(
|
|
table,
|
|
columns: [columnDeviceFolder],
|
|
distinct: true,
|
|
where: '$columnRemoteFolderId IS NULL',
|
|
);
|
|
List<String> result = List<String>();
|
|
for (final row in rows) {
|
|
result.add(row[columnDeviceFolder]);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
Future<File> getLatestFileInPath(String path) async {
|
|
final db = await instance.database;
|
|
final rows = await db.query(
|
|
table,
|
|
where: '$columnDeviceFolder =?',
|
|
whereArgs: [path],
|
|
orderBy: '$columnCreationTime DESC',
|
|
limit: 1,
|
|
);
|
|
if (rows.isNotEmpty) {
|
|
return _getFileFromRow(rows[0]);
|
|
} else {
|
|
throw ("No file found in path");
|
|
}
|
|
}
|
|
|
|
Future<File> getLatestFileInRemoteFolder(int folderId) async {
|
|
final db = await instance.database;
|
|
final rows = await db.query(
|
|
table,
|
|
where: '$columnRemoteFolderId =?',
|
|
whereArgs: [folderId],
|
|
orderBy: '$columnCreationTime DESC',
|
|
limit: 1,
|
|
);
|
|
if (rows.isNotEmpty) {
|
|
return _getFileFromRow(rows[0]);
|
|
} else {
|
|
throw ("No file found in remote folder " + folderId.toString());
|
|
}
|
|
}
|
|
|
|
Future<File> getLastSyncedFileInRemoteFolder(int folderId) async {
|
|
final db = await instance.database;
|
|
final rows = await db.query(
|
|
table,
|
|
where: '$columnRemoteFolderId =?',
|
|
whereArgs: [folderId],
|
|
orderBy: '$columnUpdationTime DESC',
|
|
limit: 1,
|
|
);
|
|
if (rows.isNotEmpty) {
|
|
return _getFileFromRow(rows[0]);
|
|
} else {
|
|
throw ("No file found in remote folder " + folderId.toString());
|
|
}
|
|
}
|
|
|
|
Future<File> getLatestFileAmongGeneratedIds(List<String> generatedIds) async {
|
|
final db = await instance.database;
|
|
final rows = await db.query(
|
|
table,
|
|
where: '$columnGeneratedId IN (${generatedIds.join(",")})',
|
|
orderBy: '$columnCreationTime DESC',
|
|
limit: 1,
|
|
);
|
|
if (rows.isNotEmpty) {
|
|
return _getFileFromRow(rows[0]);
|
|
} else {
|
|
throw ("No file found with ids " + generatedIds.join(", ").toString());
|
|
}
|
|
}
|
|
|
|
List<File> _convertToFiles(List<Map<String, dynamic>> results) {
|
|
final files = List<File>();
|
|
for (final result in results) {
|
|
files.add(_getFileFromRow(result));
|
|
}
|
|
return files;
|
|
}
|
|
|
|
Map<String, dynamic> _getRowForFile(File file) {
|
|
final row = new Map<String, dynamic>();
|
|
row[columnLocalId] = file.localId;
|
|
row[columnUploadedFileId] = file.uploadedFileId;
|
|
row[columnTitle] = file.title;
|
|
row[columnDeviceFolder] = file.deviceFolder;
|
|
if (file.location != null) {
|
|
row[columnLatitude] = file.location.latitude;
|
|
row[columnLongitude] = file.location.longitude;
|
|
}
|
|
switch (file.fileType) {
|
|
case FileType.image:
|
|
row[columnFileType] = 0;
|
|
break;
|
|
case FileType.video:
|
|
row[columnFileType] = 1;
|
|
break;
|
|
default:
|
|
row[columnFileType] = -1;
|
|
}
|
|
row[columnRemoteFolderId] = file.remoteFolderId;
|
|
row[columnCreationTime] = file.creationTime;
|
|
row[columnModificationTime] = file.modificationTime;
|
|
row[columnUpdationTime] = file.updationTime;
|
|
return row;
|
|
}
|
|
|
|
File _getFileFromRow(Map<String, dynamic> row) {
|
|
final file = File();
|
|
file.generatedId = row[columnGeneratedId];
|
|
file.localId = row[columnLocalId];
|
|
file.uploadedFileId = row[columnUploadedFileId];
|
|
file.title = row[columnTitle];
|
|
file.deviceFolder = row[columnDeviceFolder];
|
|
if (row[columnLatitude] != null && row[columnLongitude] != null) {
|
|
file.location = Location(row[columnLatitude], row[columnLongitude]);
|
|
}
|
|
file.fileType = getFileType(row[columnFileType]);
|
|
file.remoteFolderId = row[columnRemoteFolderId];
|
|
file.creationTime = int.parse(row[columnCreationTime]);
|
|
file.modificationTime = int.parse(row[columnModificationTime]);
|
|
file.updationTime = row[columnUpdationTime] == null
|
|
? -1
|
|
: int.parse(row[columnUpdationTime]);
|
|
return file;
|
|
}
|
|
}
|