/// <summary>
/// 插入实体记录
/// </summary>
/// <param name="entity"> 实体对象 </param>
/// <param name="isSave"> 是否执行保存 </param>
/// <returns> 操作影响的行数 </returns>
public virtual Int32 Insert(TEntity entity, bool isSave = true)
{
PublicHelper.CheckArgument(entity, "entity");
EFContext.RegisterNew <TEntity, TKey>(entity);
return(isSave ? EFContext.Commit() : 0);
}
/// <summary>
/// 删除实体记录集合
/// </summary>
/// <param name="entities"> 实体记录集合 </param>
/// <param name="isSave"> 是否执行保存 </param>
/// <returns> 操作影响的行数 </returns>
public virtual async Task <int> DeleteAsync(IEnumerable <TEntity> entities, bool isSave = true)
{
PublicHelper.CheckArgument(entities, "entities");
UnitOfWorkContext.RegisterDeleted(entities);
return(isSave ? await SaveAsync() : 0);
}
/// <summary>
/// 查找指定主键的实体记录
/// </summary>
/// <param name="key"> 指定主键 </param>
/// <returns> 符合编号的记录，不存在返回null </returns>
public virtual TEntity Query(object key)
{
PublicHelper.CheckArgument(key, "key");
return(UnitOfWorkContext.Set <TEntity>().Find(key));
}
public virtual OperationResult FindEntity(string key)
{
PublicHelper.CheckArgument(key, "solution");
return(solutionRepository.GetByKey(key));
}
/// <summary>
/// 更新实体记录
/// </summary>
/// <param name="entity"> 实体对象 </param>
/// <param name="isSave"> 是否执行保存 </param>
/// <returns> 操作影响的行数 </returns>
public virtual int Update(TEntity entity, bool isSave = true)
{
PublicHelper.CheckArgument(entity, "entity");
UnitOfWorkContext.RegisterModified(entity);
return(isSave ? Save() : 0);
}
/// <summary>
/// 更新实体记录
/// </summary>
/// <param name="entity"> 实体对象 </param>
/// <param name="isSave"> 是否执行保存 </param>
/// <returns> 操作影响的行数 </returns>
public virtual int Update(TEntity entity, bool isSave = true)
{
PublicHelper.CheckArgument(entity, "entity");
Context.Update <TEntity, TKey>(entity);
return(isSave ? Context.SaveChanges() : 0);
}
public virtual OperationResult FindEntity(string key)
{
PublicHelper.CheckArgument(key, "tsErrorCause2Com");
return(tsErrorCause2ComRepository.GetByKey(key));
}
/// <summary>
/// 查找指定主键的实体记录
/// </summary>
/// <param name="key"> 指定主键 </param>
/// <returns> 符合编号的记录，不存在返回null </returns>
public virtual TEntity SelectById(object key)
{
PublicHelper.CheckArgument(key, "key");
return(EfContext.Set <TEntity>().Find(key));
}
public void RemoveFromContext(TEntity entity)
{
PublicHelper.CheckArgument(entity, "entity");
EfContext.RegisterRemove(entity);
}
/// <summary>
/// 删除实体记录集合
/// </summary>
/// <param name="entities"> 实体记录集合 </param>
/// <param name="isSave"> 是否执行保存 </param>
/// <returns> 操作影响的行数 </returns>
public virtual int Delete(IEnumerable <TEntity> entities, bool isSave = true)
{
PublicHelper.CheckArgument(entities, "entities");
EFContext.RegisterDeleted <TEntity, TKey>(entities);
return(isSave ? EFContext.Commit() : 0);
}
/// <summary>
/// 更新实体记录
/// </summary>
/// <param name="entity"> 实体对象 </param>
/// <param name="isSave"> 是否执行保存 </param>
/// <returns> 操作影响的行数 </returns>
public virtual int Update(TEntity entity, bool isSave = true)
{
PublicHelper.CheckArgument(entity, "entity");
EfContext.RegisterModified <TEntity>(entity);
return(isSave ? EfContext.Commit() : 0);
}
/// <summary>
/// 删除实体记录
/// </summary>
/// <param name="entity"> 实体对象 </param>
/// <param name="isSave"> 是否执行保存 </param>
/// <returns> 操作影响的行数 </returns>
public virtual int Delete(TEntity entity, bool isSave = true)
{
PublicHelper.CheckArgument(entity, "entity");
EFContext.RegisterDeleted <TEntity, TKey>(entity);
return(isSave ? EFContext.Commit() : 0);
}
/// <summary>
/// 从数据库中批量刷新记录，放弃更改
/// </summary>
/// <param name="entities">要刷新的对象集合</param>
public void Refresh(IEnumerable <TEntity> entities)
{
PublicHelper.CheckArgument(entities, "entities");
EFContext.Refresh <TEntity, TKey>(entities);
}
/// <summary>
/// 从数据库中刷新一条记录，放弃更改
/// </summary>
/// <param name="entity">要刷新的对象</param>
public void Refresh(TEntity entity)
{
PublicHelper.CheckArgument(entity, "entity");
EFContext.Refresh <TEntity, TKey>(entity);
}
/// <summary>
/// 删除所有符合特定表达式的数据（EntityFramework.Extensions扩展））,用法详见https://github.com/loresoft/EntityFramework.Extended
/// </summary>
/// <param name="predicate"> 查询条件谓语表达式 </param>
/// <param name="isSave"> 是否执行保存 </param>
/// <returns> 操作影响的行数 </returns>
public virtual int Delete(Expression <Func <TEntity, bool> > predicate, bool isSave = true)
{
PublicHelper.CheckArgument(predicate, "predicate");
Context.Set <TEntity>().Where(predicate).Delete();
return(isSave ? Context.SaveChanges() : 0);
}
/// <summary>
/// 插入实体记录
/// </summary>
/// <param name="entity"> 实体对象 </param>
/// <param name="isSave"> 是否执行保存 </param>
/// <returns> 操作影响的行数 </returns>
public virtual int Insert(TEntity entity, bool isSave = true)
{
PublicHelper.CheckArgument(entity, "entity");
EfContext.RegisterNew(entity);
return(isSave ? EfContext.Commit() : 0);
}
/// <summary>
/// 删除实体记录
/// </summary>
/// <param name="entity"> 实体对象 </param>
/// <param name="isSave"> 是否执行保存 </param>
/// <returns> 操作影响的行数 </returns>
public virtual int Delete(TEntity entity, bool isSave = true)
{
PublicHelper.CheckArgument(entity, "entity");
Context.Entry(entity).State = EntityState.Deleted;
return(isSave ? Context.SaveChanges() : 0);
}
/// <summary>
/// 批量插入实体记录集合
/// </summary>
/// <param name="entities"> 实体记录集合 </param>
/// <param name="isSave"> 是否执行保存 </param>
/// <returns> 操作影响的行数 </returns>
public virtual int Insert(IEnumerable <TEntity> entities, bool isSave = true)
{
PublicHelper.CheckArgument(entities, "entities");
EfContext.RegisterNew(entities);
return(isSave ? EfContext.Commit() : 0);
}
/// <summary>
/// 查找指定主键的实体记录
/// </summary>
/// <param name="key"> 指定主键 </param>
/// <returns> 符合编号的记录，不存在返回null </returns>
public virtual TEntity GetByKey(TKey key)
{
PublicHelper.CheckArgument(key, "key");
return(Context.Set <TEntity>().Find(key));
}
/// <summary>
/// 用户登录
/// </summary>
/// <param name="loginVM">登录模型信息</param>
/// <returns>登录操作结果</returns>
public OperationResult Login(LoginVM loginVM)
{
PublicHelper.CheckArgument(loginVM, "loginVM");
User user = _UserRepository.GetEntitiesByEager(new List <string> {
"Roles", "UserGroups"
}).SingleOrDefault(m => m.UserName == loginVM.LoginName.Trim());
OperationResult result;
if (user == null)
{
result = new OperationResult(OperationResultType.QueryNull, "指定账号的用户不存在");
}
else if (String.IsNullOrEmpty(loginVM.Password))
{
result = new OperationResult(OperationResultType.QueryNull, "请输入密码");
}
else if (user.Password != EncryptionHelper.GetMd5Hash(loginVM.Password.Trim()))
{
result = new OperationResult(OperationResultType.Warning, "登录密码不正确。");
}
else
{
var roleIdsByUser = user.Roles.Select(r => r.Id).ToList();
/*
* //采用设置系统封闭时间方式 begin
* //若没有特别设定指定一到五日系统维护，普通用户无法登陆
* var now = DateTime.Now;
* var startTime = new DateTime(now.Year, now.Month, 1);
* var endTime = new DateTime(now.Year, now.Month, 6);
* //从数据库表SafeguardTime获取用户保存的系统维护时间
* var saveStartTime = _SafeguardTimeService.SafeguardTimes.First().StartTime;
* var saveEndTime = _SafeguardTimeService.SafeguardTimes.First().EndTime;
* if (now <= saveEndTime)
* {
* startTime = saveStartTime;
* endTime = saveEndTime;
* }
* if(now >= startTime && now < endTime)
* {
* foreach (var roleId in roleIdsByUser)
* {
* Role role = _RoleService.Roles.FirstOrDefault(r => r.Id == roleId);
* if (role != null && role.RoleName == "普通用户")
* {
* return new OperationResult(OperationResultType.Warning, "系统维护状态中。。。请于"+endTime.ToShortDateString()+"日之后使用。");
* }
* }
* }
* //采用设置系统封闭时间方式 end
*/
//采用设置系统开放时间方式 begin
var now = DateTime.Now;
//从数据库表SafeguardTime获取用户保存的系统维护时间
var saveStartTime = _SafeguardTimeService.SafeguardTimes.First().StartTime;
var saveEndTime = _SafeguardTimeService.SafeguardTimes.First().EndTime;
if (!(now >= saveStartTime && now <= saveEndTime))
{
foreach (var roleId in roleIdsByUser)
{
Role role = _RoleService.Roles.FirstOrDefault(r => r.Id == roleId);
if (role != null && role.RoleName == "普通用户")
{
return(new OperationResult(OperationResultType.Warning, "系统维护状态中。。。请于本月" + saveStartTime.ToShortDateString() + "日与" + saveEndTime.ToShortDateString() + "之间使用。"));
}
}
}
//采用设置系统开放时间方式 end
result = new OperationResult(OperationResultType.Success, "登录成功。", user);
#region 设置用户权限缓存
var roleIdsByUserGroup = user.UserGroups.SelectMany(g => g.Roles).Select(r => r.Id).ToList();
roleIdsByUser.AddRange(roleIdsByUserGroup);
var roleIds = roleIdsByUser.Distinct().ToList();
List <Permission> permissions = _RoleService.Roles.Where(t => roleIds.Contains(t.Id) && t.Enabled == true).SelectMany(c => c.Permissions).Distinct().ToList();
var strKey = CacheKey.StrPermissionsByUid + "_" + user.Id;
//设置Cache滑动过期时间为1天
CacheHelper.SetCache(strKey, permissions, Cache.NoAbsoluteExpiration, new TimeSpan(1, 0, 0, 0));
#endregion
}
if (result.ResultType != OperationResultType.Success)
{
return(result);
}
User userTemp = (User)result.Data;
DateTime expiration = loginVM.IsRememberLogin
? DateTime.Now.AddDays(14)
: DateTime.Now.Add(FormsAuthentication.Timeout);
FormsAuthenticationTicket ticket = new FormsAuthenticationTicket(
1, //指定版本号：可随意指定
userTemp.UserName, //登录用户名：对应 Web.config 中 <allow users="Admin" … /> 的 users 属性
DateTime.Now, //发布时间
expiration, //失效时间
true, //是否为持久 Cookie
userTemp.Id.ToString(), //用户数据：可用 ((System.Web.Security.FormsIdentity)(HttpContext.Current.User.Identity)).Ticket.UserData 获取
FormsAuthentication.FormsCookiePath); //指定 Cookie 为 Web.config 中 <forms path="/" … /> path 属性，不指定则默认为“/”
string str = FormsAuthentication.Encrypt(ticket); //加密身份验票
//声明一个 Cookie，名称为 Web.config 中 <forms name=".APSX" … /> 的 name 属性，对应的值为身份验票加密后的字串
HttpCookie cookie = new HttpCookie(FormsAuthentication.FormsCookieName, str);
if (loginVM.IsRememberLogin)
{
cookie.Expires = DateTime.Now.AddDays(14); //此句非常重要，少了的话，就算此 Cookie 在身份验票中指定为持久性 Cookie ，也只是即时型的 Cookie 关闭浏览器后就失效；
}
HttpContext.Current.Response.Cookies.Set(cookie); //或Response.Cookies.Add(ck);添加至客户端
result.Data = null;
return(result);
}
/// <summary>
/// 用户登录
/// </summary>
/// <param name="model">登录模型信息</param>
/// <returns>业务操作结果</returns>
public OperationResult Login(LoginModel model)
{
PublicHelper.CheckArgument(model, "model");
LoginInfo loginInfo = new LoginInfo
{
Account = model.Account,
Password = Encrypt.Encode(model.Password),
IpAddress = HttpContext.Current.Request.UserHostAddress
};
OperationResult result = AccountContract.Login(loginInfo);
if (result.ResultType == OperationResultType.Success)
{
Member member = (Member)result.AppendData;
DateTime expiration = model.IsRememberLogin
? DateTime.Now.AddDays(7)
: DateTime.Now.Add(FormsAuthentication.Timeout);
string useridString = member.Id.ToString();
string roleIdString = member.Roles == null ? string.Empty : string.Join(",", member.Roles.Select(r => r.RoleTypeNum.ToString()));
string publishTimes = member.PubishingEnableTimes.ToString();
string areaCity = member.Extend.Address.City;
string areaTown = member.Extend.Address.Town;
// 若存在先删除
if (Cookie.Get("publishTimes") != null)
{
Cookie.Remove("publishTimes");
}
//保存Cookie
Cookie.Save("publishTimes", Encrypt.Encode(publishTimes), 24);
// 若存在先删除
if (Cookie.Get("areaCity") != null)
{
Cookie.Remove("areaCity");
}
if (!string.IsNullOrEmpty(areaCity))
{
Cookie.Save("areaCity", Encrypt.Encode(areaCity.Trim()), 24);
}
// 若存在先删除
if (Cookie.Get("areaTown") != null)
{
Cookie.Remove("areaTown");
}
if (!string.IsNullOrEmpty(areaTown))
{
Cookie.Save("areaTown", Encrypt.Encode(areaTown.Trim()), 24);
}
FormsAuthenticationTicket ticket = new FormsAuthenticationTicket(1, member.UserName, DateTime.Now, expiration,
true, string.Join("|", new string[] { useridString, roleIdString, publishTimes }), FormsAuthentication.FormsCookiePath);
HttpCookie cookie = new HttpCookie(FormsAuthentication.FormsCookieName, FormsAuthentication.Encrypt(ticket));
if (model.IsRememberLogin)
{
cookie.Expires = DateTime.Now.AddDays(7);
}
HttpContext.Current.Response.Cookies.Set(cookie);
result.AppendData = null;
}
return(result);
}
/// <summary>
/// 把IOrderedQueryable[T]集合继续指定属性排序方式进行排序
/// </summary>
/// <typeparam name="T">动态类型</typeparam>
/// <param name="source">要排序的数据集</param>
/// <param name="propertySort">列表属性排序条件</param>
/// <returns></returns>
public static IOrderedQueryable <T> ThenBy <T>(this IOrderedQueryable <T> source, PropertySort propertySort)
{
PublicHelper.CheckArgument(propertySort, "propertySort");
return(source.ThenBy(propertySort.PropertyName, propertySort.SortDirection));
}
/// <summary>
/// 删除实体记录集合
/// </summary>
/// <param name="entities"> 实体记录集合 </param>
/// <param name="isSave"> 是否执行保存 </param>
/// <returns> 操作影响的行数 </returns>
public virtual int Delete(IEnumerable <TEntity> entities, bool isSave = true)
{
PublicHelper.CheckArgument(entities, "entities");
UnitOfWorkContext.RegisterDeleted(entities);
return(isSave ? Save() : 0);
}
/// <summary>
/// 把IOrderedQueryable[T]集合继续按指定属性排序方式进行排序
/// </summary>
/// <typeparam name="T">动态类型</typeparam>
/// <param name="source">要排序的数据集</param>
/// <param name="propertyName">排序属性名</param>
/// <param name="sortDirection">排序方向</param>
/// <returns></returns>
public static IOrderedQueryable <T> ThenBy <T>(this IOrderedQueryable <T> source, string propertyName,
ListSortDirection sortDirection = ListSortDirection.Ascending)
{
PublicHelper.CheckArgument(propertyName, "propertyName");
return(QueryableHelper <T> .ThenBy(source, propertyName, sortDirection));
}
/// <summary>
/// 查找指定主键的实体记录
/// </summary>
/// <param name="key"> 指定主键 </param>
/// <returns> 符合编号的记录，不存在返回null </returns>
public virtual async Task <TEntity> QueryAsync(object key)
{
PublicHelper.CheckArgument(key, "key");
return(await UnitOfWorkContext.Set <TEntity>().FindAsync(key));
}
/// <summary>
/// 把IOrderedQueryable[T]集合继续指定属性排序方式进行排序
/// </summary>
/// <typeparam name="T">动态类型</typeparam>
/// <param name="source">要排序的数据集</param>
/// <param name="sortCondition">列表属性排序条件</param>
/// <returns></returns>
public static IOrderedQueryable <T> ThenBy <T>(this IOrderedQueryable <T> source, PropertySortCondition sortCondition)
{
PublicHelper.CheckArgument(sortCondition, "sortCondition");
return(source.ThenBy(sortCondition.PropertyName, sortCondition.ListSortDirection));
}
/// <summary>
/// 更新实体记录
/// </summary>
/// <param name="entity"> 实体对象 </param>
/// <param name="isSave"> 是否执行保存 </param>
/// <returns> 操作影响的行数 </returns>
public virtual async Task <int> UpdateAsync(TEntity entity, bool isSave = true)
{
PublicHelper.CheckArgument(entity, "entity");
UnitOfWorkContext.RegisterModified(entity);
return(isSave ? await SaveAsync() : 0);
}
/// <summary>
/// 根据第三方条件是否为真来决定是否执行指定条件的查询
/// </summary>
/// <param name="source"> 要查询的源 </param>
/// <param name="predicate"> 查询条件 </param>
/// <param name="condition"> 第三方条件 </param>
/// <typeparam name="T"> 动态类型 </typeparam>
/// <returns> 查询的结果 </returns>
public static IQueryable <T> WhereIf <T>(this IQueryable <T> source, Expression <Func <T, bool> > predicate, bool condition)
{
PublicHelper.CheckArgument(predicate, "predicate");
return(condition ? source.Where(predicate) : source);
}
/// <summary>
/// 插入实体记录
/// </summary>
/// <param name="entity"> 实体对象 </param>
/// <param name="isSave"> 是否执行保存 </param>
/// <returns> 操作影响的行数 </returns>
public virtual int Insert(TEntity entity, bool isSave = true)
{
PublicHelper.CheckArgument(entity, "entity");
UnitOfWorkContext.RegisterNew(entity);
return(isSave ? Save() : 0);
}
/// <summary>
/// 添加奖品
/// </summary>
/// <param name="prizebetting">奖品信息</param>
/// <param name="shouldMinus">是否该对用户的可发起抽奖次数减</param>
/// <returns>业务操作结果</returns>
public OperationResult Add(PrizeOrderView povmodel, bool shouldMinus = false)
{
PublicHelper.CheckArgument(povmodel, "povmodel");
int?sortorder = PrizeOrderContract.PrizeOrders.Max(po => po.SortOrder);
PrizeOrder pmodel = new PrizeOrder
{
RevealTypeNum = povmodel.RevealTypeNum,
RevealState = Component.Tools.RevealState.UnDrawn,
Prize = PrizeContract.Prizes.SingleOrDefault(m => m.Id.Equals(povmodel.PrizeId)),
Extend = new PrizeOrderExtend()
{
Id = povmodel.Id
},
SortOrder = (sortorder ?? 0) + 1
};
switch (povmodel.RevealType)
{
case RevealType.Timing:
pmodel.Extend.LaunchTime = povmodel.LaunchTime;
pmodel.Extend.MinLuckyCount = povmodel.MinLuckyCount;
pmodel.Extend.LuckyCount = povmodel.LuckyCount;
//pmodel.Extend.LuckyPercent = povmodel.LuckyPercent;
break;
case RevealType.Quota:
pmodel.Extend.PoolCount = povmodel.PoolCount;
pmodel.Extend.MinLuckyCount = povmodel.MinLuckyCount;
pmodel.Extend.LuckyCount = povmodel.LuckyCount;
//pmodel.Extend.LuckyPercent = povmodel.LuckyPercent;
break;
case RevealType.Answer:
pmodel.Extend.PrizeAsking.Question = povmodel.Question;
pmodel.Extend.PrizeAsking.AnswerOptions = povmodel.AnswerOptions;
pmodel.Extend.PrizeAsking.Answer = povmodel.Answer;
pmodel.Extend.MinLuckyCount = povmodel.MinLuckyCount;
pmodel.Extend.LuckyCount = povmodel.LuckyCount;
pmodel.Extend.RevealTypeOfAnswer = povmodel.RevealTypeOfAnswer;
if (pmodel.Extend.RevealTypeOfAnswer == RevealTypeOfAnswer.Auto)
{
pmodel.Extend.AnswerRevealConditionTypeNum = (int)povmodel.AnswerRevealConditionType;
if (povmodel.AnswerRevealConditionType == AnswerRevealConditionType.Timing)
{
pmodel.Extend.LaunchTime = povmodel.LaunchTime;
}
else if (povmodel.AnswerRevealConditionType == AnswerRevealConditionType.Quota)
{
pmodel.Extend.PoolCount = povmodel.PoolCount;
}
}
//pmodel.Extend.LuckyPercent = povmodel.LuckyPercent;
break;
case RevealType.Scene:
break;
}
try
{
return(PrizeOrderContract.Add(pmodel, shouldMinus));
}
catch (Exception ex)
{
return(new OperationResult(OperationResultType.Error, ex.Message));
}
}
