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
UnitOfWorkHelper <MixCmsContext> .CloseDbContext(ref context, ref transaction);
}
return(result);
}
public static async System.Threading.Tasks.Task <RepositoryResponse <List <ReadViewModel> > > UpdateInfosAsync(List <MixPortalPagePortalPages.ReadViewModel> cates)
{
MixCmsContext context = new MixCmsContext();
var transaction = context.Database.BeginTransaction();
var result = new RepositoryResponse <List <ReadViewModel> >();
try
{
foreach (var item in cates)
{
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();
UnitOfWorkHelper <MixCmsContext> .CloseDbContext(ref context, ref transaction);
}
}
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))
{
MixRelatedAttributeDatas.UpdateViewModel nav = new MixRelatedAttributeDatas.UpdateViewModel()
{
DataId = 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 <UpdateViewModel>(ex, isRoot, transaction));
}
finally
{
if (isRoot)
{
UnitOfWorkHelper <MixCmsContext> .CloseDbContext(ref context, ref transaction);
}
}
}
public static async Task <RepositoryResponse <PaginationModel <TView> > > GetPostListByPageId <TView>(
int pageId
, string keyword = null
, string culture = null
, string orderByPropertyName = "CreatedDateTime"
, Heart.Enums.MixHeartEnums.DisplayDirection direction = Heart.Enums.MixHeartEnums.DisplayDirection.Desc
, int?pageSize = null, int?pageIndex = null
, MixCmsContext _context = null, IDbContextTransaction _transaction = null)
where TView : ViewModelBase <MixCmsContext, MixPagePost, TView>
{
UnitOfWorkHelper <MixCmsContext> .InitTransaction(_context, _transaction, out MixCmsContext context, out IDbContextTransaction transaction, out bool isRoot);
try
{
culture = culture ?? MixService.GetConfig <string>("DefaultCulture");
var result = await DefaultRepository <MixCmsContext, MixPagePost, TView> .Instance.GetModelListByAsync(
m => m.Specificulture == culture && m.PageId == pageId &&
(string.IsNullOrEmpty(keyword) ||
(EF.Functions.Like(m.MixPost.Title, $"%{keyword}%")) ||
(EF.Functions.Like(m.MixPost.Excerpt, $"%{keyword}%")) ||
(EF.Functions.Like(m.MixPost.Content, $"%{keyword}%"))
)
, orderByPropertyName, direction, pageSize, pageIndex
, _context : context, _transaction : transaction
);
return(result);
}
catch (Exception ex)
{
return(UnitOfWorkHelper <MixCmsContext> .HandleException <PaginationModel <TView> >(ex, isRoot, transaction));
}
finally
{
if (isRoot)
{
//if current Context is Root
UnitOfWorkHelper <MixCmsContext> .CloseDbContext(ref context, ref transaction);
}
}
}
public static async Task <RepositoryResponse <FileViewModel> > ParseSitemapAsync()
{
UnitOfWorkHelper <MixCmsContext> .InitTransaction(null, null, out MixCmsContext context, out IDbContextTransaction transaction, out bool isRoot);
try
{
XNamespace aw = "http://www.sitemaps.org/schemas/sitemap/0.9";
var root = new XElement(aw + "urlset");
await ParseNavigationsAsync(root, context, transaction);
await ParsePostsDocAsync(root, context, transaction);
string folder = $"wwwroot";
MixFileRepository.Instance.CreateDirectoryIfNotExist(folder);
string filename = $"sitemap";
string filePath = $"{folder}/{filename}{MixFileExtensions.Xml}";
root.Save(filePath);
return(new RepositoryResponse <FileViewModel>()
{
IsSucceed = true,
Data = new FileViewModel()
{
Extension = MixFileExtensions.Xml,
Filename = filename,
FileFolder = folder
}
});
}
catch (Exception ex)
{
return(UnitOfWorkHelper <MixCmsContext> .HandleException <FileViewModel>(ex, isRoot, transaction));
}
finally
{
if (isRoot)
{
//if current Context is Root
UnitOfWorkHelper <MixCmsContext> .CloseDbContext(ref context, ref transaction);
}
}
}
public RepositoryResponse <string> ExportSelectedItemsAsync()
{
UnitOfWorkHelper <MixCmsContext> .InitTransaction(null, null, out MixCmsContext context, out IDbContextTransaction transaction, out bool isRoot);
var result = new RepositoryResponse <string>()
{
IsSucceed = true
};
try
{
Configurations = MixConfigurations.ImportViewModel.Repository.GetModelListBy(
m => m.Specificulture == Specificulture, context, transaction).Data;
Languages = MixLanguages.ImportViewModel.Repository.GetModelListBy(
m => m.Specificulture == Specificulture, context, transaction).Data;
ExportPages(context, transaction);
ExportModules(context, transaction);
ExportMixDatabasesAsync(context, transaction);
ExportDatas(context, transaction);
return(result);
}
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 = ex;
return(result);
}
finally
{
//if current Context is Root
if (isRoot)
{
UnitOfWorkHelper <MixCmsContext> .CloseDbContext(ref context, ref transaction);
}
}
}
public static async Task <RepositoryResponse <PaginationModel <TView> > > GetModelistByMeta <TView>(
string metaName,
string metaValue,
string postType,
PagingRequest pagingData,
string culture = null,
MixCmsContext _context = null,
IDbContextTransaction _transaction = null)
where TView : ViewModelBase <MixCmsContext, MixPost, TView>
{
UnitOfWorkHelper <MixCmsContext> .InitTransaction(_context, _transaction, out MixCmsContext context, out IDbContextTransaction transaction, out bool isRoot);
try
{
culture ??= MixService.GetAppSetting <string>(MixAppSettingKeywords.DefaultCulture);
postType ??= MixDatabaseNames.ADDITIONAL_COLUMN_POST;
var valExp = Expressions.GetMetaExpression(metaName, metaValue, culture);
var searchPostData = new SearchPostQueryModel()
{
PagingData = pagingData,
PostType = postType,
Specificulture = culture
};
return(await SearchPostByValue <TView>(valExp, searchPostData, context, transaction));
}
catch (Exception ex)
{
return(UnitOfWorkHelper <MixCmsContext> .HandleException <PaginationModel <TView> >(ex, isRoot, transaction));
}
finally
{
if (isRoot)
{
//if current Context is Root
UnitOfWorkHelper <MixCmsContext> .CloseDbContext(ref context, ref transaction);
}
}
}
/// <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);
}
}
}
public static List <NavUserRoleViewModel> GetRoleNavs(string userId)
{
UnitOfWorkHelper <MixCmsAccountContext> .InitTransaction(
null, null, out MixCmsAccountContext context,
out IDbContextTransaction transaction, out bool isRoot);
try
{
var query = context.AspNetRoles
.Include(cp => cp.AspNetUserRoles)
.ToList()
.Select(p => new NavUserRoleViewModel()
{
UserId = userId,
RoleId = p.Id,
Description = p.Name,
IsActived = context.AspNetUserRoles.Any(m => m.UserId == userId && m.RoleId == p.Id)
})
.OrderBy(m => m.Priority)
.ToList();
query.ForEach(m => m.ExpandView(context, transaction));
return(query);
}
catch (Exception ex)
{
return(UnitOfWorkHelper <MixCmsAccountContext> .HandleException <List <NavUserRoleViewModel> >(
ex, isRoot, transaction).Data);
}
finally
{
if (isRoot)
{
//if current Context is Root
UnitOfWorkHelper <MixCmsAccountContext> .CloseDbContext(ref context, ref transaction);
}
}
}
/// <summary>
/// Edits 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> EditModel(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.Modified;
result.IsSucceed = context.SaveChanges() > 0;
result.Data = view;
if (result.IsSucceed)
{
RemoveCacheAsync(view.Model, context, transaction).GetAwaiter().GetResult();
}
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);
}
}
}
private async Task <RepositoryResponse <bool> > ImportPagesAsync(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 = MixPages.UpdateViewModel.ModelRepository.Max(m => m.Id, context, transaction).Data;
int startModuleId = MixModules.UpdateViewModel.ModelRepository.Max(m => m.Id, context, transaction).Data;
//var pages = MixFileRepository.Instance.GetFile(MixConstants.CONST_FILE_PAGES, MixFolders.JsonDataFolder, true, "{}");
//var obj = JObject.Parse(pages.Content);
//var initPages = obj["data"].ToObject<JArray>();
foreach (var item in Pages)
{
// store old id => update to related data if save success
var oldId = item.Id;
item.CreatedBy = CreatedBy;
// TODO: Id > 7 => not system init page
if (!context.MixPage.Any(p => p.SeoName == item.SeoName))
{
startId++;
item.Id = startId;
item.CreatedDateTime = DateTime.UtcNow;
item.ThemeName = ThemeName;
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 (!dicPageIds.Any(m => m.Key == item.Id))
{
dicPageIds.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);
}
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 (Configurations != null && Configurations.Count > 0)
{
result = await ImportConfigurationsAsync(destCulture, context, transaction);
}
if (result.IsSucceed && Languages != null && Languages.Count > 0)
{
result = await ImportLanguagesAsync(destCulture, context, transaction);
}
if (result.IsSucceed && Pages != null && Pages.Count > 0)
{
result = await ImportPagesAsync(destCulture, context, transaction);
}
if (result.IsSucceed && Modules != null && Modules.Count > 0)
{
result = await ImportModulesAsync(destCulture, context, transaction);
}
if (result.IsSucceed && ModuleDatas.Count > 0)
{
result = await ImportModuleDatas(destCulture, context, transaction);
}
if (result.IsSucceed && Posts != null && Posts.Count > 0)
{
result = await ImportPostsAsync(destCulture, context, transaction);
}
if (result.IsSucceed && MixDatabases != null && MixDatabases.Count > 0)
{
result = await ImportMixDatabasesAsync(context, transaction);
}
if (result.IsSucceed && MixDatabaseDatas.Count > 0)
{
result = await ImportMixDatabaseDatas(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)
{
UnitOfWorkHelper <MixCmsContext> .CloseDbContext(ref context, ref transaction);
}
}
return(result);
}
public static RepositoryResponse <AdditionalViewModel> LoadAdditionalData(
MixDatabaseParentType parentType,
string parentId,
string databaseName,
string culture = null,
MixCmsContext _context = null, IDbContextTransaction _transaction = null)
{
culture = culture ?? MixService.GetConfig <string>("DefaultCulture");
UnitOfWorkHelper <MixCmsContext> .InitTransaction(_context, _transaction, out MixCmsContext context, out IDbContextTransaction transaction, out bool isRoot);
try
{
var dataId = context.MixRelatedAttributeData.FirstOrDefault(
m => m.AttributeSetName == databaseName && m.ParentType == parentType && m.ParentId == parentId && m.Specificulture == culture)?.DataId;
if (!string.IsNullOrEmpty(dataId))
{
return(AdditionalViewModel.Repository.GetSingleModel(
m => m.Id == dataId && m.Specificulture == culture
, context, transaction));
}
else
{
// Init default data
var getAttrSet = MixAttributeSets.UpdateViewModel.Repository.GetSingleModel(
m => m.Name == databaseName
, context, transaction);
if (getAttrSet.IsSucceed)
{
AdditionalViewModel result = new AdditionalViewModel()
{
Specificulture = culture,
AttributeSetId = getAttrSet.Data.Id,
AttributeSetName = getAttrSet.Data.Name,
Status = MixContentStatus.Published,
Fields = getAttrSet.Data.Fields,
ParentType = parentType,
ParentId = parentId
};
result.ExpandView(context, transaction);
return(new RepositoryResponse <AdditionalViewModel>()
{
IsSucceed = true,
Data = result
});
}
return(new RepositoryResponse <AdditionalViewModel>());
}
}
catch (Exception ex)
{
return(UnitOfWorkHelper <MixCmsContext> .HandleException <AdditionalViewModel>(ex, isRoot, transaction));
}
finally
{
if (isRoot)
{
//if current Context is Root
UnitOfWorkHelper <MixCmsContext> .CloseDbContext(ref context, ref transaction);
}
}
}
public static async Task <RepositoryResponse <AdditionalViewModel> > GetAdditionalData(
MixDatabaseParentType parentType, int parentId,
HttpRequest request, string culture = null,
MixCmsContext _context = null, IDbContextTransaction _transaction = null)
{
UnitOfWorkHelper <MixCmsContext> .InitTransaction(_context, _transaction, out MixCmsContext context, out IDbContextTransaction transaction, out bool isRoot);
try
{
// Additional Data is sub data of page / post / module only
culture = culture ?? MixService.GetConfig <string>("DefaultCulture");
var databaseName = request.Query["databaseName"].ToString();
var dataId = (await context.MixRelatedAttributeData.FirstOrDefaultAsync(
m => m.AttributeSetName == databaseName && m.ParentType == parentType && m.ParentId == parentId.ToString() && m.Specificulture == culture))?.DataId;
if (!string.IsNullOrEmpty(dataId))
{
return(await AdditionalViewModel.Repository.GetSingleModelAsync(
m => m.Id == dataId && m.Specificulture == culture
, context, transaction));
}
else
{
// Init default data
var getAttrSet = await Lib.ViewModels.MixAttributeSets.UpdateViewModel.Repository.GetSingleModelAsync(
m => m.Name == request.Query["databaseName"].ToString()
, context, transaction);
if (getAttrSet.IsSucceed)
{
AdditionalViewModel result = new AdditionalViewModel()
{
Specificulture = culture,
AttributeSetId = getAttrSet.Data.Id,
AttributeSetName = getAttrSet.Data.Name,
Status = MixContentStatus.Published,
Fields = getAttrSet.Data.Fields,
ParentType = parentType
};
result.ExpandView(context, transaction);
return(new RepositoryResponse <AdditionalViewModel>()
{
IsSucceed = true,
Data = result
});
}
}
return(new RepositoryResponse <AdditionalViewModel>());
}
catch (Exception ex)
{
return(UnitOfWorkHelper <MixCmsContext> .HandleException <AdditionalViewModel>(ex, isRoot, transaction));
}
finally
{
if (isRoot)
{
//if current Context is Root
UnitOfWorkHelper <MixCmsContext> .CloseDbContext(ref context, ref transaction);
}
}
}
/// <summary>
/// Clones the specified clone cultures.
/// </summary>
/// <param name="model"></param>
/// <param name="cloneCultures">The clone cultures.</param>
/// <param name="_context">The context.</param>
/// <param name="_transaction">The transaction.</param>
/// <returns></returns>
public virtual RepositoryResponse <List <TView> > Clone(TModel model, List <SupportedCulture> cloneCultures, TDbContext _context = null, IDbContextTransaction _transaction = null)
{
UnitOfWorkHelper <TDbContext> .InitTransaction(_context, _transaction, out TDbContext context, out IDbContextTransaction transaction, out bool isRoot);
RepositoryResponse <List <TView> > result = new RepositoryResponse <List <TView> >()
{
IsSucceed = true,
Data = new List <TView>()
};
try
{
if (cloneCultures != null)
{
foreach (var culture in cloneCultures)
{
string desSpecificulture = culture.Specificulture;
//TView view = InitView();
TModel m = (TModel)context.Entry(model).CurrentValues.ToObject();
Type myType = typeof(TModel);
var myFieldInfo = myType.GetProperty("Specificulture");
myFieldInfo.SetValue(m, desSpecificulture);
//view.Model = m;
//view.ParseView(isExpand: false, _context: context, _transaction: transaction);
bool isExist = Repository.CheckIsExists(m, _context: context, _transaction: transaction);
if (isExist)
{
result.IsSucceed = true;
//result.Data.Add(view);
}
else
{
context.Entry(m).State = EntityState.Added;
context.SaveChanges();
var cloneSubResult = CloneSubModels(m, cloneCultures, context, transaction);
if (!cloneSubResult.IsSucceed)
{
cloneSubResult.Errors.AddRange(cloneSubResult.Errors);
cloneSubResult.Exception = cloneSubResult.Exception;
}
result.IsSucceed = result.IsSucceed && cloneSubResult.IsSucceed && cloneSubResult.IsSucceed;
//result.Data.Add(cloneResult.Data);
}
UnitOfWorkHelper <TDbContext> .HandleTransaction(result.IsSucceed, isRoot, transaction);
}
return(result);
}
else
{
return(result);
}
}
catch (Exception ex)
{
result.IsSucceed = false;
result.Exception = ex;
return(result);
}
finally
{
if (isRoot)
{
UnitOfWorkHelper <TDbContext> .CloseDbContext(ref context, ref transaction);
}
}
}
public static async Task <RepositoryResponse <PaginationModel <TView> > > GetPostListByValueId <TView>(
string valueId
, string culture = null
, string orderByPropertyName = "CreatedDateTime"
, Heart.Enums.MixHeartEnums.DisplayDirection direction = Heart.Enums.MixHeartEnums.DisplayDirection.Desc
, int?pageSize = null, int?pageIndex = null
, MixCmsContext _context = null, IDbContextTransaction _transaction = null)
where TView : ViewModelBase <MixCmsContext, MixPost, TView>
{
UnitOfWorkHelper <MixCmsContext> .InitTransaction(_context, _transaction, out MixCmsContext context, out IDbContextTransaction transaction, out bool isRoot);
try
{
culture = culture ?? MixService.GetConfig <string>("DefaultCulture");
var result = new RepositoryResponse <PaginationModel <TView> >()
{
IsSucceed = true,
Data = new PaginationModel <TView>()
{
PageIndex = pageIndex.HasValue ? pageIndex.Value : 0,
PageSize = pageSize
}
};
// Get Tag
var getVal = await MixDatabaseDataValues.ReadViewModel.Repository.GetSingleModelAsync(
m => m.Specificulture == culture &&
m.Status == MixContentStatus.Published &&
m.Id == valueId
, context, transaction);
if (getVal.IsSucceed)
{
result = await GetPostListByDataId <TView>(
dataId : getVal.Data.DataId,
culture : culture,
orderByPropertyName : orderByPropertyName,
direction : direction,
pageSize : pageSize,
pageIndex : pageIndex,
_context : context,
_transaction : transaction);
//var query = context.MixRelatedAttributeData.Where(m=> m.Specificulture == culture
// && m.Id == getVal.Data.DataId && m.ParentId == parentId && m.ParentType == (int) MixEnums.MixDatabaseDataType.Post)
// .Select(m => m.ParentId).Distinct().ToList();
}
return(result);
}
catch (Exception ex)
{
return(UnitOfWorkHelper <MixCmsContext> .HandleException <PaginationModel <TView> >(ex, isRoot, transaction));
}
finally
{
if (isRoot)
{
//if current Context is Root
UnitOfWorkHelper <MixCmsContext> .CloseDbContext(ref context, ref transaction);
}
}
}
public static async Task <RepositoryResponse <PaginationModel <TView> > > SearchPostByIds <TView>(
string keyword
, List <string> dataIds
, List <int> pageIds = null
, string culture = null
, string orderByPropertyName = "CreatedDateTime"
, Heart.Enums.MixHeartEnums.DisplayDirection direction = Heart.Enums.MixHeartEnums.DisplayDirection.Desc
, int?pageSize = null, int?pageIndex = null
, MixCmsContext _context = null, IDbContextTransaction _transaction = null)
where TView : ViewModelBase <MixCmsContext, MixPost, TView>
{
UnitOfWorkHelper <MixCmsContext> .InitTransaction(_context, _transaction, out MixCmsContext context, out IDbContextTransaction transaction, out bool isRoot);
try
{
culture = culture ?? MixService.GetConfig <string>("DefaultCulture");
Expression <Func <MixPost, bool> > postPredicate = m => m.Specificulture == culture &&
(string.IsNullOrEmpty(keyword) ||
(EF.Functions.Like(m.Title, $"%{keyword}%")) ||
(EF.Functions.Like(m.Excerpt, $"%{keyword}%")) ||
(EF.Functions.Like(m.Content, $"%{keyword}%")));
if (dataIds.Count > 0)
{
var searchPostByDataIds = SearchPostByDataIdsPredicate(dataIds, culture, context);
postPredicate = searchPostByDataIds.AndAlso(postPredicate);
}
if (pageIds != null && pageIds.Count > 0)
{
var searchPostByPageIds = SearchPostByPageIdsPredicate(pageIds, culture, context);
postPredicate = searchPostByPageIds.AndAlso(postPredicate);
}
if (!typeof(MixPost).GetProperties().Any(p => p.Name.ToLower() == orderByPropertyName.ToLower()))
{
var postIds = context.MixPost.Where(postPredicate).Select(p => p.Id);
var orderedPostIds = context.MixDatabaseDataAssociation.Where(
m => m.Specificulture == culture && postIds.Any(p => p.ToString() == m.ParentId))
.Join(context.MixDatabaseDataValue, r => r.DataId, v => v.DataId, (r, v) => new { r, v })
.OrderBy(rv => rv.v.StringValue)
.Select(rv => rv.r.ParentId);
postPredicate = p => orderedPostIds.Distinct().Any(o => o == p.Id.ToString() && p.Specificulture == culture);
}
return(await DefaultRepository <MixCmsContext, MixPost, TView> .Instance.GetModelListByAsync(
postPredicate
, orderByPropertyName, direction
, pageSize, pageIndex
, _context : context, _transaction : transaction));
}
catch (Exception ex)
{
return(UnitOfWorkHelper <MixCmsContext> .HandleException <PaginationModel <TView> >(ex, isRoot, transaction));
}
finally
{
if (isRoot)
{
//if current Context is Root
UnitOfWorkHelper <MixCmsContext> .CloseDbContext(ref context, ref transaction);
}
}
}
public void LoadData(int?postId = null, int?productId = null, int?pageId = null
, int?pageSize = null, int?pageIndex = 0
, MixCmsContext _context = null, IDbContextTransaction _transaction = null)
{
UnitOfWorkHelper <MixCmsContext> .InitTransaction(_context, _transaction, out MixCmsContext context, out IDbContextTransaction transaction, out bool isRoot);
try
{
pageSize = pageSize > 0 ? pageSize : PageSize;
pageIndex = pageIndex > 0 ? pageIndex : 0;
Expression <Func <MixModuleData, bool> > dataExp = null;
Expression <Func <MixModulePost, bool> > postExp = null;
switch (Type)
{
case MixModuleType.Content:
case MixModuleType.Data:
dataExp = m => m.ModuleId == Id && m.Specificulture == Specificulture;
//postExp = n => n.ModuleId == Id && n.Specificulture == Specificulture;
//productExp = m => m.ModuleId == Id && m.Specificulture == Specificulture;
break;
case MixModuleType.ListPost:
postExp = n => n.ModuleId == Id && n.Specificulture == Specificulture;
break;
default:
dataExp = m => m.ModuleId == Id && m.Specificulture == Specificulture;
postExp = n => n.ModuleId == Id && n.Specificulture == Specificulture;
break;
}
if (dataExp != null)
{
var getDataResult = Cms.Lib.ViewModels.MixModuleDatas.ReadViewModel.Repository
.GetModelListBy(
dataExp
, MixService.GetAppSetting <string>(MixAppSettingKeywords.SortBy
), 0
, pageSize, pageIndex
, _context: context, _transaction: transaction);
if (getDataResult.IsSucceed)
{
//getDataResult.Data.JsonItems = new List<JObject>();
//getDataResult.Data.Items.ForEach(d => getDataResult.Data.JsonItems.Add(d.JItem));
Data = getDataResult.Data;
}
}
if (postExp != null)
{
var getPosts = Cms.Lib.ViewModels.MixModulePosts.ReadViewModel.Repository
.GetModelListBy(postExp
, MixService.GetAppSetting <string>(MixAppSettingKeywords.SortBy), 0
, pageSize, pageIndex
, _context: context, _transaction: transaction);
if (getPosts.IsSucceed)
{
Posts = getPosts.Data;
}
}
}
catch (Exception ex)
{
UnitOfWorkHelper <MixCmsContext> .HandleException <PaginationModel <ModuleViewModel> >(ex, isRoot, transaction);
}
finally
{
if (isRoot)
{
//if current Context is Root
UnitOfWorkHelper <MixCmsContext> .CloseDbContext(ref context, ref transaction);
}
}
}
public static Task <RepositoryResponse <List <TView> > > FilterByValueAsync <TView>(string culture, string attributeSetName
, Dictionary <string, Microsoft.Extensions.Primitives.StringValues> queryDictionary
, MixCmsContext _context = null, IDbContextTransaction _transaction = null)
where TView : ODataViewModelBase <MixCmsContext, MixAttributeSetData, TView>
{
UnitOfWorkHelper <MixCmsContext> .InitTransaction(_context, _transaction, out MixCmsContext context, out IDbContextTransaction transaction, out bool isRoot);
try
{
Expression <Func <MixAttributeSetValue, bool> > valPredicate = m => m.Specificulture == culture && m.AttributeSetName == attributeSetName;
RepositoryResponse <List <TView> > result = new RepositoryResponse <List <TView> >()
{
IsSucceed = true,
Data = new List <TView>()
};
var tasks = new List <Task <RepositoryResponse <TView> > >();
// Loop queries string => predicate
foreach (var q in queryDictionary)
{
if (!string.IsNullOrEmpty(q.Key) && !string.IsNullOrEmpty(q.Value))
{
Expression <Func <MixAttributeSetValue, bool> > pre = m => m.AttributeFieldName == q.Key && m.StringValue.Contains(q.Value);
valPredicate = ReflectionHelper.CombineExpression(valPredicate, pre, Heart.Enums.MixHeartEnums.ExpressionMethod.And);
}
}
var query = context.MixAttributeSetValue.Where(valPredicate).Select(m => m.DataId).Distinct().ToList();
if (query != null)
{
foreach (var item in query)
{
tasks.Add(Task.Run(async() =>
{
var resp = await ODataDefaultRepository <MixCmsContext, MixAttributeSetData, TView> .Instance.GetSingleModelAsync(
m => m.Id == item && m.Specificulture == culture);
return(resp);
}));
}
var continuation = Task.WhenAll(tasks);
continuation.Wait();
if (continuation.Status == TaskStatus.RanToCompletion)
{
foreach (var data in continuation.Result)
{
if (data.IsSucceed)
{
result.Data.Add(data.Data);
}
else
{
result.Errors.AddRange(data.Errors);
}
}
}
// Display information on faulted tasks.
else
{
foreach (var t in tasks)
{
result.Errors.Add($"Task {t.Id}: {t.Status}");
}
}
}
return(Task.FromResult(result));
}
catch (Exception ex)
{
return(Task.FromResult(UnitOfWorkHelper <MixCmsContext> .HandleException <List <TView> >(ex, isRoot, transaction)));
}
finally
{
if (isRoot)
{
//if current Context is Root
UnitOfWorkHelper <MixCmsContext> .CloseDbContext(ref context, ref transaction);
}
}
}
public static RepositoryResponse <List <MixModulePosts.ReadViewModel> > GetModulePostNavAsync(int postId, string specificulture
, MixCmsContext _context = null, IDbContextTransaction _transaction = null)
{
UnitOfWorkHelper <MixCmsContext> .InitTransaction(_context, _transaction, out MixCmsContext context, out IDbContextTransaction transaction, out bool isRoot);
try
{
var result = MixModulePosts.ReadViewModel.Repository.GetModelListBy(
m => m.PostId == postId && m.Specificulture == specificulture,
context, transaction).Data;
var activeIds = result.Select(n => n.ModuleId);
var inactiveNavs = context.MixModule
.Where(a => a.Specificulture == specificulture &&
!activeIds.Any(m => m == a.Id) &&
(a.Type == (int)MixModuleType.ListPost)
)
.AsEnumerable()
.Select(p => new MixModulePosts.ReadViewModel(
new MixModulePost()
{
PostId = postId,
ModuleId = p.Id,
Specificulture = specificulture
},
_context, _transaction)
{
IsActived = p.MixModulePost.Any(cp => cp.PostId == postId && cp.Specificulture == specificulture),
Description = p.Title
});
result.AddRange(inactiveNavs.ToList());
return(new RepositoryResponse <List <ReadViewModel> >()
{
IsSucceed = true,
Data = result
});
}
catch (Exception ex) // TODO: Add more specific exeption types instead of Exception only
{
if (isRoot)
{
transaction.Rollback();
}
return(new RepositoryResponse <List <MixModulePosts.ReadViewModel> >()
{
IsSucceed = true,
Data = null,
Exception = ex
});
}
finally
{
if (isRoot)
{
//if current Context is Root
transaction.Dispose();
UnitOfWorkHelper <MixCmsContext> .CloseDbContext(ref context, ref transaction);
}
}
}
/// <summary>
/// Clones the asynchronous.
/// </summary>
/// <param name="model"></param>
/// <param name="cloneCultures">The clone cultures.</param>
/// <param name="_context">The context.</param>
/// <param name="_transaction">The transaction.</param>
/// <returns></returns>
public virtual async Task <RepositoryResponse <List <TView> > > CloneAsync(TModel model, List <SupportedCulture> cloneCultures
, TDbContext _context = null, IDbContextTransaction _transaction = null)
{
UnitOfWorkHelper <TDbContext> .InitTransaction(_context, _transaction, out TDbContext context, out IDbContextTransaction transaction, out bool isRoot);
RepositoryResponse <List <TView> > result = new RepositoryResponse <List <TView> >()
{
IsSucceed = true,
Data = new List <TView>()
};
try
{
if (cloneCultures != null)
{
foreach (var culture in cloneCultures)
{
string desSpecificulture = culture.Specificulture;
TModel m = (TModel)context.Entry(model).CurrentValues.ToObject();
Type myType = typeof(TModel);
var myFieldInfo = myType.GetProperty("Specificulture");
myFieldInfo.SetValue(m, desSpecificulture);
bool isExist = Repository.CheckIsExists(m, _context: context, _transaction: transaction);
if (isExist)
{
result.IsSucceed = true;
}
else
{
context.Entry(m).State = EntityState.Added;
await context.SaveChangesAsync();
var cloneSubResult = await CloneSubModelsAsync(m, cloneCultures, context, transaction).ConfigureAwait(false);
if (!cloneSubResult.IsSucceed)
{
cloneSubResult.Errors.AddRange(cloneSubResult.Errors);
cloneSubResult.Exception = cloneSubResult.Exception;
}
result.IsSucceed = result.IsSucceed && cloneSubResult.IsSucceed && cloneSubResult.IsSucceed;
}
_ = this.SendNotifyAsync(this, RepositoryAction.Clone, result.IsSucceed);
}
UnitOfWorkHelper <TDbContext> .HandleTransaction(result.IsSucceed, isRoot, transaction);
return(result);
}
else
{
return(result);
}
}
catch (Exception ex)
{
return(UnitOfWorkHelper <TDbContext> .HandleException <List <TView> >(ex, isRoot, transaction));
}
finally
{
if (isRoot)
{
UnitOfWorkHelper <TDbContext> .CloseDbContext(ref context, ref transaction);
}
}
}
public static async Task <RepositoryResponse <PaginationModel <TView> > > SearchPosts <TView>(
SearchPostQueryModel searchPostData,
MixCmsContext _context = null,
IDbContextTransaction _transaction = null)
where TView : ViewModelBase <MixCmsContext, MixPost, TView>
{
UnitOfWorkHelper <MixCmsContext> .InitTransaction(_context, _transaction, out MixCmsContext context, out IDbContextTransaction transaction, out bool isRoot);
try
{
Expression <Func <MixDatabaseDataValue, bool> > valPredicate = null;
Expression <Func <MixDatabaseDataValue, bool> > catePredicate = GetCategoryPredicate(searchPostData);
Expression <Func <MixDatabaseDataValue, bool> > tagPredicate = GetTagPredicate(searchPostData);
Expression <Func <MixDatabaseDataValue, bool> > queryPredicate = GetQueryPredicate(searchPostData);
valPredicate = valPredicate
.AndAlsoIf(queryPredicate != null, queryPredicate)
.AndAlsoIf(catePredicate != null, catePredicate)
.AndAlsoIf(tagPredicate != null, tagPredicate);
if (valPredicate != null)
{
return(await SearchPostByValue <TView>(valPredicate, searchPostData, context, transaction));
}
else
{
Expression <Func <MixPost, bool> > predicate = BuildPostExpression(searchPostData);
if (searchPostData.PagingData.OrderBy.StartsWith("additionalData."))
{
return(GetSortedPostByValue <TView>(predicate, searchPostData, context, transaction));
}
if (searchPostData.PageId.HasValue)
{
return(GetSortedPostByPage <TView>(predicate, searchPostData, context, transaction));
}
return(await DefaultRepository <MixCmsContext, MixPost, TView> .Instance.GetModelListByAsync(
predicate,
searchPostData.PagingData.OrderBy,
searchPostData.PagingData.Direction,
searchPostData.PagingData.PageSize,
searchPostData.PagingData.PageIndex,
null, null,
context,
transaction));
}
}
catch (Exception ex)
{
return(UnitOfWorkHelper <MixCmsContext> .HandleException <PaginationModel <TView> >(ex, isRoot, transaction));
}
finally
{
if (isRoot)
{
//if current Context is Root
UnitOfWorkHelper <MixCmsContext> .CloseDbContext(ref context, ref transaction);
}
}
}
public static async Task <RepositoryResponse <PaginationModel <TView> > > SearchPosts <TView>(
SearchPostQueryModel searchPostData,
MixCmsContext _context = null,
IDbContextTransaction _transaction = null)
where TView : ViewModelBase <MixCmsContext, MixPost, TView>
{
UnitOfWorkHelper <MixCmsContext> .InitTransaction(_context, _transaction, out MixCmsContext context, out IDbContextTransaction transaction, out bool isRoot);
try
{
Expression <Func <MixDatabaseDataValue, bool> > valPredicate = null;
valPredicate = valPredicate.AndAlsoIf(
!string.IsNullOrEmpty(searchPostData.Category),
Expressions.GetMetaExpression(MixDatabaseNames.SYSTEM_CATEGORY, searchPostData.Category, searchPostData.Specificulture));
valPredicate = valPredicate.AndAlsoIf(
!string.IsNullOrEmpty(searchPostData.Tag),
Expressions.GetMetaExpression(MixDatabaseNames.SYSTEM_TAG, searchPostData.Tag, searchPostData.Specificulture));
if (valPredicate != null)
{
return(await SearchPostByValue <TView>(valPredicate, searchPostData.PagingData, searchPostData.PostType, searchPostData.Specificulture, context, transaction));
}
else
{
Expression <Func <MixPost, bool> > predicate = BuildPostExpression(searchPostData);
if (searchPostData.PagingData.OrderBy.StartsWith("additionalData."))
{
var total = context.MixPost.Count(predicate);
var allPostIds = context.MixPost.Where(predicate)
.AsEnumerable()
.Select(m => m.Id);
var posts = IQueryableHelper.GetSortedPost(allPostIds, context, searchPostData).ToList();
return(new RepositoryResponse <PaginationModel <TView> >()
{
IsSucceed = true,
Data = new PaginationModel <TView>()
{
Items = DefaultRepository <MixCmsContext, MixPost, TView> .Instance.GetCachedData(posts, context, transaction),
PageSize = searchPostData.PagingData.PageSize,
PageIndex = searchPostData.PagingData.PageIndex
}
});
}
return(await DefaultRepository <MixCmsContext, MixPost, TView> .Instance.GetModelListByAsync(
predicate,
searchPostData.PagingData.OrderBy,
searchPostData.PagingData.Direction,
searchPostData.PagingData.PageSize,
searchPostData.PagingData.PageIndex,
null, null,
context,
transaction));
}
}
catch (Exception ex)
{
return(UnitOfWorkHelper <MixCmsContext> .HandleException <PaginationModel <TView> >(ex, isRoot, transaction));
}
finally
{
if (isRoot)
{
//if current Context is Root
UnitOfWorkHelper <MixCmsContext> .CloseDbContext(ref context, ref transaction);
}
}
}
public static async Task <RepositoryResponse <PaginationModel <TView> > > GetPostListByDataIds <TView>(
List <string> dataIds
, string culture = null
, string orderByPropertyName = "CreatedDateTime"
, Heart.Enums.MixHeartEnums.DisplayDirection direction = Heart.Enums.MixHeartEnums.DisplayDirection.Desc
, int?pageSize = null, int?pageIndex = null
, MixCmsContext _context = null, IDbContextTransaction _transaction = null)
where TView : ViewModelBase <MixCmsContext, MixPost, TView>
{
UnitOfWorkHelper <MixCmsContext> .InitTransaction(_context, _transaction, out MixCmsContext context, out IDbContextTransaction transaction, out bool isRoot);
try
{
culture = culture ?? MixService.GetConfig <string>("DefaultCulture");
var result = new RepositoryResponse <PaginationModel <TView> >();
Expression <Func <MixDatabaseDataAssociation, bool> > predicate = m => m.Specificulture == culture && dataIds.Contains(m.DataId) &&
m.ParentType == MixDatabaseParentType.Post;
foreach (var id in dataIds)
{
Expression <Func <MixDatabaseDataAssociation, bool> > pre = m => m.DataId == id;
predicate = predicate.AndAlso(pre);
}
var getRelatedData = await MixDatabaseDataAssociations.ReadViewModel.Repository.GetModelListByAsync(
predicate
, orderByPropertyName = "CreatedDateTime", direction, pageSize, pageIndex
, _context : context, _transaction : transaction
);
if (getRelatedData.IsSucceed)
{
foreach (var item in getRelatedData.Data.Items)
{
if (int.TryParse(item.ParentId, out int postId))
{
var getData = await DefaultRepository <MixCmsContext, MixPost, TView> .Instance.GetSingleModelAsync(
m => m.Specificulture == item.Specificulture && m.Id == postId
, context, transaction);
if (getData.IsSucceed)
{
result = new RepositoryResponse <PaginationModel <TView> >()
{
IsSucceed = true,
Data = new PaginationModel <TView>()
{
Items = new List <TView>(),
PageIndex = pageIndex ?? 0,
PageSize = pageSize
}
};
result.Data.Items.Add(getData.Data);
}
}
}
result.Data.TotalItems = getRelatedData.Data.TotalItems;
result.Data.TotalPage = getRelatedData.Data.TotalPage;
}
return(result);
}
catch (Exception ex)
{
return(UnitOfWorkHelper <MixCmsContext> .HandleException <PaginationModel <TView> >(ex, isRoot, transaction));
}
finally
{
if (isRoot)
{
//if current Context is Root
UnitOfWorkHelper <MixCmsContext> .CloseDbContext(ref context, ref transaction);
}
}
}
public static async Task <RepositoryResponse <JObject> > SaveByModuleName(string culture, string createdBy, string name, string formName, JObject obj
, MixCmsContext _context = null, IDbContextTransaction _transaction = null)
{
UnitOfWorkHelper <MixCmsContext> .InitTransaction(_context, _transaction, out MixCmsContext context, out IDbContextTransaction transaction, out bool isRoot);
try
{
var getModule = await Repository.GetSingleModelAsync(m => m.Specificulture == culture && m.Name == name, context, transaction);
string dataId = obj["id"]?.Value <string>();
if (getModule.IsSucceed)
{
// Get Attribute set
var getAttrSet = await Lib.ViewModels.MixAttributeSets.ReadViewModel.Repository.GetSingleModelAsync(m => m.Name == formName, context, transaction);
if (getAttrSet.IsSucceed)
{
// Save attr data + navigation
MixAttributeSetDatas.UpdateViewModel data = new MixAttributeSetDatas.UpdateViewModel()
{
Id = dataId,
CreatedBy = createdBy,
AttributeSetId = getAttrSet.Data.Id,
AttributeSetName = getAttrSet.Data.Name,
Specificulture = culture,
Data = obj
};
// Create navigation module - attr data
var getNavigation = await MixRelatedAttributeDatas.ReadViewModel.Repository.GetSingleModelAsync(
m => m.ParentId == getModule.Data.Id.ToString() && m.ParentType == MixEnums.MixAttributeSetDataType.Module.ToString() && m.Specificulture == culture
, context, transaction);
if (!getNavigation.IsSucceed)
{
data.RelatedData.Add(new MixRelatedAttributeDatas.UpdateViewModel()
{
ParentId = getModule.Data.Id.ToString(),
Specificulture = culture,
ParentType = MixAttributeSetDataType.Module
});
}
var portalResult = await data.SaveModelAsync(true, context, transaction);
UnitOfWorkHelper <MixCmsContext> .HandleTransaction(portalResult.IsSucceed, isRoot, transaction);
return(new RepositoryResponse <JObject>()
{
IsSucceed = portalResult.IsSucceed,
Data = portalResult.Data?.Data,
Exception = portalResult.Exception,
Errors = portalResult.Errors
});
}
else
{
return(new RepositoryResponse <JObject>()
{
IsSucceed = false,
Status = (int)MixEnums.ResponseStatus.BadRequest
});
}
}
else
{
return(new RepositoryResponse <JObject>()
{
IsSucceed = false,
Status = (int)MixEnums.ResponseStatus.BadRequest
});
}
}
catch (Exception ex)
{
return(UnitOfWorkHelper <MixCmsContext> .HandleException <JObject>(ex, isRoot, transaction));
}
finally
{
if (isRoot)
{
//if current Context is Root
UnitOfWorkHelper <MixCmsContext> .CloseDbContext(ref context, ref transaction);
}
}
}
public static async Task <RepositoryResponse <PaginationModel <TView> > > SearchPostByField <TView>(
string fieldName, string value
, string culture = null
, string orderByPropertyName = "CreatedDateTime", Heart.Enums.MixHeartEnums.DisplayDirection direction = Heart.Enums.MixHeartEnums.DisplayDirection.Desc
, int?pageSize = null, int?pageIndex = 0
, MixCmsContext _context = null, IDbContextTransaction _transaction = null)
where TView : ViewModelBase <MixCmsContext, MixPost, TView>
{
UnitOfWorkHelper <MixCmsContext> .InitTransaction(_context, _transaction, out MixCmsContext context, out IDbContextTransaction transaction, out bool isRoot);
try
{
culture ??= MixService.GetConfig <string>(MixAppSettingKeywords.DefaultCulture);
var result = new RepositoryResponse <PaginationModel <TView> >()
{
IsSucceed = true,
Data = new PaginationModel <TView>()
{
PageIndex = pageIndex.HasValue ? pageIndex.Value : 0,
PageSize = pageSize
}
};
var tasks = new List <Task <RepositoryResponse <TView> > >();
// Get Value
var dataIds = await context.MixDatabaseDataValue.Where(
m => m.MixDatabaseName == MixConstants.MixDatabaseName.ADDITIONAL_FIELD_POST && m.Specificulture == culture &&
EF.Functions.Like(m.StringValue, value) && m.MixDatabaseColumnName == fieldName)
.Select(m => m.DataId)?.ToListAsync();
if (dataIds != null && dataIds.Count > 0)
{
var getRelatedData = await MixDatabaseDataAssociations.ReadViewModel.Repository.GetModelListByAsync(
m => dataIds.Contains(m.DataId)
, orderByPropertyName, direction, pageSize, pageIndex
, _context : context, _transaction : transaction
);
if (getRelatedData.IsSucceed)
{
foreach (var item in getRelatedData.Data.Items)
{
if (int.TryParse(item.ParentId, out int postId))
{
var getData = await DefaultRepository <MixCmsContext, MixPost, TView> .Instance.GetSingleModelAsync(
m => m.Specificulture == item.Specificulture && m.Id == postId
, context, transaction);
if (getData.IsSucceed)
{
result.Data.Items.Add(getData.Data);
}
}
}
result.Data.TotalItems = getRelatedData.Data.TotalItems;
result.Data.TotalPage = getRelatedData.Data.TotalPage;
}
}
return(result);
}
catch (Exception ex)
{
return(UnitOfWorkHelper <MixCmsContext> .HandleException <PaginationModel <TView> >(ex, isRoot, transaction));
}
finally
{
if (isRoot)
{
//if current Context is Root
UnitOfWorkHelper <MixCmsContext> .CloseDbContext(ref context, ref transaction);
}
}
}
public static async Task <RepositoryResponse <PaginationModel <TView> > > FilterByKeywordAsync <TView>(string culture, string attributeSetName
, RequestPaging request, string keyword
, Dictionary <string, Microsoft.Extensions.Primitives.StringValues> queryDictionary = null
, MixCmsContext _context = null, IDbContextTransaction _transaction = null)
where TView : ViewModelBase <MixCmsContext, MixAttributeSetData, TView>
{
UnitOfWorkHelper <MixCmsContext> .InitTransaction(_context, _transaction, out MixCmsContext context, out IDbContextTransaction transaction, out bool isRoot);
try
{
Expression <Func <MixAttributeSetValue, bool> > attrPredicate =
m => m.Specificulture == culture && m.AttributeSetName == attributeSetName &&
(!request.FromDate.HasValue ||
(m.CreatedDateTime >= request.FromDate.Value)
) &&
(!request.ToDate.HasValue ||
(m.CreatedDateTime <= request.ToDate.Value)
)
;
Expression <Func <MixAttributeSetValue, bool> > valPredicate = null;
RepositoryResponse <PaginationModel <TView> > result = new RepositoryResponse <PaginationModel <TView> >()
{
IsSucceed = true,
Data = new PaginationModel <TView>()
};
var filterType = queryDictionary.FirstOrDefault(q => q.Key == "filterType");
var tasks = new List <Task <RepositoryResponse <TView> > >();
if (queryDictionary != null)
{
foreach (var q in queryDictionary)
{
if (!string.IsNullOrEmpty(q.Key) && q.Key != "attributeSetId" && q.Key != "attributeSetName" && q.Key != "filterType" && !string.IsNullOrEmpty(q.Value))
{
if (!string.IsNullOrEmpty(filterType.Value) && filterType.Value == "equal")
{
Expression <Func <MixAttributeSetValue, bool> > pre = m =>
m.AttributeFieldName == q.Key && m.StringValue == (q.Value.ToString());
valPredicate = valPredicate == null
? pre
: valPredicate = valPredicate.AndAlso(pre);
}
else
{
Expression <Func <MixAttributeSetValue, bool> > pre =
m => m.AttributeFieldName == q.Key &&
(EF.Functions.Like(m.StringValue, $"%{q.Value}%"));
valPredicate = valPredicate == null
? pre
: valPredicate = valPredicate.AndAlso(pre);
}
}
}
if (valPredicate != null)
{
attrPredicate = valPredicate.AndAlso(attrPredicate);
}
}
// Loop queries string => predicate
if (!string.IsNullOrEmpty(keyword))
{
Expression <Func <MixAttributeSetValue, bool> > pre = m => m.AttributeSetName == attributeSetName && m.Specificulture == culture && m.StringValue.Contains(keyword);
attrPredicate = attrPredicate.AndAlso(pre);
}
var query = context.MixAttributeSetValue.Where(attrPredicate).Select(m => m.DataId).Distinct();
var dataIds = query.ToList();
if (query != null)
{
Expression <Func <MixAttributeSetData, bool> > predicate = m => dataIds.Any(id => m.Id == id);
result = await DefaultRepository <MixCmsContext, MixAttributeSetData, TView> .Instance.GetModelListByAsync(
predicate, request.OrderBy, request.Direction, request.PageSize, request.PageIndex, null, null, context, transaction);
}
return(result);
}
catch (Exception ex)
{
return(UnitOfWorkHelper <MixCmsContext> .HandleException <PaginationModel <TView> >(ex, isRoot, transaction));
}
finally
{
if (isRoot)
{
//if current Context is Root
UnitOfWorkHelper <MixCmsContext> .CloseDbContext(ref context, ref transaction);
}
}
}
public static async Task <PaginationModel <TView> > GetMixData <TView>(
string mixDatabaseName,
string culture = null,
string keyword = null,
string fieldName = null,
string filterType = "contain", // or "equal"
int?pageIndex = 0,
int pageSize = 100,
string orderBy = "Priority",
DisplayDirection direction = DisplayDirection.Asc,
MixCmsContext _context = null,
IDbContextTransaction _transaction = null)
where TView : ViewModelBase <MixCmsContext, MixDatabaseData, TView>
{
culture ??= MixService.GetAppSetting <string>(MixAppSettingKeywords.DefaultCulture);
UnitOfWorkHelper <MixCmsContext> .InitTransaction(_context, _transaction, out MixCmsContext context, out IDbContextTransaction transaction, out bool isRoot);
try
{
var getfields = await ViewModels.MixDatabaseColumns.ReadViewModel.Repository.GetModelListByAsync(
m => m.MixDatabaseName == mixDatabaseName, context, transaction);
var fields = getfields.IsSucceed ? getfields.Data : new List <ViewModels.MixDatabaseColumns.ReadViewModel>();
// Data predicate
Expression <Func <MixDatabaseData, bool> > predicate = m => m.Specificulture == culture &&
(m.MixDatabaseName == mixDatabaseName);
// val predicate
Expression <Func <MixDatabaseDataValue, bool> > attrPredicate = m => m.Specificulture == culture &&
(m.MixDatabaseName == mixDatabaseName);
// if filter by field name or keyword => filter by attr value
if (!string.IsNullOrEmpty(keyword))
{
// filter by all fields if have keyword
Expression <Func <MixDatabaseDataValue, bool> > pre = null;
if (!string.IsNullOrEmpty(fieldName)) // filter by specific field name
{
pre = m => m.MixDatabaseColumnName == fieldName;
pre = pre.AndAlsoIf(filterType == "equal", m => m.StringValue == keyword);
pre = pre.AndAlsoIf(filterType == "contain", m => EF.Functions.Like(m.StringValue, $"%{keyword}%"));
attrPredicate = attrPredicate.AndAlsoIf(pre != null, pre);
}
else
{
foreach (var field in fields)
{
Expression <Func <MixDatabaseDataValue, bool> > keywordPredicate = m => m.MixDatabaseColumnName == field.Name;
keywordPredicate = keywordPredicate.AndAlsoIf(filterType == "equal", m => m.StringValue == keyword);
keywordPredicate = keywordPredicate.AndAlsoIf(filterType == "contain", m => EF.Functions.Like(m.StringValue, $"%{keyword}%"));
pre = pre == null
? keywordPredicate
: pre.Or(keywordPredicate);
}
attrPredicate = attrPredicate.AndAlsoIf(pre != null, pre);
}
var valDataIds = context.MixDatabaseDataValue.Where(attrPredicate).Select(m => m.DataId).Distinct();
predicate = predicate.AndAlsoIf(valDataIds != null, m => valDataIds.Any(id => m.Id == id));
}
else
{
predicate = m => m.Specificulture == culture && (m.MixDatabaseName == mixDatabaseName);
predicate = predicate.AndAlso(m => m.Status == MixContentStatus.Published);
}
var getData = await DefaultRepository <MixCmsContext, MixDatabaseData, TView> .Instance.GetModelListByAsync(
predicate,
orderBy,
direction,
pageSize,
pageIndex,
null, null,
context,
transaction);
return(getData.Data);
}
catch (Exception ex)
{
Console.WriteLine(ex);
return(null);
}
finally
{
if (isRoot)
{
//if current Context is Root
UnitOfWorkHelper <MixCmsContext> .CloseDbContext(ref context, ref transaction);
}
}
}
/// <summary>
/// Saves the model.
/// </summary>
/// <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 <TView> SaveModel(bool isSaveSubModels = false, 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
};
Validate(context, transaction);
if (IsValid)
{
try
{
ParseModel(context, transaction);
result = Repository.SaveModel((TView)this, _context: context, _transaction: transaction);
// Save sub Models
if (result.IsSucceed && isSaveSubModels)
{
var saveResult = SaveSubModels(Model, context, transaction);
if (!saveResult.IsSucceed)
{
result.Errors.AddRange(saveResult.Errors);
result.Exception = saveResult.Exception;
}
result.IsSucceed = result.IsSucceed && saveResult.IsSucceed;
}
UnitOfWorkHelper <TDbContext> .HandleTransaction(result.IsSucceed, isRoot, transaction);
return(result);
}
catch (Exception ex)
{
return(UnitOfWorkHelper <TDbContext> .HandleException <TView>(ex, isRoot, transaction));
}
finally
{
if (result.IsSucceed && IsCache)
{
RemoveCache(Model, context, transaction).ConfigureAwait(true).GetAwaiter();
}
if (isRoot)
{
//if current Context is Root
UnitOfWorkHelper <TDbContext> .CloseDbContext(ref context, ref transaction);
}
}
}
else
{
if (isRoot)
{
//if current Context is Root
UnitOfWorkHelper <TDbContext> .CloseDbContext(ref context, ref transaction);
}
return(new RepositoryResponse <TView>()
{
IsSucceed = false,
Data = null,
Errors = Errors
});
}
}