public SessionConfigurationCache(IConfigurationService configurationService,
IShellBlueprintFactory blueprintFactory,
IUserFolder userfolder,
[Import(LogNames.Operations)] ILogWriter logger)
: this(configurationService, blueprintFactory.CreateBlueprint(), userfolder)
{
Logger = logger;
}
public CustomRegionFileImporter(IUserFolder folder
, IDomainSessionFactoryProvider provider
, IHospitalRegistryService hospitalRegistryService
, IEventAggregator events
, [Import(LogNames.Session)] ILogWriter logger)
: base(folder, provider, hospitalRegistryService, events, logger)
{
}
public PhysicianFileImporter(IUserFolder folder
, IDomainSessionFactoryProvider provider
, IHospitalRegistryService hospitalRegistryService
, IEventAggregator events
, [Import(LogNames.Session)] ILogWriter logger
, IConfigurationService configurationService)
: base(folder, provider, hospitalRegistryService, events, logger)
{
_configurationService = configurationService;
}
/// <inheritdoc/>
public async Task GetChildrenAsync(string pattern, IOperationContext operationContext, IFolderListingResultContext resultContext)
{
// This method has a 60 sec timeout.
// To process longer requests and reset the timout timer call one of the following:
// - resultContext.ReturnChildren() method.
// - resultContext.ReportProgress() method.
Logger.LogMessage($"IFolder.GetChildrenAsync({pattern})", UserFileSystemPath);
IUserFolder userFolder = await VirtualDrive.GetItemAsync <IUserFolder>(UserFileSystemPath);
IEnumerable <FileSystemItemBasicInfo> children = await userFolder.EnumerateChildrenAsync(pattern);
// Filtering existing files/folders. This is only required to avoid extra errors in the log.
List <IFileSystemItemBasicInfo> newChildren = new List <IFileSystemItemBasicInfo>();
foreach (FileSystemItemBasicInfo child in children)
{
string userFileSystemItemPath = Path.Combine(UserFileSystemPath, child.Name);
if (!FsPath.Exists(userFileSystemItemPath))
{
Logger.LogMessage("Creating", child.Name);
// If the file is moved/renamed and the app is not running this will help us
// to sync the file/folder to remote storage after app starts.
child.CustomData = new CustomData
{
OriginalPath = userFileSystemItemPath
}.Serialize();
newChildren.Add(child);
}
}
// To signal that the children enumeration is completed
// always call ReturnChildren(), even if the folder is empty.
resultContext.ReturnChildren(newChildren.ToArray(), newChildren.Count());
// Save ETags and set "locked by another user" icon.
foreach (FileSystemItemBasicInfo child in children)
{
string userFileSystemItemPath = Path.Combine(UserFileSystemPath, child.Name);
// Create ETags.
// ETags must correspond with a server file/folder, NOT with a client placeholder.
// It should NOT be moved/deleted/updated when a placeholder in the user file system is moved/deleted/updated.
// It should be moved/deleted when a file/folder in the remote storage is moved/deleted.
await ETag.SetETagAsync(userFileSystemItemPath, child.ETag);
// Set the "locked by another user" icon and all custom columns data.
await new UserFileSystemRawItem(userFileSystemItemPath).SetLockedByAnotherUserAsync(child.LockedByAnotherUser);
await new UserFileSystemRawItem(userFileSystemItemPath).SetCustomColumnsDataAsync(child.CustomProperties);
}
}
protected EntityFileImporter(IUserFolder folder
, IDomainSessionFactoryProvider provider
, IHospitalRegistryService hospitalRegistryService
, IEventAggregator events
, [Import(LogNames.Session)] ILogWriter logger)
{
Provider = provider;
Logger = logger;
Folder = folder;
Events = events;
HospitalRegistryService = hospitalRegistryService;
Description = string.Format("{0} Import", ExportAttribute.ContractName);
Inserted = new List <object>();
ImportErrors = new List <ImportError>();
}
public SessionConfigurationCache(IConfigurationService configurationService,
ShellBlueprint shellBlueprint,
IUserFolder userFolder)
{
ConfigurationService = configurationService;
UserFolder = userFolder;
_shellBlueprint = shellBlueprint;
_currentConfig = null;
Logger = NullLogger.Instance;
lock (syncRoot)
{
if (!HasBeenInitialized)
{
DeleteCache();
HasBeenInitialized = true;
}
}
}
public SessionFactoryHolder(
IConfigurationService configService,
[Import(RequiredCreationPolicy = CreationPolicy.Shared)]
IShellBlueprintFactory shellBlueprintFactory,
IDataServicesProviderFactory dataServicesProviderFactory,
IUserFolder userFolder,
[Import(RequiredCreationPolicy = CreationPolicy.Shared)]
ISessionConfigurationCache sessionConfigurationCache)
{
ConfigService = configService;
ShellBlueprint = shellBlueprintFactory.CreateBlueprint();
BluePrintFactory = () =>
{
shellBlueprintFactory.Reset();
return(shellBlueprintFactory.CreateBlueprint());
};
_dataServicesProviderFactory = dataServicesProviderFactory;
_userFolder = userFolder;
_sessionConfigurationCache = sessionConfigurationCache;
Logger = NullLogger.Instance;
}
/// <summary>
/// Creates or updates the item in the remote storage.
/// </summary>
/// <param name="mode">
/// Indicates if the file should created or updated.
/// Supported modes are <see cref="FileMode.CreateNew"/> and <see cref="FileMode.Open"/>
/// </param>
/// <param name="lockInfo">Information about the lock. Pass null if the item is not locked.</param>
private async Task CreateOrUpdateAsync(FileMode mode, ServerLockInfo lockInfo = null)
{
if ((mode != FileMode.CreateNew) && (mode != FileMode.Open))
{
throw new ArgumentOutOfRangeException("mode", $"Must be {FileMode.CreateNew} or {FileMode.Open}");
}
FileSystemInfo userFileSystemItem = FsPath.GetFileSystemItem(userFileSystemPath);
using (WindowsFileSystemItem userFileSystemWinItem = WindowsFileSystemItem.OpenReadAttributes(userFileSystemPath, FileMode.Open, FileShare.Read))
//await using (FileStream userFileSystemStream = userFileSystemFile.Open(FileMode.Open, FileAccess.Read, FileShare.Read))
{
// Create the new file/folder in the remote storage only if the file/folder in the user file system was not moved.
// If the file is moved in user file system, move must first be syched to remote storage.
if ((mode == FileMode.CreateNew) && PlaceholderItem.GetItem(userFileSystemPath).IsMoved())
{
string originalPath = PlaceholderItem.GetItem(userFileSystemPath).GetOriginalPath();
throw new ConflictException(Modified.Client, $"The item was moved. Original path: {originalPath}");
}
// Ensures LastWriteTimeUtc is in sync with file content after Open() was called.
userFileSystemItem.Refresh();
IFileSystemItemBasicInfo info = GetBasicInfo(userFileSystemItem);
// Update remote storage file.
FileStream userFileSystemStream = null;
try
{
string eTag = null;
if (FsPath.IsFile(userFileSystemPath))
{
// File is marked as not in-sync when updated OR moved.
// Opening a file for reading triggers hydration, make sure to open only if content is modified.
if (PlaceholderFile.GetFileDataSizeInfo(userFileSystemWinItem.SafeHandle).ModifiedDataSize > 0)
{
//userFileSystemStream = new FileStream(userFileSystemWinItem.SafeHandle, FileAccess.Read);
userFileSystemStream = ((FileInfo)userFileSystemItem).Open(FileMode.Open, FileAccess.Read, FileShare.Read);
}
if (mode == FileMode.CreateNew)
{
string userFileSystemParentPath = Path.GetDirectoryName(userFileSystemPath);
IUserFolder userFolder = await virtualDrive.GetItemAsync <IUserFolder>(userFileSystemParentPath);
eTag = await userFolder.CreateFileAsync((IFileBasicInfo)info, userFileSystemStream);
}
else
{
IUserFile userFile = await virtualDrive.GetItemAsync <IUserFile>(userFileSystemPath);
eTag = await userFile.UpdateAsync((IFileBasicInfo)info, userFileSystemStream, lockInfo);
}
}
else
{
if (mode == FileMode.CreateNew)
{
string userFileSystemParentPath = Path.GetDirectoryName(userFileSystemPath);
IUserFolder userFolder = await virtualDrive.GetItemAsync <IUserFolder>(userFileSystemParentPath);
eTag = await userFolder.CreateFolderAsync((IFolderBasicInfo)info);
}
else
{
IUserFolder userFolder = await virtualDrive.GetItemAsync <IUserFolder>(userFileSystemPath);
eTag = await userFolder.UpdateAsync((IFolderBasicInfo)info, lockInfo);
}
}
await ETag.SetETagAsync(userFileSystemPath, eTag);
if (mode == FileMode.CreateNew)
{
PlaceholderItem.GetItem(userFileSystemPath).SetOriginalPath(userFileSystemPath);
}
}
finally
{
if (userFileSystemStream != null)
{
userFileSystemStream.Close();
}
}
PlaceholderItem.SetInSync(userFileSystemWinItem.SafeHandle, true);
}
}
public SqlServerDataServicesProvider(string dataFolder, string connectionString, IUserFolder userFolder)
: base(userFolder)
{
_dataFolder = dataFolder;
_connectionString = connectionString;
}
protected AbstractDataServicesProvider(IUserFolder userFolder)
{
UserFolder = userFolder;
}
/// <summary>
/// Recursively synchronizes all files and folders from server to client.
/// Synchronizes only folders already loaded into the user file system.
/// </summary>
/// <param name="userFileSystemFolderPath">Folder path in user file system.</param>
internal async Task SyncronizeFolderAsync(string userFileSystemFolderPath)
{
// In case of on-demand loading the user file system contains only a subset of the server files and folders.
// Here we sync folder only if its content already loaded into user file system (folder is not offline).
// The folder content is loaded inside IFolder.GetChildrenAsync() method.
if (new DirectoryInfo(userFileSystemFolderPath).Attributes.HasFlag(System.IO.FileAttributes.Offline))
{
// LogMessage("Folder offline, skipping:", userFileSystemFolderPath);
return;
}
IEnumerable <string> userFileSystemChildren = Directory.EnumerateFileSystemEntries(userFileSystemFolderPath, "*");
//LogMessage("Synchronizing:", userFileSystemFolderPath);
IUserFolder userFolder = await virtualDrive.GetItemAsync <IUserFolder>(userFileSystemFolderPath);
IEnumerable <FileSystemItemBasicInfo> remoteStorageChildrenItems = await userFolder.EnumerateChildrenAsync("*");
// Create new files/folders in the user file system.
foreach (FileSystemItemBasicInfo remoteStorageItem in remoteStorageChildrenItems)
{
string userFileSystemPath = Path.Combine(userFileSystemFolderPath, remoteStorageItem.Name);
try
{
// We do not want to sync MS Office temp files, etc. from remote storage.
// We also do not want to create MS Office files during transactional save in user file system.
if (!FsPath.AvoidSync(remoteStorageItem.Name) && !FsPath.AvoidSync(userFileSystemPath))
{
if (!FsPath.Exists(userFileSystemPath))
{
LogMessage($"Creating", userFileSystemPath);
// If the file is moved/renamed and the app is not running this will help us
// to sync the file/folder to remote storage after app starts.
remoteStorageItem.CustomData = new CustomData
{
OriginalPath = userFileSystemPath
}.Serialize();
await UserFileSystemRawItem.CreateAsync(userFileSystemFolderPath, new[] { remoteStorageItem });
LogMessage($"Created succesefully", userFileSystemPath);
}
}
}
catch (Exception ex)
{
LogError("Creation failed", userFileSystemPath, null, ex);
}
}
// Update files/folders in user file system and sync subfolders.
userFileSystemChildren = Directory.EnumerateFileSystemEntries(userFileSystemFolderPath, "*");
foreach (string userFileSystemPath in userFileSystemChildren)
{
try
{
string itemName = Path.GetFileName(userFileSystemPath);
FileSystemItemBasicInfo remoteStorageItem = remoteStorageChildrenItems.FirstOrDefault(x => x.Name.Equals(itemName, StringComparison.InvariantCultureIgnoreCase));
if (!FsPath.AvoidSync(userFileSystemPath))
{
if (remoteStorageItem == null)
{
if (PlaceholderItem.GetItem(userFileSystemPath).GetInSync())
{
// Delete the file/folder in user file system.
LogMessage("Deleting item", userFileSystemPath);
await new UserFileSystemRawItem(userFileSystemPath).DeleteAsync();
LogMessage("Deleted succesefully", userFileSystemPath);
}
}
else
{
if (PlaceholderItem.GetItem(userFileSystemPath).GetInSync() &&
!await ETag.ETagEqualsAsync(userFileSystemPath, remoteStorageItem))
{
// User file system <- remote storage update.
LogMessage("Remote item modified", userFileSystemPath);
await new UserFileSystemRawItem(userFileSystemPath).UpdateAsync(remoteStorageItem);
LogMessage("Updated succesefully", userFileSystemPath);
}
// Set the "locked by another user" icon and all custom columns data.
if (PlaceholderItem.GetItem(userFileSystemPath).GetInSync())
{
await new UserFileSystemRawItem(userFileSystemPath).SetLockedByAnotherUserAsync(remoteStorageItem.LockedByAnotherUser);
await new UserFileSystemRawItem(userFileSystemPath).SetCustomColumnsDataAsync(remoteStorageItem.CustomProperties);
}
// Hydrate / dehydrate the file.
if (new UserFileSystemRawItem(userFileSystemPath).HydrationRequired())
{
LogMessage("Hydrating", userFileSystemPath);
new PlaceholderFile(userFileSystemPath).Hydrate(0, -1);
LogMessage("Hydrated succesefully", userFileSystemPath);
}
else if (new UserFileSystemRawItem(userFileSystemPath).DehydrationRequired())
{
LogMessage("Dehydrating", userFileSystemPath);
new PlaceholderFile(userFileSystemPath).Dehydrate(0, -1);
LogMessage("Dehydrated succesefully", userFileSystemPath);
}
}
}
}
catch (Exception ex)
{
LogError("Update failed", userFileSystemPath, null, ex);
}
// Synchronize subfolders.
try
{
if (Directory.Exists(userFileSystemPath))
{
await SyncronizeFolderAsync(userFileSystemPath);
}
}
catch (Exception ex)
{
LogError("Folder sync failed:", userFileSystemPath, null, ex);
}
}
}