/// <summary>
/// 清除按主键查询的缓存
/// </summary>
public static void ClearCacheSelectByID(string emailAddress, Where where = null)
{
string cacheName = "TH.Mailer.EmailListCache_SelectByID_{0}";
string cacheNameKey = string.Format(cacheName, emailAddress + "_" + "_" + where);
Cache2.Remove(cacheNameKey);
}
/// <summary>
/// 邮件模版修改记录
/// </summary>
/// <param name="htmlTemplate">邮件模版实体类</param>
/// <param name="where">修改时附加条件，统一的前面要加链接符（and、or等等）</param>
/// <param name="delCache">修改成功后清理的CACHE key，支持正则</param>
/// <param name="dbkey">存在数据库连接池中的连接key，为空时使用ConnString连接</param>
/// <returns>修改是否成功</returns>
public static bool Update(HtmlTemplate htmlTemplate, string dbkey = "", Where where = null, string[] delCache = null)
{
if (htmlTemplate.TemplateID.IsNull())
{
return(false);
}
int value = new SQL().Database(dbkey).Update(HtmlTemplate._)
.SetP(HtmlTemplate._Subject, htmlTemplate.Subject)
.SetP(HtmlTemplate._Body, htmlTemplate.Body)
.SetP(HtmlTemplate._ShowName, htmlTemplate.ShowName)
.SetP(HtmlTemplate._IsHTML, htmlTemplate.IsHTML)
.SetP(HtmlTemplate._Status, htmlTemplate.Status)
.SetP(HtmlTemplate._CreateTime, htmlTemplate.CreateTime)
.Where(new Where()
.AndP(HtmlTemplate._TemplateID, htmlTemplate.TemplateID, Operator.Equal, true)
).Where(where).ToExec();
if (value <= 0)
{
return(false);
}
if (delCache.IsNull())
{
return(true);
}
Cache2.Remove("TH.Mailer.HtmlTemplateCache_", delCache);
return(true);
}
/// <summary>
/// 路由修改记录
/// </summary>
/// <param name="routeSetting">路由实体类</param>
/// <param name="where">修改时附加条件，统一的前面要加链接符（and、or等等）</param>
/// <param name="delCache">修改成功后清理的CACHE key，支持正则</param>
/// <param name="dbkey">存在数据库连接池中的连接key，为空时使用ConnString连接</param>
/// <returns>修改是否成功</returns>
public static bool Update(RouteSetting routeSetting, string dbkey = "", Where where = null, string[] delCache = null)
{
if (routeSetting.RouteID.IsNull())
{
return(false);
}
int value = new SQL().Database(dbkey).Update(RouteSetting._)
.SetP(RouteSetting._RouteIP, routeSetting.RouteIP)
.SetP(RouteSetting._UserName, routeSetting.UserName)
.SetP(RouteSetting._RPassword, routeSetting.RPassword)
.SetP(RouteSetting._RouteConnect, routeSetting.RouteConnect)
.SetP(RouteSetting._RouteDisConnect, routeSetting.RouteDisConnect)
.SetP(RouteSetting._RouteMethod, routeSetting.RouteMethod)
.Where(new Where()
.AndP(RouteSetting._RouteID, routeSetting.RouteID, Operator.Equal, true)
).Where(where).ToExec();
if (value <= 0)
{
return(false);
}
if (delCache.IsNull())
{
return(true);
}
Cache2.Remove("TH.Mailer.RouteSettingCache_", delCache);
return(true);
}
/// <summary>
/// 查询所有记录
/// </summary>
/// <param name="where">附加条件，统一的前面要加链接符（and、or等等）</param>
/// <param name="order">排序字段，不加“order by”</param>
/// <param name="fieldList">设置需要返回的字段</param>
/// <param name="dbkey">存在数据库连接池中的连接key，为空时随机取连接key</param>
/// <returns>返回实体记录集</returns>
public static IList <EmailList> SelectListByAll(string dbkey = "", Where where = null, string order = "", string fieldList = "")
{
string cacheNameKey = "TH.Mailer.EmailListCache_SelectListByAll_{0}_{1}_{2}".FormatWith(where, order, fieldList);
return(Cache2.Get <IList <EmailList> >(cacheNameKey, cacheSeconds, () => {
IList <EmailList> list = new List <EmailList>();
if (fieldList.IsNullEmpty())
{
list = new SQL().Database(dbkey).From(EmailList._)
.Select(EmailList._EmailAddress)
.Select(EmailList._NickName)
.Select(EmailList._LastSendStatus)
.Select(EmailList._LastSendError)
.Select(EmailList._LastSendTime)
.Select(EmailList._LastSendSmtp)
.Select(EmailList._SendCount)
.Select(EmailList._CreateTime)
.Select(EmailList._ex0)
.Select(EmailList._ex1)
.Select(EmailList._ex2)
.Select(EmailList._ex3)
.Select(EmailList._ex4)
.Select(EmailList._ex5)
.Select(EmailList._ex6)
.Select(EmailList._ex7)
.Select(EmailList._ex8)
.Where(where).Order(order).ToList <EmailList>();
}
else
{
list = new SQL().Database(dbkey).From(EmailList._).Select(fieldList).Where(where).Order(order).ToList <EmailList>();
}
return list;
}));
}
/// <summary>
/// 邮件模版查询所有记录
/// </summary>
/// <param name="where">附加条件，统一的前面要加链接符（and、or等等）</param>
/// <param name="order">排序字段，不加“order by”</param>
/// <param name="fieldList">设置需要返回的字段</param>
/// <param name="dbkey">存在数据库连接池中的连接key，为空时随机取连接key</param>
/// <returns>返回实体记录集</returns>
public static IList <HtmlTemplate> SelectListByAll(string dbkey = "", Where where = null, string order = "", string fieldList = "")
{
string cacheNameKey = "TH.Mailer.HtmlTemplateCache_SelectListByAll_{0}_{1}_{2}".FormatWith(where, order, fieldList);
return(Cache2.Get <IList <HtmlTemplate> >(cacheNameKey, cacheSeconds, () => {
IList <HtmlTemplate> list = new List <HtmlTemplate>();
if (fieldList.IsNullEmpty())
{
list = new SQL().Database(dbkey).From(HtmlTemplate._)
.Select(HtmlTemplate._TemplateID)
.Select(HtmlTemplate._Subject)
.Select(HtmlTemplate._Body)
.Select(HtmlTemplate._ShowName)
.Select(HtmlTemplate._IsHTML)
.Select(HtmlTemplate._Status)
.Select(HtmlTemplate._CreateTime)
.Where(where).Order(order).ToList <HtmlTemplate>();
}
else
{
list = new SQL().Database(dbkey).From(HtmlTemplate._).Select(fieldList).Where(where).Order(order).ToList <HtmlTemplate>();
}
return list;
}));
}
/// <summary>
/// 查询所有记录
/// </summary>
/// <param name="where">附加条件，统一的前面要加链接符（and、or等等）</param>
/// <param name="order">排序字段，不加“order by”</param>
/// <param name="fieldList">设置需要返回的字段</param>
/// <param name="dbkey">存在数据库连接池中的连接key，为空时随机取连接key</param>
/// <returns>返回实体记录集</returns>
public static IList <SmtpList> SelectListByAll(string dbkey = "", Where where = null, string order = "", string fieldList = "")
{
string cacheNameKey = "TH.Mailer.SmtpListCache_SelectListByAll_{0}_{1}_{2}".FormatWith(where, order, fieldList);
return(Cache2.Get <IList <SmtpList> >(cacheNameKey, cacheSeconds, () => {
IList <SmtpList> list = new List <SmtpList>();
if (fieldList.IsNullEmpty())
{
list = new SQL().Database(dbkey).From(SmtpList._)
.Select(SmtpList._SmtpServer)
.Select(SmtpList._SmtpPort)
.Select(SmtpList._UserName)
.Select(SmtpList._SPassword)
.Select(SmtpList._SSL)
.Select(SmtpList._Status)
.Select(SmtpList._Sends)
.Select(SmtpList._SendFails)
.Select(SmtpList._CreateTime)
.Where(where).Order(order).ToList <SmtpList>();
}
else
{
list = new SQL().Database(dbkey).From(SmtpList._).Select(fieldList).Where(where).Order(order).ToList <SmtpList>();
}
return list;
}));
}
/// <summary>
/// 按主键查询，返回数据的实体类
/// </summary>
/// <param name="emailAddress">发送的Email</param>
/// <param name="where">附加条件，统一的前面要加链接符（and、or等等）</param>
/// <param name="dbkey">存在数据库连接池中的连接key，为空时随机取连接key</param>
/// <returns>返回单条记录的实体类</returns>
public static EmailList SelectByID(string emailAddress, string dbkey = "", Where where = null)
{
string cacheNameKey = "TH.Mailer.EmailListCache_SelectByID_{0}".FormatWith(emailAddress + "_" + "_" + where);
return(Cache2.Get <EmailList>(cacheNameKey, cacheSeconds, () => {
EmailList obj = new SQL().Database(dbkey).From(EmailList._)
.Select(EmailList._EmailAddress)
.Select(EmailList._NickName)
.Select(EmailList._LastSendStatus)
.Select(EmailList._LastSendError)
.Select(EmailList._LastSendTime)
.Select(EmailList._LastSendSmtp)
.Select(EmailList._SendCount)
.Select(EmailList._CreateTime)
.Select(EmailList._ex0)
.Select(EmailList._ex1)
.Select(EmailList._ex2)
.Select(EmailList._ex3)
.Select(EmailList._ex4)
.Select(EmailList._ex5)
.Select(EmailList._ex6)
.Select(EmailList._ex7)
.Select(EmailList._ex8)
.Where(new Where()
.AndP(EmailList._EmailAddress, emailAddress, Operator.Equal)
).Where(where).ToEntity <EmailList>();
return obj;
}));
}
/// <summary>
/// 修改多条记录
/// </summary>
/// <param name="emailAddressList">发送的Email列表，用“,”号分隔</param>
/// <param name="emailList">实体类</param>
/// <param name="where">修改时附加条件，统一的前面要加链接符（and、or等等）</param>
/// <param name="delCache">修改成功后清理的CACHE key，支持正则</param>
/// <param name="dbkey">存在数据库连接池中的连接key，为空时使用ConnString连接</param>
/// <returns>修改是否成功</returns>
public static bool UpdateByIDList(IEnumerable <string> emailAddressList, EmailList emailList, string dbkey = "", Where where = null, string[] delCache = null)
{
int value = new SQL().Database(dbkey).Update(EmailList._)
.SetP(EmailList._NickName, emailList.NickName)
.SetP(EmailList._LastSendStatus, emailList.LastSendStatus)
.SetP(EmailList._LastSendError, emailList.LastSendError)
.SetP(EmailList._LastSendTime, emailList.LastSendTime)
.SetP(EmailList._LastSendSmtp, emailList.LastSendSmtp)
.SetP(EmailList._SendCount, emailList.SendCount)
.SetP(EmailList._CreateTime, emailList.CreateTime)
.SetP(EmailList._ex0, emailList.ex0)
.SetP(EmailList._ex1, emailList.ex1)
.SetP(EmailList._ex2, emailList.ex2)
.SetP(EmailList._ex3, emailList.ex3)
.SetP(EmailList._ex4, emailList.ex4)
.SetP(EmailList._ex5, emailList.ex5)
.SetP(EmailList._ex6, emailList.ex6)
.SetP(EmailList._ex7, emailList.ex7)
.SetP(EmailList._ex8, emailList.ex8)
.Where(new Where()
.And(EmailList._EmailAddress, "(" + emailAddressList.Join(",") + ")", Operator.In)
).Where(where).ToExec();
if (value <= 0)
{
return(false);
}
if (delCache.IsNull())
{
return(true);
}
Cache2.Remove("TH.Mailer.EmailListCache_", delCache);
return(true);
}
/// <summary>
/// 清除路由按主键查询的缓存
/// </summary>
public static void ClearCacheSelectByID(int routeID, Where where = null)
{
string cacheName = "TH.Mailer.RouteSettingCache_SelectByID_{0}";
string cacheNameKey = string.Format(cacheName, routeID + "_" + "_" + where);
Cache2.Remove(cacheNameKey);
}
/// <summary>
/// 清除按主键查询的缓存
/// </summary>
public static void ClearCacheSelectByID(string smtpServer, int smtpPort, string userName, Where where = null)
{
string cacheName = "TH.Mailer.SmtpListCache_SelectByID_{0}";
string cacheNameKey = string.Format(cacheName, smtpServer + "_" + smtpPort + "_" + userName + "_" + "_" + where);
Cache2.Remove(cacheNameKey);
}
/// <summary>
/// 修改记录
/// </summary>
/// <param name="smtpList">实体类</param>
/// <param name="where">修改时附加条件，统一的前面要加链接符（and、or等等）</param>
/// <param name="delCache">修改成功后清理的CACHE key，支持正则</param>
/// <param name="dbkey">存在数据库连接池中的连接key，为空时使用ConnString连接</param>
/// <returns>修改是否成功</returns>
public static bool Update(SmtpList smtpList, string dbkey = "", Where where = null, string[] delCache = null)
{
if (smtpList.SmtpServer.IsNullEmpty() && smtpList.SmtpPort.IsNull() && smtpList.UserName.IsNullEmpty())
{
return(false);
}
int value = new SQL().Database(dbkey).Update(SmtpList._)
.SetP(SmtpList._SPassword, smtpList.SPassword)
.SetP(SmtpList._SSL, smtpList.SSL)
.SetP(SmtpList._Status, smtpList.Status)
.SetP(SmtpList._Sends, smtpList.Sends)
.SetP(SmtpList._SendFails, smtpList.SendFails)
.SetP(SmtpList._CreateTime, smtpList.CreateTime)
.Where(new Where()
.AndP(SmtpList._SmtpServer, smtpList.SmtpServer, Operator.Equal, true)
.AndP(SmtpList._SmtpPort, smtpList.SmtpPort, Operator.Equal, true)
.AndP(SmtpList._UserName, smtpList.UserName, Operator.Equal, true)
).Where(where).ToExec();
if (value <= 0)
{
return(false);
}
if (delCache.IsNull())
{
return(true);
}
Cache2.Remove("TH.Mailer.SmtpListCache_", delCache);
return(true);
}
public void ClearCache()
{
Cache1.Clear();
Cache2.Clear();
CacheM.Clear();
Timestep = 0;
}
/// <summary>
/// 拨号连接修改记录
/// </summary>
/// <param name="modelSetting">拨号连接实体类</param>
/// <param name="where">修改时附加条件，统一的前面要加链接符（and、or等等）</param>
/// <param name="delCache">修改成功后清理的CACHE key，支持正则</param>
/// <param name="dbkey">存在数据库连接池中的连接key，为空时使用ConnString连接</param>
/// <returns>修改是否成功</returns>
public static bool Update(ModelSetting modelSetting, string dbkey = "", Where where = null, string[] delCache = null)
{
if (modelSetting.ModelID.IsNull())
{
return(false);
}
int value = new SQL().Database(dbkey).Update(ModelSetting._)
.SetP(ModelSetting._ModelName, modelSetting.ModelName)
.SetP(ModelSetting._UserName, modelSetting.UserName)
.SetP(ModelSetting._MPassword, modelSetting.MPassword)
.Where(new Where()
.AndP(ModelSetting._ModelID, modelSetting.ModelID, Operator.Equal, true)
).Where(where).ToExec();
if (value <= 0)
{
return(false);
}
if (delCache.IsNull())
{
return(true);
}
Cache2.Remove("TH.Mailer.ModelSettingCache_", delCache);
return(true);
}
/// <summary>
/// 添加记录
/// </summary>
/// <param name="emailList">实体类</param>
/// <param name="delCache">添加成功后清理的CACHE key，支持正则</param>
/// <param name="dbkey">存在数据库连接池中的连接key，为空时使用ConnString连接</param>
/// <returns>添加是否成功</returns>
public static bool Insert(EmailList emailList, string dbkey = "", string[] delCache = null)
{
int obj = new SQL().Database(dbkey).Insert(EmailList._)
.ValueP(EmailList._EmailAddress, emailList.EmailAddress)
.ValueP(EmailList._NickName, emailList.NickName)
.ValueP(EmailList._LastSendStatus, emailList.LastSendStatus)
.ValueP(EmailList._LastSendError, emailList.LastSendError)
.ValueP(EmailList._LastSendTime, emailList.LastSendTime)
.ValueP(EmailList._LastSendSmtp, emailList.LastSendSmtp)
.ValueP(EmailList._SendCount, emailList.SendCount)
.ValueP(EmailList._CreateTime, emailList.CreateTime)
.ValueP(EmailList._ex0, emailList.ex0)
.ValueP(EmailList._ex1, emailList.ex1)
.ValueP(EmailList._ex2, emailList.ex2)
.ValueP(EmailList._ex3, emailList.ex3)
.ValueP(EmailList._ex4, emailList.ex4)
.ValueP(EmailList._ex5, emailList.ex5)
.ValueP(EmailList._ex6, emailList.ex6)
.ValueP(EmailList._ex7, emailList.ex7)
.ValueP(EmailList._ex8, emailList.ex8)
.ToExec();
if (delCache.IsNull())
{
return(obj == 1);
}
Cache2.Remove("TH.Mailer.EmailListCache_", delCache);
return(obj == 1);
}
/// <summary>
/// 获取IP配置修改记录
/// </summary>
/// <param name="ipSetting">获取IP配置实体类</param>
/// <param name="where">修改时附加条件，统一的前面要加链接符（and、or等等）</param>
/// <param name="delCache">修改成功后清理的CACHE key，支持正则</param>
/// <param name="dbkey">存在数据库连接池中的连接key，为空时使用ConnString连接</param>
/// <returns>修改是否成功</returns>
public static bool Update(IpSetting ipSetting, string dbkey = "", Where where = null, string[] delCache = null)
{
if (ipSetting.IPCID.IsNull())
{
return(false);
}
int value = new SQL().Database(dbkey).Update(IpSetting._)
.SetP(IpSetting._WebName, ipSetting.WebName)
.SetP(IpSetting._IPUrl, ipSetting.IPUrl)
.SetP(IpSetting._IPRegex, ipSetting.IPRegex)
.SetP(IpSetting._DataEncode, ipSetting.DataEncode)
.Where(new Where()
.AndP(IpSetting._IPCID, ipSetting.IPCID, Operator.Equal, true)
).Where(where).ToExec();
if (value <= 0)
{
return(false);
}
if (delCache.IsNull())
{
return(true);
}
Cache2.Remove("TH.Mailer.IpSettingCache_", delCache);
return(true);
}
/// <summary>
/// 邮件模版添加记录
/// </summary>
/// <param name="htmlTemplate">邮件模版实体类</param>
/// <param name="delCache">添加成功后清理的CACHE key，支持正则</param>
/// <param name="dbkey">存在数据库连接池中的连接key，为空时使用ConnString连接</param>
/// <returns>返回添加成功后的ID</returns>
public static Int64 Insert(HtmlTemplate htmlTemplate, string dbkey = "", string[] delCache = null)
{
object obj = new SQL().Database(dbkey).Insert(HtmlTemplate._)
.ValueP(HtmlTemplate._TemplateID, htmlTemplate.TemplateID)
.ValueP(HtmlTemplate._Subject, htmlTemplate.Subject)
.ValueP(HtmlTemplate._Body, htmlTemplate.Body)
.ValueP(HtmlTemplate._ShowName, htmlTemplate.ShowName)
.ValueP(HtmlTemplate._IsHTML, htmlTemplate.IsHTML)
.ValueP(HtmlTemplate._Status, htmlTemplate.Status)
.ValueP(HtmlTemplate._CreateTime, htmlTemplate.CreateTime)
.ToExec();
if (obj.ToInt() != 1)
{
return(0);
}
obj = new SQL().Database(dbkey).From(HtmlTemplate._).Max("TemplateID").ToScalar();
if (obj.IsAllNull())
{
return(0);
}
Int64 value = obj.ToString().ToBigInt();
if (delCache.IsNull())
{
return(value);
}
Cache2.Remove("TH.Mailer.HtmlTemplateCache_", delCache);
return(value);
}
/// <summary>
/// 获取IP配置添加记录
/// </summary>
/// <param name="ipSetting">获取IP配置实体类</param>
/// <param name="delCache">添加成功后清理的CACHE key，支持正则</param>
/// <param name="dbkey">存在数据库连接池中的连接key，为空时使用ConnString连接</param>
/// <returns>返回添加成功后的ID</returns>
public static Int64 Insert(IpSetting ipSetting, string dbkey = "", string[] delCache = null)
{
object obj = new SQL().Database(dbkey).Insert(IpSetting._)
.ValueP(IpSetting._IPCID, ipSetting.IPCID)
.ValueP(IpSetting._WebName, ipSetting.WebName)
.ValueP(IpSetting._IPUrl, ipSetting.IPUrl)
.ValueP(IpSetting._IPRegex, ipSetting.IPRegex)
.ValueP(IpSetting._DataEncode, ipSetting.DataEncode)
.ToExec();
if (obj.ToInt() != 1)
{
return(0);
}
obj = new SQL().Database(dbkey).From(IpSetting._).Max("IPCID").ToScalar();
if (obj.IsAllNull())
{
return(0);
}
Int64 value = obj.ToString().ToBigInt();
if (delCache.IsNull())
{
return(value);
}
Cache2.Remove("TH.Mailer.IpSettingCache_", delCache);
return(value);
}
/// <summary>
/// 设置修改记录
/// </summary>
/// <param name="sendSetting">设置实体类</param>
/// <param name="where">修改时附加条件，统一的前面要加链接符（and、or等等）</param>
/// <param name="delCache">修改成功后清理的CACHE key，支持正则</param>
/// <param name="dbkey">存在数据库连接池中的连接key，为空时使用ConnString连接</param>
/// <returns>修改是否成功</returns>
public static bool Update(SendSetting sendSetting, string dbkey = "", Where where = null, string[] delCache = null)
{
if (sendSetting.SettingID.IsNull())
{
return(false);
}
int value = new SQL().Database(dbkey).Update(SendSetting._)
.SetP(SendSetting._TemplateID, sendSetting.TemplateID)
.SetP(SendSetting._ConnectType, sendSetting.ConnectType)
.SetP(SendSetting._SendInterval, sendSetting.SendInterval)
.SetP(SendSetting._IPInterval, sendSetting.IPInterval)
.SetP(SendSetting._SmtpInterval, sendSetting.SmtpInterval)
.SetP(SendSetting._DeleteInterval, sendSetting.DeleteInterval)
.SetP(SendSetting._MaxRetryCount, sendSetting.MaxRetryCount)
.SetP(SendSetting._SendRetryCount, sendSetting.SendRetryCount)
.SetP(SendSetting._Status, sendSetting.Status)
.Where(new Where()
.AndP(SendSetting._SettingID, sendSetting.SettingID, Operator.Equal, true)
).Where(where).ToExec();
if (value <= 0)
{
return(false);
}
if (delCache.IsNull())
{
return(true);
}
Cache2.Remove("TH.Mailer.SendSettingCache_", delCache);
return(true);
}
/// <summary>
/// 清除查询记录，带分页的缓存
/// </summary>
public static void ClearCacheSelectPageList()
{
string cacheNameKey = "TH.Mailer.SmtpListCache_SelectPageList_(.+?)";
string cacheRecordsKey = "TH.Mailer.SmtpListCache_RecordsSelectPageList_(.+?)";
Cache2.RemoveByPattern(cacheNameKey);
Cache2.RemoveByPattern(cacheRecordsKey);
}
public T Get(string key)
{
if (Cache1 != null && Cache1.ContainsKey(key))
{
return(Cache1[key]);
}
if (Cache2 != null && Cache2.ContainsKey(key))
{
return(Cache2[key]);
}
return(null);
}
/// <summary>
/// 添加记录
/// </summary>
/// <param name="ipHistory">实体类</param>
/// <param name="delCache">添加成功后清理的CACHE key，支持正则</param>
/// <param name="dbkey">存在数据库连接池中的连接key，为空时使用ConnString连接</param>
/// <returns>添加是否成功</returns>
public static bool Insert(IpHistory ipHistory, string dbkey = "", string[] delCache = null)
{
int obj = new SQL().Database(dbkey).Insert(IpHistory._)
.ValueP(IpHistory._IP, ipHistory.IP)
.ValueP(IpHistory._CreateTime, ipHistory.CreateTime)
.ToExec();
if (delCache.IsNull())
{
return(obj == 1);
}
Cache2.Remove("TH.Mailer.IpHistoryCache_", delCache);
return(obj == 1);
}
/// <summary>
/// 天翼连接设置添加记录
/// </summary>
/// <param name="tianYiSetting">天翼连接设置实体类</param>
/// <param name="delCache">添加成功后清理的CACHE key，支持正则</param>
/// <param name="dbkey">存在数据库连接池中的连接key，为空时使用ConnString连接</param>
/// <returns>添加是否成功</returns>
public static bool Insert(TianYiSetting tianYiSetting, string dbkey = "", string[] delCache = null)
{
int obj = new SQL().Database(dbkey).Insert(TianYiSetting._)
.ValueP(TianYiSetting._TianYiID, tianYiSetting.TianYiID)
.ValueP(TianYiSetting._TianYiExePath, tianYiSetting.TianYiExePath)
.ToExec();
if (delCache.IsNull())
{
return(obj == 1);
}
Cache2.Remove("TH.Mailer.TianYiSettingCache_", delCache);
return(obj == 1);
}
/// <summary>
/// 天翼连接设置按主键查询，返回数据的实体类
/// </summary>
/// <param name="tianYiID">天翼连接设置编号</param>
/// <param name="where">附加条件，统一的前面要加链接符（and、or等等）</param>
/// <param name="dbkey">存在数据库连接池中的连接key，为空时随机取连接key</param>
/// <returns>返回单条记录的实体类</returns>
public static TianYiSetting SelectByID(int tianYiID, string dbkey = "", Where where = null)
{
string cacheNameKey = "TH.Mailer.TianYiSettingCache_SelectByID_{0}".FormatWith(tianYiID + "_" + "_" + where);
return(Cache2.Get <TianYiSetting>(cacheNameKey, cacheSeconds, () => {
TianYiSetting obj = new SQL().Database(dbkey).From(TianYiSetting._)
.Select(TianYiSetting._TianYiID)
.Select(TianYiSetting._TianYiExePath)
.Where(new Where()
.AndP(TianYiSetting._TianYiID, tianYiID, Operator.Equal)
).Where(where).ToEntity <TianYiSetting>();
return obj;
}));
}
/// <summary>
/// 拨号连接添加记录
/// </summary>
/// <param name="modelSetting">拨号连接实体类</param>
/// <param name="delCache">添加成功后清理的CACHE key，支持正则</param>
/// <param name="dbkey">存在数据库连接池中的连接key，为空时使用ConnString连接</param>
/// <returns>添加是否成功</returns>
public static bool Insert(ModelSetting modelSetting, string dbkey = "", string[] delCache = null)
{
int obj = new SQL().Database(dbkey).Insert(ModelSetting._)
.ValueP(ModelSetting._ModelID, modelSetting.ModelID)
.ValueP(ModelSetting._ModelName, modelSetting.ModelName)
.ValueP(ModelSetting._UserName, modelSetting.UserName)
.ValueP(ModelSetting._MPassword, modelSetting.MPassword)
.ToExec();
if (delCache.IsNull())
{
return(obj == 1);
}
Cache2.Remove("TH.Mailer.ModelSettingCache_", delCache);
return(obj == 1);
}
/// <summary>
/// 拨号连接按主键查询，返回数据的实体类
/// </summary>
/// <param name="modelID">拨号连接编号</param>
/// <param name="where">附加条件，统一的前面要加链接符（and、or等等）</param>
/// <param name="dbkey">存在数据库连接池中的连接key，为空时随机取连接key</param>
/// <returns>返回单条记录的实体类</returns>
public static ModelSetting SelectByID(int modelID, string dbkey = "", Where where = null)
{
string cacheNameKey = "TH.Mailer.ModelSettingCache_SelectByID_{0}".FormatWith(modelID + "_" + "_" + where);
return(Cache2.Get <ModelSetting>(cacheNameKey, cacheSeconds, () => {
ModelSetting obj = new SQL().Database(dbkey).From(ModelSetting._)
.Select(ModelSetting._ModelID)
.Select(ModelSetting._ModelName)
.Select(ModelSetting._UserName)
.Select(ModelSetting._MPassword)
.Where(new Where()
.AndP(ModelSetting._ModelID, modelID, Operator.Equal)
).Where(where).ToEntity <ModelSetting>();
return obj;
}));
}
/// <summary>
/// 查询数据，带分页
/// </summary>
/// <param name="pageIndex">当前第几页，从1开始</param>
/// <param name="pageSize">每页记录数</param>
/// <param name="totalRecords">返回总记录数</param>
/// <param name="where">附加条件，统一的前面要加链接符（and、or等等）</param>
/// <param name="order">排序字段，不加“order by”</param>
/// <param name="fieldList">设置需要返回的字段</param>
/// <param name="dbkey">存在数据库连接池中的连接key，为空时随机取连接key</param>
/// <param name="pageEnum">使用哪种分页方式（not_in、max_top、top_top、row_number、mysql、oracle、sqlite）</param>
/// <returns>返回实体记录集</returns>
public static IList <EmailList> SelectPageList(int pageIndex, int pageSize, out long totalRecords, string dbkey = "", Where where = null, string order = "", string fieldList = "", PagerSQLEnum pageEnum = PagerSQLEnum.sqlite)
{
string cacheNameKey = "TH.Mailer.EmailListCache_SelectPageList_{0}_{1}_{2}_{3}_{4}".FormatWith(pageIndex, pageSize, where, order, fieldList);
string cacheRecordsKey = "TH.Mailer.EmailListCache_RecordsSelectPageList_{0}_{1}_{2}_{3}_{4}".FormatWith(pageIndex, pageSize, where, order, fieldList);
IList <EmailList> list = (IList <EmailList>)Cache2.Get(cacheNameKey);
if (!list.IsNull())
{
totalRecords = (int)Cache2.Get(cacheRecordsKey); return(list);
}
using (PagerSQLHelper s = new PagerSQLHelper(pageEnum)) {
list = s.GetSQL(pageIndex, pageSize, EmailList._, EmailList._EmailAddress, fieldList.IfNullOrEmpty("[EmailAddress],[NickName],[LastSendStatus],[LastSendError],[LastSendTime],[LastSendSmtp],[SendCount],[CreateTime],[ex0],[ex1],[ex2],[ex3],[ex4],[ex5],[ex6],[ex7],[ex8],"), where, "", order).ToList <EmailList>(out totalRecords, dbkey);
}
Cache2.Insert(cacheNameKey, list, cacheSeconds);
Cache2.Insert(cacheRecordsKey, totalRecords, cacheSeconds);
return(list);
}
/// <summary>
/// 查询数据，带分页
/// </summary>
/// <param name="pageIndex">当前第几页，从1开始</param>
/// <param name="pageSize">每页记录数</param>
/// <param name="totalRecords">返回总记录数</param>
/// <param name="where">附加条件，统一的前面要加链接符（and、or等等）</param>
/// <param name="order">排序字段，不加“order by”</param>
/// <param name="fieldList">设置需要返回的字段</param>
/// <param name="dbkey">存在数据库连接池中的连接key，为空时随机取连接key</param>
/// <param name="pageEnum">使用哪种分页方式（not_in、max_top、top_top、row_number、mysql、oracle、sqlite）</param>
/// <returns>返回实体记录集</returns>
public static IList <IpHistory> SelectPageList(int pageIndex, int pageSize, out long totalRecords, string dbkey = "", Where where = null, string order = "", string fieldList = "", PagerSQLEnum pageEnum = PagerSQLEnum.sqlite)
{
string cacheNameKey = "TH.Mailer.IpHistoryCache_SelectPageList_{0}_{1}_{2}_{3}_{4}".FormatWith(pageIndex, pageSize, where, order, fieldList);
string cacheRecordsKey = "TH.Mailer.IpHistoryCache_RecordsSelectPageList_{0}_{1}_{2}_{3}_{4}".FormatWith(pageIndex, pageSize, where, order, fieldList);
IList <IpHistory> list = (IList <IpHistory>)Cache2.Get(cacheNameKey);
if (!list.IsNull())
{
totalRecords = (int)Cache2.Get(cacheRecordsKey); return(list);
}
using (PagerSQLHelper s = new PagerSQLHelper(pageEnum)) {
list = s.GetSQL(pageIndex, pageSize, IpHistory._, IpHistory._IP, fieldList.IfNullOrEmpty("[IP],[CreateTime],"), where, "", order).ToList <IpHistory>(out totalRecords, dbkey);
}
Cache2.Insert(cacheNameKey, list, cacheSeconds);
Cache2.Insert(cacheRecordsKey, totalRecords, cacheSeconds);
return(list);
}
/// <summary>
/// 删除多条记录
/// </summary>
/// <param name="iPList">IP地址列表，用“,”号分隔</param>
/// <param name="where">删除时附加条件，统一的前面要加链接符（and、or等等）</param>
/// <param name="delCache">修改成功后清理的CACHE key，支持正则</param>
/// <param name="dbkey">存在数据库连接池中的连接key，为空时使用ConnString连接</param>
/// <returns>删除是否成功</returns>
public static bool DeleteByIDList(IEnumerable <string> iPList, string dbkey = "", Where where = null, string[] delCache = null)
{
int value = new SQL().Database(dbkey).Delete(IpHistory._)
.Where(new Where()
.And(IpHistory._IP, "(" + iPList.Join(",") + ")", Operator.In)
).Where(where).ToExec();
if (value <= 0)
{
return(false);
}
if (delCache.IsNull())
{
return(true);
}
Cache2.Remove("TH.Mailer.IpHistoryCache_", delCache);
return(true);
}
/// <summary>
/// 查询数据，带分页
/// </summary>
/// <param name="pageIndex">当前第几页，从1开始</param>
/// <param name="pageSize">每页记录数</param>
/// <param name="totalRecords">返回总记录数</param>
/// <param name="where">附加条件，统一的前面要加链接符（and、or等等）</param>
/// <param name="order">排序字段，不加“order by”</param>
/// <param name="fieldList">设置需要返回的字段</param>
/// <param name="dbkey">存在数据库连接池中的连接key，为空时随机取连接key</param>
/// <param name="pageEnum">使用哪种分页方式（not_in、max_top、top_top、row_number、mysql、oracle、sqlite）</param>
/// <returns>返回实体记录集</returns>
public static IList <SmtpList> SelectPageList(int pageIndex, int pageSize, out long totalRecords, string dbkey = "", Where where = null, string order = "", string fieldList = "", PagerSQLEnum pageEnum = PagerSQLEnum.sqlite)
{
string cacheNameKey = "TH.Mailer.SmtpListCache_SelectPageList_{0}_{1}_{2}_{3}_{4}".FormatWith(pageIndex, pageSize, where, order, fieldList);
string cacheRecordsKey = "TH.Mailer.SmtpListCache_RecordsSelectPageList_{0}_{1}_{2}_{3}_{4}".FormatWith(pageIndex, pageSize, where, order, fieldList);
IList <SmtpList> list = (IList <SmtpList>)Cache2.Get(cacheNameKey);
if (!list.IsNull())
{
totalRecords = (int)Cache2.Get(cacheRecordsKey); return(list);
}
using (PagerSQLHelper s = new PagerSQLHelper(pageEnum)) {
list = s.GetSQL(pageIndex, pageSize, SmtpList._, SmtpList._SmtpServer, fieldList.IfNullOrEmpty("[SmtpServer],[SmtpPort],[UserName],[SPassword],[SSL],[Status],[Sends],[SendFails],[CreateTime],"), where, "", order).ToList <SmtpList>(out totalRecords, dbkey);
}
Cache2.Insert(cacheNameKey, list, cacheSeconds);
Cache2.Insert(cacheRecordsKey, totalRecords, cacheSeconds);
return(list);
}
/// <summary>
/// 路由添加记录
/// </summary>
/// <param name="routeSetting">路由实体类</param>
/// <param name="delCache">添加成功后清理的CACHE key，支持正则</param>
/// <param name="dbkey">存在数据库连接池中的连接key，为空时使用ConnString连接</param>
/// <returns>添加是否成功</returns>
public static bool Insert(RouteSetting routeSetting, string dbkey = "", string[] delCache = null)
{
int obj = new SQL().Database(dbkey).Insert(RouteSetting._)
.ValueP(RouteSetting._RouteID, routeSetting.RouteID)
.ValueP(RouteSetting._RouteIP, routeSetting.RouteIP)
.ValueP(RouteSetting._UserName, routeSetting.UserName)
.ValueP(RouteSetting._RPassword, routeSetting.RPassword)
.ValueP(RouteSetting._RouteConnect, routeSetting.RouteConnect)
.ValueP(RouteSetting._RouteDisConnect, routeSetting.RouteDisConnect)
.ValueP(RouteSetting._RouteMethod, routeSetting.RouteMethod)
.ToExec();
if (delCache.IsNull())
{
return(obj == 1);
}
Cache2.Remove("TH.Mailer.RouteSettingCache_", delCache);
return(obj == 1);
}
