static void UpdateDatabase()
{
// Update database
Console.WriteLine();
logger.Info("Updating database");
var iCryptoService = AnonimizeProvider.GetInstance().GetCryptoService();
logger.Warn($"CryptoService: {iCryptoService.GetType().Name}");
if (iCryptoService is BaseSymmetricCryptoService cryptoService)
{
if (string.IsNullOrWhiteSpace(xConfig.Iv))
{
logger.Warn("Using default Anonimize:Iv");
}
else
{
logger.Warn($"Anonimize:Iv: '{xConfig.Iv}'");
}
if (string.IsNullOrWhiteSpace(xConfig.Key))
{
logger.Warn("Using default Anonimize:Key");
}
else
{
logger.Warn($"Anonimize:Key: '{xConfig.Key}'");
}
}
logger.Warn("Connection: {0}", xConfig.ConnectionString);
RunUpdateService(new DatabaseUpdateService(jConfig, xConfig));
}
public void ShouldProvideAnonimizeServiceSingleton()
{
var instance = AnonimizeProvider.GetInstance();
Assert.IsNotNull(instance);
var otherInstance = AnonimizeProvider.GetInstance();
Assert.IsNotNull(otherInstance);
Assert.AreEqual(instance, otherInstance, "Sequenced calls to {0}.{1} should provide the same {2}",
typeof(AnonimizeProvider).Name, nameof(AnonimizeProvider.GetInstance), typeof(Services.AnonimizeService).Name);
}
public override void ReadXmlDocument()
{
base.ReadXmlDocument();
connectionString = GetConnectionString(Document, CONNECTION_NAME);
if (!connectionString.EndsWith(";", StringComparison.Ordinal))
{
connectionString += ";";
}
connectionString += CONNECTION_STRING_POSFIX;
var anonimize = AnonimizeProvider.GetInstance();
var serviceName = GetAppSetting(Document, "Anonimize:CryptoService");
if (!string.IsNullOrEmpty(serviceName))
{
serviceName = serviceName.ToUpperInvariant().Trim();
if (serviceName.StartsWith("AES"))
{
anonimize.SetCryptoService(new AesCryptoService());
}
else if (serviceName.StartsWith("TRIPLEDES"))
{
anonimize.SetCryptoService(new TripleDESCryptoService());
}
}
var iCryptoService = anonimize.GetCryptoService();
if (iCryptoService is BaseSymmetricCryptoService cryptoService)
{
iv = GetAppSetting(Document, "Anonimize:Iv");
if (!string.IsNullOrWhiteSpace(iv))
{
cryptoService.SetIV(iv);
}
key = GetAppSetting(Document, "Anonimize:Key");
if (!string.IsNullOrWhiteSpace(key))
{
cryptoService.SetIV(key);
}
}
}
public void Init()
{
anonimizeService = AnonimizeProvider.GetInstance();
}
protected override bool UpdateTable(Table table)
{
if (!table.Columns.Any())
{
logger.Info("No columns for table `{0}`", table.Name);
return(true);
}
var items = (IEnumerable <IDictionary <string, object> >)dbContext.ReadAll(table.NameSnakeCase);
if (!items.Any())
{
logger.Info("No actions needed for table `{0}`", table.NameSnakeCase);
return(true);
}
var modelItem = items.First();
if (!modelItem.ContainsKey(table.PrimaryKey))
{
logger.Warn("Missing primary key `{0}` of table `{1}`", table.PrimaryKey, table.NameSnakeCase);
return(false);
}
foreach (var column in table.Columns)
{
if (!modelItem.ContainsKey(column.Name))
{
logger.Warn("Missing column `{0}` of table `{1}`", column.Name, table.NameSnakeCase);
return(false);
}
}
var schemas = dbContext.GetTableSchema(table.NameSnakeCase).Where(q => q.RequiresUpdate());
var columnsToAlter = new List <string>();
foreach (var column in table.Columns)
{
if (schemas.Where(q => q.ColumnName == column.Name).Any())
{
columnsToAlter.Add(column.Name);
}
}
if (columnsToAlter.Any())
{
logger.Info($"Altering table `{table.NameSnakeCase}`");
columnsToAlter.ForEach(column => logger.Info($"Altering column `{table.NameSnakeCase}`.`{column}`"));
dbContext.AlterTable(table.NameSnakeCase, columnsToAlter);
}
logger.Info("Updating table `{0}` with total count of {1}", table.NameSnakeCase, items.Count());
var anonimize = AnonimizeProvider.GetInstance();
var cryptoService = anonimize.GetCryptoService();
foreach (var item in items)
{
logger.Debug("Anonimizing `{0}`.`{1}` = {2}", table.NameSnakeCase, table.PrimaryKey, item[table.PrimaryKey]);
var primaryKey = new Tuple <string, int>(table.PrimaryKey, (int)item[table.PrimaryKey]);
var columns = new Dictionary <string, string>();
foreach (var column in table.Columns)
{
var updateColumn = false;
var decryptedValue = item[column.Name];
var encryptedValue = (string)decryptedValue;
if (decryptedValue != null && !decryptedValue.IsEncrypted())
{
logger.Debug("Encrypting field {0}", column.Name);
encryptedValue = cryptoService.Encrypt(decryptedValue);
updateColumn = true;
}
else if (decryptedValue == null)
{
logger.Debug("Field {0} is null", column.Name);
}
else
{
logger.Debug("Field {0} was previously encrypted", column.Name);
}
if (updateColumn)
{
columns.Add(column.Name, encryptedValue);
}
}
if (columns.Any())
{
dbContext.Update(table.NameSnakeCase, columns, primaryKey);
}
else
{
logger.Debug("No updates needed for `{0}`.`{1}` = {2}", table.NameSnakeCase, table.PrimaryKey, item[table.PrimaryKey]);
}
}
return(true);
}
protected AEncryptedType()
{
defaultType = typeof(T);
cryptoService = AnonimizeProvider.GetInstance().GetCryptoService();
}
protected AEncryptedType()
{
cryptoService = AnonimizeProvider.GetInstance().GetCryptoService();
}
