/// <summary>
/// 编辑权限时，获取指定角色的所有菜单权限
/// </summary>
/// <param name="roleId"></param>
/// <returns></returns>
public async Task <WebResponseContent> GetUserTreePermission(int roleId)
{
if (!UserContext.IsRoleIdSuperAdmin(roleId) && UserContext.Current.RoleId != roleId)
{
if (!(await GetAllChildrenAsync(UserContext.Current.RoleId)).Exists(x => x.Id == roleId))
{
return(_responseContent.Error("没有权限获取此角色的权限信息"));
}
}
//获取用户权限
List <Permissions> permissions = UserContext.Current.GetPermissions(roleId);
//权限用户权限查询所有的菜单信息
List <Sys_Menu> menus = await Task.Run(() => Sys_MenuService.Instance.GetUserMenuList(roleId));
//获取当前用户权限如:(Add,Search)对应的显示文本信息如:Add：添加，Search:查询
var data = menus.Select(x => new UserPermissions
{
Id = x.Menu_Id,
Pid = x.ParentId,
Text = x.MenuName,
Actions = GetActions(x.Menu_Id, x.Actions, permissions, roleId)
});
return(_responseContent.OK(null, data));
}
public override WebResponseContent Add(SaveModel saveDataModel)
{
WebResponseContent responseContent = WebResponseContent.Instance;
AddOnExecuting = (NewsPraise newsPraise, object list) =>
{
if (newsPraise.NewsId > 0)
{
if (repository.Exists(m => m.NewsId == newsPraise.NewsId && m.CreateID == UserContext.Current.UserId))
{
return(responseContent.Error("已赞过了.."));
}
}
else
{
return(responseContent.Error("未获取到点赞文章.."));
}
return(responseContent.OK());
};
AddOnExecuted = (NewsPraise user, object list) =>
{
return(responseContent.OK("点赞成功."));
};
return(base.Add(saveDataModel));
}
/// <summary>
///
/// </summary>
/// <param name="entity"></param>
/// <param name="updateDetail">是否修改明细</param>
/// <param name="delNotExist">是否删除明细不存在的数据</param>
/// <param name="updateMainFields">主表指定修改字段</param>
/// <param name="updateDetailFields">明细指定修改字段</param>
/// <param name="saveChange">是否保存</param>
/// <returns></returns>
public virtual WebResponseContent UpdateRange <Detail>(TEntity entity,
bool updateDetail = false,
bool delNotExist = false,
Expression <Func <TEntity, object> > updateMainFields = null,
Expression <Func <Detail, object> > updateDetailFields = null,
bool saveChange = false) where Detail : class
{
WebResponseContent webResponse = new WebResponseContent();
Update(entity, updateMainFields);
string message = "";
if (updateDetail)
{
PropertyInfo[] properties = typeof(TEntity).GetProperties();
PropertyInfo detail = properties.Where(x => x.PropertyType.Name == "List`1").ToList().FirstOrDefault();
if (detail != null)
{
PropertyInfo key = properties.GetKeyProperty();
object obj = detail.GetValue(entity);
Type detailType = typeof(TEntity).GetCustomAttribute <EntityAttribute>().DetailTable[0];
message = UpdateDetail <Detail>(obj as List <Detail>, key.Name, key.GetValue(entity), updateDetailFields, delNotExist);
}
}
if (!saveChange)
{
return(webResponse.OK());
}
DbContext.SaveChanges();
return(webResponse.OK("修改成功,明细" + message, entity));
}
/// <summary>
/// 修改用户拦截过滤
///
/// </summary>
/// <param name="saveModel"></param>
/// <returns></returns>
public override WebResponseContent Update(SaveModel saveModel)
{
WebResponseContent responseContent = new WebResponseContent();
UserInfo userInfo = UserContext.Current.UserInfo;
//禁止修改用户名
base.UpdateOnExecute = (SaveModel saveInfo) =>
{
int roleId = saveModel.MainData["Role_Id"].GetInt();
string roleName = GetChildrenName(roleId);
saveInfo.MainData.TryAdd("RoleName", roleName);
if (UserContext.IsRoleIdSuperAdmin(userInfo.Role_Id))
{
if (userInfo.Role_Id == roleId)
{
saveInfo.MainData["RoleName"] = userInfo.RoleName;
}
return(responseContent.OK());
}
if (string.IsNullOrEmpty(roleName))
{
return(responseContent.Error("不能选择此角色"));
}
return(responseContent.OK());
};
base.UpdateOnExecuting = (Sys_User user, object obj1, object obj2, List <object> list) =>
{
if (user.User_Id == userInfo.User_Id && user.Role_Id != userInfo.Role_Id)
{
return(responseContent.Error("不能修改自己的角色"));
}
var _user = repository.Find(x => x.User_Id == user.User_Id,
s => new { s.UserName, s.UserPwd })
.FirstOrDefault();
user.UserName = _user.UserName;
//Sys_User实体的UserPwd用户密码字段的属性不是编辑，此处不会修改密码。但防止代码生成器将密码字段的修改成了可编辑造成密码被修改
user.UserPwd = _user.UserPwd;
return(responseContent.OK());
};
//用户信息被修改后，将用户的缓存信息清除
base.UpdateOnExecuted = (Sys_User user, object obj1, object obj2, List <object> List) =>
{
base.CacheContext.Remove(user.User_Id.GetUserIdKey());
return(new WebResponseContent(true));
};
return(base.Update(saveModel));
}
public IActionResult ModifyUserPwd(string password, string userName)
{
WebResponseContent webResponse = new WebResponseContent();
if (string.IsNullOrEmpty(password) || string.IsNullOrEmpty(userName))
{
return(Json(webResponse.Error("参数不完整")));
}
if (password.Length < 6)
{
return(Json(webResponse.Error("密码长度不能少于6位")));
}
ISys_UserRepository repository = Sys_UserRepository.Instance;
Sys_User user = repository.FindFirst(x => x.UserName == userName);
if (user == null)
{
return(Json(webResponse.Error("用户不存在")));
}
user.UserPwd = password.EncryptDES(AppSetting.Secret.User);
repository.Update(user, x => new { x.UserPwd }, true);
//如果用户在线，强制下线
UserContext.Current.LogOut(user.User_Id);
return(Json(webResponse.OK("密码修改成功")));
}
/// <summary>
/// 新建或编辑菜单
/// </summary>
/// <param name="menu"></param>
/// <returns></returns>
public async Task <WebResponseContent> Save(Sys_Menu menu)
{
WebResponseContent webResponse = new WebResponseContent();
bool result = true;;
try
{
if (menu == null)
{
return(webResponse.Error("没有获取到提交的参数"));
}
webResponse = menu.ValidationEntity(x => new { x.MenuName, x.TableName });
if (!webResponse.Status)
{
return(webResponse);
}
if (menu.Menu_Id <= 0)
{
menu.SetCreateDefaultVal();
repository.Add(menu);
}
else
{
menu.SetModifyDefaultVal();
repository.Update(menu, p => new
{
p.ParentId,
p.MenuName,
p.Url,
p.Auth,
p.OrderNo,
p.Icon,
p.Enable,
p.TableName,
p.ModifyDate,
p.Modifier
});
}
await repository.SaverChangesAsync();
if (result)
{
_menuVersionn = DateTime.Now.ToString("yyyyMMddHHMMssfff");
_menus = null;
}
webResponse.OK("保存成功", menu);
}
catch (Exception ex)
{
webResponse.Error(ex.Message);
}
finally
{
Logger.Info($"表:{menu.TableName},菜单：{menu.MenuName},权限{menu.Auth},{(webResponse.Status ? "成功" : "失败")}{webResponse.Message}");
}
return(webResponse);
}
/// <summary>
/// WebApi登陆
/// </summary>
/// <param name="loginInfo"></param>
/// <param name="verificationCode"></param>
/// <returns></returns>
public async Task <WebResponseContent> Login(LoginInfo loginInfo)
{
string msg = string.Empty;
WebResponseContent responseContent = new WebResponseContent();
try
{
var db = DbContext.Set <Hiiops_Cart_SellerUser>();
var user = await db.Where(x => x.Phone == loginInfo.UserName ||
x.OpenId == loginInfo.UserName || x.Account == loginInfo.UserName).FirstOrDefaultAsync();
if (user == null || loginInfo.PassWord.Trim() != (user.Password ?? "").DecryptDES(AppSetting.Secret.User))
{
return(responseContent.Error(ResponseType.LoginError));
}
string token = JwtHelper.IssueJwt(user.Id.ToString());
user.Token = token;
responseContent.Data = new { token, user.NickName, user.Phone, user.Account, user.Country, user.HeadImgUrl, user.Id, user.Name, user.Privilege, user.Province, user.Remark, user.SearchKey, user.Sex, user.Status };
db.Update(user);
SellerContent.Current.LogOut(user.Id);
loginInfo.PassWord = string.Empty;
return(responseContent.OK(ResponseType.LoginSuccess));
}
catch (Exception ex)
{
msg = ex.Message + ex.StackTrace;
return(responseContent.Error(ResponseType.ServerError));
}
finally
{
Logger.Info(LoggerType.Login, loginInfo.Serialize(), responseContent.Message, msg);
}
}
/// <summary>
/// 手机号快捷登录
/// </summary>
/// <param name="code">验证码</param>
/// <param name="phone">手机号码</param>
/// <returns></returns>
public async Task <WebResponseContent> Login(string code, string phone)
{
WebResponseContent responseContent = new WebResponseContent();
string _code = CacheContext.Get <string>(phone + "ValidateSMSCode");
if (_code == null)
{
return(responseContent.Error("请先获取短信验证码"));
}
if (_code != code)
{
return(responseContent.Error("验证码有误"));
}
var user = await DbContext.Set <Hiiops_Cart_SellerUser>().Where(x => x.Phone == phone).FirstOrDefaultAsync();
if (user == null)
{
return(responseContent.Error("手机未注册"));
}
string token = JwtHelper.IssueJwt(user.Id.ToString());
user.Token = token;
responseContent.Data = new { token, user.NickName, user.Phone, user.Account, user.Country, user.HeadImgUrl, user.Id, user.Name, user.Privilege, user.Province, user.Remark, user.SearchKey, user.Sex, user.Status };
DbContext.Update(user);
SellerContent.Current.LogOut(user.Id);
return(responseContent.OK(ResponseType.LoginSuccess));
}
/// <summary>
///当token将要过期时，提前置换一个新的token
/// </summary>
/// <returns></returns>
public async Task <WebResponseContent> ReplaceToken()
{
var db = DbContext.Set <Hiiops_Cart_SellerUser>();
WebResponseContent responseContent = new WebResponseContent();
string error = "";
Hiiops_Cart_LoginInfo loginInfo = null;
try
{
string requestToken = HttpContext.Current.Request.Headers[AppSetting.TokenHeaderName];
requestToken = requestToken?.Replace("Bearer ", "");
if (SellerContent.Current.Token != requestToken)
{
return(responseContent.Error("Token已失效!"));
}
if (JwtHelper.IsExp(requestToken))
{
return(responseContent.Error("Token已过期!"));
}
int Id = SellerContent.Current.Id;
loginInfo = await db.Where(x => x.Id == Id).Select(s => new Hiiops_Cart_LoginInfo()
{
Id = Id,
Account = s.Account,
UnionId = s.UnionId,
NickNme = s.NickName,
OpenId = s.OpenId,
Phone = s.Phone,
Enable = s.Status,
Token = s.Token,
UserName = s.Name
}).FirstAsync();
if (loginInfo == null)
{
return(responseContent.Error("未查到用户信息!"));
}
string token = JwtHelper.IssueJwt(Id.ToString());
//移除当前缓存
base.CacheContext.Remove(Id.GetUserIdKey());
//只更新的token字段
DbContext.Database.ExecuteSqlRaw($"UPDATA Hiiops_Cart_SellerUser SET Token = '{token}'");
responseContent.OK(null, token);
}
catch (Exception ex)
{
error = ex.Message + ex.StackTrace + ex.Source;
responseContent.Error("token替换出错了..");
}
finally
{
Logger.Info(LoggerType.ReplaceToeken, ($"用户Id:{loginInfo?.Id},用户{loginInfo?.UserName}")
+ (responseContent.Status ? "token替换成功" : "token替换失败"), null, error);
}
return(responseContent);
}
/// <summary>
/// WebApi登陆
/// </summary>
/// <param name="loginInfo"></param>
/// <param name="verificationCode"></param>
/// <returns></returns>
public async Task <WebResponseContent> Login(LoginInfo loginInfo, bool verificationCode = true)
{
string msg = string.Empty;
WebResponseContent responseContent = new WebResponseContent();
if (loginInfo.UUID != loginInfo.VerificationCode && loginInfo.UUID != "gpsq")
{
IMemoryCache memoryCache = HttpContext.Current.GetService <IMemoryCache>();
string cacheCode = (memoryCache.Get(loginInfo.UUID) ?? "").ToString();
if (string.IsNullOrEmpty(cacheCode))
{
return(responseContent.Error("验证码已失效"));
}
if (cacheCode.ToLower() != loginInfo.VerificationCode.ToLower())
{
memoryCache.Remove(loginInfo.UUID);
return(responseContent.Error("验证码不正确"));
}
memoryCache.Remove(loginInfo.UUID);
}
try
{
Sys_User user = await repository.FindAsIQueryable(x => x.UserName == loginInfo.UserName)
.FirstOrDefaultAsync();
if (user == null || loginInfo.PassWord.Trim() != (user.UserPwd ?? "").DecryptDES(AppSetting.Secret.User))
{
return(responseContent.Error(ResponseType.LoginError));
}
if (user.Enable.ToInt() < 1)
{
return(responseContent.Error("该账号已被锁住."));
}
string token = JwtHelper.IssueJwt(new UserInfo()
{
User_Id = user.User_Id,
UserName = user.UserName,
Role_Id = user.Role_Id
});
user.Token = token;
responseContent.Data = new { token, userName = user.UserTrueName, img = user.HeadImageUrl };
repository.Update(user, x => x.Token, true);
UserContext.Current.LogOut(user.User_Id);
loginInfo.PassWord = string.Empty;
return(responseContent.OK(ResponseType.LoginSuccess));
}
catch (Exception ex)
{
msg = ex.Message + ex.StackTrace;
return(responseContent.Error(ResponseType.ServerError));
}
finally
{
Logger.Info(LoggerType.Login, loginInfo.Serialize(), responseContent.Message, msg);
}
}
/// <summary>
///当token将要过期时，提前置换一个新的token
/// </summary>
/// <returns></returns>
public async Task <WebResponseContent> ReplaceToken()
{
WebResponseContent responseContent = new WebResponseContent();
string error = "";
UserInfo userInfo = null;
try
{
string requestToken = HttpContext.Current.Request.Headers[AppSetting.TokenHeaderName];
requestToken = requestToken?.Replace("Bearer ", "");
if (UserContext.Current.Token != requestToken)
{
return(responseContent.Error("Token已失效!"));
}
if (JwtHelper.IsExp(requestToken))
{
return(responseContent.Error("Token已过期!"));
}
int userId = UserContext.Current.UserId;
userInfo = await
repository.FindFirstAsync(x => x.User_Id == userId,
s => new UserInfo()
{
User_Id = userId,
UserName = s.UserName,
UserTrueName = s.UserTrueName,
Role_Id = s.Role_Id,
RoleName = s.RoleName
});
if (userInfo == null)
{
return(responseContent.Error("未查到用户信息!"));
}
string token = JwtHelper.IssueJwt(userInfo);
//移除当前缓存
base.CacheContext.Remove(userId.GetUserIdKey());
//只更新的token字段
repository.Update(new Sys_User()
{
User_Id = userId, Token = token
}, x => x.Token, true);
responseContent.OK(null, token);
}
catch (Exception ex)
{
error = ex.Message + ex.StackTrace + ex.Source;
responseContent.Error("token替换出错了..");
}
finally
{
Logger.Info(LoggerType.ReplaceToeken, ($"用户Id:{userInfo?.User_Id},用户{userInfo?.UserTrueName}")
+ (responseContent.Status ? "token替换成功" : "token替换失败"), null, error);
}
return(responseContent);
}
/// <summary>
/// 小程序获取首页数据
/// </summary>
/// <returns></returns>
public async Task <WebResponseContent> Home()
{
WebResponseContent webResponseContent = new WebResponseContent();
var data = service.GetHomeModel();
await Task.CompletedTask;
return(webResponseContent.OK("获取成功", data));
}
/// <summary>
/// 添加资讯
/// </summary>
/// <param name="saveModel"></param>
/// <returns></returns>
public override WebResponseContent Add(SaveModel saveModel)
{
WebResponseContent responseContent = WebResponseContent.Instance;
AddOnExecuted = (News news, object list) =>
{
if (news.Tags.IsNullOrEmpty())
{
return(responseContent.OK());
}
string[] tags = news.Tags?.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
if (tags.Length > 5)
{
return(responseContent.Error("标签不能超过5个"));
}
if (tags.Length > 0)
{
for (int i = 0; i < tags.Length; i++)
{
var tagModel = repository.DbContext.Set <NewsTag>().Where(m => m.Tag == tags[i]).FirstOrDefault();
if (tagModel == null)
{
tagModel = new NewsTag()
{
Tag = tags[i], UseCount = 1
};
tagModel.SetCreateDefaultVal();
repository.DbContext.Set <NewsTag>().Add(tagModel);
}
else
{
tagModel.UseCount += 1;
repository.DbContext.Set <NewsTag>().Update(tagModel);
}
}
if (repository.DbContext.SaveChanges() > 0)
{
return(responseContent.OK("创建成功."));
}
}
news.SetModifyDefaultVal();
return(responseContent.OK());
};
return(base.Add(saveModel).OK("已提交，正在审核中.."));
}
/// <summary>
/// 新建用户，根据实际情况自行处理
/// </summary>
/// <param name="saveModel"></param>
/// <returns></returns>
public override WebResponseContent Add(SaveModel saveModel)
{
WebResponseContent responseData = new WebResponseContent();
base.AddOnExecute = (SaveModel userModel) =>
{
int roleId = userModel?.MainData?["Role_Id"].GetInt() ?? 0;
if (roleId > 0)
{
string roleName = GetChildrenName(roleId);
if (string.IsNullOrEmpty(roleName))
{
return(responseData.Error("不能选择此角色"));
}
//选择新建的角色ID，手动添加角色ID的名称
userModel.MainData["RoleName"] = roleName;
}
return(responseData.OK());
};
///生成6位数随机密码
string pwd = 6.GenerateRandomNumber();
//在AddOnExecuting之前已经对提交的数据做过验证是否为空
base.AddOnExecuting = (Sys_User user, object obj) =>
{
user.UserName = user.UserName.Trim();
if (repository.Exists(x => x.UserName == user.UserName))
{
return(responseData.Error("用户名已经被注册"));
}
user.UserPwd = pwd.EncryptDES(AppSetting.Secret.User);
//设置默认头像
user.HeadImageUrl = "https://imgs-1256993465.cos.ap-chengdu.myqcloud.com/h5pic/x1.jpg";
return(responseData.OK());
};
base.AddOnExecuted = (Sys_User user, object list) =>
{
return(responseData.OK($"用户新建成功.帐号{user.UserName}密码{pwd}"));
};
return(base.Add(saveModel));;
}
/// <summary>
/// 新建用户，根据实际情况自行处理
/// </summary>
/// <param name="saveModel"></param>
/// <returns></returns>
public override WebResponseContent Add(SaveModel saveModel)
{
WebResponseContent responseData = new WebResponseContent();
base.AddOnExecute = (SaveModel userModel) =>
{
int roleId = userModel?.MainData?["Role_Id"].GetInt() ?? 0;
if (roleId > 0)
{
string roleName = GetChildrenName(roleId);
if ((!UserContext.Current.IsSuperAdmin && roleId == 1) || string.IsNullOrEmpty(roleName))
{
return(responseData.Error("不能选择此角色"));
}
//选择新建的角色ID，手动添加角色ID的名称
userModel.MainData["RoleName"] = roleName;
}
return(responseData.OK());
};
///生成6位数随机密码
string pwd = 6.GenerateRandomNumber();
//在AddOnExecuting之前已经对提交的数据做过验证是否为空
base.AddOnExecuting = (Sys_User user, object obj) =>
{
user.UserName = user.UserName.Trim();
if (repository.Exists(x => x.UserName == user.UserName))
{
return(responseData.Error("用户名已经被注册"));
}
user.UserPwd = pwd.EncryptDES(AppSetting.Secret.User);
//设置默认头像
return(responseData.OK());
};
base.AddOnExecuted = (Sys_User user, object list) =>
{
return(responseData.OK($"用户新建成功.帐号{user.UserName}密码{pwd}"));
};
return(base.Add(saveModel));;
}
/// <summary>
/// 编辑权限时获取当前用户下的所有角色与当前用户的菜单权限
/// </summary>
/// <returns></returns>
public async Task <WebResponseContent> GetCurrentTreePermission()
{
_responseContent = await GetCurrentUserTreePermission();
int roleId = UserContext.Current.RoleId;
return(_responseContent.OK(null, new
{
tree = _responseContent.Data,
roles = await GetAllChildrenAsync(roleId)
}));
}
private WebResponseContent CheckKeyValue(List <Sys_DictionaryList> dictionaryLists)
{
WebResponseContent webResponse = new WebResponseContent();
if (dictionaryLists == null || dictionaryLists.Count == 0)
{
return(webResponse.OK());
}
if (dictionaryLists.GroupBy(g => g.DicName).Any(x => x.Count() > 1))
{
return(webResponse.Error("【字典项名称】不能有重复的值"));
}
if (dictionaryLists.GroupBy(g => g.DicValue).Any(x => x.Count() > 1))
{
return(webResponse.Error("【字典项Key】不能有重复的值"));
}
return(webResponse.OK());
}
/// <summary>
/// 新建
/// </summary>
/// <param name="saveDataModel"></param>
/// <returns></returns>
public override WebResponseContent Add(SaveModel saveDataModel)
{
WebResponseContent responseContent = WebResponseContent.Instance;
//此处saveModel是从前台提交的原生数据，可对数据进修改过滤
AddOnExecute = (SaveModel saveModel) =>
{
//如果返回false,后面代码不会再执行
return(responseContent.OK());
};
// 在保存数据库前的操作，所有数据都验证通过了，这一步执行完就执行数据库保存
AddOnExecuting = (SellOrder order, object list) =>
{
List <SellOrderList> orderLists = list as List <SellOrderList>;
if (orderLists == null || orderLists.Count == 0)
{//如果没有界面上没有填写明细，则中断执行
return(responseContent.Error("必须填写明细数据"));
}
if (orderLists.Exists(x => x.Qty <= 20))
{
return(responseContent.Error("明细数量必须大于20"));
}
return(responseContent.OK());
};
//此方法中已开启了事务，如果在此方法中做其他数据库操作，请不要再开启事务
// 在保存数据库后的操作，此时已进行数据提交，但未提交事务，如果返回false，则会回滚提交
AddOnExecuted = (SellOrder order, object list) =>
{
if (order.Qty < 10)
{ //如果输入的销售数量<10，会回滚数据库
return(responseContent.Error("销售数量必须大于1000"));
}
return(responseContent.OK("已新建成功,台AddOnExecuted方法返回的消息"));
};
return(base.Add(saveDataModel));
}
public async Task <WebResponseContent> RegisterUser(string openid, string nickName, string avatarUrl, int gender)
{
string msg = string.Empty;
WebResponseContent responseContent = new WebResponseContent();
try
{
var user = await repository.FindAsIQueryable(x => x.OpenId == openid)
.FirstOrDefaultAsync();
if (user != null)
{
return(responseContent.Error("用户名已经被注册"));
}
user = new Sys_User()
{
OpenId = openid,
UserName = openid,
UserTrueName = nickName,
HeadImageUrl = avatarUrl,
Gender = gender,
Role_Id = 1001,
RoleName = GetChildrenName(1001),
Enable = 1
};
base.AddOnExecuted = (Sys_User sys_User, object list) =>
{
return(responseContent.OK($"用户新建成功.帐号{user.UserName}"));
};
return(Add <Sys_User>(user));
}
catch (Exception ex)
{
msg = ex.Message + ex.StackTrace;
return(responseContent.Error(ResponseType.ServerError));
}
finally
{
Logger.Info(LoggerType.ApiRegister, nickName, responseContent.Message, msg);
}
}
/// <summary>
/// WebApi登陆
/// </summary>
/// <param name="loginInfo"></param>
/// <param name="verificationCode"></param>
/// <returns></returns>
public async Task <WebResponseContent> Login(LoginInfo loginInfo, bool verificationCode = true)
{
string msg = string.Empty;
WebResponseContent responseContent = new WebResponseContent();
try
{
responseContent = loginInfo.ValidationEntity(x => new { x.UserName, x.PassWord });
if (!responseContent.Status)
{
return(responseContent);
}
Sys_User user = await repository.FindAsIQueryable(x => x.UserName == loginInfo.UserName)
.FirstOrDefaultAsync();
if (user == null || loginInfo.PassWord.Trim() != (user.UserPwd ?? "").DecryptDES(AppSetting.Secret.User))
{
return(responseContent.Error(ResponseType.LoginError));
}
string token = JwtHelper.IssueJwt(new UserInfo()
{
User_Id = user.User_Id,
UserName = user.UserName,
Role_Id = user.Role_Id
});
user.Token = token;
responseContent.Data = new { token, userName = user.UserTrueName, img = user.HeadImageUrl };
repository.Update(user, x => x.Token, true);
UserContext.Current.LogOut(user.User_Id);
loginInfo.PassWord = string.Empty;
return(responseContent.OK(ResponseType.LoginSuccess));
}
catch (Exception ex)
{
msg = ex.Message + ex.StackTrace;
return(responseContent.Error(ResponseType.ServerError));
}
finally
{
Logger.Info(LoggerType.Login, loginInfo.Serialize(), responseContent.Message, msg);
}
}
public async Task <WebResponseContent> CreatePage(App_News news)
{
WebResponseContent webResponseContent = WebResponseContent.Instance;
if (news == null)
{
return(webResponseContent.Error("未获取到数据"));
}
if (!await repository.ExistsAsync(x => x.Id == news.Id))
{
return(webResponseContent.Error("请求的数据已发生变化,请刷新页面重新提交"));
}
string template = FileHelper.ReadFile(@"Template\\AppHtml\\news.html");
if (string.IsNullOrEmpty(template))
{
return(webResponseContent.Error("未获取到页面的模板,请确认模板是否存在"));
}
string filePath;
string fileName;
string urlPath;
if (!string.IsNullOrEmpty(news.DetailUrl) && news.DetailUrl.IndexOf("/") != -1 && news.DetailUrl.Split(".").Length == 2)
{
var file = news.DetailUrl.Split("/");
fileName = file[file.Length - 1];
filePath = news.DetailUrl.Replace(fileName, "");
urlPath = filePath;
}
else
{
string day = DateTime.Now.ToString("yyyyMMdd");
fileName = DateTime.Now.ToString("HHmmsss") + new Random().Next(1000, 9999) + ".html";
urlPath = $"static/news/{day}/";
filePath = urlPath.MapPath(true);
}
string content = template.Replace("{title}", news.Title).Replace("{date}", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")).Replace("{content}", news.Content);
FileHelper.WriteFile((filePath.IndexOf("wwwroot") == -1 ? "wwwroot/" : "") + filePath, fileName, content);
//更新数据库的url
news.DetailUrl = $"{urlPath}{fileName}";
repository.Update(news, x => new { news.DetailUrl, news.Content }, true);
return(webResponseContent.OK("面发布成功,可预览看效果", new { url = news.DetailUrl }));
}
/// <summary>
/// 找回密码
/// </summary>
/// <param name="phone">手机号码</param>
/// <param name="code">验证码</param>
/// <param name="sessionKey">提交表单验证码</param>
/// <param name="newPassWord">新密码</param>
/// <param name="againPassWord">重复密码</param>
/// <returns></returns>
public WebResponseContent FindPassword(string phone, string code, string sessionKey, string newPassWord, string againPassWord)
{
WebResponseContent webResponseContent = new WebResponseContent();
if (string.IsNullOrEmpty(phone) || string.IsNullOrEmpty(code) || string.IsNullOrEmpty(newPassWord) || string.IsNullOrEmpty(againPassWord))
{
return(webResponseContent.Error("请输入完整信息"));
}
if (!phone.IsPhoneNo())
{
return(webResponseContent.Error("请输入正确的手机号码"));
}
if (string.IsNullOrEmpty(CacheContext.Get(sessionKey)))
{
return(webResponseContent.Error("请先获取验证码"));
}
if (CacheContext.Get(sessionKey) != code)
{
return(webResponseContent.Error("请输入正确的验证码"));
}
if (!newPassWord.Equals(againPassWord))
{
return(webResponseContent.Error("两次输入的密码不一致"));
}
var seller = DbContext.Set <Hiiops_Cart_SellerUser>().Where(x => x.Phone == phone).FirstOrDefault();
if (seller == null)
{
return(webResponseContent.Error("手机号未注册"));
}
string token = JwtHelper.IssueJwt(seller.Id.ToString());
seller.Token = token;
seller.Password = newPassWord.EncryptDES(AppSetting.Secret.User);
DbContext.Update(seller);
if (DbContext.SaveChanges() > 0)
{
return(webResponseContent.OK("密码修改成功", data: new { token = seller.Token }));
}
return(webResponseContent.Error("密码修改失败"));
}
public override WebResponseContent Export(PageDataOptions pageData)
{
string path = null;
string fileName = null;
WebResponseContent webResponse = new WebResponseContent();
ExportOnExecuting = (List <FormCollectionObject> list, List <string> columns) =>
{
var formId = list[0].FormId;
var data = _designOptionsRepository.FindAsIQueryable(x => x.FormId == formId)
.Select(s => new { s.Title, s.FormConfig }).FirstOrDefault();
try
{
List <FormOptions> formObj = data.FormConfig.DeserializeObject <List <FormOptions> >();
List <Dictionary <string, object> > listDic = new List <Dictionary <string, object> >();
foreach (var item in list)
{
Dictionary <string, object> dic = new Dictionary <string, object>();
var formData = item.FormData.DeserializeObject <Dictionary <string, string> >();
dic.Add("标题", data.Title);
dic.Add("提交人", item.Creator);
dic.Add("提交时间", item.CreateDate.ToString("yyyy-MM-dd HH:mm:sss"));
foreach (var obj in formObj)
{
dic.Add(obj.Title, formData.Where(x => x.Key == obj.Field).Select(s => s.Value).FirstOrDefault());
}
listDic.Add(dic);
}
fileName = data.Title + ".xlsx";
path = EPPlusHelper.ExportGeneralExcel(listDic, fileName);
}
catch (Exception ex)
{
Logger.Error($"解析表单出错：{data.Title},表单配置：{data.FormConfig},{ex.Message}");
return(webResponse.Error("获取表单出错"));
}
webResponse.Code = "-1";
return(webResponse.OK(null, path.EncryptDES(AppSetting.Secret.ExportFile)));
};
return(base.Export(pageData));
}
/// <summary>
///
/// </summary>
/// <param name="userName"></param>
/// <param name="password"></param>
/// <returns></returns>
public WebResponseContent Login(string userName, string password)
{
WebResponseContent responseContent = new WebResponseContent();
if (string.IsNullOrWhiteSpace(userName) || string.IsNullOrWhiteSpace(password))
{
return(responseContent.Error("登录错误"));
}
// var encryptPwd = AESEncrypt.Encrypt(password, AESEncrypt.pwdKey);
var user = repository.Sys_User.Where(q => q.Enable == (byte)DataStatus.Enable)
.Where(q => q.UserName == userName && q.UserPwd == password).First();
if (user == null)
{
return(responseContent.Error("账户或密码错误"));
}
var adminToken = new AdminUser
{
User_Id = user.UID,
Email = user.Email,
Role_Id = user.Role_Id,
UserName = user.UserName,
};
//获取token配置
var tokenManagement = AutofacContainerModule.GetService <IOptions <TokenManagement> >().Value;
var token = TokenHelper.CreateAdminToken(tokenManagement, adminToken);
//HttpContext.Current.Response.Headers.Add("Authorization", new StringValues(token));
return(responseContent.OK("登录成功", new M_AdminUserRP
{
id = user.UID,
UserName = user.UserName,
RoleId = user.Role_Id,
HeadImageUrl = user.HeadImageUrl,
Moblie = user.Mobile,
Email = user.Email,
Token = token,
}));
}
/// <summary>
/// 获取所有菜单
/// </summary>
/// <returns></returns>
public async Task <WebResponseContent> Save(Sys_Menu menu)
{
WebResponseContent webResponse = new WebResponseContent();
if (menu == null)
{
return(webResponse.Error("没有获取到提交的参数"));
}
if (menu.Menu_Id > 0 && menu.Menu_Id == menu.ParentId)
{
return(webResponse.Error("父级ID不能是当前菜单的ID"));
}
var isSave = false;
if (menu.Menu_Id <= 0)
{
menu.CreateDate = DateTime.Now;
menu.Creator = UserContext.Current.UserName;
isSave = await repository.Sys_Menu.AddAsync(menu);
}
else
{
//2020.05.07新增禁止选择上级角色为自己
if (menu.Menu_Id == menu.ParentId)
{
return(WebResponseContent.Instance.Error($"父级id不能为自己"));
}
if (repository.Sys_Menu.IsExists(x => x.ParentId == menu.Menu_Id && menu.ParentId == x.Menu_Id))
{
return(WebResponseContent.Instance.Error($"不能选择此父级id，选择的父级id与当前菜单形成依赖关系"));
}
menu.ModifyDate = DateTime.Now;
menu.Modifier = UserContext.Current.UserName;
menu.Enable = (byte)EnumDataStatus.Enable;
isSave = await repository.Sys_Menu.UpdateAsync(menu);
}
if (isSave)
{
webResponse.OK("保存成功", menu);
}
return(webResponse);
}
public async Task <WebResponseContent> CardsGenerate(CardsSet cardsSet)
{
WebResponseContent responseContent = new WebResponseContent();
var shop = ShopsRepository.Instance.FindFirst(x => x.User_Id == UserContext.Current.UserId);
if (shop.IsNullOrEmpty())
{
return(responseContent.Error("商家信息未设定"));
}
var startnumber = (shop.Prefix.ToLong() * 10000 + shop.Middle.ToLong()) * 10000;
var cardslist = new List <Cards>();
for (int i = 0; i < cardsSet.Qty; i++)
{
var cardno = startnumber + i;
Cards card = new Cards();
card.Card_Name = cardsSet.Card_Name;
card.Card_No = cardno.ToString();
Random ran = new Random();
card.Card_Pwd = ran.Next(100000, 999999).ToString();
card.Card_Status = 0;
card.Card_Ship_Status = 0;
card.CateGory_Id = cardsSet.CateGory_Id;
card.CreateDate = DateTime.Now;
card.Customer_Id = cardsSet.Customer_Id;
card.Expiry_Time = cardsSet.Expiry_Time;
card.Price = cardsSet.Price;
card.Strategy_Id = cardsSet.Strategy_Id;
card.Remark = cardsSet.Remark;
card.Sku_Id = cardsSet.Sku_Id;
card.CreateDate = DateTime.Now;
card.CreateID = UserContext.Current.UserId;
card.Creator = UserContext.Current.UserName;
cardslist.Add(card);
}
_repository.AddRange(cardslist, true);
shop.Middle += 1;
ShopsRepository.Instance.Update(shop);
return(responseContent.OK("生成成功"));
}
/// <summary>
/// 验证提交的从表参数
/// saveModel.Extra在App_ReportPrice.js中addBefore/updateBefore新建与编辑时提交到的后台
/// </summary>
/// <param name="saveModel"></param>
/// <returns></returns>
private WebResponseContent ValidateExtra(SaveModel saveModel)
{
if (saveModel == null || saveModel.Extra == null)
{
return(_webResponse.Error("请提交参数"));
}
try
{
TableExtra tableExtra = saveModel.Extra.ToString().DeserializeObject <TableExtra>();
if (tableExtra == null ||
tableExtra.Table1List == null ||
tableExtra.Table1List.Count == 0 ||
tableExtra.Table1List == null ||
tableExtra.Table2List.Count == 0)
{
return(_webResponse.Error("请提交从表1与从表2的参数"));
}
//校验 从表1字段:Title,CreateDate必填
_webResponse = tableExtra.Table1List.ValidationEntityList(x => new { x.Title, x.CreateDate });
if (!_webResponse.Status)
{
_webResponse.Message = "从表1：" + _webResponse.Message;
return(_webResponse);
}
//校验 从表2字段:Describe, Name,PhoneNo 必填
_webResponse = tableExtra.Table2List.ValidationEntityList(x => new { x.Describe, x.Name, x.PhoneNo });
if (!_webResponse.Status)
{
_webResponse.Message = "从表2：" + _webResponse.Message;
return(_webResponse);
}
//校验成功返回
return(_webResponse.OK(null, tableExtra));
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
return(_webResponse.Error("参数不正确"));
}
}
public WebResponseContent MovieWebsiteTypePost(MovieWebsiteType type)
{
WebResponseContent Response = type.ValidationEntity();
if (!Response.Status)
{
return(Response);
}
if (type.Id > 0)
{
repository.DbContext.Set <MovieWebsiteType>().Update(type);
}
else
{
repository.DbContext.Set <MovieWebsiteType>().Add(type);
}
if (repository.DbContext.SaveChanges() > 0)
{
return(Response.OK(ResponseType.SaveSuccess));
}
return(Response.Error("绑定失败."));
}
public async Task <WebResponseContent> LoginOpenId(string openid)
{
string msg = string.Empty;
WebResponseContent responseContent = new WebResponseContent();
try
{
var user = await repository.FindAsIQueryable(x => x.OpenId == openid)
.FirstOrDefaultAsync();
if (user == null)
{
return(responseContent.Error(ResponseType.UserNotFound));
}
string token = JwtHelper.IssueJwt(new UserInfo()
{
User_Id = user.User_Id,
UserName = user.UserName
});
user.Token = token;
responseContent.Data = new { token, userName = user.UserTrueName, img = user.HeadImageUrl };
repository.Update(user, x => x.Token, true);
UserContext.Current.LogOut(user.User_Id);
//loginInfo.PassWord = string.Empty;
return(responseContent.OK(ResponseType.LoginSuccess));
}
catch (Exception ex)
{
msg = ex.Message + ex.StackTrace;
return(responseContent.Error(ResponseType.ServerError));
}
finally
{
Logger.Info(LoggerType.Login, openid, responseContent.Message, msg);
}
}
/// <summary>
/// 保存角色权限
/// </summary>
/// <param name="userPermissions"></param>
/// <param name="roleId"></param>
/// <returns></returns>
public async Task <WebResponseContent> SavePermission(List <UserPermissions> userPermissions, int roleId)
{
WebResponseContent webResponse = new WebResponseContent();
string message = "";
try
{
UserInfo user = UserContext.Current.UserInfo;
if (!(await GetAllChildren(user.Role_Id)).Exists(x => x.Id == roleId))
{
return(webResponse.Error("没有权限修改此角色的权限信息"));
}
//当前用户的权限
List <Permissions> permissions = UserContext.Current.Permissions;
List <int> originalMeunIds = new List <int>();
//被分配角色的权限
List <Sys_RoleAuth> roleAuths = await repository.FindAsync <Sys_RoleAuth>(x => x.Role_Id == roleId);
List <Sys_RoleAuth> updateAuths = new List <Sys_RoleAuth>();
foreach (UserPermissions x in userPermissions)
{
Permissions per = permissions.Where(p => p.Menu_Id == x.Id).FirstOrDefault();
//不能分配超过当前用户的权限
if (per == null)
{
continue;
}
//per.UserAuthArr.Contains(a.Value)校验权限范围
string[] arr = x.Actions == null || x.Actions.Count == 0
? new string[0]
: x.Actions.Where(a => per.UserAuthArr.Contains(a.Value))
.Select(s => s.Value).ToArray();
//如果当前权限没有分配过，设置Auth_Id默认为0，表示新增的权限
var auth = roleAuths.Where(r => r.Menu_Id == x.Id).Select(s => new { s.Auth_Id, s.AuthValue, s.Menu_Id }).FirstOrDefault();
string newAuthValue = string.Join(",", arr);
//权限没有发生变化则不处理
if (auth == null || auth.AuthValue != newAuthValue)
{
updateAuths.Add(new Sys_RoleAuth()
{
Role_Id = roleId,
Menu_Id = x.Id,
AuthValue = string.Join(",", arr),
Auth_Id = auth == null ? 0 : auth.Auth_Id,
ModifyDate = DateTime.Now,
Modifier = user.UserTrueName,
CreateDate = DateTime.Now,
Creator = user.UserTrueName
});
}
else
{
originalMeunIds.Add(auth.Menu_Id);
}
}
//更新权限
repository.UpdateRange(updateAuths.Where(x => x.Auth_Id > 0), x => new
{
x.Menu_Id,
x.AuthValue,
x.Modifier,
x.ModifyDate
});
//新增的权限
repository.AddRange(updateAuths.Where(x => x.Auth_Id <= 0));
//获取权限取消的权限
int[] authIds = roleAuths.Where(x => userPermissions.Select(u => u.Id)
.ToList().Contains(x.Menu_Id) || originalMeunIds.Contains(x.Menu_Id))
.Select(s => s.Auth_Id)
.ToArray();
List <Sys_RoleAuth> delAuths = roleAuths.Where(x => x.AuthValue != "" && !authIds.Contains(x.Auth_Id)).ToList();
delAuths.ForEach(x =>
{
x.AuthValue = "";
});
//将取消的权限设置为""
repository.UpdateRange(delAuths, x => new
{
x.Menu_Id,
x.AuthValue,
x.Modifier,
x.ModifyDate
});
int addCount = updateAuths.Where(x => x.Auth_Id <= 0).Count();
int updateCount = updateAuths.Where(x => x.Auth_Id > 0).Count();
await repository.SaveChangesAsync();
string _version = DateTime.Now.ToString("yyyyMMddHHMMssfff");
//标识缓存已更新
base.CacheContext.Add(roleId.GetRoleIdKey(), _version);
webResponse.OK($"保存成功：新增加配菜单权限{addCount}条,更新菜单{updateCount}条,删除权限{delAuths.Count()}条");
}
catch (Exception ex)
{
message = "异常信息：" + ex.Message + ex.StackTrace + ",";
}
finally
{
Logger.Info($"权限分配置:{message}{webResponse.Message}");
}
return(webResponse);
}