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; }