/// <summary>
/// 获取父级列表
/// </summary>
/// <param name="dictId"></param>
/// <param name="withSelf"></param>
/// <returns></returns>
public List <DataDict> GetParentList(int dictType, long dictId, bool withSelf)
{
var list = new List <DataDict>();
if (dictId == 0)
{
return(list);
}
var self = _dataDictDao.SingleWhere(DictBuilder.Assign("DictType", dictType).Assign("DictId", dictId));
if (withSelf)
{
list.Add(self);
}
var cur = self;
while (cur.ParentId != 0)
{
var par = _dataDictDao.SingleWhere(DictBuilder.Assign("DictType", dictType)
.Assign("DictId", cur.ParentId));
list.Add(par);
cur = par;
}
list.Reverse();
return(list);
}
public UCAddDictionary()
{
InitializeComponent();
dictBuilder = DictBuilder.dictBuilder();
cmbLanguage.Items.AddRange(Dictionary.languages.ToArray());
cmbLanguage.SelectedItem = Dictionary.languages[0];
}
public void CompressionImprovesWithDictionary()
{
var trainingData = new byte[100][];
for (int i = 0; i < trainingData.Length; i++)
{
trainingData[i] = DataGenerator.GetSmallBuffer(DataFill.Random);
}
var dict = DictBuilder.TrainFromBuffer(trainingData);
var compressionOptions = new CompressionOptions(dict);
var testStream = DataGenerator.GetSmallStream(DataFill.Random);
var normalResultStream = new MemoryStream();
using (var compressionStream = new CompressorStream(normalResultStream))
testStream.CopyTo(compressionStream);
var dictResultStream = new MemoryStream();
using (var compressionStream = new CompressorStream(dictResultStream, compressionOptions))
testStream.CopyTo(compressionStream);
Assert.Greater(normalResultStream.Length, dictResultStream.Length);
}
public OrmLitePageResult <Announcement> SelectList(string title, int pageIndex, int pageSize)
{
StringBuilder sb = new StringBuilder();
var ps = DictBuilder.New();
sb.Append("1=1");
var orderBy = "id desc";
title = SqlInjection.Filter(title);
if (!string.IsNullOrEmpty(title))
{
sb.AppendFormat(" and Title like '%{0}%'", title);
}
var factor = new OrmLitePageFactor
{
Conditions = sb.ToString(),
PageIndex = pageIndex,
PageSize = pageSize,
OrderBy = orderBy,
Params = ps
};
return(announcementDao.SelectPage(factor));
}
public CountLimit SingleByUniqueId(string uniqueId)
{
using (var db = Open())
{
return(db.SingleWhere <CountLimit>(DictBuilder.Assign("UniqueId", uniqueId)));
}
}
/// <summary>
/// 列表重新排序，支持三级，用于select的option
/// </summary>
/// <param name="dictType"></param>
/// <returns></returns>
public List <DataDict> GetTreeList(int dictType)
{
var dataDictList = _dataDictDao.SelectWhere(DictBuilder
.Assign("DictType", dictType), "OrderNum asc,id");
List <DataDict> newList = new List <DataDict>();
foreach (var item0 in dataDictList.Where(x => x.ParentId == 0))
{
item0.igLevel = 0;
newList.Add(item0);
foreach (var item1 in dataDictList.Where(x => x.ParentId == item0.DictId))
{
item1.igLevel = 1;
newList.Add(item1);
foreach (var item2 in dataDictList.Where(x => x.ParentId == item1.DictId))
{
item2.igLevel = 2;
newList.Add(item2);
}
}
}
return(newList);
}
/// <summary>
/// 收到通知，设置状态，成功锁死
/// </summary>
/// <param name="id"></param>
/// <param name="payStatus"></param>
/// <param name="payTime"></param>
/// <returns></returns>
public int SetPay(long id, int payStatus, DateTime payTime)
{
return(_payOrderDao.UpdateWhere(
DictBuilder
.Assign("PayStatus", payStatus)
.Assign("PayTime", payTime),
DictBuilder.Assign("Id", id).NEQ("PayStatus", 2)));
}
public int ResetOne(long id, DateTime beginTime)
{
using (var db = Open())
{
return(db.UpdateById <CountLimit>(DictBuilder.Assign("AlreadyCount", 1).Assign("BeginTime", beginTime),
id));
}
}
public int RetryUpdate(DelayTask task)
{
using (var db = Open())
{
var flag = db.Update <DelayTask>(DictBuilder
.Assign("TriggerTime", task.TriggerTime)
.Assign("$ExecCount", "ExecCount+1"), "Id=" + task.Id, null);
return(flag);
}
}
private static byte[] TrainDict()
{
var trainingData = new byte[100][];
for (int i = 0; i < trainingData.Length; i++)
{
trainingData[i] = DataGenerator.GetSmallBuffer(DataFill.Sequential);
}
return(DictBuilder.TrainFromBuffer(trainingData));
}
public T SingleTrigger <T>(string schedName, string triggerName, string triggerGroup)
where T : QRTZ_TRIGGERKEY
{
using var db = Open();
return(db.SingleWhere <T>(DictBuilder
.Assign("SCHED_NAME", schedName)
.Assign("TRIGGER_NAME", triggerName)
.Assign("TRIGGER_GROUP", triggerGroup)
));
}
public int ExecuteOne(TimedTask task)
{
using (var db = Open())
{
return(db.UpdateById <TimedTask>(
DictBuilder.Assign("LastExecTime", task.LastExecTime)
.Assign("LastStatus", task.LastStatus)
.Assign("$ExecCount", "ExecCount+1"), task.Id));
}
}
public List <DataDict> GetList(int dictType, int?parentId)
{
var dict = DictBuilder
.Assign("DictType", dictType);
if (parentId != null)
{
dict.Assign("ParentId", parentId);
}
return(_dataDictDao.SelectWhere(dict, "OrderNum asc,Id desc"));
}
public void TrainDictionaryParallel()
{
var buffer = Enumerable.Range(0, 100000).Select(i => unchecked ((byte)(i * i))).ToArray();
var samples = Enumerable.Range(0, 100)
.Select(i => buffer.Skip(i).Take(200 - i).ToArray())
.ToArray();
var dict = DictBuilder.TrainFromBuffer(samples);
Assert.Greater(dict.Length, 0);
Assert.LessOrEqual(dict.Length, DictBuilder.DefaultDictCapacity);
Enumerable.Range(0, 100000)
.AsParallel().WithDegreeOfParallelism(Environment.ProcessorCount * 4)
.ForAll(_ => Assert.IsTrue(dict.SequenceEqual(DictBuilder.TrainFromBuffer(samples))));
}
public OrmLitePageResult <Ad> SelectList(string title, int?adTypeId, DateTime?start, DateTime?end,
int pageIndex, int pageSize)
{
StringBuilder sb = new StringBuilder();
var ps = DictBuilder.New();
sb.Append("1=1");
var orderBy = "id desc";
title = SqlInjection.Filter(title);
if (!string.IsNullOrEmpty(title))
{
sb.AppendFormat(" and Title like '%{0}%'", title);
}
if (adTypeId > 0)
{
orderBy = "OrderNum";
sb.AppendFormat(" and TypeId={0}", adTypeId);
}
if (start.HasValue)
{
sb.AppendFormat(" and EndTime>@start");
ps.EQ("start", start.Value);
}
if (end.HasValue)
{
sb.Append(" and EndTime<@end");
ps.EQ("end", end.Value.AddDays(1));
}
var factor = new OrmLitePageFactor
{
Conditions = sb.ToString(),
PageIndex = pageIndex,
PageSize = pageSize,
OrderBy = orderBy,
Params = ps
};
return(_adDao.SelectPage(factor));
}
public static int UpdateStatus(DrawBonus m)
{
if (m.Replay.Length > 200)
{
m.Replay = m.Replay.Substring(0, 200);
}
m.ModifyDate = DateTime.Now;
using (var db = Open())
{
return(db.UpdateById <DrawBonus>(DictBuilder
.Assign("IsCheck", m.IsCheck)
.Assign("Replay", m.Replay)
.Assign("ModifyDate", m.ModifyDate), m.Id));
}
}
public OrmLitePageResult <QRTZ_TRIGGERS> SelectPage(string sched, string name, string group, string state,
string type,
int pageIndex, int pageSize)
{
StringBuilder sb = new StringBuilder("SCHED_NAME=@sched");
var ps = DictBuilder.Assign("sched", sched);
if (!string.IsNullOrEmpty(name))
{
sb.AppendFormat(" and TRIGGER_NAME=@name");
ps.Assign("name", name);
}
if (!string.IsNullOrEmpty(group))
{
sb.AppendFormat(" and TRIGGER_GROUP=@group");
ps.Assign("group", group);
}
if (!string.IsNullOrEmpty(state))
{
sb.AppendFormat(" and TRIGGER_STATE=@state");
ps.Assign("state", state);
}
if (!string.IsNullOrEmpty(type))
{
sb.AppendFormat(" and TRIGGER_TYPE=@type");
ps.Assign("type", type);
}
return(qrtzTriggersDao.SelectPage(new OrmLitePageFactor
{
PageIndex = pageIndex,
PageSize = pageSize,
Conditions = sb.ToString(),
Params = ps,
OrderBy = "SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP"
}));
}
private static byte[] BuildDictionary() => DictBuilder.TrainFromBuffer(Enumerable.Range(0, 8).Select(_ => GenerateSample()).ToArray(), 1024);
public List <Region> GetCounty(int cityCode)
{
return(regionDao.SelectWhere(DictBuilder.GT("Code", cityCode).LT("Code", cityCode + 100).EQ("Level", 3)));
}
public List <Region> GetCity(int provinceCode)
{
return(regionDao.SelectWhere(DictBuilder.GT("Code", provinceCode).LT("Code", provinceCode + 10000).EQ("Level", 2)));
}
public SystemUser Login(string username, string password)
{
return(SingleWhere(DictBuilder.Assign("username", username).Assign("password", password)));
}
public bool ExistsUsername(string username)
{
var count = CountWhere(DictBuilder.Assign("username", username));
return(count > 0);
}
public static DictBase Create(Type type) => DictBuilder.Ctor(type);
