public static async Task <RepositoryResponse <bool> > ImportAsync(List <SioPages.ImportViewModel> arrPage, string destCulture,
SioCmsContext _context = null, IDbContextTransaction _transaction = null)
{
var result = new RepositoryResponse <bool>()
{
IsSucceed = true
};
bool isRoot = _context == null;
var context = _context ?? new SioCmsContext();
var transaction = _transaction ?? context.Database.BeginTransaction();
try
{
int id = UpdateViewModel.ModelRepository.Max(m => m.Id, context, transaction).Data + 1;
var pages = FileRepository.Instance.GetFile(SioConstants.CONST_FILE_PAGES, "data", true, "{}");
var obj = JObject.Parse(pages.Content);
var initPages = obj["data"].ToObject <JArray>();
foreach (var item in arrPage)
{
if (item.Id > initPages.Count)
{
item.Id = id;
item.CreatedDateTime = DateTime.UtcNow;
}
item.Specificulture = destCulture;
var saveResult = await item.SaveModelAsync(true, context, transaction);
if (!saveResult.IsSucceed)
{
result.IsSucceed = false;
result.Exception = saveResult.Exception;
result.Errors = saveResult.Errors;
break;
}
else if (item.Id > initPages.Count)
{
id++;
}
}
result.Data = true;
UnitOfWorkHelper <SioCmsContext> .HandleTransaction(result.IsSucceed, isRoot, transaction);
}
catch (Exception ex) // TODO: Add more specific exeption types instead of Exception only
{
var error = UnitOfWorkHelper <SioCmsContext> .HandleException <ReadMvcViewModel>(ex, isRoot, transaction);
result.IsSucceed = false;
result.Errors = error.Errors;
result.Exception = error.Exception;
}
finally
{
//if current Context is Root
if (isRoot)
{
context?.Dispose();
}
}
return(result);
}
public async Task <RepositoryResponse <bool> > SavePermissionsAsync(AspNetRoles parent, MixCmsContext _context = null, IDbContextTransaction _transaction = null)
{
UnitOfWorkHelper <MixCmsContext> .InitTransaction(_context, _transaction, out MixCmsContext context, out IDbContextTransaction transaction, out bool isRoot);
var result = new RepositoryResponse <bool>()
{
IsSucceed = true
};
try
{
foreach (var item in Permissions)
{
if (result.IsSucceed)
{
result = await HandlePermission(item, context, transaction);
}
else
{
break;
}
}
UnitOfWorkHelper <MixCmsContext> .HandleTransaction(result.IsSucceed, isRoot, transaction);
return(result);
}
catch (Exception ex)
{
return(UnitOfWorkHelper <MixCmsContext> .HandleException <bool>(ex, isRoot, transaction));
}
finally
{
UnitOfWorkHelper <MixCmsContext> .CloseDbContext(ref context, ref transaction);
}
}
protected async Task <RepositoryResponse <FileViewModel> > ExportListAsync(Expression <Func <TModel, bool> > predicate, string type)
{
var getData = await DefaultModelRepository <TDbContext, TModel> .Instance.GetModelListByAsync(predicate, _context);
FileViewModel file = null;
if (getData.IsSucceed)
{
string exportPath = $"Exports/Structures/{typeof(TModel).Name}";
string filename = $"{type.ToString()}_{DateTime.UtcNow.ToString("ddMMyyyy")}";
var objContent = new JObject(
new JProperty("type", type.ToString()),
new JProperty("data", JArray.FromObject(getData.Data))
);
file = new FileViewModel()
{
Filename = filename,
Extension = ".json",
FileFolder = exportPath,
Content = objContent.ToString()
};
// Copy current templates file
FileRepository.Instance.SaveWebFile(file);
}
UnitOfWorkHelper <TDbContext> .HandleTransaction(getData.IsSucceed, true, _transaction);
return(new RepositoryResponse <FileViewModel>()
{
IsSucceed = true,
Data = file,
});
}
private async Task <RepositoryResponse <bool> > ImportLanguagesAsync(string destCulture,
MixCmsContext _context = null, IDbContextTransaction _transaction = null)
{
var result = new RepositoryResponse <bool>()
{
IsSucceed = true
};
UnitOfWorkHelper <MixCmsContext> .InitTransaction(_context, _transaction, out MixCmsContext context, out IDbContextTransaction transaction, out bool isRoot);
try
{
int startId = MixLanguages.UpdateViewModel.ModelRepository.Max(m => m.Id, context, transaction).Data;
foreach (var item in Languages)
{
var oldId = item.Id;
item.CreatedBy = CreatedBy;
if (!context.MixLanguage.Any(p => p.Keyword == item.Keyword))
{
startId++;
item.Id = startId;
item.CreatedDateTime = DateTime.UtcNow;
item.Specificulture = destCulture;
var saveResult = await item.SaveModelAsync(false, context, transaction);
if (!saveResult.IsSucceed)
{
result.IsSucceed = false;
result.Exception = saveResult.Exception;
result.Errors = saveResult.Errors;
break;
}
}
if (!dicLanguageIds.Any(m => m.Key == item.Id))
{
dicLanguageIds.Add(oldId, startId);
}
}
UnitOfWorkHelper <MixCmsContext> .HandleTransaction(result.IsSucceed, isRoot, transaction);
}
catch (Exception ex) // TODO: Add more specific exeption types instead of Exception only
{
var error = UnitOfWorkHelper <MixCmsContext> .HandleException <MixPages.ImportViewModel>(ex, isRoot, transaction);
result.IsSucceed = false;
result.Errors = error.Errors;
result.Exception = error.Exception;
}
finally
{
//if current Context is Root
if (isRoot)
{
UnitOfWorkHelper <MixCmsContext> .CloseDbContext(ref context, ref transaction);
}
}
return(result);
}
/// <summary>
/// Step 2
/// - Init Configurations
/// </summary>
/// <param name="siteName"></param>
/// <param name="specifiCulture"></param>
/// <param name="_context"></param>
/// <param name="_transaction"></param>
/// <returns></returns>
public static async Task <RepositoryResponse <bool> > InitAttributeSetsAsync(string siteName, string specifiCulture, MixCmsContext _context = null, IDbContextTransaction _transaction = null)
{
/* Init Configs */
UnitOfWorkHelper <MixCmsContext> .InitTransaction(_context, _transaction, out MixCmsContext context, out IDbContextTransaction transaction, out bool isRoot);
var result = new RepositoryResponse <bool>()
{
IsSucceed = true
};
var getData = FileRepository.Instance.GetFile(MixConstants.CONST_FILE_ATTRIBUTE_SETS, "data", true, "{}");
var obj = JObject.Parse(getData.Content);
var data = obj["data"].ToObject <List <ViewModels.MixAttributeSets.UpdateViewModel> >();
foreach (var item in data)
{
if (result.IsSucceed)
{
item.CreatedDateTime = DateTime.UtcNow;
var saveResult = await item.SaveModelAsync(true, context, transaction);
ViewModelHelper.HandleResult(saveResult, ref result);
}
else
{
break;
}
}
UnitOfWorkHelper <MixCmsContext> .HandleTransaction(result.IsSucceed, isRoot, transaction);
return(result);
}
/// <summary>
/// Step 4
/// - Init default theme
/// </summary>
/// <param name="siteName"></param>
/// <param name="_context"></param>
/// <param name="_transaction"></param>
/// <returns></returns>
public async Task <RepositoryResponse <bool> > InitThemesAsync(string siteName
, MixCmsContext _context = null, IDbContextTransaction _transaction = null)
{
UnitOfWorkHelper <MixCmsContext> .InitTransaction(_context, _transaction, out MixCmsContext context, out IDbContextTransaction transaction, out bool isRoot);
var result = new RepositoryResponse <bool>()
{
IsSucceed = true
};
var getThemes = ViewModels.MixThemes.InitViewModel.Repository.GetModelList(_context: context, _transaction: transaction);
if (!context.MixTheme.Any())
{
ViewModels.MixThemes.InitViewModel theme = new ViewModels.MixThemes.InitViewModel(new MixTheme()
{
Id = 1,
Title = siteName,
Name = SeoHelper.GetSEOString(siteName),
CreatedDateTime = DateTime.UtcNow,
CreatedBy = "Admin",
Status = (int)MixContentStatus.Published,
}, context, transaction);
var saveResult = await theme.SaveModelAsync(true, context, transaction);
ViewModelHelper.HandleResult(saveResult, ref result);
}
UnitOfWorkHelper <MixCmsContext> .HandleTransaction(result.IsSucceed, isRoot, transaction);
return(new RepositoryResponse <bool>()
{
IsSucceed = result.IsSucceed
});
}
// Cannot use asyn method for signalr hub
public RepositoryResponse <bool> Join(MixChatServiceContext _context = null, IDbContextTransaction _transaction = null)
{
var result = new RepositoryResponse <bool>()
{
IsSucceed = true
};
UnitOfWorkHelper <MixChatServiceContext> .InitTransaction(_context, _transaction, out MixChatServiceContext context, out IDbContextTransaction transaction, out bool isRoot);
try
{
result = UpdateUser(context, transaction);
if (result.IsSucceed)
{
result = UpdateDevice(context, transaction);
}
UnitOfWorkHelper <MixChatServiceContext> .HandleTransaction(result.IsSucceed, isRoot, transaction);
return(result);
}
catch (Exception ex)
{
return(UnitOfWorkHelper <MixChatServiceContext> .HandleException <bool>(ex, isRoot, transaction));
}
finally
{
if (isRoot)
{
//if current Context is Root
transaction.Dispose();
context.Database.CloseConnection(); transaction.Dispose(); context.Dispose();
}
}
}
/// <summary>
/// Saves the model hronous.
/// </summary>
/// <param name="data">The view.</param>
/// <param name="isSaveSubModels">if set to <c>true</c> [is save sub models].</param>
/// <param name="_context">The context.</param>
/// <param name="_transaction">The transaction.</param>
/// <returns></returns>
public virtual RepositoryResponse <List <TView> > SaveListModel(List <TView> data, bool isSaveSubModels = false
, TDbContext _context = null, IDbContextTransaction _transaction = null)
{
UnitOfWorkHelper <TDbContext> .InitTransaction(_context, _transaction, out TDbContext context, out IDbContextTransaction transaction, out bool isRoot);
var result = new RepositoryResponse <List <TView> >()
{
IsSucceed = true
};
try
{
foreach (var item in data)
{
var saveResult = item.SaveModel(isSaveSubModels, context, transaction);
if (!saveResult.IsSucceed)
{
result.IsSucceed = false;
result.Exception = saveResult.Exception;
result.Errors = saveResult.Errors;
break;
}
}
UnitOfWorkHelper <TDbContext> .HandleTransaction(result.IsSucceed, isRoot, transaction);
return(result);
}
catch (Exception ex)
{
return(UnitOfWorkHelper <TDbContext> .HandleException <List <TView> >(default, ex, isRoot, transaction));
public override async Task <RepositoryResponse <ImportViewModel> > SaveModelAsync(bool isSaveSubModels = false, MixCmsContext _context = null, IDbContextTransaction _transaction = null)
{
UnitOfWorkHelper <MixCmsContext> .InitTransaction(_context, _transaction, out MixCmsContext context, out IDbContextTransaction transaction, out bool isRoot);
try
{
var result = await base.SaveModelAsync(isSaveSubModels, context, transaction);
if (result.IsSucceed && !string.IsNullOrEmpty(ParentId))
{
var getNav = MixRelatedAttributeDatas.UpdateViewModel.Repository.CheckIsExists(
m => m.DataId == Id && m.ParentId == ParentId && m.ParentType == ParentType && m.Specificulture == Specificulture
, context, transaction);
if (!getNav)
{
var nav = new MixRelatedAttributeDatas.UpdateViewModel()
{
DataId = Id,
Specificulture = Specificulture,
AttributeSetId = AttributeSetId,
AttributeSetName = AttributeSetName,
ParentType = ParentType,
ParentId = ParentId,
Status = MixContentStatus.Published
};
var saveResult = await nav.SaveModelAsync(false, context, transaction);
if (!saveResult.IsSucceed)
{
result.IsSucceed = false;
result.Exception = saveResult.Exception;
result.Errors = saveResult.Errors;
}
}
}
UnitOfWorkHelper <MixCmsContext> .HandleTransaction(result.IsSucceed, isRoot, transaction);
if (result.IsSucceed)
{
Obj = Helper.ParseData(Id, Specificulture, context, transaction);
}
return(result);
}
catch (Exception ex)
{
return(UnitOfWorkHelper <MixCmsContext> .HandleException <ImportViewModel>(ex, isRoot, transaction));
}
finally
{
if (isRoot)
{
transaction.Dispose();
context.Dispose();
}
}
}
public async Task <RepositoryResponse <bool> > ImportAsync(string destCulture,
MixCmsContext _context = null, IDbContextTransaction _transaction = null)
{
var result = new RepositoryResponse <bool>()
{
IsSucceed = true
};
UnitOfWorkHelper <MixCmsContext> .InitTransaction(_context, _transaction, out MixCmsContext context, out IDbContextTransaction transaction, out bool isRoot);
try
{
if (Pages != null)
{
result = await ImportPagesAsync(destCulture, context, transaction);
}
if (result.IsSucceed && Modules != null)
{
result = await ImportModulesAsync(destCulture, context, transaction);
}
if (result.IsSucceed && Modules != null)
{
result = await ImportPostsAsync(destCulture, context, transaction);
}
if (result.IsSucceed && AttributeSets != null)
{
result = await ImportAttributeSetsAsync(context, transaction);
}
if (result.IsSucceed && AttributeSetDatas.Count > 0)
{
result = await ImportAttributeSetDatas(destCulture, context, transaction);
}
if (result.IsSucceed && RelatedData.Count > 0)
{
result = await ImportRelatedDatas(destCulture, context, transaction);
}
UnitOfWorkHelper <MixCmsContext> .HandleTransaction(result.IsSucceed, isRoot, transaction);
}
catch (Exception ex) // TODO: Add more specific exeption types instead of Exception only
{
var error = UnitOfWorkHelper <MixCmsContext> .HandleException <MixPages.ImportViewModel>(ex, isRoot, transaction);
result.IsSucceed = false;
result.Errors = error.Errors;
result.Exception = error.Exception;
}
finally
{
//if current Context is Root
if (isRoot)
{
context.Database.CloseConnection(); transaction.Dispose(); context.Dispose();
}
}
return(result);
}
public async Task <RepositoryResponse <bool> > ImportAsync(string destCulture,
MixCmsContext _context = null, IDbContextTransaction _transaction = null)
{
var result = new RepositoryResponse <bool>()
{
IsSucceed = true
};
UnitOfWorkHelper <MixCmsContext> .InitTransaction(_context, _transaction, out MixCmsContext context, out IDbContextTransaction transaction, out bool isRoot);
try
{
if (Pages != null)
{
result = await ImportPagesAsync(Pages, destCulture, context, transaction);
}
if (result.IsSucceed)
{
if (Modules != null)
{
foreach (var module in Modules)
{
if (result.IsSucceed)
{
if (!context.MixModule.Any(m => m.Name == module.Name && m.Specificulture == destCulture))
{
module.Id = context.MixModule.Max(m => m.Id) + 1;
module.CreatedDateTime = DateTime.UtcNow;
var saveResult = await module.SaveModelAsync(true, context, transaction);
ViewModelHelper.HandleResult(saveResult, ref result);
}
}
}
}
}
UnitOfWorkHelper <MixCmsContext> .HandleTransaction(result.IsSucceed, isRoot, transaction);
}
catch (Exception ex) // TODO: Add more specific exeption types instead of Exception only
{
var error = UnitOfWorkHelper <MixCmsContext> .HandleException <MixPages.ImportViewModel>(ex, isRoot, transaction);
result.IsSucceed = false;
result.Errors = error.Errors;
result.Exception = error.Exception;
}
finally
{
//if current Context is Root
if (isRoot)
{
context?.Dispose();
}
}
return(result);
}
/// <summary>
/// Removes the model asynchronous.
/// </summary>
/// <param name="isRemoveRelatedModels">if set to <c>true</c> [is remove related models].</param>
/// <param name="_context">The context.</param>
/// <param name="_transaction">The transaction.</param>
/// <returns></returns>
public virtual async Task <RepositoryResponse <TModel> > RemoveModelAsync(bool isRemoveRelatedModels = false, TDbContext _context = null, IDbContextTransaction _transaction = null)
{
UnitOfWorkHelper <TDbContext> .InitTransaction(_context, _transaction, out TDbContext context, out IDbContextTransaction transaction, out bool isRoot);
RepositoryResponse <TModel> result = new RepositoryResponse <TModel>()
{
IsSucceed = true
};
try
{
ParseModel(_context, _transaction);
if (isRemoveRelatedModels)
{
var removeRelatedResult = await RemoveRelatedModelsAsync((TView)this, context, transaction).ConfigureAwait(false);
if (removeRelatedResult.IsSucceed)
{
result = await Repository.RemoveModelAsync(Model, context, transaction).ConfigureAwait(false);
}
else
{
result.IsSucceed = result.IsSucceed && removeRelatedResult.IsSucceed;
result.Errors.AddRange(removeRelatedResult.Errors);
result.Exception = removeRelatedResult.Exception;
}
}
else
{
result = await Repository.RemoveModelAsync(Model, context, transaction).ConfigureAwait(false);
}
UnitOfWorkHelper <TDbContext> .HandleTransaction(result.IsSucceed, isRoot, transaction);
_ = this.SendNotifyAsync(this, RepositoryAction.Delete, result.IsSucceed);
return(result);
}
catch (Exception ex)
{
return(UnitOfWorkHelper <TDbContext> .HandleException <TModel>(ex, isRoot, transaction));
}
finally
{
if (result.IsSucceed && IsCache)
{
await RemoveCache(Model, context, transaction);
}
if (isRoot)
{
//if current Context is Root
UnitOfWorkHelper <TDbContext> .CloseDbContext(ref context, ref transaction);
}
}
}
/// <summary>
/// Step 3
/// - Init Languages for translate
/// </summary>
/// <param name="culture"></param>
/// <param name="_context"></param>
/// <param name="_transaction"></param>
/// <returns></returns>
public async Task <RepositoryResponse <bool> > InitLanguagesAsync(string specificulture, List <MixLanguage> languages
, MixCmsContext _context = null, IDbContextTransaction _transaction = null)
{
/* Init Languages */
UnitOfWorkHelper <MixCmsContext> .InitTransaction(_context, _transaction, out MixCmsContext context, out IDbContextTransaction transaction, out bool isRoot);
var result = await ViewModels.MixLanguages.ReadMvcViewModel.ImportLanguages(languages, specificulture, context, transaction);
UnitOfWorkHelper <MixCmsContext> .HandleTransaction(result.IsSucceed, isRoot, transaction);
return(result);
}
public static async Task <bool> InitPositionsAsync(MixCmsContext _context = null, IDbContextTransaction _transaction = null)
{
/* Init Positions */
UnitOfWorkHelper <MixCmsContext> .InitTransaction(_context, _transaction, out MixCmsContext context, out IDbContextTransaction transaction, out bool isRoot);
var positions = FileRepository.Instance.GetFile(MixConstants.CONST_FILE_POSITIONS, "data", true, "{}");
var obj = JObject.Parse(positions.Content);
var arrPosition = obj["data"].ToObject <List <MixPosition> >();
var result = await ViewModels.MixPositions.ReadViewModel.ImportPositions(arrPosition, context, transaction);
UnitOfWorkHelper <MixCmsContext> .HandleTransaction(result.IsSucceed, isRoot, transaction);
return(result.IsSucceed);
}
public override async Task <RepositoryResponse <FormViewModel> > SaveModelAsync(bool isSaveSubModels = false, MixCmsContext _context = null, IDbContextTransaction _transaction = null)
{
var result = new RepositoryResponse <FormViewModel>()
{
IsSucceed = true
};
UnitOfWorkHelper <MixCmsContext> .InitTransaction(_context, _transaction, out MixCmsContext context, out IDbContextTransaction transaction, out bool isRoot);
try
{
if (AttributeData != null && string.IsNullOrEmpty(AttributeData.Id))
{
var saveData = await AttributeData.SaveModelAsync(true, context, transaction);
if (!saveData.IsSucceed)
{
result.IsSucceed = false;
result.Errors = saveData.Errors;
result.Exception = saveData.Exception;
}
else
{
DataId = saveData.Data.Id;
}
}
else
{
DataId = AttributeData.Id;
}
if (result.IsSucceed)
{
result = await base.SaveModelAsync(true, context, transaction);
}
UnitOfWorkHelper <MixCmsContext> .HandleTransaction(result.IsSucceed, isRoot, transaction);
return(result);
}
catch (Exception ex)
{
return(UnitOfWorkHelper <MixCmsContext> .HandleException <FormViewModel>(ex, isRoot, transaction));
}
finally
{
if (isRoot)
{
context.Dispose();
}
}
}
public static async Task <RepositoryResponse <bool> > ImportConfigurations(List <MixConfiguration> arrConfiguration, string destCulture,
MixCmsContext _context = null, IDbContextTransaction _transaction = null)
{
var result = new RepositoryResponse <bool>()
{
IsSucceed = true
};
bool isRoot = _context == null;
var context = _context ?? new MixCmsContext();
var transaction = _transaction ?? context.Database.BeginTransaction();
try
{
foreach (var item in arrConfiguration)
{
var lang = new ReadMvcViewModel(item, context, transaction);
lang.CreatedDateTime = DateTime.UtcNow;
lang.Specificulture = destCulture;
var saveResult = await lang.SaveModelAsync(false, context, transaction);
result.IsSucceed = result.IsSucceed && saveResult.IsSucceed;
if (!result.IsSucceed)
{
result.Exception = saveResult.Exception;
result.Errors = saveResult.Errors;
break;
}
}
result.Data = true;
UnitOfWorkHelper <MixCmsContext> .HandleTransaction(result.IsSucceed, isRoot, transaction);
}
catch (Exception ex) // TODO: Add more specific exeption types instead of Exception only
{
var error = UnitOfWorkHelper <MixCmsContext> .HandleException <ReadMvcViewModel>(ex, isRoot, transaction);
result.IsSucceed = false;
result.Errors = error.Errors;
result.Exception = error.Exception;
}
finally
{
//if current Context is Root
if (isRoot)
{
context?.Dispose();
}
}
return(result);
}
public static void LoadFromDatabase(SioCmsContext _context = null, IDbContextTransaction _transaction = null)
{
UnitOfWorkHelper<SioCmsContext>.InitTransaction(_context, _transaction
, out SioCmsContext context, out IDbContextTransaction transaction, out bool isRoot);
try
{
Instance.Translator = new JObject();
var ListLanguage = context.SioLanguage;
foreach (var culture in context.SioCulture)
{
JObject arr = new JObject();
foreach (var lang in ListLanguage.Where(l => l.Specificulture == culture.Specificulture))
{
JProperty l = new JProperty(lang.Keyword, lang.Value ?? lang.DefaultValue);
arr.Add(l);
}
Instance.Translator.Add(new JProperty(culture.Specificulture, arr));
}
Instance.LocalSettings = new JObject();
var listLocalSettings = context.SioConfiguration;
foreach (var culture in context.SioCulture)
{
JObject arr = new JObject();
foreach (var cnf in listLocalSettings.Where(l => l.Specificulture == culture.Specificulture))
{
JProperty l = new JProperty(cnf.Keyword, cnf.Value);
arr.Add(l);
}
Instance.LocalSettings.Add(new JProperty(culture.Specificulture, arr));
}
UnitOfWorkHelper<SioCmsContext>.HandleTransaction(true, isRoot, transaction);
}
catch (Exception ex) // TODO: Add more specific exeption types instead of Exception only
{
var error = UnitOfWorkHelper<SioCmsContext>.HandleException<SioLanguage>(ex, isRoot, transaction);
}
finally
{
//if current Context is Root
if (isRoot)
{
context?.Dispose();
}
}
}
public override async Task <RepositoryResponse <UpdateViewModel> > SaveModelAsync(bool isSaveSubModels = false, MixCmsContext _context = null, IDbContextTransaction _transaction = null)
{
UnitOfWorkHelper <MixCmsContext> .InitTransaction(_context, _transaction, out MixCmsContext context, out IDbContextTransaction transaction, out bool isRoot);
try
{
var result = await base.SaveModelAsync(isSaveSubModels, context, transaction);
// if save current data success and there is related parent data
if (result.IsSucceed && !string.IsNullOrEmpty(ParentId))
{
MixDatabaseDataAssociations.UpdateViewModel nav = new MixDatabaseDataAssociations.UpdateViewModel()
{
DataId = result.Data.Id,
Specificulture = Specificulture,
MixDatabaseId = result.Data.MixDatabaseId,
MixDatabaseName = result.Data.MixDatabaseName,
ParentId = ParentId,
ParentType = ParentType,
IsClone = IsClone,
Cultures = Cultures
};
var saveNav = await nav.SaveModelAsync(true, context, transaction);
if (IsClone)
{
}
result.IsSucceed = result.IsSucceed && saveNav.IsSucceed;
result.Errors = saveNav.Errors;
result.Exception = saveNav.Exception;
}
UnitOfWorkHelper <MixCmsContext> .HandleTransaction(result.IsSucceed, isRoot, transaction);
return(result);
}
catch (Exception ex)
{
return(UnitOfWorkHelper <MixCmsContext> .HandleException <UpdateViewModel>(ex, isRoot, transaction));
}
finally
{
if (isRoot)
{
UnitOfWorkHelper <MixCmsContext> .CloseDbContext(ref context, ref transaction);
}
}
}
public static async Task <RepositoryResponse <bool> > ImportLanguages(List <MixLanguage> arrLanguage, string destCulture
, MixCmsContext _context = null, IDbContextTransaction _transaction = null)
{
var result = new RepositoryResponse <bool>()
{
IsSucceed = true
};
UnitOfWorkHelper <MixCmsContext> .InitTransaction(_context, _transaction, out MixCmsContext context, out IDbContextTransaction transaction, out bool isRoot);
try
{
foreach (var item in arrLanguage)
{
var lang = new UpdateViewModel(item, context, transaction);
lang.Specificulture = destCulture;
lang.CreatedDateTime = DateTime.UtcNow;
var saveResult = await lang.SaveModelAsync(false, context, transaction);
result.IsSucceed = result.IsSucceed && saveResult.IsSucceed;
if (!result.IsSucceed)
{
result.Exception = saveResult.Exception;
result.Errors = saveResult.Errors;
break;
}
}
UnitOfWorkHelper <MixCmsContext> .HandleTransaction(result.IsSucceed, isRoot, transaction);
}
catch (Exception ex) // TODO: Add more specific exeption types instead of Exception only
{
var error = UnitOfWorkHelper <MixCmsContext> .HandleException <ReadMvcViewModel>(ex, isRoot, transaction);
result.IsSucceed = false;
result.Errors = error.Errors;
result.Exception = error.Exception;
}
finally
{
if (isRoot)
{
context.Dispose();
}
}
return(result);
}
public static async System.Threading.Tasks.Task <RepositoryResponse <List <ReadViewModel> > > UpdateInfosAsync(List <ReadViewModel> data)
{
MixCmsContext context = new MixCmsContext();
var transaction = context.Database.BeginTransaction();
var result = new RepositoryResponse <List <ReadViewModel> >();
try
{
foreach (var item in data)
{
var model = context.MixModuleData.FirstOrDefault(m => m.Id == item.Id && m.Specificulture == item.Specificulture);
if (model != null)
{
model.Priority = item.Priority;
context.Entry(model).State = Microsoft.EntityFrameworkCore.EntityState.Modified;
}
}
result.IsSucceed = (await context.SaveChangesAsync()) > 0;
if (!result.IsSucceed)
{
result.Errors.Add("Nothing changed");
}
UnitOfWorkHelper <MixCmsContext> .HandleTransaction(result.IsSucceed, true, transaction);
return(result);
}
catch (Exception ex) // TODO: Add more specific exeption types instead of Exception only
{
UnitOfWorkHelper <MixCmsContext> .HandleException <ReadViewModel>(ex, true, transaction);
return(new RepositoryResponse <List <ReadViewModel> >()
{
IsSucceed = false,
Data = null,
Exception = ex
});
}
finally
{
//if current Context is Root
transaction.Dispose();
context.Dispose();
}
#endregion Expands
}
public static async Task <RepositoryResponse <bool> > ActivedThemeAsync(
int themeId,
string themeName,
string culture,
MixCmsContext _context = null, IDbContextTransaction _transaction = null)
{
UnitOfWorkHelper <MixCmsContext> .InitTransaction(_context, _transaction, out MixCmsContext context, out IDbContextTransaction transaction, out bool isRoot);
try
{
var result = new RepositoryResponse <bool>()
{
IsSucceed = true
};
var saveResult = await SaveNewConfigAsync(MixAppSettingKeywords.ThemeName, themeName, culture, context, transaction);
if (saveResult.IsSucceed)
{
saveResult = await SaveNewConfigAsync(MixAppSettingKeywords.ThemeFolder, themeName, culture, context, transaction);
}
ViewModelHelper.HandleResult(saveResult, ref result);
if (result.IsSucceed)
{
saveResult = await SaveNewConfigAsync(MixAppSettingKeywords.ThemeId, themeId.ToString(), culture, context, transaction);
ViewModelHelper.HandleResult(saveResult, ref result);
}
UnitOfWorkHelper <MixCmsContext> .HandleTransaction(result.IsSucceed, isRoot, transaction);
return(result);
}
catch (Exception ex)
{
return(UnitOfWorkHelper <MixCmsContext> .HandleException <bool>(ex, isRoot, transaction));
}
finally
{
if (isRoot)
{
context.Dispose();
}
}
}
public static async Task <RepositoryResponse <bool> > ImportLanguages(List <MixLanguage> arrLanguage, string destCulture)
{
UnitOfWorkHelper <MixCmsContext> .InitTransaction(null, null, out MixCmsContext context, out IDbContextTransaction transaction, out bool isRoot);
var result = new RepositoryResponse <bool>()
{
IsSucceed = true
};
try
{
foreach (var item in arrLanguage)
{
var lang = new SystemLanguageViewModel(item, context, transaction);
lang.Specificulture = destCulture;
var saveResult = await lang.SaveModelAsync(false, context, transaction);
result.IsSucceed = result.IsSucceed && saveResult.IsSucceed;
if (!result.IsSucceed)
{
result.Exception = saveResult.Exception;
result.Errors = saveResult.Errors;
break;
}
}
UnitOfWorkHelper <MixCmsContext> .HandleTransaction(result.IsSucceed, true, transaction);
}
catch (Exception ex) // TODO: Add more specific exeption types instead of Exception only
{
var error = UnitOfWorkHelper <MixCmsContext> .HandleException <SystemLanguageViewModel>(ex, true, transaction);
result.IsSucceed = false;
result.Errors = error.Errors;
result.Exception = error.Exception;
}
finally
{
//if current Context is Root
if (isRoot)
{
context.Database.CloseConnection(); transaction.Dispose(); context.Dispose();
}
}
return(result);
}
public static async Task <RepositoryResponse <bool> > Import(List <MixModule> arrModule, string destCulture,
MixCmsContext _context = null, IDbContextTransaction _transaction = null)
{
var result = new RepositoryResponse <bool>()
{
IsSucceed = true
};
bool isRoot = _context == null;
var context = _context ?? new MixCmsContext();
var transaction = _transaction ?? context.Database.BeginTransaction();
try
{
int id = UpdateViewModel.ModelRepository.Max(m => m.Id, context, transaction).Data + 1;
foreach (var item in arrModule)
{
item.Id = id;
item.CreatedDateTime = DateTime.UtcNow;
item.Specificulture = destCulture;
context.MixModule.Add(item);
id++;
}
await context.SaveChangesAsync();
result.Data = true;
UnitOfWorkHelper <MixCmsContext> .HandleTransaction(result.IsSucceed, isRoot, transaction);
}
catch (Exception ex) // TODO: Add more specific exeption types instead of Exception only
{
var error = UnitOfWorkHelper <MixCmsContext> .HandleException <ReadMvcViewModel>(ex, isRoot, transaction);
result.IsSucceed = false;
result.Errors = error.Errors;
result.Exception = error.Exception;
}
finally
{
//if current Context is Root
if (isRoot)
{
context?.Dispose();
}
}
return(result);
}
public static async Task <RepositoryResponse <bool> > ImportData(
string culture, Lib.ViewModels.MixAttributeSets.ReadViewModel attributeSet, IFormFile file)
{
var result = new RepositoryResponse <bool>()
{
IsSucceed = true
};
UnitOfWorkHelper <MixCmsContext> .InitTransaction(null, null, out MixCmsContext context, out IDbContextTransaction transaction, out bool isRoot);
try
{
List <ImportViewModel> data = LoadFileData(culture, attributeSet, file);
var fields = MixAttributeFields.UpdateViewModel.Repository.GetModelListBy(f => f.AttributeSetId == attributeSet.Id, context, transaction).Data;
foreach (var item in data)
{
if (result.IsSucceed)
{
var isCreateNew = string.IsNullOrEmpty(item.Id);
item.Fields = fields;
item.AttributeSetName = attributeSet.Name;
item.Status = MixService.GetEnumConfig <MixContentStatus>(MixAppSettingKeywords.DefaultContentStatus);
var saveResult = await item.SaveModelAsync(true, context, transaction);
ViewModelHelper.HandleResult(saveResult, ref result);
}
}
UnitOfWorkHelper <MixCmsContext> .HandleTransaction(result.IsSucceed, isRoot, transaction);
return(result);
}
catch (Exception ex)
{
return(UnitOfWorkHelper <MixCmsContext> .HandleException <bool>(ex, isRoot, transaction));
}
finally
{
if (isRoot)
{
//if current Context is Root
UnitOfWorkHelper <MixCmsContext> .CloseDbContext(ref context, ref transaction);
}
}
}
public static async Task <RepositoryResponse <List <ReadViewModel> > > UpdateInfosAsync(List <ReadViewModel> cates)
{
MixCmsContext context = new MixCmsContext();
var transaction = context.Database.BeginTransaction();
var result = new RepositoryResponse <List <ReadViewModel> >();
try
{
foreach (var item in cates)
{
item.LastModified = DateTime.UtcNow;
var saveResult = await item.SaveModelAsync(false, context, transaction);
result.IsSucceed = saveResult.IsSucceed;
if (!result.IsSucceed)
{
result.Errors.AddRange(saveResult.Errors);
result.Exception = saveResult.Exception;
break;
}
}
UnitOfWorkHelper <MixCmsContext> .HandleTransaction(result.IsSucceed, true, transaction);
return(result);
}
catch (Exception ex) // TODO: Add more specific exeption types instead of Exception only
{
UnitOfWorkHelper <MixCmsContext> .HandleException <ReadViewModel>(ex, true, transaction);
return(new RepositoryResponse <List <ReadViewModel> >()
{
IsSucceed = false,
Data = null,
Exception = ex
});
}
finally
{
//if current Context is Root
transaction.Dispose();
context.Dispose();
}
}
public override async Task <RepositoryResponse <ODataUpdateViewModel> > SaveModelAsync(bool isSaveSubModels = false, MixCmsContext _context = null, IDbContextTransaction _transaction = null)
{
UnitOfWorkHelper <MixCmsContext> .InitTransaction(_context, _transaction, out MixCmsContext context, out IDbContextTransaction transaction, out bool isRoot);
try
{
var result = await base.SaveModelAsync(isSaveSubModels, context, transaction);
// if save current data success and there is related parent data
if (result.IsSucceed && !string.IsNullOrEmpty(ParentId))
{
Lib.ViewModels.MixRelatedAttributeDatas.UpdateViewModel nav = new Lib.ViewModels.MixRelatedAttributeDatas.UpdateViewModel()
{
Id = result.Data.Id,
Specificulture = Specificulture,
AttributeSetId = result.Data.AttributeSetId,
AttributeSetName = result.Data.AttributeSetName,
ParentId = ParentId,
ParentType = ParentType
};
var saveNav = await nav.SaveModelAsync(true, context, transaction);
result.IsSucceed = result.IsSucceed && saveNav.IsSucceed;
result.Errors = saveNav.Errors;
result.Exception = saveNav.Exception;
}
UnitOfWorkHelper <MixCmsContext> .HandleTransaction(result.IsSucceed, isRoot, transaction);
return(result);
}
catch (Exception ex)
{
return(UnitOfWorkHelper <MixCmsContext> .HandleException <ODataUpdateViewModel>(ex, isRoot, transaction));
}
finally
{
if (isRoot)
{
context.Database.CloseConnection(); transaction.Dispose(); context.Dispose();
}
}
}
public static async Task <RepositoryResponse <bool> > ImportConfigurations(List <MixConfiguration> arrConfiguration, string destCulture)
{
var result = new RepositoryResponse <bool>()
{
IsSucceed = true
};
var context = new MixCmsContext();
var transaction = context.Database.BeginTransaction();
try
{
foreach (var item in arrConfiguration)
{
var lang = new SystemConfigurationViewModel(item, context, transaction);
lang.Specificulture = destCulture;
var saveResult = await lang.SaveModelAsync(false, context, transaction);
result.IsSucceed = result.IsSucceed && saveResult.IsSucceed;
if (!result.IsSucceed)
{
result.Exception = saveResult.Exception;
result.Errors = saveResult.Errors;
break;
}
}
UnitOfWorkHelper <MixCmsContext> .HandleTransaction(result.IsSucceed, true, transaction);
}
catch (Exception ex) // TODO: Add more specific exeption types instead of Exception only
{
var error = UnitOfWorkHelper <MixCmsContext> .HandleException <SystemConfigurationViewModel>(ex, true, transaction);
result.IsSucceed = false;
result.Errors = error.Errors;
result.Exception = error.Exception;
}
finally
{
//if current Context is Root
context?.Dispose();
}
return(result);
}
public static async Task <RepositoryResponse <bool> > ImportPositions(List <MixPosition> arrPosition,
MixCmsContext _context = null, IDbContextTransaction _transaction = null)
{
var result = new RepositoryResponse <bool>()
{
IsSucceed = true
};
bool isRoot = _context == null;
var context = _context ?? new MixCmsContext();
var transaction = _transaction ?? context.Database.BeginTransaction();
try
{
foreach (var item in arrPosition)
{
context.Entry(item).State = Microsoft.EntityFrameworkCore.EntityState.Added;
}
await context.SaveChangesAsync();
UnitOfWorkHelper <MixCmsContext> .HandleTransaction(result.IsSucceed, isRoot, transaction);
}
catch (Exception ex) // TODO: Add more specific exeption types instead of Exception only
{
var error = UnitOfWorkHelper <MixCmsContext> .HandleException <MixPosition>(ex, isRoot, transaction);
result.IsSucceed = false;
result.Errors = error.Errors;
result.Exception = error.Exception;
}
finally
{
//if current Context is Root
if (isRoot)
{
context?.Dispose();
}
}
return(result);
}
/// <summary>
/// Creates the model.
/// </summary>
/// <param name="view">The view.</param>
/// <param name="_context">The context.</param>
/// <param name="_transaction">The transaction.</param>
/// <returns></returns>
public virtual RepositoryResponse <TView> CreateModel(TView view
, TDbContext _context = null, IDbContextTransaction _transaction = null)
{
UnitOfWorkHelper <TDbContext> .InitTransaction(_context, _transaction, out TDbContext context, out IDbContextTransaction transaction, out bool isRoot);
RepositoryResponse <TView> result = new RepositoryResponse <TView>()
{
IsSucceed = true
};
try
{
context.Entry(view.Model).State = EntityState.Added;
result.IsSucceed = context.SaveChanges() > 0;
result.Data = view;
UnitOfWorkHelper <TDbContext> .HandleTransaction(result.IsSucceed, isRoot, transaction);
return(result);
}
catch (Exception ex)
{
LogErrorMessage(ex);
result.IsSucceed = false;
result.Exception = ex;
if (isRoot)
{
transaction.Rollback();
}
return(result);
}
finally
{
if (isRoot)
{
//if current Context is Root
UnitOfWorkHelper <TDbContext> .CloseDbContext(ref context, ref transaction);
}
}
}
/// <summary>
/// Creates the model asynchronous.
/// </summary>
/// <param name="view">The view.</param>
/// <param name="_context">The context.</param>
/// <param name="_transaction">The transaction.</param>
/// <returns></returns>
public virtual async Task <RepositoryResponse <TView> > CreateModelAsync(TView view
, TDbContext _context = null, IDbContextTransaction _transaction = null)
{
UnitOfWorkHelper <TDbContext> .InitTransaction(_context, _transaction, out TDbContext context, out IDbContextTransaction transaction, out bool isRoot);
RepositoryResponse <TView> result = new RepositoryResponse <TView>()
{
IsSucceed = true
};
try
{
context.Entry(view.Model).State = EntityState.Added;
result.IsSucceed = await context.SaveChangesAsync().ConfigureAwait(false) > 0;
result.Data = view;
if (result.IsSucceed)
{
result.Data.ParseView(false, context, transaction);
}
UnitOfWorkHelper <TDbContext> .HandleTransaction(result.IsSucceed, isRoot, transaction);
return(result);
}
catch (Exception ex)
{
return(UnitOfWorkHelper <TDbContext> .HandleException <TView>(view, ex, isRoot, transaction));
}
finally
{
if (isRoot)
{
//if current Context is Root
UnitOfWorkHelper <TDbContext> .CloseDbContext(ref context, ref transaction);
}
}
}
