public virtual ResourceType GetMediaType(string resourcePath)
{
GuardClausesParameter.NullOrEmpty(resourcePath, nameof(resourcePath));
string fileExtentson = CoreUtility.GetFileExtension(resourcePath, false);
if (!string.IsNullOrEmpty(fileExtentson))
{
if (!string.IsNullOrEmpty(_systemSettings.Upload.ImageAllowedExtensions) && _systemSettings.Upload.ImageAllowedExtensions.Split(',', ';').Contains(fileExtentson, StringComparer.OrdinalIgnoreCase))
{
return(ResourceType.Image);
}
if (!string.IsNullOrEmpty(_systemSettings.Upload.VideoAllowedExtensions) && _systemSettings.Upload.VideoAllowedExtensions.Split(',', ';').Contains(fileExtentson, StringComparer.OrdinalIgnoreCase))
{
return(ResourceType.Movie);
}
if (!string.IsNullOrEmpty(_systemSettings.Upload.AudioAllowedExtensions) && _systemSettings.Upload.AudioAllowedExtensions.Split(',', ';').Contains(fileExtentson, StringComparer.OrdinalIgnoreCase))
{
return(ResourceType.Audio);
}
if (!string.IsNullOrEmpty(_systemSettings.Upload.FileAllowedExtensions) && _systemSettings.Upload.FileAllowedExtensions.Split(',', ';').Contains(fileExtentson, StringComparer.OrdinalIgnoreCase))
{
return(ResourceType.None);
}
}
return(ResourceType.None);
}
public virtual string GetFilePath(ResourceType fileType, string fileName)
{
GuardClausesParameter.NullOrEmpty(fileName, nameof(fileName));
string filePath = string.Empty;
switch (fileType)
{
case ResourceType.Image:
filePath = _systemSettings.Upload.UploadImgPath;
break;
case ResourceType.Movie:
filePath = _systemSettings.Upload.UploadVideoPath;
break;
case ResourceType.Audio:
filePath = _systemSettings.Upload.UploadAudioPath;
break;
case ResourceType.Avatar:
filePath = _systemSettings.User.UploadAvatarPath;
break;
case ResourceType.None:
break;
default:
filePath = _systemSettings.Upload.UploadFilePath;
break;
}
return(string.IsNullOrEmpty(fileName) ? filePath : Path.Combine(filePath, fileName));
}
/// <summary>
/// Get queue email for send email wellcome user
/// </summary>
/// <param name="emailTemplate">Template email</param>
/// <param name="userEmail">Email of user</param>
/// <param name="userPassowrd">Password of user optional</param>
/// <param name="userDisplayName">full name of user</param>
/// <param name="linkCallback">link if have</param>
/// <returns></returns>
public virtual QueuedEmail GetQueuedEmailForNewUser(MessageTemplate emailTemplate, string userEmail, string userPassowrd, string userDisplayName, string linkCallback = "")
{
GuardClausesParameter.Null(emailTemplate, nameof(emailTemplate));
GuardClausesParameter.NullOrEmpty(userEmail, nameof(userEmail));
Dictionary <string, string> replaceValue = new Dictionary <string, string>
{
{ "[useremail]", userEmail },
{ "[userpassword]", userPassowrd },
{ "[userfullname]", userDisplayName },
{ "[callbacklink]", linkCallback }
};
string title = CoreUtility.ReplaceContentHelper(emailTemplate.Title, replaceValue);
string content = CoreUtility.ReplaceContentHelper(emailTemplate.Body, replaceValue) + "<br />" + _systemSettings.Common.EmailSignature;
return(new QueuedEmail()
{
To = userEmail,
Title = title,
EmailBody = content,
Cc = null,
Bcc = null,
ToName = userDisplayName,
EmailAccountId = null,
SendTime = null,
Priority = 5,
TrySend = 0
});
}
public virtual async Task <bool> InsertAsync(IEnumerable <T> entities)
{
GuardClausesParameter.NullOrEmpty(entities, nameof(entities));
await DbContext.Set <T>().AddRangeAsync(entities);
return(await DbContext.SaveChangesAsync() > 0);
}
public async Task <bool> ImportFromJsonAsync(string json)
{
GuardClausesParameter.NullOrEmpty(json, nameof(json));
List <CmsMenu> listMenu = JsonSerializer.Deserialize <List <CmsMenu> >(json);
IEnumerable <TreeItem <CmsMenu> > treeMenu = listMenu.GenerateTree(q => q.Id, q => q.ParentId, q => q.DisplayOrder, string.Empty);
await CreateMenuAsync(treeMenu, string.Empty);
return(true);
async Task CreateMenuAsync(IEnumerable <TreeItem <CmsMenu> > listTreeMenu, string parentId)
{
foreach (TreeItem <CmsMenu> cMenu in listTreeMenu)
{
CmsMenu menuInsert = new CmsMenu()
{
Active = cMenu.Item.Active,
DisplayOrder = cMenu.Item.DisplayOrder,
CssClass = cMenu.Item.CssClass,
Link = cMenu.Item.Link,
Name = cMenu.Item.Name,
ParentId = parentId,
Position = cMenu.Item.Position,
RolesString = cMenu.Item.RolesString,
TargetType = cMenu.Item.TargetType
};
bool checkInsert = await InsertAsync(menuInsert);
if (checkInsert)
{
await CreateMenuAsync(cMenu.Children, menuInsert.Id);
}
}
}
}
/// <summary>
/// Get queue email for send email to revovery user passowrd
/// </summary>
/// <param name="emailTemplate">Template email</param>
/// <param name="userEmail">active email user</param>
/// <param name="webSiteName">system name</param>
/// <param name="userDisplayName">User full name</param>
/// <param name="recoveryLink">recovery link</param>
public virtual QueuedEmail UserPasswordRecovery(MessageTemplate emailTemplate, string userEmail, string webSiteName, string userDisplayName, string recoveryLink)
{
GuardClausesParameter.Null(emailTemplate, nameof(emailTemplate));
GuardClausesParameter.NullOrEmpty(userEmail, nameof(userEmail));
GuardClausesParameter.NullOrEmpty(recoveryLink, nameof(recoveryLink));
Dictionary <string, string> replaceValue = new Dictionary <string, string>
{
{ "[systemname]", webSiteName },
{ "[userfullname]", userDisplayName },
{ "[recoverylink]", recoveryLink }
};
string title = CoreUtility.ReplaceContentHelper(emailTemplate.Title, replaceValue);
string content = CoreUtility.ReplaceContentHelper(emailTemplate.Body, replaceValue) + "<br />" + _systemSettings.Common.EmailSignature;
return(new QueuedEmail()
{
To = userEmail,
Title = title,
EmailBody = content,
Cc = null,
Bcc = null,
ToName = userDisplayName,
EmailAccountId = null,
SendTime = null,
Priority = 5,
TrySend = 0
});
}
public virtual async Task <User> CacheGetUserById(string userId)
{
GuardClausesParameter.NullOrEmpty(userId, nameof(userId));
string cacheKey = $"{CoreConstants.UserCacheKey}gcua_{userId}uid";
return(await _asyncCacheService.GetOrCreateAsync(cacheKey, async() => await _userData.FindAsync(userId), CoreConstants.DefaultCacheTime));
}
public async Task SetLocalizedModelLocalAsync <T>(IEnumerable <T> listLocalizedData, string objectId, ObjectTypeEnum objectType)
{
GuardClausesParameter.NullOrEmpty(listLocalizedData, nameof(listLocalizedData));
foreach (var istem in listLocalizedData)
{
await SetLocalizedStringAsync(istem, objectId, CoreUtility.GetProperty <string>(istem, "LanguageCulture"), objectType);
}
}
public virtual async Task <IReadOnlyList <T> > SqlQueryAsync(string queryCommand, IsolationLevel isolationLevel = IsolationLevel.ReadCommitted, params object[] parameters)
{
GuardClausesParameter.NullOrEmpty(queryCommand, nameof(queryCommand));
using IDbContextTransaction dbContextTransaction = await DbContext.Database.BeginTransactionAsync(isolationLevel);
IQueryable <T> dataQuery = DbContext.Set <T>().FromSqlRaw(queryCommand, parameters);
dbContextTransaction.Commit();
return(await dataQuery.ToListAsync());
}
public virtual async Task <bool> ExecuteSqlCommandAsync(string queryCommand, IsolationLevel isolationLevel = IsolationLevel.ReadCommitted, params object[] parameters)
{
GuardClausesParameter.NullOrEmpty(queryCommand, nameof(queryCommand));
using IDbContextTransaction dbContextTransaction = await DbContext.Database.BeginTransactionAsync(isolationLevel);
int dataQuery = await DbContext.Database.ExecuteSqlRawAsync(queryCommand, default(CancellationToken), parameters);
dbContextTransaction.Commit();
return(dataQuery > 0);
}
public virtual async Task <bool> UpdateAsync(IEnumerable <T> entities)
{
GuardClausesParameter.NullOrEmpty(entities, nameof(entities));
foreach (T entity in entities)
{
DbContext.Entry(entity).State = EntityState.Modified;
}
return(await DbContext.SaveChangesAsync() > 0);
}
public async Task <IEnumerable <T> > GetLocalizedStringAsync <T>(IEnumerable <T> entitys, string languageCulture, ObjectTypeEnum objectType) where T : IBaseEntity
{
GuardClausesParameter.NullOrEmpty(entitys, nameof(entitys));
var ids = string.Join(",", entitys.Select(q => $"'{q.Id}'"));
var localizedStrings = await SqlQueryAsync($"SELECT * FROM {TableName} WHERE LanguageCulture = '{languageCulture}' AND ObjectType = {objectType} AND ObjectId IN ({ids})");
foreach (var entity in entitys)
{
var itemLocalizedSting = localizedStrings.Where(q => q.ObjectId == entity.Id);
foreach (ObjectLocalized item in itemLocalizedSting)
{
CoreUtility.SetProperty(entity, item.PropertyName, item.LocalizedValue);
}
}
return(entitys);
}
/// <summary>
/// Get data protecter by file system key manager. if your aplication run on multi server you need use redis of azure key manager
/// </summary>
/// <param name="basePath">Base folder to save key
/// ex. in asp.net core set WebHostEnvironment.ContentRootPath
/// </param>
/// <param name="applicationName">The application name
/// ex. in asp.net core set WebHostEnvironment.ApplicationName
/// </param>
/// <param name="applicationKey">system key to identity system to read and write protected data
/// ex. in asp.net core set WebHostEnvironment.EnvironmentName
/// </param>
public static IDataProtector InitializeFileSystemProtecter(string basePath, string applicationName, string applicationKey)
{
if (_dataProtector != null)
{
return(_dataProtector);
}
GuardClausesParameter.NullOrEmpty(basePath, nameof(basePath));
GuardClausesParameter.NullOrEmpty(applicationName, nameof(applicationName));
GuardClausesParameter.NullOrEmpty(applicationKey, nameof(applicationKey));
var destFolder = Path.Combine(basePath, "datakey");
var dataProtectionProvider = DataProtectionProvider.Create(new DirectoryInfo(destFolder), options =>
{
options.SetApplicationName(applicationName);
});
_dataProtector = dataProtectionProvider.CreateProtector(applicationKey);
return(_dataProtector);
}
/// <summary>
/// add sql localized
/// </summary>
/// <param name="services">Service container</param>
/// <param name="dbConnection">connection string to db localized</param>
public static void AddSqlLocalizationProvider(this IServiceCollection services, string dbConnection)
{
services.Configure <WebEncoderOptions>(webEncoderOptions => webEncoderOptions.TextEncoderSettings = new TextEncoderSettings(UnicodeRanges.All));
using var systemDbContext = new SystemDbContext(new DbContextOptionsBuilder <SystemDbContext>().UseSqlServer(dbConnection).Options);
SqlStringLocalizer.SetResourceLocalizations(systemDbContext.LanguageResources.ToList());
services.Configure <SqlLocalizationOptions>(option => option.UseSettings(dbConnection, true));
services.AddSingleton <IStringLocalizerFactory, SqlStringLocalizerFactory>();
services.Configure <RequestLocalizationOptions>(options =>
{
var systemLanguages = systemDbContext.Languages.Where(q => q.Published || q.DisplayDefault).OrderByDescending(q => q.DisplayOrder);
var defaultLanguage = systemLanguages.FirstOrDefault(q => q.DisplayDefault);
GuardClausesParameter.NullOrEmpty(systemLanguages, nameof(systemLanguages));
GuardClausesParameter.Null(defaultLanguage, nameof(defaultLanguage));
var supportedCultures = systemLanguages.Select(q => new CultureInfo(q.Culture)).ToList();
options.DefaultRequestCulture = new RequestCulture(new CultureInfo(defaultLanguage.Culture));
options.SupportedCultures = supportedCultures;
options.SupportedUICultures = supportedCultures;
options.RequestCultureProviders.Insert(0, new CustomRequestCultureProvider(context =>
{
string cultureKey = context.Request.Query["culture"];
if (string.IsNullOrWhiteSpace(cultureKey))
{
cultureKey = context.Request?.Cookies[IdentityConstants.LanguageSessionCookieKey];
}
if (string.IsNullOrWhiteSpace(cultureKey))
{
cultureKey = defaultLanguage.Culture;
}
return(Task.FromResult(new ProviderCultureResult(cultureKey)));
}));
});
//need startup website call following code
//services.AddControllersWithViews().AddMvcLocalization().AddDataAnnotationsLocalization();
}
public virtual async Task <bool> DeleteByKeyAsync(string primaryKey)
{
GuardClausesParameter.NullOrEmpty(primaryKey, nameof(primaryKey));
return(await ExecuteSqlCommandAsync($"DELETE {TableName} WHERE Id = {primaryKey}"));
}
public virtual async Task <bool> DeleteByKeysAsync(List <string> primaryKeys)
{
GuardClausesParameter.NullOrEmpty(primaryKeys, nameof(primaryKeys));
return(await ExecuteSqlCommandAsync($"DELETE {TableName} WHERE Id IN ({string.Join(",", primaryKeys)})"));
}
/// <summary>
/// Hàm validate captcha
/// Được đặt ở đầu mỗi action khi cần validate
/// True là valid và false là unvalid
/// </summary>
/// <param name="returnParameterName">Tên parameter nhận giá chị validate</param>
public CaptchaValidator(string returnParameterName)
{
GuardClausesParameter.NullOrEmpty(returnParameterName, nameof(returnParameterName));
parameterName = returnParameterName;
}