internal static void Save(Stream stream, SaveFilter filter)
{
if (filter == SaveFilter.SaveWorld)
{
lock (Game.Workspace.Locker)
{
if (Game.Workspace.PlaceId != string.Empty)
{
Inst.Serialize(Game.Workspace, stream);
stream.Position = 0;
Engine.SavePlace?.Invoke(Game.Workspace.PlaceId, stream);
}
else
{
Game.DataModel.Logger.Warn($"Workspace.Place is empty: cannot save.");
}
}
}
if (filter == SaveFilter.SaveGame)
{
Inst.Serialize(Game.DataModel, stream, includeWorkspaceInGame: false);
stream.Position = 0;
Engine.SaveGame?.Invoke(stream);
}
if (filter == SaveFilter.SaveTogether)
{
Inst.Serialize(Game.DataModel, stream, includeWorkspaceInGame: true);
}
}
/// <summary>
/// Saves the given <see cref="ConnectionTreeModel"/>.
/// If <see cref="useDatabase"/> is true, <see cref="connectionFileName"/> is ignored
/// </summary>
/// <param name="connectionTreeModel"></param>
/// <param name="useDatabase"></param>
/// <param name="saveFilter"></param>
/// <param name="connectionFileName"></param>
/// <param name="forceSave">Bypasses safety checks that prevent saving if a connection file isn't loaded.</param>
/// <param name="propertyNameTrigger">
/// Optional. The name of the property that triggered
/// this save.
/// </param>
public void SaveConnections(ConnectionTreeModel connectionTreeModel,
bool useDatabase,
SaveFilter saveFilter,
string connectionFileName,
bool forceSave = false,
string propertyNameTrigger = "")
{
if (connectionTreeModel == null)
{
return;
}
if (!forceSave && !IsConnectionsFileLoaded)
{
return;
}
if (_batchingSaves)
{
_saveRequested = true;
return;
}
try
{
Runtime.MessageCollector.AddMessage(MessageClass.InformationMsg, "Saving connections...");
RemoteConnectionsSyncronizer?.Disable();
var previouslyUsingDatabase = UsingDatabase;
var saver = useDatabase
? (ISaver <ConnectionTreeModel>) new SqlConnectionsSaver(saveFilter,
_localConnectionPropertiesSerializer,
_localConnectionPropertiesDataProvider)
: new XmlConnectionsSaver(connectionFileName, saveFilter);
saver.Save(connectionTreeModel, propertyNameTrigger);
if (UsingDatabase)
{
LastSqlUpdate = DateTime.Now;
}
UsingDatabase = useDatabase;
ConnectionFileName = connectionFileName;
RaiseConnectionsSavedEvent(connectionTreeModel, previouslyUsingDatabase, UsingDatabase,
connectionFileName);
Runtime.MessageCollector.AddMessage(MessageClass.InformationMsg, "Successfully saved connections");
}
catch (Exception ex)
{
Runtime.MessageCollector?.AddExceptionMessage(
string.Format(Language.strConnectionsFileCouldNotSaveAs,
connectionFileName), ex, logOnly: false);
}
finally
{
RemoteConnectionsSyncronizer?.Enable();
}
}
public DataTableSerializer(SaveFilter saveFilter,
ICryptographyProvider cryptographyProvider,
SecureString encryptionKey)
{
_saveFilter = saveFilter.ThrowIfNull(nameof(saveFilter));
_cryptographyProvider = cryptographyProvider.ThrowIfNull(nameof(cryptographyProvider));
_encryptionKey = encryptionKey.ThrowIfNull(nameof(encryptionKey));
}
public SqlConnectionsSaver(SaveFilter saveFilter)
{
if (saveFilter == null)
{
throw new ArgumentNullException(nameof(saveFilter));
}
_saveFilter = saveFilter;
}
public void Setup()
{
_saveFilter = new SaveFilter();
_dataTableSerializer = new DataTableSerializer(
_saveFilter,
new LegacyRijndaelCryptographyProvider(),
new SecureString());
}
public void Setup()
{
_cryptographyProvider = new CryptographyProviderFactory().CreateAeadCryptographyProvider(BlockCipherEngines.AES, BlockCipherModes.GCM);
var saveFilter = new SaveFilter();
_documentCompiler = new XmlConnectionsDocumentCompiler(_cryptographyProvider, saveFilter);
_connectionTreeModel = SetupConnectionTreeModel();
}
public CsvConnectionsSerializerMremotengFormat(SaveFilter saveFilter, ICredentialRepositoryList credentialRepositoryList)
{
saveFilter.ThrowIfNull(nameof(saveFilter));
credentialRepositoryList.ThrowIfNull(nameof(credentialRepositoryList));
_saveFilter = saveFilter;
_credentialRepositoryList = credentialRepositoryList;
}
public void Setup()
{
var connectionTreeModel = SetupConnectionTreeModel();
var cryptoProvider = new CryptographyProviderFactory().CreateAeadCryptographyProvider(BlockCipherEngines.AES, BlockCipherModes.GCM);
var saveFilter = new SaveFilter();
_originalDocument = new XmlConnectionsDocumentCompiler(cryptoProvider, saveFilter).CompileDocument(connectionTreeModel, false, false);
_documentEncryptor = new XmlConnectionsDocumentEncryptor(cryptoProvider);
}
public void SerializerRespectsSaveFilterSettings(string valueThatShouldntExist)
{
var saveFilter = new SaveFilter(true);
var serializer = new CsvConnectionsSerializerMremotengFormat(saveFilter, _credentialRepositoryList);
var connectionInfo = BuildConnectionInfo();
var csv = serializer.Serialize(connectionInfo);
Assert.That(csv, Does.Not.Match(valueThatShouldntExist));
}
public static void ExportToFile(ConnectionInfo selectedNode, ConnectionTreeModel connectionTreeModel)
{
try
{
var saveFilter = new SaveFilter();
using (var exportForm = new ExportForm())
{
if (selectedNode?.GetTreeNodeType() == TreeNodeType.Container)
{
exportForm.SelectedFolder = selectedNode as ContainerInfo;
}
else if (selectedNode?.GetTreeNodeType() == TreeNodeType.Connection)
{
if (selectedNode.Parent.GetTreeNodeType() == TreeNodeType.Container)
{
exportForm.SelectedFolder = selectedNode.Parent;
}
exportForm.SelectedConnection = selectedNode;
}
if (exportForm.ShowDialog(FrmMain.Default) != DialogResult.OK)
{
return;
}
ConnectionInfo exportTarget;
switch (exportForm.Scope)
{
case ExportForm.ExportScope.SelectedFolder:
exportTarget = exportForm.SelectedFolder;
break;
case ExportForm.ExportScope.SelectedConnection:
exportTarget = exportForm.SelectedConnection;
break;
default:
exportTarget = connectionTreeModel.RootNodes.First(node => node is RootNodeInfo);
break;
}
saveFilter.SaveUsername = exportForm.IncludeUsername;
saveFilter.SavePassword = exportForm.IncludePassword;
saveFilter.SaveDomain = exportForm.IncludeDomain;
saveFilter.SaveInheritance = exportForm.IncludeInheritance;
saveFilter.SaveCredentialId = exportForm.IncludeAssignedCredential;
SaveExportFile(exportForm.FileName, exportForm.SaveFormat, saveFilter, exportTarget);
}
}
catch (Exception ex)
{
Runtime.MessageCollector.AddExceptionMessage("App.Export.ExportToFile() failed.", ex);
}
}
public void InheritanceNotSerialiedWhenFiltered(string attributeName, ConnectionInfo connectionInfo)
{
var saveFilter = new SaveFilter(true);
_connectionNodeSerializer = new XmlConnectionNodeSerializer(_cryptographyProvider, "myPassword1".ConvertToSecureString(), saveFilter);
var returnVal = _connectionNodeSerializer.SerializeConnectionInfo(connectionInfo);
var targetAttribute = returnVal.Attribute(XName.Get(attributeName));
Assert.That(targetAttribute?.Value, Is.EqualTo(false.ToString()));
}
public void AttributesNotSerializedWhenFiltered(string attributeName, ConnectionInfo connectionInfo)
{
var saveFilter = new SaveFilter(true);
var cryptoProvider = new CryptographyProviderFactory().CreateAeadCryptographyProvider(BlockCipherEngines.AES, BlockCipherModes.GCM);
_connectionNodeSerializer = new XmlConnectionNodeSerializer(cryptoProvider, "myPassword1".ConvertToSecureString(), saveFilter);
var returnVal = _connectionNodeSerializer.SerializeConnectionInfo(connectionInfo);
var targetAttribute = returnVal.Attribute(XName.Get(attributeName));
Assert.That(targetAttribute?.Value, Is.EqualTo(string.Empty));
}
public SqlConnectionsSaver(
SaveFilter saveFilter,
ISerializer <IEnumerable <LocalConnectionPropertiesModel>, string> localPropertieSerializer,
IDataProvider <string> localPropertiesDataProvider)
{
if (saveFilter == null)
{
throw new ArgumentNullException(nameof(saveFilter));
}
_saveFilter = saveFilter;
_localPropertiesSerializer = localPropertieSerializer.ThrowIfNull(nameof(localPropertieSerializer));
_dataProvider = localPropertiesDataProvider.ThrowIfNull(nameof(localPropertiesDataProvider));
}
public XmlConnectionsDocumentCompiler(ICryptographyProvider cryptographyProvider, SaveFilter saveFilter)
{
if (cryptographyProvider == null)
{
throw new ArgumentNullException(nameof(cryptographyProvider));
}
if (saveFilter == null)
{
throw new ArgumentNullException(nameof(saveFilter));
}
_cryptographyProvider = cryptographyProvider;
_saveFilter = saveFilter;
}
public XmlConnectionsSaver(string connectionFileName, SaveFilter saveFilter)
{
if (string.IsNullOrEmpty(connectionFileName))
{
throw new ArgumentException($"Argument '{nameof(connectionFileName)}' cannot be null or empty");
}
if (saveFilter == null)
{
throw new ArgumentNullException(nameof(saveFilter));
}
_connectionFileName = connectionFileName;
_saveFilter = saveFilter;
}
private static void SaveExportFile(string fileName,
SaveFormat saveFormat,
SaveFilter saveFilter,
ConnectionInfo exportTarget)
{
try
{
ISerializer <ConnectionInfo, string> serializer;
switch (saveFormat)
{
case SaveFormat.mRXML:
var cryptographyProvider = new CryptoProviderFactoryFromSettings().Build();
var rootNode = exportTarget.GetRootParent() as RootNodeInfo;
var connectionNodeSerializer = new XmlConnectionNodeSerializer27(
cryptographyProvider,
rootNode?.PasswordString
.ConvertToSecureString() ??
new RootNodeInfo(RootNodeType
.Connection)
.PasswordString
.ConvertToSecureString(),
saveFilter);
serializer = new XmlConnectionsSerializer(cryptographyProvider, connectionNodeSerializer);
break;
case SaveFormat.mRCSV:
serializer =
new CsvConnectionsSerializerMremotengFormat(saveFilter, Runtime.CredentialProviderCatalog);
break;
default:
throw new ArgumentOutOfRangeException(nameof(saveFormat), saveFormat, null);
}
var serializedData = serializer.Serialize(exportTarget);
var fileDataProvider = new FileDataProvider(fileName);
fileDataProvider.Save(serializedData);
}
catch (Exception ex)
{
Runtime.MessageCollector.AddExceptionStackTrace($"Export.SaveExportFile(\"{fileName}\") failed.", ex);
}
finally
{
Runtime.ConnectionsService.RemoteConnectionsSyncronizer?.Enable();
}
}
public XmlConnectionNodeSerializer26(ICryptographyProvider cryptographyProvider, SecureString encryptionKey, SaveFilter saveFilter)
{
if (cryptographyProvider == null)
{
throw new ArgumentNullException(nameof(cryptographyProvider));
}
if (encryptionKey == null)
{
throw new ArgumentNullException(nameof(encryptionKey));
}
if (saveFilter == null)
{
throw new ArgumentNullException(nameof(saveFilter));
}
_cryptographyProvider = cryptographyProvider;
_encryptionKey = encryptionKey;
_saveFilter = saveFilter;
}
public static string ToString(SaveFilter saveFilter)
{
return string.Format("{0} ({1})|{1}", saveFilter._name, saveFilter.Extensions);
}
public DataTableSerializer(SaveFilter saveFilter)
{
_saveFilter = saveFilter;
}
public async Task <SaveFilterViewModel> SaveFilterById(int id, int userId, Language language, string deviceId)
{
SaveFilter saveFilter = null;
Guest guest = new Guest();
var user = await _repository.FilterAsNoTracking <User>(u => u.Id == userId).FirstOrDefaultAsync();
if (user == null)
{
guest = await _repository.FilterAsNoTracking <Guest>(g => g.DeviceId == deviceId).FirstOrDefaultAsync();
if (guest == null)
{
throw new Exception(_optionsBinder.Error().UserNotFound);
}
saveFilter = await _repository.FilterAsNoTracking <SaveFilter>(sf => sf.Id == id).FirstOrDefaultAsync();
if (saveFilter.GuestId != guest.Id)
{
throw new Exception(_optionsBinder.Error().NotParticipating);
}
}
else
{
saveFilter = await _repository.FilterAsNoTracking <SaveFilter>(sf => sf.Id == id).FirstOrDefaultAsync();
if (saveFilter.UserId != user.Id)
{
throw new Exception(_optionsBinder.Error().NotParticipating);
}
}
return(await _repository.FilterAsNoTracking <SaveFilter>(sf => sf.Id == id)
.Select(sf => new SaveFilterViewModel
{
Id = sf.Id,
SaveFilterName = sf.SaveFilterName,
Search = sf.Search,
AnnouncementType = sf.AnnouncementType,
AnnouncementEstateType = sf.AnnouncementEstateType,
AnnouncementRentType = sf.AnnouncementRentType,
AnnouncementResidentialType = sf.AnnouncementResidentialType,
CityName = sf.CityName,
CountryName = sf.CountryName,
FurnishingStatus = sf.FurnishingStatus,
LandCategory = sf.LandCategory,
Features = sf.Features.Select(f => f.FeatureType).ToList(),
BathroomCount = sf.BathroomCount,
BedroomCount = sf.BedroomCount,
PriceFrom = sf.PriceFrom,
PriceTo = sf.PriceTo,
MinArea = sf.MinArea,
MaxArea = sf.MaxArea,
FilterCount = sf.FilterCount,
CityId = sf.CityId,
CountryId = sf.CountryId,
SittingCount = sf.SittingCount,
SaleType = sf.SaleType,
BuildingAge = sf.BuildingAge,
ConstructionStatus = sf.ConstructionStatus,
OwnerShip = sf.OwnerShip,
CommercialType = sf.CommercialType,
LandType = sf.LandType,
MaxMeterPrice = sf.MaxMeterPrice,
MinMeterPrice = sf.MinMeterPrice,
FacadeType = sf.FacadeType
}).FirstOrDefaultAsync());
}
public async Task <bool> Edit(UpdateSaveFilterModel model, int userId, int id, Language language, string deviceId)
{
SaveFilter saveFilter = null;
Guest guest = new Guest();
var user = await _repository.FilterAsNoTracking <User>(u => u.Id == userId).FirstOrDefaultAsync();
if (user == null)
{
guest = await _repository.FilterAsNoTracking <Guest>(g => g.DeviceId == deviceId).FirstOrDefaultAsync();
if (guest == null)
{
throw new Exception(_optionsBinder.Error().UserNotFound);
}
saveFilter = await _repository.FilterAsNoTracking <SaveFilter>(sf => sf.Id == id).FirstOrDefaultAsync();
if (saveFilter.GuestId != guest.Id)
{
throw new Exception(_optionsBinder.Error().NotParticipating);
}
}
else
{
saveFilter = await _repository.FilterAsNoTracking <SaveFilter>(sf => sf.Id == id).FirstOrDefaultAsync();
if (saveFilter.UserId != user.Id)
{
throw new Exception(_optionsBinder.Error().NotParticipating);
}
}
var filterCount = 0;
if (string.IsNullOrEmpty(model.SaveFilterName))
{
throw new Exception(_optionsBinder.Error().FilterName);
}
if (!string.IsNullOrEmpty(model.Search))
{
saveFilter.Search = model.Search;
filterCount += 1;
}
if (model.AnnouncementType.HasValue)
{
if (saveFilter.Description == null)
{
saveFilter.Description = model.AnnouncementType.ToString();
}
saveFilter.AnnouncementType = model.AnnouncementType;
filterCount += 1;
}
if (model.AnnouncementEstateType.HasValue)
{
if (saveFilter.Description == null)
{
saveFilter.Description = model.AnnouncementEstateType.ToString();
}
saveFilter.AnnouncementEstateType = model.AnnouncementEstateType;
filterCount += 1;
}
if (model.AnnouncementRentType.HasValue)
{
saveFilter.AnnouncementRentType = model.AnnouncementRentType;
filterCount += 1;
}
if (model.AnnouncementResidentialType.HasValue)
{
saveFilter.AnnouncementResidentialType = model.AnnouncementResidentialType;
filterCount += 1;
}
if (model.LandType.HasValue)
{
saveFilter.LandType = model.LandType;
filterCount += 1;
}
if (model.ConstructionStatus.HasValue)
{
saveFilter.ConstructionStatus = model.ConstructionStatus;
filterCount += 1;
}
if (model.LandCategory.HasValue)
{
saveFilter.LandCategory = model.LandCategory;
filterCount += 1;
}
if (model.FurnishingStatus.HasValue)
{
saveFilter.FurnishingStatus = model.FurnishingStatus;
filterCount += 1;
}
if (model.SaleType.HasValue)
{
saveFilter.SaleType = model.SaleType;
filterCount += 1;
}
if (model.BuildingAge.HasValue)
{
saveFilter.BuildingAge = model.BuildingAge;
filterCount += 1;
}
if (model.CommercialType.HasValue)
{
saveFilter.CommercialType = model.CommercialType;
filterCount += 1;
}
if (model.FacadeType.HasValue)
{
saveFilter.FacadeType = model.FacadeType;
filterCount += 1;
}
if (model.OwnerShip.HasValue)
{
saveFilter.OwnerShip = model.OwnerShip;
filterCount += 1;
}
if (model.SittingCount.HasValue)
{
saveFilter.SittingCount = model.SittingCount;
filterCount += 1;
}
if (model.CountryId.HasValue)
{
saveFilter.CountryId = model.CountryId;
saveFilter.CountryName = model.CountryName;
filterCount += 1;
}
if (model.CityId.HasValue)
{
saveFilter.CityId = model.CityId;
saveFilter.CityName = model.CountryName;
filterCount += 1;
}
if (model.PriceFrom > 0 || model.PriceTo > 0)
{
saveFilter.PriceTo = model.PriceTo;
saveFilter.PriceFrom = model.PriceFrom;
filterCount += 1;
}
if (model.MinArea > 0 || model.MaxArea > 0)
{
saveFilter.MinArea = model.MinArea;
saveFilter.MaxArea = model.MaxArea;
filterCount += 1;
}
if (model.MaxMeterPrice.HasValue || model.MinMeterPrice.HasValue)
{
saveFilter.MinMeterPrice = model.MinMeterPrice;
saveFilter.MaxMeterPrice = model.MaxMeterPrice;
filterCount += 1;
}
if (model.BathroomCount != 0 && model.BathroomCount.HasValue)
{
saveFilter.BathroomCount = model.BathroomCount;
filterCount += 1;
}
if (model.BedroomCount != 0 && model.BedroomCount.HasValue)
{
saveFilter.BedroomCount = model.BedroomCount;
filterCount += 1;
}
saveFilter.SaveFilterName = model.SaveFilterName;
var features = await _repository
.Filter <SaveFilterFeature>(x => x.SaveFilterId == saveFilter.Id).ToListAsync();
_repository.HardDeleteRange(features);
if (model.Features.Count() != 0)
{
foreach (var item in model.Features)
{
_repository.Create(new SaveFilterFeature
{
FeatureType = item,
SaveFilterId = saveFilter.Id
});
}
filterCount += 1;
}
_repository.Update(saveFilter);
await _repository.SaveChangesAsync();
return(true);
}
public void Teardown()
{
_saveFilter = null;
_dataTableSerializer = null;
}
public XmlConnectionNodeSerializer(ICryptographyProvider cryptographyProvider, SecureString encryptionKey, SaveFilter saveFilter)
{
_cryptographyProvider = cryptographyProvider;
_encryptionKey = encryptionKey;
_saveFilter = saveFilter;
}
public void Setup()
{
_saveFilter = new SaveFilter();
_dataTableSerializer = new DataTableSerializer(_saveFilter);
}
private static void SaveExportFile(string fileName, ConnectionsSaver.Format saveFormat, SaveFilter saveFilter, ConnectionInfo exportTarget)
{
try
{
ISerializer <string> serializer;
switch (saveFormat)
{
case ConnectionsSaver.Format.mRXML:
serializer = new XmlConnectionsSerializer();
((XmlConnectionsSerializer)serializer).SaveFilter = saveFilter;
break;
case ConnectionsSaver.Format.mRCSV:
serializer = new CsvConnectionsSerializerMremotengFormat();
((CsvConnectionsSerializerMremotengFormat)serializer).SaveFilter = saveFilter;
break;
default:
throw new ArgumentOutOfRangeException(nameof(saveFormat), saveFormat, null);
}
var serializedData = serializer.Serialize(exportTarget);
var fileDataProvider = new FileDataProvider(fileName);
fileDataProvider.Save(serializedData);
}
catch (Exception ex)
{
Runtime.MessageCollector.AddExceptionStackTrace($"Export.SaveExportFile(\"{fileName}\") failed.", ex);
}
finally
{
Runtime.RemoteConnectionsSyncronizer?.Enable();
}
}
private static void SaveExportFile(string fileName, ConnectionsSaver.Format saveFormat, SaveFilter saveFilter, ConnectionInfo exportTarget)
{
try
{
ISerializer <string> serializer;
switch (saveFormat)
{
case ConnectionsSaver.Format.mRXML:
var factory = new CryptographyProviderFactory();
var cryptographyProvider = factory.CreateAeadCryptographyProvider(mRemoteNG.Settings.Default.EncryptionEngine, mRemoteNG.Settings.Default.EncryptionBlockCipherMode);
cryptographyProvider.KeyDerivationIterations = Settings.Default.EncryptionKeyDerivationIterations;
serializer = new XmlConnectionsSerializer(cryptographyProvider)
{
Export = true,
SaveFilter = saveFilter
};
break;
case ConnectionsSaver.Format.mRCSV:
serializer = new CsvConnectionsSerializerMremotengFormat
{
SaveFilter = saveFilter
};
break;
default:
throw new ArgumentOutOfRangeException(nameof(saveFormat), saveFormat, null);
}
var serializedData = serializer.Serialize(exportTarget);
var fileDataProvider = new FileDataProvider(fileName);
fileDataProvider.Save(serializedData);
}
catch (Exception ex)
{
Runtime.MessageCollector.AddExceptionStackTrace($"Export.SaveExportFile(\"{fileName}\") failed.", ex);
}
finally
{
Runtime.RemoteConnectionsSyncronizer?.Enable();
}
}
internal static void Save(SaveFilter filter)
{
var stream = new MemoryStream(1024);
Save(stream, filter);
}
/// <summary>
/// Serializes the DataModel and/or Workspace.
/// </summary>
public void SaveGame(SaveFilter filter)
{
Logger.Info($"Saving DataModel. ({filter})");
Save(filter);
}
