public void Init()
{
//todo Make Async and show activityindicator
//copy xml files on first load(should it be here?)
if (!LocalFileStorage.Exists(FILE_ARTGROUP))
{
LocalFileStorage.CopyToAppFolder(FILE_ARTGROUP);
}
if (!LocalFileStorage.Exists(FILE_ART))
{
LocalFileStorage.CopyToAppFolder(FILE_ART);
}
if (!LocalFileStorage.Exists(FILE_LOGGTYPE_GROUP))
{
LocalFileStorage.CopyToAppFolder(FILE_LOGGTYPE_GROUP);
}
if (!LocalFileStorage.Exists(FILE_LOGGTYPER))
{
LocalFileStorage.CopyToAppFolder(FILE_LOGGTYPER);
}
GetJegere();
GetArter();
GetDogs();
GetJakts();
GetLoggs();
GetSelectedArter();
GetSelectedLoggTyper();
}
public IFileStorage GetFileStorage(IOConnectionInfo iocInfo, bool allowCache)
{
IFileStorage fileStorage;
if (iocInfo.IsLocalFile())
{
fileStorage = new LocalFileStorage(this);
}
else
{
IFileStorage innerFileStorage = GetCloudFileStorage(iocInfo);
if (DatabaseCacheEnabled && allowCache)
{
fileStorage = new CachingFileStorage(innerFileStorage, Application.Context, this);
}
else
{
fileStorage = innerFileStorage;
}
}
if (fileStorage is IOfflineSwitchable)
{
((IOfflineSwitchable)fileStorage).IsOffline = App.Kp2a.OfflineMode;
}
return(fileStorage);
}
protected override void OnStart()
{
base.OnStart();
Kp2aLog.Log("FileSelect.OnStart");
//if no database is loaded: load the most recent database
if ((Intent.GetBooleanExtra(NoForwardToPasswordActivity, false) == false) && _dbHelper.HasRecentFiles() && !App.Kp2a.OpenDatabases.Any())
{
var fileStorage = new LocalFileStorage(App.Kp2a);
ICursor filesCursor = _dbHelper.FetchAllFiles();
filesCursor = new FilteredCursor(filesCursor, cursor => !fileStorage.IsLocalBackup(IOConnectionInfo.FromPath(cursor.GetString(1))));
StartManagingCursor(filesCursor);
if (filesCursor.Count > 0)
{
filesCursor.MoveToFirst();
IOConnectionInfo ioc = _dbHelper.CursorToIoc(filesCursor);
if (App.Kp2a.GetFileStorage(ioc).RequiresSetup(ioc) == false)
{
LaunchPasswordActivityForIoc(ioc);
}
else
{
App.Kp2a.GetFileStorage(ioc)
.PrepareFileUsage(new FileStorageSetupInitiatorActivity(this, OnActivityResult, null), ioc, 0, false);
}
}
}
}
/* GET ALL */
public List <T> GetEntity <T>(string filename) where T : class, IEntity
{
var localList = LocalFileStorage.LoadFromLocalStorage <List <T> >(filename);
var remoteList = new List <T>();
if (App.SyncWithServer)
{
remoteList = DataService.LoadFromServer <T>(filename);
if (remoteList != null && remoteList.Any())
{
if (localList == null || !localList.Any() || remoteList.Max(r => r.Changed) > localList.Max(l => l.Changed))
{
//remote er nyere enn local
remoteList.Save(filename);
localList = remoteList;
}
else if (!remoteList.Any() || remoteList.Max(r => r.Changed) < localList.Max(l => l.Changed))
{
//remote er eldre enn local
localList.UploadToServer(filename);
}
}
else
{
localList.UploadToServer(filename);
}
}
return(localList);
}
public async Task ExportGameEventToFile()
{
string csv = "";
for (int i = 0; i < this.Game.Sets.Count; i++)
{
csv += this.Game.Sets[i].Export(i + 1);
}
csv += "" + Environment.NewLine;
string filename = string.Empty;
if (!string.IsNullOrEmpty(this.Game.OpposingTeam))
{
filename += "-" + Game.OpposingTeam;
}
if (!string.IsNullOrEmpty(this.Game.Tournament))
{
filename += "-" + Game.Tournament;
}
if (!string.IsNullOrEmpty(this.Game.Name))
{
filename += "-" + Game.Name;
}
if (Game.Date.HasValue)
{
filename += "-" + Game.Date.Value.ToString("yyyy-MM-dd");
}
await LocalFileStorage.Save(filename, csv);
}
public IEnumerable <Art> GetArter()
{
ArtList = LocalFileStorage.LoadFromLocalStorage <List <Art> >(FILE_ART);
GetSelectedArter();
foreach (var art in SelectedArtList)
{
var artToSelect = ArtList.FirstOrDefault(a => a.ID == art.ID);
if (artToSelect != null)
{
artToSelect.Selected = true;
}
}
//ArtList.AddRange(LocalFileStorage.Load<List<Art>>(FILE_MY_ART)); //TODO: add this functionality (egne arter)
return(ArtList);
}
private void FillData()
{
// Get all of the rows from the database and create the item list
ICursor filesCursor = _dbHelper.FetchAllFiles();
if (FindViewById <Switch>(Resource.Id.local_backups_switch).Checked == false)
{
var fileStorage = new LocalFileStorage(App.Kp2a);
filesCursor = new FilteredCursor(filesCursor, cursor => !fileStorage.IsLocalBackup(IOConnectionInfo.FromPath(cursor.GetString(1))));
}
StartManagingCursor(filesCursor);
FragmentManager.FindFragmentById <RecentFilesFragment>(Resource.Id.recent_files).SetAdapter(new MyCursorAdapter(this, filesCursor, App.Kp2a));
}
static void Main(string[] args)
{
Config.Setup("appsettings.json", Directory.GetCurrentDirectory(), null, "MistwareFilesTest");
string connection = Config.Get("AzureConnectionString");
string container = Config.Get("AzureContainer");
string root = Config.Get("LocalFilesRoot");
string logs = Config.Get("Logs");
string testfile = "Test.log";
string testfolder = "ZZTestZZ";
// Setup Testing - creates a file called Test.log in ~/Temp
Directory.SetCurrentDirectory(root);
Log.Me.LogFile = testfile;
Log.Me.Info("Hello, World");
long length = (new FileInfo(testfile)).Length;
Directory.CreateDirectory(testfolder);
string dirsep = Path.DirectorySeparatorChar.ToString();
string upload = root;
string download = root + dirsep + testfolder;
IFile local = new LocalFileStorage(root);
Directory.SetCurrentDirectory(root);
FileTest(local, "Local", testfile, upload, "Test1", "Test2", download, length, true);
Console.WriteLine("");
IFile azure = new AzureFileStorage(connection, container);
FileTest(azure, "Azure", testfile, upload, "Test1", "Test2", download, length, true);
// Clear up test artifacts
Directory.SetCurrentDirectory(download);
File.Delete(testfile);
Directory.SetCurrentDirectory(upload);
Directory.Delete(testfolder);
File.Delete(testfile);
// Test Azure Blob Logging
Log.Me.Logger = new BlobLogger(connection, logs);
Log.Me.LogFile = "LoggerTest.log";
Log.Me.Info("This is a test");
}
public void SaveFileTest()
{
var environment = new Mock <IHostingEnvironment>();
environment.SetupGet(t => t.ContentRootPath).Returns("base/");
var fileGenerator = new Mock <IFileNameGenerator>();
fileGenerator.Setup(t => t.Generate(".jpg")).Returns("file.jpg");
var file = new Mock <IFormFile>();
file.SetupGet(t => t.FileName).Returns("upload.jpg");
file.Setup(t => t.CopyTo(null));
var repository = new LocalFileStorage(environment.Object, fileGenerator.Object);
var res = repository.SaveFile(file.Object);
Assert.AreEqual("base/file.jpg", res);
}
public async Task <IActionResult> Get(string id)
{
try
{
var fileInfo = await filesService.GetFileInfoAsync(id).ConfigureAwait(false);
if (fileInfo == null)
{
var nodeConnections = connectionsService.GetNodeConnections().Where(conn => conn.NodeWebSocket.State == WebSocketState.Open);
foreach (var nodeConnection in nodeConnections)
{
var filesInfo = await nodeRequestSender.GetFilesInformationAsync(new List <string> {
id
}, nodeConnection.Node.Id).ConfigureAwait(false);
if (!filesInfo.Any())
{
continue;
}
Uri fileUri = new Uri($"https://{nodeConnection.Node.Domains.FirstOrDefault()}:{nodeConnection.Node.NodesPort}/api/Files/{id}");
var fileRequest = WebRequest.CreateHttp(fileUri);
fileRequest.Method = HttpMethods.Get;
var fileResponse = (HttpWebResponse)await fileRequest.GetResponseAsync().ConfigureAwait(false);
var contentDisposition = fileResponse.Headers["content-disposition"];
string filename = id;
if (contentDisposition != null)
{
System.Net.Mime.ContentDisposition disposition = new System.Net.Mime.ContentDisposition(contentDisposition);
filename = disposition.FileName;
}
return(File(fileResponse.GetResponseStream(), MediaTypeNames.Application.Octet, filename));
}
return(StatusCode(StatusCodes.Status404NotFound));
}
if (fileInfo.Storage == "Local" || string.IsNullOrWhiteSpace(fileInfo.Storage))
{
LocalFileStorage localFileStorage = new LocalFileStorage();
if (fileInfo != null && fileInfo.Url != null)
{
return(File(await localFileStorage.GetStreamAsync(fileInfo.Url).ConfigureAwait(false), MediaTypeNames.Application.Octet, fileInfo.FileName));
}
else if (fileInfo != null && fileInfo.Url == null && fileInfo.NodeId != NodeSettings.Configs.Node.Id)
{
NodeVm nodeInformation = await nodesService.GetAllNodeInfoAsync(fileInfo.NodeId).ConfigureAwait(false);
Uri fileUri = new Uri($"https://{nodeInformation.Domains.FirstOrDefault()}:{nodeInformation.NodesPort}/api/Files/{fileInfo.Id}");
var fileRequest = WebRequest.CreateHttp(fileUri);
fileRequest.Method = HttpMethods.Get;
var fileResponse = await fileRequest.GetResponseAsync().ConfigureAwait(false);
return(File(fileResponse.GetResponseStream(), MediaTypeNames.Application.Octet, fileInfo.FileName));
}
else
{
return(NotFound());
}
}
else if (!string.IsNullOrWhiteSpace(fileInfo.Storage))
{
var stream = await fileStorage.GetStreamAsync(fileInfo.Id).ConfigureAwait(false);
return(File(stream, MediaTypeNames.Application.Octet, fileInfo.FileName));
}
else
{
return(NotFound());
}
}
catch (DownloadFileException ex)
{
if (ex.InnerException is WebException webException)
{
Console.WriteLine(ex.InnerException.ToString());
return(StatusCode(StatusCodes.Status503ServiceUnavailable));
}
return(StatusCode(StatusCodes.Status500InternalServerError));
}
catch (ObjectDoesNotExistsException)
{
return(NotFound());
}
catch (Exception ex)
{
Logger.WriteLog(ex);
return(StatusCode(StatusCodes.Status500InternalServerError));
}
}
public Database LoadDatabase(IOConnectionInfo ioConnectionInfo, MemoryStream memoryStream, CompositeKey compositeKey, ProgressDialogStatusLogger statusLogger, IDatabaseFormat databaseFormat, bool makeCurrent)
{
var prefs = PreferenceManager.GetDefaultSharedPreferences(Application.Context);
var createBackup = prefs.GetBoolean(Application.Context.GetString(Resource.String.CreateBackups_key), true) &&
!(new LocalFileStorage(this).IsLocalBackup(ioConnectionInfo));
MemoryStream backupCopy = new MemoryStream();
if (createBackup)
{
memoryStream.CopyTo(backupCopy);
backupCopy.Seek(0, SeekOrigin.Begin);
//reset stream if we need to reuse it later:
memoryStream.Seek(0, SeekOrigin.Begin);
}
foreach (Database openDb in _openDatabases)
{
if (openDb.Ioc.IsSameFileAs(ioConnectionInfo))
{
//TODO check this earlier and simply open the database's root group
throw new Exception("Database already loaded!");
}
}
_openAttempts.Add(ioConnectionInfo);
var newDb = new Database(new DrawableFactory(), this);
newDb.LoadData(this, ioConnectionInfo, memoryStream, compositeKey, statusLogger, databaseFormat);
if ((_currentDatabase == null) || makeCurrent)
{
_currentDatabase = newDb;
}
_openDatabases.Add(newDb);
if (createBackup)
{
statusLogger.UpdateMessage(Application.Context.GetString(Resource.String.UpdatingBackup));
Java.IO.File internalDirectory = IoUtil.GetInternalDirectory(Application.Context);
string baseDisplayName = App.Kp2a.GetFileStorage(ioConnectionInfo).GetDisplayName(ioConnectionInfo);
string targetPath = baseDisplayName;
var charsToRemove = "|\\?*<\":>+[]/'";
foreach (char c in charsToRemove)
{
targetPath = targetPath.Replace(c.ToString(), string.Empty);
}
if (targetPath == "")
{
targetPath = "local_backup";
}
var targetIoc = IOConnectionInfo.FromPath(new Java.IO.File(internalDirectory, targetPath).CanonicalPath);
using (var transaction = new LocalFileStorage(App.Kp2a).OpenWriteTransaction(targetIoc, false))
{
using (var file = transaction.OpenFile())
{
backupCopy.CopyTo(file);
transaction.CommitWrite();
}
}
Java.Lang.Object baseIocDisplayName = baseDisplayName;
string keyfile = App.Kp2a.FileDbHelper.GetKeyFileForFile(ioConnectionInfo.Path);
App.Kp2a.StoreOpenedFileAsRecent(targetIoc, keyfile, false, Application.Context.
GetString(Resource.String.LocalBackupOf, new Java.Lang.Object[] { baseIocDisplayName }));
prefs.Edit()
.PutBoolean(IoUtil.GetIocPrefKey(ioConnectionInfo, "has_local_backup"), true)
.PutBoolean(IoUtil.GetIocPrefKey(targetIoc, "is_local_backup"), true)
.Commit();
}
else
{
prefs.Edit()
.PutBoolean(IoUtil.GetIocPrefKey(ioConnectionInfo, "has_local_backup"), false) //there might be an older local backup, but we won't "advertise" this anymore
.Commit();
}
UpdateOngoingNotification();
return(newDb);
}
public IEnumerable <LoggTypeGroup> GetLoggTypeGroups()
{
LoggTypeGroupList = LocalFileStorage.LoadFromLocalStorage <List <LoggTypeGroup> >(FILE_LOGGTYPE_GROUP);
return(LoggTypeGroupList);
}
public IEnumerable <LoggType> GetLoggTyper()
{
LoggTypeList = LocalFileStorage.LoadFromLocalStorage <List <LoggType> >(FILE_LOGGTYPER);
return(LoggTypeList);
}
public IEnumerable <ArtGroup> GetArtGroups()
{
ArtGroupList = LocalFileStorage.LoadFromLocalStorage <List <ArtGroup> >(FILE_ARTGROUP);
return(ArtGroupList);
}
public FileAuditor(string path)
{
storage = LocalFileStorage.Create();
this.path = path;
}
public void LoadDatabase(IOConnectionInfo ioConnectionInfo, MemoryStream memoryStream, CompositeKey compositeKey,
ProgressDialogStatusLogger statusLogger, IDatabaseFormat databaseFormat)
{
var prefs = PreferenceManager.GetDefaultSharedPreferences(Application.Context);
var createBackup = prefs.GetBoolean(Application.Context.GetString(Resource.String.CreateBackups_key), true);
MemoryStream backupCopy = new MemoryStream();
if (createBackup)
{
memoryStream.CopyTo(backupCopy);
backupCopy.Seek(0, SeekOrigin.Begin);
//reset stream if we need to reuse it later:
memoryStream.Seek(0, SeekOrigin.Begin);
}
_db.LoadData(this, ioConnectionInfo, memoryStream, compositeKey, statusLogger, databaseFormat);
if (createBackup)
{
statusLogger.UpdateMessage(Application.Context.GetString(Resource.String.UpdatingBackup));
Java.IO.File internalDirectory = IoUtil.GetInternalDirectory(Application.Context);
string baseDisplayName = App.Kp2a.GetFileStorage(ioConnectionInfo).GetDisplayName(ioConnectionInfo);
string targetPath = baseDisplayName;
var charsToRemove = "|\\?*<\":>+[]/'";
foreach (char c in charsToRemove)
{
targetPath = targetPath.Replace(c.ToString(), string.Empty);
}
if (targetPath == "")
{
targetPath = "local_backup";
}
var targetIoc = IOConnectionInfo.FromPath(new Java.IO.File(internalDirectory, targetPath).CanonicalPath);
using (var transaction = new LocalFileStorage(App.Kp2a).OpenWriteTransaction(targetIoc, false))
{
var file = transaction.OpenFile();
backupCopy.CopyTo(file);
transaction.CommitWrite();
}
Java.Lang.Object baseIocDisplayName = baseDisplayName;
string keyfile = App.Kp2a.FileDbHelper.GetKeyFileForFile(ioConnectionInfo.Path);
App.Kp2a.StoreOpenedFileAsRecent(targetIoc, keyfile, Application.Context.
GetString(Resource.String.LocalBackupOf, new Java.Lang.Object[] { baseIocDisplayName }));
prefs.Edit()
.PutBoolean(IoUtil.GetIocPrefKey(ioConnectionInfo, "has_local_backup"), true)
.PutBoolean(IoUtil.GetIocPrefKey(targetIoc, "is_local_backup"), true)
.Commit();
}
else
{
prefs.Edit()
.PutBoolean(IoUtil.GetIocPrefKey(ioConnectionInfo, "has_local_backup"), false) //there might be an older local backup, but we won't "advertise" this anymore
.Commit();
}
UpdateOngoingNotification();
}
