public void Serialize_TypeExpression_Null_Test()
{
var filter = new CremaDataSetFilter
{
TypeExpression = null
};
}
public void Serialize_Tables_Null_Test()
{
var filter = new CremaDataSetFilter
{
Tables = null
};
}
public void Serialize_Empty_Test()
{
var formatter = new BinaryFormatter();
var stream = new MemoryStream();
var filter1 = new CremaDataSetFilter();
formatter.Serialize(stream, filter1);
stream.Position = 0;
var filter2 = formatter.Deserialize(stream) as CremaDataSetFilter;
Assert.AreEqual(filter1.TypeExpression, filter2.TypeExpression);
Assert.AreEqual(filter1.TableExpression, filter2.TableExpression);
Assert.AreEqual(filter1.OmitType, filter2.OmitType);
Assert.AreEqual(filter1.OmitTable, filter2.OmitTable);
Assert.AreEqual(filter1.OmitContent, filter2.OmitContent);
}
public async Task ViewAsync([CommandCompletion(nameof(GetDataBaseNamesAsync))] string dataBaseName, string revision = null)
{
var sb = new StringBuilder();
var dataBase = this.GetDataBase(dataBaseName);
var authentication = this.CommandContext.GetAuthentication(this);
var filter = new CremaDataSetFilter()
{
TableExpression = FilterProperties.FilterExpression
};
var dataSet = await dataBase.GetDataSetAsync(authentication, filter, revision);
var props = dataSet.ToDictionary(DataSetTypeProperties.TableOnly == true, DataSetTypeProperties.TypeOnly == true);
var format = FormatProperties.Format;
sb.AppendLine(props, format);
await this.Out.WriteAsync(sb.ToString());
}
public async Task ImportAsync_Arg0_Expired_FailTestAsync()
{
var dataBaseFilter = new DataBaseFilter(DataBaseFlags.Loaded | DataBaseFlags.Public | DataBaseFlags.NotLocked)
{
Settings = DataBaseSettings.Default
};
var dataBase = await dataBaseFilter.GetDataBaseAsync(app);
var filter = new CremaDataSetFilter()
{
OmitContent = true
};
var dataSet = await dataBase.GetDataSetAsync(Authentication.System, filter, string.Empty);
var comment = RandomUtility.NextString();
await dataBase.ImportAsync(expiredAuthentication, dataSet, comment);
}
public async Task ImportAsync_Arg1_Empty_FailTestAsync()
{
var authentication = await this.TestContext.LoginRandomAsync(Authority.Admin);
var dataBaseFilter = new DataBaseFilter(DataBaseFlags.Loaded | DataBaseFlags.Public | DataBaseFlags.NotLocked)
{
Settings = DataBaseSettings.Default
};
var dataBase = await dataBaseFilter.GetDataBaseAsync(app);
var filter = new CremaDataSetFilter()
{
OmitContent = true
};
var dataSet = await dataBase.GetDataSetAsync(authentication, filter, string.Empty);
await Base_TestAsync(dataBase, authentication, dataSet, string.Empty);
}
private async Task ImportAsync_Locked_NotLocker_FailTestAsync(Authority authority)
{
var dataBaseFilter = new DataBaseFilter(DataBaseFlags.Loaded | DataBaseFlags.Public | DataBaseFlags.Locked)
{
Settings = DataBaseSettings.Default
};
var dataBase = await dataBaseFilter.GetDataBaseAsync(app);
var lockInfo = dataBase.LockInfo;
var authentication = await this.TestContext.LoginRandomAsync(authority, item => item.ID != lockInfo.ID);
var filter = new CremaDataSetFilter()
{
OmitContent = true
};
var dataSet = await dataBase.GetDataSetAsync(authentication, filter, string.Empty);
var comment = RandomUtility.NextString();
await Base_TestAsync(dataBase, authentication, dataSet, comment);
}
private async Task ImportAsync_Private_AccessTypeNone_FailTestAsync(Authority authority)
{
var dataBaseFilter = new DataBaseFilter(DataBaseFlags.Loaded | DataBaseFlags.Private | DataBaseFlags.NotLocked)
{
Settings = DataBaseSettings.Default
};
var dataBase = await dataBaseFilter.GetDataBaseAsync(app);
var accessInfo = dataBase.AccessInfo;
var authentication = await this.TestContext.LoginRandomAsync(authority, item => accessInfo.GetAccessType(item.ID) == AccessType.None);
var filter = new CremaDataSetFilter()
{
OmitContent = true
};
var dataSet = await dataBase.GetDataSetAsync(authentication, filter, string.Empty);
var comment = RandomUtility.NextString();
await Base_TestAsync(dataBase, authentication, dataSet, comment);
}
public async Task ImportAsync_Private_Admin_Owner_TestAsync()
{
var dataBaseFilter = new DataBaseFilter(DataBaseFlags.Loaded | DataBaseFlags.Private | DataBaseFlags.NotLocked)
{
Settings = DataBaseSettings.Default
};
var dataBase = await dataBaseFilter.GetDataBaseAsync(app);
var accessInfo = dataBase.AccessInfo;
var authentication = await this.TestContext.LoginAsync(accessInfo.ID);
var filter = new CremaDataSetFilter()
{
OmitContent = true
};
var dataSet = await dataBase.GetDataSetAsync(authentication, filter, string.Empty);
var comment = RandomUtility.NextString();
await Base_TestAsync(dataBase, authentication, dataSet, comment);
}
public void Serialize_Full_Test()
{
var formatter = new BinaryFormatter();
var stream = new MemoryStream();
var filter1 = new CremaDataSetFilter()
{
TableExpression = "a;b;c",
TypeExpression = "c;b;a",
OmitContent = true,
OmitTable = false,
OmitType = true,
};
formatter.Serialize(stream, filter1);
stream.Position = 0;
var filter2 = formatter.Deserialize(stream) as CremaDataSetFilter;
Assert.AreEqual(filter1.TypeExpression, filter2.TypeExpression);
Assert.AreEqual(filter1.TableExpression, filter2.TableExpression);
Assert.AreEqual(filter1.OmitType, filter2.OmitType);
Assert.AreEqual(filter1.OmitTable, filter2.OmitTable);
Assert.AreEqual(filter1.OmitContent, filter2.OmitContent);
}
private async Task ImportAsync_Private_TestAsync(Authority authority, AccessType accessType)
{
var dataBaseFilter = new DataBaseFilter(DataBaseFlags.Loaded | DataBaseFlags.Private | DataBaseFlags.NotLocked)
{
Settings = DataBaseSettings.Default
};
var dataBase = await dataBaseFilter.GetDataBaseAsync(app);
var accessInfo = dataBase.AccessInfo;
var query = from item in accessInfo.Members
where item.AccessType == accessType
select item.ID;
var authentication = await this.TestContext.LoginRandomAsync(authority, item => query.Contains(item.ID));
var filter = new CremaDataSetFilter()
{
OmitContent = true
};
var dataSet = await dataBase.GetDataSetAsync(authentication, filter, string.Empty);
var comment = RandomUtility.NextString();
await Base_TestAsync(dataBase, authentication, dataSet, comment);
}
public async Task <Guid> ImportAsync(Authentication authentication, CremaDataSet dataSet, string comment)
{
try
{
if (authentication is null)
{
throw new ArgumentNullException(nameof(authentication));
}
if (authentication.IsExpired == true)
{
throw new AuthenticationExpiredException(nameof(authentication));
}
if (dataSet is null)
{
throw new ArgumentNullException(nameof(dataSet));
}
if (comment is null)
{
throw new ArgumentNullException(nameof(comment));
}
await this.Dispatcher.InvokeAsync(() =>
{
this.CremaHost.DebugMethod(authentication, this, nameof(ImportAsync), comment);
this.ValidateImport(authentication, dataSet, comment);
this.CremaHost.Sign(authentication);
});
var taskID = Guid.NewGuid();
var filter = new CremaDataSetFilter()
{
Tables = dataSet.Tables.Select(item => item.Name).ToArray(),
OmitContent = true
};
var targetSet = await this.GetDataSetAsync(authentication, filter, string.Empty);
await this.Dispatcher.InvokeAsync(() =>
{
this.LockTypes(authentication, targetSet, comment);
this.LockTables(authentication, targetSet, comment);
});
try
{
targetSet.SignatureDateProvider = new SignatureDateProvider(authentication.ID);
foreach (var item in targetSet.Tables)
{
var dataTable = dataSet.Tables[item.Name];
foreach (var row in dataTable.Rows)
{
item.ImportRow(row);
}
item.BeginLoad();
foreach (var row in item.Rows)
{
row.CreationInfo = authentication.SignatureDate;
row.ModificationInfo = authentication.SignatureDate;
}
item.ContentsInfo = authentication.SignatureDate;
item.EndLoad();
}
var dataBaseSet = await DataBaseSet.CreateAsync(this, targetSet);
await this.Repository.Dispatcher.InvokeAsync(() =>
{
try
{
this.Repository.Modify(dataBaseSet);
this.Repository.Commit(authentication, comment);
}
catch
{
this.Repository.Revert();
throw;
}
});
await this.Dispatcher.InvokeAsync(() =>
{
this.UpdateTables(authentication, targetSet);
});
return(taskID);
}
finally
{
await this.Dispatcher.InvokeAsync(() =>
{
this.UnlockTypes(authentication, targetSet);
this.UnlockTables(authentication, targetSet);
});
}
}
catch (Exception e)
{
this.CremaHost.Error(e);
throw;
}
}
