public List <User> GetUserListForPlatformId(int id)
{
User user = new User()
{
PlatformId = id
};
return(OQL.From(user).Select().Where(user.PlatformId).END.ToList <User>());
}
public User GetLastLoginUser()
{
User user = new User()
{
RecentLogin = true
};
return(OQL.From(user).Select().Where(user.RecentLogin).END.ToEntity <User>());
}
/// <summary>
/// 获取列表（全部）
/// </summary>
/// <param name="pageIndex"></param>
/// <param name="pageSize"></param>
/// <returns></returns>
public List<BankAccountModel> GetAllModelList()
{
BankAccountModel model = new BankAccountModel();
OQL q = OQL.From(model)
.Select()
.OrderBy(model.ID, "asc")
.END;
return q.ToList<BankAccountModel>();//使用OQL扩展
}
static void TestDynamicEntity()
{
ITable_User user = EntityBuilder.CreateEntity <ITable_User>();
//如果接口的名称不是"ITableName" 这样的格式，那么需要调用 MapNewTableName方法指定
//((EntityBase)user).MapNewTableName("Table_User");
OQL qUser = OQL.From((EntityBase)user).Select(user.UID, user.Name, user.Sex).END;
List <ITable_User> users = EntityQuery.QueryList <ITable_User>(qUser, MyDB.Instance);
}
/// <summary>
/// 查询列表
/// </summary>
/// <param name="sqlWhere"></param>
/// <param name="pageSize"></param>
/// <param name="pageCurrent"></param>
/// <param name="listCount"></param>
/// <param name="orderBy"></param>
/// <returns></returns>
public List <FgSys_BaseConfig> GetBaseConfigList(Dictionary <string, string> sqlWhere, int pageSize, int pageCurrent, ref int listCount, string[] orderBy)
{
try
{
FgSys_BaseConfig entity = new FgSys_BaseConfig();
OQLCompareFunc <FgSys_BaseConfig> cmpFun = (cmp, u) =>
{
OQLCompare cmpResult = null;
if (sqlWhere.Keys.Contains("NodeCode") && !string.IsNullOrEmpty(sqlWhere["NodeCode"]))
{
cmpResult = cmpResult & cmp.Comparer(entity.NodeCode, OQLCompare.CompareType.Like, "%" + sqlWhere["NodeCode"] + "%");
}
if (sqlWhere.Keys.Contains("NodeDomain") && !string.IsNullOrEmpty(sqlWhere["NodeDomain"]))
{
cmpResult = cmpResult & cmp.Comparer(entity.NodeDomain, OQLCompare.CompareType.Like, "%" + sqlWhere["NodeDomain"] + "%");
}
return(cmpResult);
};
OQL query;
if (orderBy != null)
{
query = OQL.From(entity).Select().Where(cmpFun).OrderBy(orderBy).END;
}
else
{
query = OQL.From(entity).Select().Where(cmpFun).OrderBy(new string[1] {
"NodeCode asc"
}).END;
}
if (pageSize != 0 && pageCurrent != 0)
{
//查询总条数
OQL qCount = OQL.From(entity).Select().Count(entity.NodeCode, "").Where(cmpFun).END;
listCount = Convert.ToInt32(EntityQuery <FgSys_BaseConfig> .QueryObject(qCount, db_dataReportWJW).NodeCode);//总条数
//构造分页
query.Limit(pageSize, pageCurrent);//分页大小，第几页
query.PageWithAllRecordCount = listCount;
}
//OQL query = OQL.From(entity).Select().END;
List <FgSys_BaseConfig> list = EntityQuery <FgSys_BaseConfig> .QueryList(query, db_dataReportWJW);
return(list);
}
catch (Exception err)
{
throw err;
}
}
/// <summary>
/// 根据id获取实体对象
/// </summary>
/// <param name="ID">对象id</param>
/// <returns></returns>
public static T GetModel <T>(int ID, bool IsUseCache = false) where T : EntityBase, ILongID, new()
{
T model = new T();
model.ID = ID;
//UpdateCacheEventSource es = new UpdateCacheEventSource();
//model.Subscribe(es);
//es.RaiseEvent("GetModel");
if (RedisHelper.IsUseCache && IsUseCache && (model is ICacheEvent))
{
MemoryCache mc = MemoryCache.Default;
ICacheEvent im = model as ICacheEvent;
string rule = im.GetCacheKeyRule();
string key = string.Format(rule, model.GetIdentityName(), model.ID);
CacheItemPolicy cip = new CacheItemPolicy();
cip.AbsoluteExpiration = DateTimeOffset.Now.AddHours(6);
var cache = mc.Get(key);
if (cache != null)
{
model = cache as T;
}
else
{
model = RedisHelper.GetStringKey <T>(key);
if (model == null)
{
model = OQL.FromObject <T>().Select().Where((cmp, m) => cmp.Comparer(m.ID, "=", ID)).END.ToObject();
if (model != null)
{
RedisHelper.SetStringKey <T>(key, model, DateTime.Now.AddDays(7) - DateTime.Now);
}
}
if (model != null)
{
//更新本地缓存
mc.Set(key, model, cip);
}
}
}
else
{
model = OQL.FromObject <T>().Select().Where((cmp, m) => cmp.Comparer(m.ID, "=", ID)).END.ToObject();
}
return(model);
}
/// <summary>
/// 导出实体数据到内存数据库。如果当前实体操作失败，请检查导出事件的异常参数对象。
/// </summary>
/// <param name="funQ">获取导出数据的查询表达式委托方法，委托方法的参数为导出批次号；如果结果为空，导出实体全部数据</param>
/// <param name="initBatchNumber">要初始化导出批次号的函数</param>
public void Export(Func <int, T, OQL> funQ, Func <T, int> initBatchNumber)
{
Type entityType = typeof(T);
try
{
//导出批次管理
string exportTableName = EntityFieldsCache.Item(entityType).TableName;
List <ExportBatchInfo> batchList = MemDB.Get <ExportBatchInfo>();
ExportBatchInfo currBatch = batchList.FirstOrDefault(p => p.ExportTableName == exportTableName);
if (currBatch == null)
{
currBatch = new ExportBatchInfo();
currBatch.BatchNumber = initBatchNumber == null?1: initBatchNumber(new T());
currBatch.ExportTableName = exportTableName;
currBatch.LastExportDate = DateTime.Now;
// batchList.Add(currBatch);
MemDB.Add(currBatch);
}
else
{
currBatch.BatchNumber += 1;
currBatch.LastExportDate = DateTime.Now;
}
MemDB.Save <ExportBatchInfo>();
//导出数据
OQL q = funQ(currBatch.BatchNumber, new T());
List <T> entityList = q != null?CurrDbContext.QueryList <T>(q) : CurrDbContext.QueryAllList <T>();
ExportEntityEventArgs <T> args = new ExportEntityEventArgs <T>(entityList, entityType, exportTableName);
args.Succeed = true;
args.OperationExcepiton = null;
args.BatchNumber = currBatch.BatchNumber;
if (OnExported != null)
{
OnExported(this, args);
}
if (!args.Cancel)
{
SaveEntity(entityList.ToArray(), args);
}
}
catch (Exception ex)
{
ExportEntityEventArgs <T> args = new ExportEntityEventArgs <T>(null, entityType, EntityFieldsCache.Item(entityType).TableName);
args.Succeed = false;
args.OperationExcepiton = ex;
if (OnExported != null)
{
OnExported(this, args);
}
}
}
public User GetUserForName(string userName, int platflormId)
{
User user = new User()
{
UserName = userName,
PlatformId = platflormId
};
return(OQL.From(user).Select().Where(user.UserName, user.PlatformId).END.ToEntity <User>());
}
internal static bool GetPassword(IDataAccess dataAccess, int userId, out byte[] password, out byte[] passwordSalt, out bool isApproved, out bool isSuspended)
{
var entity = new UserEntity();
var oql = new OQL(entity);
var comparer = new Comparer(oql);
comparer = comparer.Compare(entity.UserId, "=", userId);
return GetPasswordCore(dataAccess, comparer, entity, out password, out passwordSalt, out isApproved, out isSuspended) != 0;
}
/// <summary>
/// 获取列表（全部）
/// </summary>
/// <param name="pageIndex"></param>
/// <param name="pageSize"></param>
/// <returns></returns>
public List <TenantModel> GetAllModelList()
{
TenantModel model = new TenantModel();
OQL q = OQL.From(model)
.Select()
.OrderBy(model.ID, "asc")
.END;
return(q.ToList <TenantModel>());//使用OQL扩展
}
/// <summary>
/// 使用用户对象来登录，OQL最简单最常见的使用方式
/// </summary>
/// <param name="user"></param>
/// <returns></returns>
public bool Login(User user)
{
OQL q = OQL.From(user)
.Select()
.Where(user.Name, user.Pwd) //以用户名和密码来验证登录
.END;
User dbUser =q.ToEntity<User>();//ToEntity，OQL扩展方法
return dbUser != null; //查询到用户实体类，表示登录成功
}
/// <summary>
/// 获取联系人信息记录数量
/// </summary>
/// <returns></returns>
public int GetContactInfoCount()
{
CustomerContactInfo info = new CustomerContactInfo();
OQL q = OQL.From(info)
.Select()
.Count(info.CustomerID, "tempField").END;
CustomerContactInfo infoCount = EntityQuery <CustomerContactInfo> .QueryObject(q);
return(Convert.ToInt32(infoCount.PropertyList("tempField")));
}
internal static int? GetPassword(IDataAccess dataAccess, string identity, string @namespace, out byte[] password, out byte[] passwordSalt, out bool isApproved, out bool isSuspended)
{
var entity = new UserEntity();
var oql = new OQL(entity);
var comparer = new Comparer(oql);
comparer = GetUserIdentityComparer(identity, @namespace, comparer, entity);
return GetPasswordCore(dataAccess, comparer, entity, out password, out passwordSalt, out isApproved, out isSuspended);
}
/// <summary>
/// 获取管理员列表（全部）
/// </summary>
/// <param name="pageIndex"></param>
/// <param name="pageSize"></param>
/// <returns></returns>
public List <CustomTypeModel> GetAllModelList()
{
CustomTypeModel model = new CustomTypeModel();
OQL q = OQL.From(model)
.Select()
.OrderBy(model.ID, "asc")
.END;
return(q.ToList <CustomTypeModel>());//使用OQL扩展
}
/// <summary>
/// 获取列表（全部）
/// </summary>
/// <param name="pageIndex"></param>
/// <param name="pageSize"></param>
/// <returns></returns>
public List <ContractModel> GetAllModelList()
{
ContractModel model = new ContractModel();
OQL q = OQL.From(model)
.Select()
.OrderBy(model.ID, "asc")
.END;
return(q.ToList <ContractModel>());
}
/// <summary>
/// 使用用户对象来登录，但是使用 OQLCompare 对象的 EqualValue 相等比较方式
/// </summary>
/// <param name="user"></param>
/// <returns></returns>
public bool Login1(User user)
{
OQL q = OQL.From(user)
.Select(user.ID) //仅查询一个属性字段 ID
.Where(cmp => cmp.EqualValue(user.Name) & cmp.EqualValue(user.Pwd))
.END;
User dbUser = EntityQuery<User>.QueryObject(q);
return dbUser != null; //查询到用户实体类，表示登录成功
}
/// <summary>
/// 获取列表（全部）
/// </summary>
/// <param name="pageIndex"></param>
/// <param name="pageSize"></param>
/// <returns></returns>
public List <AdminAction> GetAllModelList()
{
AdminAction model = new AdminAction();
OQL q = OQL.From(model)
.Select()
.OrderBy(model.ID, "asc")
.END;
return(q.ToList <AdminAction>());//使用OQL扩展
}
/// <summary>
/// 获取列表（全部）
/// </summary>
/// <param name="pageIndex"></param>
/// <param name="pageSize"></param>
/// <returns></returns>
public List <CustomFinancialModel> GetAllModelList()
{
CustomFinancialModel model = new CustomFinancialModel();
OQL q = OQL.From(model)
.Select()
.OrderBy(model.ID, "desc")
.END;
return(q.ToList <CustomFinancialModel>());
}
public static int GetCount()
{
V_UserModels model = new V_UserModels();
OQL q = new OQL(model);
model = EntityQuery <V_UserModels> .QueryObject(q.Select().Count(model.C_USER_INFO_ID, "count").END);
int count = model.getProperty <int>("count");
return(count);
}
/// <summary>
/// 获取列表（全部）
/// </summary>
/// <param name="pageIndex"></param>
/// <param name="pageSize"></param>
/// <returns></returns>
public List <ChargeCardsModel> GetAllModelList()
{
ChargeCardsModel model = new ChargeCardsModel();
OQL q = OQL.From(model)
.Select()
.OrderBy(model.Sort, "desc")
.OrderBy(model.ID, "asc")
.END;
return(q.ToList <ChargeCardsModel>());//使用OQL扩展
}
/// <summary>
/// 获取管理员列表（全部）
/// </summary>
/// <param name="pageIndex"></param>
/// <param name="pageSize"></param>
/// <returns></returns>
public List <TicketTypeModel> GetAllModelList()
{
TicketTypeModel model = new TicketTypeModel();
OQL q = OQL.From(model)
.Select()
.OrderBy(model.Sort, "desc")
.OrderBy(model.ID, "asc")
.END;
return(q.ToList <TicketTypeModel>());//使用OQL扩展
}
/// <summary>
/// 使用用户名密码参数来登录，使用泛型OQL查询（GOQL），对于单实体类查询最简单的使用方式。
/// </summary>
/// <param name="name"></param>
/// <param name="pwd"></param>
/// <returns></returns>
public bool Login5(string name, string pwd)
{
User dbUser = OQL.From <User>()
.Select()
.Where((cmp, user) => cmp.Property(user.Name) == name
& cmp.Property(user.Pwd) == pwd)
.END
.ToObject();
return(dbUser != null); //查询到用户实体类，表示登录成功
}
/// <summary>
/// 使用用户名密码参数来登录，使用早期的实例化OQL对象的方式，并使用OQLConditon 对象为查询条件
/// </summary>
/// <param name="name"></param>
/// <param name="pwd"></param>
/// <returns></returns>
public bool Login3(string name, string pwd)
{
User user = new User();
OQL q = new OQL(user);
q.Select(user.ID).Where(q.Condition.AND(user.Name, "=", name).AND(user.Pwd, "=", pwd));
User dbUser = EntityQuery <User> .QueryObject(q);
return(dbUser != null); //查询到用户实体类，表示登录成功
}
/// <summary>
/// 获取管理员列表（全部）
/// </summary>
/// <param name="pageIndex"></param>
/// <param name="pageSize"></param>
/// <returns></returns>
public List <CustomAccReceiptEntryModel> GetAllModelList()
{
JsonRsp <CustomAccReceiptEntryViewModel> rsp = new JsonRsp <CustomAccReceiptEntryViewModel>();
CustomAccReceiptEntryModel model = new CustomAccReceiptEntryModel();
OQL q = OQL.From(model)
.Select()
.OrderBy(model.ID, "desc")
.END;
return(q.ToList <CustomAccReceiptEntryModel>());
}
void TestOqlPage()
{
UserEntity ue = new UserEntity();
OQL q = OQL.From(ue)
.Select(ue.ID, ue.Name, ue.Age)
.Where(cmp => cmp.Comparer(ue.Age, ">", 20))
.OrderBy(ue.Age)
.END;
q.Limit(2, 3, true);
Console.WriteLine("q:Page SQL is \r\n{0}", q);
Console.WriteLine(q.PrintParameterInfo());
//当前测试总记录数5，查询后，OQL会得到总记录数
AdoHelper db = MyDB.GetDBHelperByConnectionName("conn2");
var list = EntityQuery <UserEntity> .QueryList(q, db);
Users user = new Users()
{
NickName = "pdf.net", RoleID = RoleNames.Admin, Age = 20
};
UserRoles roles = new UserRoles()
{
RoleName = "role1"
};
//测试字段直接比较
OQL q00 = OQL.From(user)
.Select(user.ID, user.NickName, user.LastLoginIP)
.Where(cmp => cmp.Comparer(user.AddTime, "=", user.LastLoginTime))
.OrderBy(o => o.Desc(user.LastLoginTime))
.END;
Console.WriteLine("q00:one table and select all fields \r\n{0}", q00);
Console.WriteLine(q00.PrintParameterInfo());
string pageSql = SQLPage.MakeSQLStringByPage(DBMSType.SqlServer, q00.ToString(), "", 10, 2, 999);
Console.WriteLine("Page SQL");
Console.WriteLine(pageSql);
OQL q2 = OQL.From(user)
.InnerJoin(roles).On(user.RoleID, roles.ID)
.Select(user.RoleID, roles.RoleName)
.Where(user.NickName, roles.RoleName)
.GroupBy(user.RoleID, roles.RoleName)
.OrderBy(user.ID)
.END;
Console.WriteLine("q2:two table query use join\r\n{0}", q2);
Console.WriteLine(q2.PrintParameterInfo());
pageSql = SQLPage.MakeSQLStringByPage(DBMSType.SqlServer, q2.ToString(), "", 10, 2, 999);
Console.WriteLine("Page SQL");
Console.WriteLine(pageSql);
}
/// <summary>
/// 获取指定页的联系人信息
/// </summary>
/// <param name="pageSize"></param>
/// <param name="pageNumber"></param>
/// <param name="allCount"></param>
/// <returns></returns>
public List <CustomerContactInfo> GetContactInfoList(int pageSize, int pageNumber, int allCount)
{
CustomerContactInfo info = new CustomerContactInfo();
OQL q = new OQL(info);
q.Select().OrderBy(info.CustomerName, "asc");
q.Limit(pageSize, pageNumber);
q.PageWithAllRecordCount = allCount;
return(EntityQuery <CustomerContactInfo> .QueryList(q));
}
/// <summary>
/// 获取列表（分页）
/// </summary>
/// <param name="pageIndex"></param>
/// <param name="pageSize"></param>
/// <returns></returns>
public JsonRsp <ChargeCardViewModel> GetPageList(int pageIndex, int pageSize, bool limit = true)
{
JsonRsp <ChargeCardViewModel> rsp = new JsonRsp <ChargeCardViewModel>();
ChargeCardsModel c = new ChargeCardsModel();
CustomModel custom = new CustomModel();
TicketTypeModel t = new TicketTypeModel();
OQL joinQ = OQL.From(c)
.Join(custom).On(c.CustomId, custom.ID)
.LeftJoin(t).On(c.TicketTypeID, t.ID)
.Select()
.OrderBy(c.Sort, "desc")
.END;
//分页
if (limit)
{
joinQ.Limit(pageSize, pageIndex, true);
}
PWMIS.DataProvider.Data.AdoHelper db = PWMIS.DataProvider.Adapter.MyDB.GetDBHelper();
EntityContainer ec = new EntityContainer(joinQ, db);
rsp.data = (List <ChargeCardViewModel>)ec.MapToList <ChargeCardViewModel>(() => new ChargeCardViewModel()
{
ID = c.ID,
CustomId = c.CustomId,
CustomName = custom.CustomName,
TicketTypeID = c.TicketTypeID,
TicketTypeName = t.TicketTypeName,
MoneyType = c.MoneyType,
CurrentCount = c.CurrentCount,
FaceAmount = c.FaceAmount,
CurrentAmount = c.CurrentAmount,
ExpireDate = c.ExpireDate,
TicketBatchId = c.TicketBatchId,
TicketStart = c.TicketStart,
TicketEnd = c.TicketEnd,
Consumptionlevel = c.Consumptionlevel,
IsCommonCard = c.IsCommonCard,
Sort = c.Sort,
CreateId = c.CreateId,
CreateUser = c.CreateUser,
CreateIP = c.CreateIP,
CreateTime = c.CreateTime,
UpdateBy = c.UpdateUser,
UpdateIP = c.UpdateIP,
UpdateTime = c.UpdateTime,
});
rsp.success = true;
rsp.code = 0;
rsp.count = joinQ.PageWithAllRecordCount;
return(rsp);
}
public int GetAllGoodsBaseInfoCount()
{
GoodsBaseInfo info = new GoodsBaseInfo();
OQL q = new OQL(info);
q.Select()
.Count(info.SerialNumber, "Count");
GoodsBaseInfo infoCount = EntityQuery <GoodsBaseInfo> .QueryObject(q);
return(Convert.ToInt32(infoCount.PropertyList("Count")));
}
/// <summary>
/// 测试实体类的外键查询
/// </summary>
static void TestEntityFK()
{
LT_UserRoles roles = new LT_UserRoles()
{
RoleName = "admin"
};
OQL q = OQL.From(roles)
.Select()
.Where(roles.RoleName)
.END;
var list = EntityQuery <LT_UserRoles> .QueryListWithChild(q, MyDB.Instance);
}
///// <summary>
///// 根据EntityMapSql的全名称 "名称空间名字.SQL名字" 获取映射的SQL语句
///// </summary>
///// <param name="fullName">EntityMapSql的全名称，格式： "名称空间名字.SQL名字"</param>
///// <returns>映射的SQL语句</returns>
//public static string GetMapSql(string fullName)
//{
//}
/// <summary>
/// 执行返回单值的查询，通常用于OQL的Count,Max等查询
/// </summary>
/// <param name="oql">查询表达式</param>
/// <param name="db">数据访问对象</param>
/// <returns>单值</returns>
public static object ExecuteScalar(OQL oql, AdoHelper db)
{
if (oql.Parameters != null && oql.Parameters.Count > 0)
{
IDataParameter[] paras = GetParameters(oql.Parameters, db);
return(db.ExecuteScalar(oql.ToString(), CommandType.Text, paras));
}
else
{
return(db.ExecuteScalar(oql.ToString()));
}
}
public List <GoodsBaseInfoVM> GetGoodsBaseInfoList(int pageSize, int pageNumber, int allCount)
{
GoodsBaseInfo info = new GoodsBaseInfo();
OQL q = new OQL(info);
q.Select()
.OrderBy(info.SerialNumber, "asc");
q.Limit(pageSize, pageNumber);
q.PageWithAllRecordCount = allCount;
return(GetGoodsBaseInfoList(q));
}
/// <summary>
/// 获取指定商品名称下面的商品信息
/// </summary>
/// <param name="goodsName">商品名称</param>
/// <returns></returns>
public List <GoodsBaseInfoVM> GetGoodsBaseInfoWhithGoodsName(string goodsName)
{
GoodsBaseInfo info = new GoodsBaseInfo();
info.GoodsName = goodsName;
OQL q = new OQL(info);
q.Select(info.SerialNumber, info.GoodsName, info.Manufacturer, info.CanUserMonth)
.Where(info.GoodsName)
.OrderBy(info.GoodsName, "asc");
return(GetGoodsBaseInfoList(q));
}
public string[] GetPasswordQuestions(string identity, string @namespace)
{
var entity = new UserEntity();
var oql = new OQL(entity);
var comparer = new Comparer(oql);
var dataAccess = this.EnsureService<IDataAccess>();
comparer = Utility.GetUserIdentityComparer(identity, @namespace, comparer, entity);
oql = OQL.From(entity)
.Select(entity.UserId, entity.PasswordQuestion1, entity.PasswordQuestion2, entity.PasswordQuestion3)
.Where(comparer)
.End();
entity = dataAccess.Find<UserEntity>(oql);
if(entity == null)
return null;
var result = new string[]
{
entity.PasswordQuestion1,
entity.PasswordQuestion2,
entity.PasswordQuestion3,
};
return result;
}
public bool ResetPassword(string identity, string @namespace, string[] passwordAnswers, string newPassword = null)
{
if(string.IsNullOrWhiteSpace(identity) || passwordAnswers == null || passwordAnswers.Length < 3)
return false;
var entity = new UserEntity();
var oql = new OQL(entity);
var comparer = new Comparer(oql);
var dataAccess = this.EnsureService<IDataAccess>();
comparer = Utility.GetUserIdentityComparer(identity, @namespace, comparer, entity);
oql = comparer.OQL
.Select(entity.UserId, entity.PasswordAnswer1, entity.PasswordAnswer2, entity.PasswordAnswer3)
.Where(comparer)
.End();
entity = dataAccess.Find<UserEntity>(oql);
if(entity == null)
return false;
var userId = entity.UserId;
var succeed = PasswordUtility.VerifyPassword(passwordAnswers[0], entity.PasswordAnswer1, this.GetPasswordAnswerSalt(userId, 1)) &&
PasswordUtility.VerifyPassword(passwordAnswers[1], entity.PasswordAnswer2, this.GetPasswordAnswerSalt(userId, 2)) &&
PasswordUtility.VerifyPassword(passwordAnswers[2], entity.PasswordAnswer3, this.GetPasswordAnswerSalt(userId, 3));
if(succeed && newPassword != null && newPassword.Length > 0)
{
//重新生成密码随机数
var passwordSalt = Zongsoft.Common.RandomGenerator.Generate(8);
entity = new UserEntity
{
Password = PasswordUtility.HashPassword(newPassword, passwordSalt),
PasswordSalt = passwordSalt
};
// 更新密码
oql = OQL.From(entity)
.Update(entity.Password, entity.PasswordSalt)
.Where(p => p.Compare(entity.UserId, CompareOperator.Equal, userId))
.End();
return dataAccess.Execute(oql) > 0;
}
return succeed;
}
public User GetUser(string identity, string @namespace)
{
var entity = new UserEntity();
var oql = new OQL(entity);
var comparer = new Comparer(oql);
var dataAccess = this.EnsureService<IDataAccess>();
comparer = Utility.GetUserIdentityComparer(identity, @namespace, comparer, entity);
entity = dataAccess.Find<UserEntity>(oql.Select().Where(comparer).End());
return Mapper.Map<UserEntity, User>(entity);
}
public bool HasPassword(string identity, string @namespace)
{
var entity = new UserEntity();
var oql = new OQL(entity);
var comparer = new Comparer(oql);
var dataAccess = this.EnsureService<IDataAccess>();
comparer = Utility.GetUserIdentityComparer(identity, @namespace, comparer, entity);
comparer = comparer & comparer.IsNotNull(entity.Password);
oql.Select(entity.UserId)
.Where(comparer)
.OrderBy(p => p.Desc(entity.UserId))
.End();
return dataAccess.Exists(oql);
}
public bool HasPassword(int userId)
{
var entity = new UserEntity();
var oql = new OQL(entity);
var dataAccess = this.EnsureService<IDataAccess>();
oql.Select(entity.UserId)
.Where(oql.Condition.And(entity.Password, "IS", "NOT NULL"))
.OrderBy(p => p.Desc(entity.UserId))
.End();
return dataAccess.Exists(oql);
}
public static bool GetUserId(IDataAccess dataAccess, string identity, string @namespace, out int userId)
{
if(dataAccess == null)
throw new ArgumentNullException("dataAccess");
if(string.IsNullOrWhiteSpace(identity))
throw new ArgumentNullException("identity");
var entity = new UserEntity();
var oql = new OQL(entity);
var comparer = new Comparer(oql);
comparer = GetUserIdentityComparer(identity, @namespace, comparer, entity);
oql = oql.Select(entity.UserId)
.Where(comparer)
.End();
entity = dataAccess.Find<UserEntity>(oql);
var result = entity != null && entity.UserId > 0;
userId = 0;
if(result)
userId = entity.UserId;
return result;
}
public bool Exists(string identity, string @namespace)
{
if(string.IsNullOrWhiteSpace(identity))
return false;
var entity = new UserEntity();
var oql = new OQL(entity);
var comparer = new Comparer(oql);
var dataAccess = this.EnsureService<IDataAccess>();
Utility.UserIdentityType identityType;
comparer = Utility.GetUserIdentityComparer(identity, @namespace, comparer, entity, out identityType);
// 确保用户名是审核通过的
if(identityType == Utility.UserIdentityType.Name)
this.Censor(identity);
oql.Select(entity.UserId)
.Where(comparer)
.OrderBy(p => p.Desc(entity.UserId))
.End();
return dataAccess.Exists(oql);
}
