protected virtual void Dispose(bool disposing)
{
if (disposing)
{
db?.Dispose();
}
}
/// <summary>
/// Releases the unmanaged resources used by the <see cref="RecordOperationsHub{T}"/> object and optionally releases the managed resources.
/// </summary>
/// <param name="disposing">true to release both managed and unmanaged resources; false to release only unmanaged resources.</param>
protected override void Dispose(bool disposing)
{
if (!m_disposed)
{
try
{
if (disposing)
{
// Update any primary key caches for session
if ((object)m_dataContext != null && (object)m_dataContextOperations != null)
{
foreach (KeyValuePair <Type, ITableOperations> item in m_dataContext.TableOperationsCache)
{
m_dataContextOperations.PrimaryKeySessionCache[item.Key] = item.Value.PrimaryKeyCache;
}
}
m_dataContext?.Dispose();
}
}
finally
{
m_disposed = true; // Prevent duplicate dispose.
base.Dispose(disposing); // Call base class Dispose().
}
}
}
private static void InitDatabase()
{
Database.SetInitializer<DataContext>(new MigrateDatabaseToLatestVersion<DataContext, Configuration>());
var context = new DataContext();
context.Database.Initialize(false);
context.Dispose();
}
protected virtual void Dispose(bool disposing)
{
if (!disposing)
{
return;
}
Context?.Dispose();
}
public void Constructor_SutIsUnitOfWork()
{
// When
var sut = new DataContext();
// Then
Assert.IsAssignableFrom<IUnitOfWork>(sut);
sut.Dispose();
}
public void GetPosts_ReturnsEmptyCollection(string databaseName)
{
// Given
var sut = new DataContext(databaseName);
// When
var result = sut.Get<Post>();
// Then
Assert.Empty(result);
sut.Database.Delete();
sut.Dispose();
}
public void GetPosts_DoesNotReturnNull(string databaseName)
{
// Given
var sut = new DataContext(databaseName);
// When
var result = sut.Get<Post>();
// Then
Assert.NotNull(result);
sut.Database.Delete();
sut.Dispose();
}
internal static PageIndexDictionary GetPageStructure(int languageId) {
var context = new DataContext();
try {
var pageIndexDictionary = new PageIndexDictionary(GetPages(context, languageId));
return pageIndexDictionary;
}
catch (Exception e) {
Logger.Write(e, Logger.Severity.Major);
throw;
}
finally {
context.Dispose();
}
}
/// <summary>
/// Releases the unmanaged resources used by the <see cref="AppModel"/> object and optionally releases the managed resources.
/// </summary>
/// <param name="disposing">true to release both managed and unmanaged resources; false to release only unmanaged resources.</param>
protected virtual void Dispose(bool disposing)
{
if (!m_disposed)
{
try
{
if (disposing)
{
m_securityDataContext?.Dispose();
m_dbDataContext?.Dispose();
}
}
finally
{
m_disposed = true; // Prevent duplicate dispose.
}
}
}
/// <summary>
/// Releases the unmanaged resources used by the <see cref="MainController"/> object and optionally releases the managed resources.
/// </summary>
/// <param name="disposing">true to release both managed and unmanaged resources; false to release only unmanaged resources.</param>
protected override void Dispose(bool disposing)
{
if (!m_disposed)
{
try
{
if (disposing)
{
m_dataContext?.Dispose();
}
}
finally
{
m_disposed = true; // Prevent duplicate dispose.
base.Dispose(disposing); // Call base class Dispose().
}
}
}
public void Delete(IEnumerable <DataSourceId> dataSourceIds, DataProviderContext dataProivderContext)
{
DataContext dataContext = null;
try
{
foreach (DataSourceId dataSourceId in dataSourceIds)
{
if (dataSourceId == null)
{
throw new ArgumentException("dataSourceIds contains null values");
}
using (new DataScope(dataSourceId.DataScopeIdentifier, dataSourceId.LocaleScope))
{
SqlDataTypeStore sqlDataTypeStore = TryGetsqlDataTypeStore(dataSourceId.InterfaceType);
if (sqlDataTypeStore == null)
{
throw new InvalidOperationException($"The interface '{dataSourceId.InterfaceType.FullName}' has not been configured");
}
IData data = sqlDataTypeStore.GetDataByDataId(dataSourceId.DataId, dataProivderContext);
Verify.That(data != null, "Row has already been deleted");
if (dataContext == null)
{
dataContext = CreateDataContext();
}
sqlDataTypeStore.RemoveData(data, dataContext);
}
}
if (dataContext != null)
{
SubmitChanges(dataContext);
}
}
finally
{
dataContext?.Dispose();
}
}
internal static PropertyCollection GetPropertiesForPage(Guid pageId, int languageId, int pageTypeId, int version, bool useCache) {
var cacheName = GetCacheName(pageId, languageId, version);
var propertyCollection = new PropertyCollection();
List<PropertyItem> propertyItems = null;
if (useCache) {
propertyItems = CacheManager.Get<List<PropertyItem>>(cacheName);
}
if (propertyItems != null) {
propertyCollection.Properties = propertyItems;
}
else {
var context = new DataContext();
try {
var properties = from p in context.Properties
join pp in context.PageProperties on new { PropertyId = p.PropertyId, PageId = pageId, LanguageId = languageId, Version = version } equals new { pp.PropertyId, pp.PageId, pp.LanguageId, pp.Version } into merge
from m in merge.DefaultIfEmpty()
where p.PageTypeId == pageTypeId
orderby p.SortOrder
select new PropertyItem {
PagePropertyId = m.PagePropertyId,
PropertyName = p.Name.ToLower(),
PropertyData = CreatePropertyData(p.PropertyTypeId, m.PageData),
PropertyId = p.PropertyId,
PropertyTypeId = p.PropertyTypeId
};
propertyCollection.Properties = properties.ToList();
}
finally {
context.Dispose();
}
if (useCache) {
CacheManager.Add(cacheName, propertyCollection.Properties, CachePriority.Medium, 30, true, true);
}
}
return propertyCollection;
}
public void TearDown()
{
_context.Dispose();
}
public void RegisterDeleted_WithPost_RemovesPost(
string databaseName,
Post post)
{
// Given
var sut = new DataContext(databaseName);
sut.RegisterAdded(post);
sut.Commit();
// When
sut.RegisterDeleted(post);
sut.Commit();
var result = sut.Get<Post>().Any();
// Then
Assert.False(result);
sut.Database.Delete();
sut.Dispose();
}
public void Dispose()
{
_sut?.Dispose();
}
public void RegisterModified_WithModifiedPost_PersistsPost(
string databaseName,
Post post,
string modifiedValue)
{
// Given
var sut = new DataContext(databaseName);
sut.RegisterAdded(post);
sut.Commit();
// When
post.Title = modifiedValue;
sut.RegisterModified(post);
sut.Commit();
var result = sut.Get<Post>().FirstOrDefault();
// Then
Assert.Equal(post, result);
sut.Database.Delete();
sut.Dispose();
}
public void Dispose()
{
_ctx?.Dispose();
}
public void RegisterModified_WithNullPost_ThrowsArgumentNullException(string databaseName)
{
// Given
var sut = new DataContext(databaseName);
// Then
Assert.Throws<ArgumentNullException>(() => sut.RegisterModified<Post>(null));
sut.Database.Delete();
sut.Dispose();
}
public void Dispose()
{
_dbContext?.Dispose();
}
/// <summary>
/// 初始化map 3
/// </summary>
/// <returns></returns>
public static void InstanceMap(string dbKey = null, string dbFile = "db.json", string mapFile = "map.json")
{
var list = BaseConfig.GetValue <MapConfigModel>(AppSettingKey.Map, mapFile);
var config = DataConfig.Get(dbKey, null, dbFile);
var db = new DataContext(dbKey);
var query = new DataQuery {
Config = config, Key = dbKey
};
if (list.Path == null)
{
return;
}
list.Path.ForEach(p => {
var info = new FileInfo(p);
var key = BaseSymmetric.Generate(info.FullName);
if (!DbCache.Exists(config.CacheType, key))
{
var temp = new MapXmlModel();
temp.LastWrite = info.LastWriteTime;
temp.FileKey = MapXml.ReadXml(info.FullName, config, info.Name.ToLower().Replace(".xml", ""));
temp.FileName = info.FullName;
if (MapXml.SaveXml(dbKey, key, info, config, db))
{
DbCache.Set <MapXmlModel>(config.CacheType, key, temp);
}
}
else if ((DbCache.Get <MapXmlModel>(config.CacheType, key).LastWrite - info.LastWriteTime).Milliseconds != 0)
{
DbCache.Get <MapXmlModel>(config.CacheType, key).FileKey.ForEach(a => { DbCache.Remove(config.CacheType, a); });
var model = new MapXmlModel();
model.LastWrite = info.LastWriteTime;
model.FileKey = MapXml.ReadXml(info.FullName, config, info.Name.ToLower().Replace(".xml", ""));
model.FileName = info.FullName;
if (MapXml.SaveXml(dbKey, key, info, config, db))
{
DbCache.Set <MapXmlModel>(config.CacheType, key, model);
}
}
});
if (config.IsMapSave)
{
query.Config.DesignModel = FastData.Core.Base.Config.CodeFirst;
if (query.Config.DbType == DataDbType.Oracle)
{
var listInfo = typeof(FastData.Core.DataModel.Oracle.Data_MapFile).GetProperties(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly).ToList();
var listAttribute = typeof(FastData.Core.DataModel.Oracle.Data_MapFile).GetTypeInfo().GetCustomAttributes().ToList();
BaseTable.Check(query, "Data_MapFile", listInfo, listAttribute);
}
if (query.Config.DbType == DataDbType.MySql)
{
var listInfo = typeof(FastData.Core.DataModel.MySql.Data_MapFile).GetProperties(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly).ToList();
var listAttribute = typeof(FastData.Core.DataModel.MySql.Data_MapFile).GetTypeInfo().GetCustomAttributes().ToList();
BaseTable.Check(query, "Data_MapFile", listInfo, listAttribute);
}
if (query.Config.DbType == DataDbType.SqlServer)
{
var listInfo = typeof(FastData.Core.DataModel.SqlServer.Data_MapFile).GetProperties(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly).ToList();
var listAttribute = typeof(FastData.Core.DataModel.SqlServer.Data_MapFile).GetTypeInfo().GetCustomAttributes().ToList();
BaseTable.Check(query, "Data_MapFile", listInfo, listAttribute);
}
}
db.Dispose();
}
public void Dispose()
{
_dbContext.Database.EnsureDeleted();
_dbContext.Dispose();
}
public void Dispose()
{
context.Dispose();
}
public virtual void Dispose()
{
context.Dispose();
}
public void Dispose()
{
Commit();
_context.Dispose();
GC.SuppressFinalize(this);
}
public void Dispose() => _context.Dispose();
protected override void Dispose(bool disposing)
{
db.Dispose();
base.Dispose(disposing);
}
public void GetPosts_WithNewPostAndEagerLoadedTag_ReturnsPostWithTheSameTag(
Post post,
Tag tag,
string databaseName)
{
// Given
post.Tags.Add(tag);
var sut = new DataContext(databaseName);
// When
sut.RegisterAdded(post);
sut.SaveChanges();
var result = sut.Get<Post>("Tags").SingleOrDefault();
// Then
Assert.True(post.Tags.SequenceEqual(result.Tags));
sut.Database.Delete();
sut.Dispose();
}
public void Dispose()
{
_context?.Dispose();
}
//TODO: Add language parameters when going multi-language
internal static Collection<Guid> DeletePage(Guid pageId) {
var pageIds = PageFactory.GetPageTreeFromPage(pageId, PublishState.All).PageIds;
pageIds.Add(pageId);
var context = new DataContext();
try {
var deleteTimeStamp = DateTime.Now.ToUniversalTime();
// TODO: Säkerställ att detta funkar mot stora mängder!!
context.PageInstances.Where(p => pageIds.Contains(p.PageId)).UpdateAll(p => p.Set(v => v.DeletedDate, v => deleteTimeStamp));
}
finally {
context.Dispose();
}
return pageIds;
}
public void GetPosts_WithNewPost_ReturnsCollectionWithOneElement(
Post post,
string databaseName)
{
// Given
var sut = new DataContext(databaseName);
// When
sut.RegisterAdded(post);
sut.SaveChanges();
var result = sut.Get<Post>();
// Then
Assert.Equal(1, result.Count());
sut.Database.Delete();
sut.Dispose();
}
public void Dispose()
{
_dbTransaction?.Dispose();
_dbContext?.Dispose();
}
public void TestCleanup()
{
dataContext.Dispose();
}
public void TearDown()
{
_dataContext?.Dispose();
DataAccessTestHelper.TryDeleteDatabase();
}
public void Dispose()
{
_context?.Dispose();
_context = null;
}
public override void Dispose(bool disposing)
{
DataContext?.Dispose();
DataContext = null;
}
protected void Dispose()
{
m_dataContext?.Dispose();
}
public void Dispose() => _dataContext?.Dispose();
public void Dispose()
{
Db?.Dispose();
}
protected override void InternalDispose()
{
_dbContext?.Dispose();
}
internal static void UpdateStructure(List<PageIndexItem> changedItems) {
var pageItems = changedItems.ToDictionary(i => i.PageId);
var pageInstanceItems = changedItems.ToDictionary(i => i.PageInstanceId);
var pageIds = pageItems.Keys;
var pageInstanceIds = pageInstanceItems.Keys;
var context = new DataContext();
try {
var pages = context.Pages.Where(p => pageIds.Contains(p.PageId));
foreach (var page in pages) {
var indexItem = pageItems[page.PageId];
page.TreeLevel = indexItem.TreeLevel;
page.ParentId = indexItem.ParentId;
page.RootId = indexItem.RootId;
}
var pageInstances = context.PageInstances.Where(p => pageInstanceIds.Contains(p.PageInstanceId));
foreach (var pageInstance in pageInstances) {
var indexItem = pageInstanceItems[pageInstance.PageInstanceId];
pageInstance.PageUrl = indexItem.UrlSegment;
}
context.SaveChanges();
}
finally {
context.Dispose();
}
}
public void Dispose()
{
userContext.Dispose();
db.Dispose();
}
public void Dispose()
{
Db.Dispose();
GC.SuppressFinalize(this);
}
public void Dispose()
{
_dataContext.Dispose();
}
public void GetPosts_WithNewPostAndNonExistentEagerLoadedProperty_Throws(
Post post,
string propertyName,
string databaseName)
{
// Given
var sut = new DataContext(databaseName);
// When
sut.RegisterAdded(post);
sut.SaveChanges();
// Then
Assert.Throws<InvalidOperationException>(() => sut.Get<Post>(propertyName).Any());
sut.Database.Delete();
sut.Dispose();
}
