/// <summary>
/// 动态加载数据库工厂
/// </summary>
/// <param name="providerInvariantName"></param>
/// <param name="dbType"></param>
/// <returns></returns>
public static DbProviderFactory GetFactory(string dbKey)
{
try
{
var config = GetConfig(dbKey);
if (BaseCache.Exists(config.ProviderName))
{
return(BaseCache.Get <object>(config.ProviderName) as DbProviderFactory);
}
else
{
var assembly = AppDomain.CurrentDomain.GetAssemblies().ToList().Find(a => a.FullName.Split(',')[0] == config.ProviderName);
if (assembly == null)
{
assembly = Assembly.Load(config.ProviderName);
}
var type = assembly.GetType(config.FactoryClient, false);
object instance = null;
if (type != null)
{
instance = Activator.CreateInstance(type);
}
BaseCache.Set <object>(config.ProviderName, instance);
return(instance as DbProviderFactory);
}
}
catch
{
return(null);
}
}
private static void SetPageItemsDownloaded(IEnumerable <Objects.LatestPageIndexItem> items, string languageCode)
{
string fileName = string.Format("AgilityPageIndex_{0}.bin", languageCode);
string pageIndexFilePath = Path.Combine(BaseCache.GetLocalContentFilePath(), fileName);
lock (_pageIndexLock)
{
Objects.LatestPageIndex index = GetLatestPageItemIndex(languageCode);
if (index == null)
{
return;
}
Objects.LatestPageIndexItem indexItem = null;
foreach (var item in items)
{
if (index.Index.TryGetValue(item.PageID, out indexItem))
{
indexItem.Downloaded = item.Downloaded;
}
}
BaseCache.WriteFile(index, pageIndexFilePath);
AgilityContext.HttpContext.Items[fileName] = index;
}
}
static GenericCache()
{
if (!string.IsNullOrEmpty(_cacheClearSpanStr) && Regex.IsMatch(_cacheClearSpanStr, @"\d+"))
{
int span = 0;
if (int.TryParse(_cacheClearSpanStr, out span))
{
_cacheClearSpan = span;
}
}
Task.Run(() =>//启动一个线程自动清理缓存
{
while (true)
{
lock (_lock)
{
List <string> keyList = new List <string>();
foreach (var key in _dicCache.Keys)
{
BaseCache cache = _dicCache[key];
if (cache.OverdueTime < DateTime.Now)
{
keyList.Add(key);
}
}
keyList.ForEach(k => _dicCache.Remove(k));
}
Thread.Sleep(1000 * _cacheClearSpan);
}
});
}
public BaseLogic(BaseCache cache, DataBase.ITable table)
{
this.Table = table;
this.Cache = cache;
//addLogic(this);
}
public static void UpdateDynamicPageFormFormulas(AgilityContent existingContent, AgilityContent deltaContent)
{
if (deltaContent == null || deltaContent.DataSet == null)
{
return;
}
Dictionary <string, List <int> > dpIndex = BaseCache.GetDynamicPageIndex();
List <int> lstPageIDs = null;
if (dpIndex.TryGetValue(deltaContent.ReferenceName.ToLowerInvariant(), out lstPageIDs))
{
foreach (int pageID in lstPageIDs)
{
AgilityPage page = BaseCache.GetPageFromID(pageID, deltaContent.LanguageCode, AgilityContext.WebsiteName, null);
if (page != null)
{
//update all of the DynamicPageIndexes that this content appears on...
BaseCache.UpdateDynamicPageFormulaIndex(page, existingContent, deltaContent, deltaContent.ReferenceName, existingContent == null);
}
}
}
}
/// <summary>
/// 删除缓存
/// </summary>
public static void Remove(string cacheType, string key)
{
if (string.Compare(cacheType, CacheType.Web, true) == 0)
{
BaseCache.Remove(key);
}
else if (string.Compare(cacheType, CacheType.Redis, true) == 0)
{
IRedis.RemoveAsy(key);
}
}
/// <summary>
/// 删除缓存
/// </summary>
public static void Remove(string cacheType, string key)
{
if (cacheType.ToLower() == CacheType.Web)
{
BaseCache.Remove(key);
}
else if (cacheType.ToLower() == CacheType.Redis)
{
IRedis.RemoveAsy(key);
}
}
/// <summary>
/// 设置缓存
/// </summary>
public static void Set <T>(string cacheType, string key, T value, int Hours = 8640) where T : class, new()
{
if (cacheType.ToLower() == CacheType.Web)
{
BaseCache.Set <T>(key, value, Hours);
}
else if (cacheType.ToLower() == CacheType.Redis)
{
IRedis.SetAsy <T>(key, value, Hours);
}
}
/// <summary>
/// 设置缓存
/// </summary>
public static void Set(string cacheType, string key, string value, int Hours = 8640)
{
if (cacheType.ToLower() == CacheType.Web)
{
BaseCache.Set(key, value, Hours);
}
else if (cacheType.ToLower() == CacheType.Redis)
{
IRedis.SetAsy(key, value, Hours);
}
}
/// <summary>
/// 设置缓存
/// </summary>
public static void Set <T>(string cacheType, string key, T value, int Hours = 8640) where T : class, new()
{
if (string.Compare(cacheType, CacheType.Web, true) == 0)
{
BaseCache.Set <T>(key, value, Hours);
}
else if (string.Compare(cacheType, CacheType.Redis, true) == 0)
{
IRedis.SetAsy <T>(key, value, Hours);
}
}
/// <summary>
/// 设置缓存
/// </summary>
public static void Set(string cacheType, string key, string value, int Hours = 8640)
{
if (string.Compare(cacheType, CacheType.Web, true) == 0)
{
BaseCache.Set(key, value, Hours);
}
else if (string.Compare(cacheType, CacheType.Redis, true) == 0)
{
IRedis.SetAsy(key, value, Hours);
}
}
/// <summary>
/// 是否存在
/// </summary>
public static bool Exists(string cacheType, string key)
{
if (cacheType.ToLower() == CacheType.Web)
{
return(BaseCache.Exists(key));
}
else if (cacheType.ToLower() == CacheType.Redis)
{
return(IRedis.ExistsAsy(key).Result);
}
return(false);
}
/// <summary>
/// 获取缓存
/// </summary>
public static T Get <T>(string cacheType, string key) where T : class, new()
{
if (cacheType.ToLower() == CacheType.Web)
{
return(BaseCache.Get <T>(key));
}
else if (cacheType.ToLower() == CacheType.Redis)
{
return(IRedis.GetAsy <T>(key).Result);
}
return(new T());
}
/// <summary>
/// 获取缓存
/// </summary>
public static T Get <T>(string cacheType, string key) where T : class, new()
{
if (string.Compare(cacheType, CacheType.Web, true) == 0)
{
return(BaseCache.Get <T>(key));
}
else if (string.Compare(cacheType, CacheType.Redis, true) == 0)
{
return(IRedis.GetAsy <T>(key).Result);
}
return(new T());
}
/// <summary>
/// 是否存在
/// </summary>
public static bool Exists(string cacheType, string key)
{
if (string.Compare(cacheType, CacheType.Web, true) == 0)
{
return(BaseCache.Exists(key));
}
else if (string.Compare(cacheType, CacheType.Redis, true) == 0)
{
return(IRedis.ExistsAsy(key).Result);
}
return(false);
}
public async Task <IResponseOutput> GetPassWordEncryptKeyAsync()
{
//写入Redis
var guid = Guid.NewGuid().ToString("N");
var key = string.Format(CacheKey.PassWordEncryptKey, guid);
var encyptKey = StringHelper.GenerateRandom(8);
await BaseCache.SetAsync(key, encyptKey, TimeSpan.FromMinutes(5));
var data = new { key = guid, encyptKey };
return(ResponseOutput.Ok(data));
}
/// <summary>
/// 获取缓存
/// </summary>
public static string Get(string cacheType, string key)
{
if (cacheType.ToLower() == CacheType.Web)
{
return(BaseCache.Get(key));
}
else if (cacheType.ToLower() == CacheType.Redis)
{
return(IRedis.GetAsy(key).Result);
}
return("");
}
/// <summary>
/// 获取缓存
/// </summary>
public static string Get(string cacheType, string key)
{
if (string.Compare(cacheType, CacheType.Web, true) == 0)
{
return(BaseCache.Get(key));
}
else if (string.Compare(cacheType, CacheType.Redis, true) == 0)
{
return(IRedis.GetAsy(key).Result);
}
return("");
}
public static DataRow GetCodeItem(string path)
{
//path is like this: DynamicAgilityCode/[ContentReferenceName]/[ItemReferenceName].ext
var pre = Agility.Web.HttpModules.AgilityHttpModule.DynamicCodePrepend;
string p1 = path.Substring(path.IndexOf(pre, StringComparison.CurrentCultureIgnoreCase) + pre.Length);
if (p1.IndexOf("/") == -1 || p1.IndexOf(".") < p1.IndexOf("/"))
{
return(null);
}
string referenceName = p1.Substring(0, p1.IndexOf("/"));
//get the content.
var content = BaseCache.GetContent(referenceName, LANGUAGECODE_CODE, AgilityContext.WebsiteName);
if (content == null ||
content.DataSet == null ||
(!content.DataSet.Tables.Contains("ContentItems")) ||
content.DataSet.Tables["ContentItems"].Rows.Count == 0)
{
return(null);
}
int slashIndex = p1.IndexOf("/");
int dotIndex = p1.IndexOf(".");
string itemReferenceName = p1.Substring(slashIndex + 1, dotIndex - slashIndex - 1);
string filter = string.Format("ReferenceName = '{0}'", itemReferenceName.Replace("'", "''"));
StringBuilder sb = new StringBuilder();
DataRow[] rows = null;
try
{
rows = content.DataSet.Tables["ContentItems"].Select(filter);
}
catch { }
if (rows == null || rows.Length == 0)
{
return(null);
}
DataRow row = rows[0];
return(row);
}
// 构建函数
static DynamicGet()
{
var key = string.Format("DynamicGet<T>.{0}.{1}", typeof(T)?.Namespace, typeof(T).Name);
if (!BaseCache.Exists(key))
{
GetValueDelegate = GenerateGetValue();
BaseCache.Set <object>(key, GetValueDelegate);
}
else
{
GetValueDelegate = BaseCache.Get <object>(key) as Func <object, string, object>;
}
}
public static void UpdateDynamicPageIndex(AgilityPage page)
{
if (!string.IsNullOrEmpty(page.DynamicPageContentViewReferenceName) ||
!string.IsNullOrEmpty(page.DynamicPageParentFieldName))
{
if (!string.IsNullOrEmpty(page.DynamicPageContentViewReferenceName.ToLowerInvariant()))
{
BaseCache.UpdateDynamicPageIndex(page.ID, page.DynamicPageContentViewReferenceName.ToLowerInvariant());
}
//update the Dynamic Page Formula Index that use this page...
BaseCache.ClearDynamicDynamicPageFormulaIndex(page);
}
}
/// <summary>
/// 获取缓存
/// </summary>
/// <typeparam name="T">缓存数据类型</typeparam>
/// <param name="key">关键字key</param>
/// <returns></returns>
public static T GetCache <T>(string key)
{
if (_dicCache.ContainsKey(key))
{
lock (_lock)
{
if (_dicCache.ContainsKey(key) && _dicCache[key].OverdueTime > DateTime.Now && _dicCache[key].GetType() == typeof(BaseCache <T>))
{
BaseCache <T> cache = (BaseCache <T>)_dicCache[key];
return(cache.Data);
}
}
}
return(default(T));
}
public T GetContentItem <T>() where T : AgilityContentItem
{
var content = BaseCache.GetContent(ContentReferenceName, AgilityContext.LanguageCode, AgilityContext.WebsiteName, false);
var row = content.GetItemByContentID(ContentID);
if (row == null)
{
return(null);
}
Type type = typeof(T);
ConstructorInfo constr = type.GetConstructor(System.Type.EmptyTypes);
return(AgilityContentRepository <T> .ConvertDataRowToObject(constr, row, AgilityContext.LanguageCode, ContentReferenceName));
}
private static Objects.LatestIndex GetLatestContentDefinitionIndex()
{
string fileName = "AgilityContentDefinitionIndex.bin";
string indexFilePath = Path.Combine(BaseCache.GetLocalContentFilePath(), fileName);
Objects.LatestIndex index = AgilityContext.HttpContext.Items[fileName] as Objects.LatestIndex;
if (index == null)
{
lock (_contentDefIndexLock)
{
index = AgilityContext.HttpContext.Items[fileName] as Objects.LatestIndex;
if (index == null)
{
index = BaseCache.ReadFile <Objects.LatestIndex>(indexFilePath);
if (index == null)
{
index = new Objects.LatestIndex();
}
DateTime maxModDate = index.MaxModDate;
var indexDelta = ServerAPI.GetLatestContentDefinitionIndex(maxModDate);
if (indexDelta != null)
{
foreach (var item in indexDelta)
{
if (item.ModifiedOn > index.MaxModDate)
{
index.MaxModDate = item.ModifiedOn;
}
index.Index[item.ID] = new Objects.LatestIndexItem()
{
ID = item.ID,
ModifiedOnStr = item.ModifiedOnStr,
Downloaded = false
};
}
BaseCache.WriteFile(index, indexFilePath);
AgilityContext.HttpContext.Items[fileName] = index;
}
}
}
}
return(index);
}
private static Objects.LatestContentItemIndex GetLatestContentItemIndex(string languageCode)
{
string fileName = string.Format("AgilityContentIndex_{0}.bin", languageCode);
string contentIndexFilePath = Path.Combine(BaseCache.GetLocalContentFilePath(), fileName);
Objects.LatestContentItemIndex index = AgilityContext.HttpContext.Items[fileName] as Objects.LatestContentItemIndex;
if (index == null)
{
lock (_contentIndexLock)
{
index = AgilityContext.HttpContext.Items[fileName] as Objects.LatestContentItemIndex;
if (index == null)
{
index = BaseCache.ReadFile <Objects.LatestContentItemIndex>(contentIndexFilePath);
if (index == null)
{
index = new Objects.LatestContentItemIndex();
}
int maxVersionID = index.MaxVersionID;
var indexDelta = ServerAPI.GetLatestContentItemIndex(maxVersionID, languageCode);
if (indexDelta != null)
{
foreach (var item in indexDelta)
{
if (item.MaxVersionID > index.MaxVersionID)
{
index.MaxVersionID = item.MaxVersionID;
}
index.Index[item.ReferenceName] = new Objects.LatestContentIndexItem()
{
MaxVersionID = item.MaxVersionID,
ReferenceName = item.ReferenceName,
Downloaded = false
};
}
BaseCache.WriteFile(index, contentIndexFilePath);
AgilityContext.HttpContext.Items[fileName] = index;
}
}
}
}
return(index);
}
/// <summary>
/// 动态加载数据库工厂
/// </summary>
/// <param name="providerInvariantName"></param>
/// <param name="dbType"></param>
/// <returns></returns>
public static DbProviderFactory GetFactory(string dbKey, bool IsResource = false, string dbFile = "db.json")
{
try
{
var config = new ConfigModel();
if (IsResource)
{
var projectName = Assembly.GetCallingAssembly().GetName().Name;
config = DataConfig.Get(dbKey, projectName, dbFile);
}
else
{
config = DataConfig.Get(dbKey);
}
if (BaseCache.Exists(config.ProviderName))
{
return(BaseCache.Get <object>(config.ProviderName) as DbProviderFactory);
}
else
{
var assembly = AppDomain.CurrentDomain.GetAssemblies().ToList().Find(a => a.FullName.Split(',')[0] == config.ProviderName);
if (assembly == null)
{
assembly = Assembly.Load(config.ProviderName);
}
var type = assembly.GetType(config.FactoryClient, false);
object instance = null;
if (type != null)
{
instance = Activator.CreateInstance(type);
}
BaseCache.Set <object>(config.ProviderName, instance);
return(instance as DbProviderFactory);
}
}
catch (Exception ex)
{
BaseLog.SaveLog(ex.Message + ex.StackTrace, "GetFactory");
return(null);
}
}
public async Task <IResponseOutput> GetVerifyCodeAsync(string lastKey)
{
var img = VerifyCodeHelper.GetBase64String(out string code);
//删除上次缓存的验证码
if (lastKey.NotNull())
{
await BaseCache.DelAsync(lastKey);
}
//写入Redis
var guid = Guid.NewGuid().ToString("N");
var key = string.Format(CacheKey.VerifyCodeKey, guid);
await BaseCache.SetAsync(key, code, TimeSpan.FromMinutes(5));
var data = new { Key = guid, Img = img };
return(ResponseOutput.Ok(data));
}
public object GetContentItemValue(string columnName)
{
if (row == null)
{
if (string.IsNullOrEmpty(LanguageCode))
{
LanguageCode = AgilityContext.LanguageCode;
}
AgilityContent content = BaseCache.GetContent(ContentReferenceName, LanguageCode, AgilityContext.WebsiteName);
row = content.GetItemByContentID(ContentID);
}
if (row != null && row.Table.Columns.Contains(columnName))
{
return(row[columnName]);
}
return(null);
}
/// <summary>
/// 请求过滤器
/// </summary>
/// <param name="filterContext"></param>
public override void OnActionExecuting(ActionExecutingContext filterContext)
{
base.OnActionExecuting(filterContext);
var controller = filterContext.Controller as Controller;
#region model验证处理
if (!controller.ModelState.IsValid)
{
var item = controller.ViewData.ModelState.Values.ToList().Find(a => a.Errors.Count > 0);
var error = item.Errors.Where(a => !string.IsNullOrEmpty(a.ErrorMessage)).Take(1).SingleOrDefault().ErrorMessage;
filterContext.Result = new JsonResult(new { success = false, msg = error });
return;
}
#endregion
foreach (var item in controller.ControllerContext.ActionDescriptor.FilterDescriptors.ToList())
{
if (item.Filter is AllowAnonymousFilter)
{
return;
}
}
#region 登陆验证
if (!BaseCache.Exists(App.Cache.UserInfo))
{
filterContext.Result = new RedirectToActionResult("login", "Home", "default");
return;
}
else
{
var dic = BaseCache.Get <Dictionary <string, object> >(App.Cache.UserInfo);
if (dic.GetValue("ip").ToStr() != App.Ip.Get(filterContext.HttpContext))
{
filterContext.Result = new RedirectToActionResult("login", "Home", "default");
}
}
#endregion
}
/// <summary>
/// 泛型缓存属性成员
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <returns></returns>
public static List <PropertyInfo> GetPropertyInfo <T>(bool IsCache = true)
{
var key = string.Format("{0}.{1}", typeof(T).Namespace, typeof(T).Name);
if (IsCache)
{
if (BaseCache.Exists(key))
{
return(BaseCache.Get <List <PropertyInfo> >(key));
}
else
{
var info = typeof(T).GetProperties(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly).ToList();
BaseCache.Set <List <PropertyInfo> >(key, info);
return(info);
}
}
else
{
BaseCache.Remove(key);
return(typeof(T).GetProperties(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly).ToList());
}
}
