private static Dictionary <string, string> BuildToken(CurrentUser currentUser)
{
Dictionary <string, string> result = new Dictionary <string, string>();
var palyloads = new Dictionary <string, object>
{
{ "UserID", currentUser.UserID },
{ "ID", Guid.NewGuid().ToString() },
{ "CompanyID", currentUser.CompanyID },
{ "UserName", currentUser.UserName }
};
var token = TokenManager.CreateTokenByHandler(palyloads, 60 * 24);
result.Add(TokenConfig.Instace.TokenKey, token);
return(result);
}
/// <summary>
/// 新增T_SM_UserAccount数据
/// </summary>
/// <param name="requestObject">返回响应结果对象，包括响应代码，新增操作结果</param>
/// <returns></returns>
public async Task <ResponseObject <string> > PostAsync(RequestPost <TSMUserAccountAddModel> requestObject)
{
var currDb = _db.Instance;
try
{
//如果没有新增数据，返回错误信息
if (requestObject.PostData == null && requestObject.PostDataList == null)
{
return(ResponseUtil <string> .FailResult(null, "PostData,PostDataList不能都为null"));
}
var result = false;
string token = string.Empty;
currDb.BeginTran();
//批量新增的优先级高于单条数据新增，且只会执行一个新增操作
if (requestObject.PostDataList != null && requestObject.PostDataList.Count > 0)
{
}
else
{
//注册账号信息
var addModel = _mapper.Map <TSMUserAccountDbModel>(requestObject.PostData);
addModel.Salt = RandCodeCreate.GenerateRandomNumber(32);
addModel.Passwd = EncryptUtil.EnAESBykey(addModel.Passwd, addModel.Salt);
addModel.Status = 1;
if (string.IsNullOrWhiteSpace(addModel.EmailAccount))
{
addModel.EmailAccount = null;
}
if (string.IsNullOrWhiteSpace(addModel.TelAccount))
{
addModel.TelAccount = null;
}
//生成用户详情记录
TSMUserInfoDbModel tSMUserInfoDbModel = new TSMUserInfoDbModel();
int cid = await _db.Instance.Insertable(tSMUserInfoDbModel).ExecuteReturnIdentityAsync();
addModel.UserInfoId = cid;
int id = _db.Instance.Insertable(addModel).ExecuteReturnIdentity();
var palyloads = new Dictionary <string, object>
{
{ "UserID", id },
{ "ID", Guid.NewGuid().ToString() },
{ "CompanyID", 0 },
{ "UserName", addModel.AccountName }
};
token = TokenManager.CreateTokenByHandler(palyloads, 60 * 24);
currDb.CommitTran();
}
//返回执行结果
return(ResponseUtil <string> .SuccessResult(token));
}
catch (Exception ex)
{
//返回异常结果
currDb.RollbackTran();
return(ResponseUtil <string> .FailResult(null, ex.Message));
}
}
/// <summary>
/// 登陆
/// </summary>
/// <param name="requestObject"></param>
/// <returns></returns>
public async Task <ResponseObject <TPMUserAccountAddModel, LoginResult> > LoginAsync(RequestObject <TPMUserAccountAddModel> requestObject)
{
LoginResult loginResult = new LoginResult()
{
IsSuccess = false
};
try
{
//当前登录账户信息
var curr = requestObject.PostData;
if (string.IsNullOrWhiteSpace(curr.LoginName))
{
return(ResponseUtil <TPMUserAccountAddModel, LoginResult> .FailResult(requestObject, loginResult, "登录失败，账户不能为空!"));
}
//查询数据库是否有该账户
var dbModel = await _db.Instance.Queryable <TUsersModel>()
.Where(p => p.LoginName == curr.LoginName && p.Status == true)
.FirstAsync();
//如果没有该账户返回错误信息
if (dbModel == null)
{
return(ResponseUtil <TPMUserAccountAddModel, LoginResult> .FailResult(requestObject, loginResult, "登录失败，账户不存在!"));
}
//验证密码
var currPwd = EncryptUtil.DeAESbyKey(dbModel.LoginPwd, Encoding.UTF8, dbModel.Salt);
if (string.Equals(curr.Passwd, currPwd))
{
loginResult.IsSuccess = true;
//生成Token
Dictionary <string, object> palyloads = new Dictionary <string, object>();
palyloads.Add("UserID", dbModel.Id);
string token = TokenManager.CreateTokenByHandler(palyloads, 60);
loginResult.Token = token;
//加载权限
//RequestObject<TRolePermissionsModel> roleQuery = new RequestObject<TRolePermissionsModel>() { IsPaging = false, QueryConditions = new List<QueryCondition>() };
//roleQuery.QueryConditions.Add(new QueryCondition() { Column = "roleID", Content = dbModel.RoleId.ToString(), Condition = ConditionEnum.Equal });
//var result = await _rolePermissionsService.LoadMenuByRoles(roleQuery);
//loginResult.Permissions = result.Data;
//返回验证成功信息
return(ResponseUtil <TPMUserAccountAddModel, LoginResult> .SuccessResult(requestObject, loginResult));
}
else
{
//返回密码验证失败的错误信息
return(ResponseUtil <TPMUserAccountAddModel, LoginResult> .FailResult(requestObject, loginResult, "登录失败，密码错误"));
}
}
catch (Exception ex)
{
//返回异常信息
return(ResponseUtil <TPMUserAccountAddModel, LoginResult> .FailResult(requestObject, loginResult, $"登录失败，发生异常,{Environment.NewLine}{ex.Message}"));
}
}
/// <summary>
/// 新增T_SM_Company数据
/// </summary>
/// <param name="requestObject">返回响应结果对象，包括响应代码，新增操作结果</param>
/// <returns></returns>
public async Task <ResponseObject <string> > PostAsync(RequestPost <TSMCompanyAddModel> requestObject, CurrentUser currentUser)
{
try
{
_db.Instance.BeginTran();
//如果没有新增数据，返回错误信息
if (requestObject.PostData == null && requestObject.PostDataList == null)
{
return(ResponseUtil <string> .FailResult(null, "PostData不能都为null"));
}
var result = false;
string token = string.Empty;
//批量新增的优先级高于单条数据新增，且只会执行一个新增操作
if (requestObject.PostDataList != null && requestObject.PostDataList.Count > 0)
{
}
else
{
#region 创建公司时，需要效验验证是否过期
var verification = CacheFactory.Instance(CacheType.Redis);
string RedisValue = verification.GetValueByKey <string>(string.Format(CacheKeyString.LoginTimes, requestObject.PostData.TelAccount));
if (RedisValue == "")
{
return(ResponseUtil <string> .FailResult(null, "注册失败，验证码无效"));
}
if (Convert.ToInt32(RedisValue) >= 3)
{
if (string.IsNullOrWhiteSpace(requestObject.PostData.VerificationCode))
{
return(ResponseUtil <string> .FailResult(null, "注册失败，请输入验证码"));
}
if (requestObject.PostData.VerificationCode != verification.GetValueByKey <string>(string.Format(CacheKeyString.TimePassMsgCode, requestObject.PostData.TelAccount)))
{
return(ResponseUtil <string> .FailResult(null, "注册失败，输入的验证码不一致"));
}
}
#endregion
var addModel = _mapper.Map <TSMCompanyDbModel>(requestObject.PostData);
if (_db.Instance.Queryable <TSMCompanyDbModel>().Any(p => p.CompanyName == addModel.CompanyName))
{
throw new Exception("公司已经存在");
}
addModel.AdminId = currentUser.UserID;
result = _db.Instance.Insertable(addModel).ExecuteCommandIdentityIntoEntity();
var tTemplates = _db.Instance.Queryable <TTemplatesModel>().Where(p => p.isDefault).First();
TTenantsModel tenantsModel = new TTenantsModel();
tenantsModel.CreateId = currentUser.UserID;
tenantsModel.TenantShortName = "";
tenantsModel.Status = true;
tenantsModel.IsTrial = true;
tenantsModel.TenantEngName = "";
tenantsModel.ValidityPeriod = DateTime.Now.AddMonths(1);
if (tTemplates != null)
{
tenantsModel.TemplateId = tTemplates.Id;
}
_db.Instance.Insertable <TTenantsModel>(tenantsModel).ExecuteCommandIdentityIntoEntity();
addModel.CompanyInfoId = tenantsModel.ID;//从表ID
_db.Instance.Updateable <TSMUserAccountDbModel>().Where(p => p.ID == currentUser.UserID).SetColumns(it => new TSMUserAccountDbModel()
{
Status = 1, CompanyId = addModel.ID
}).ExecuteCommand();
_db.Instance.Updateable(addModel).UpdateColumns(p => p.CompanyInfoId).ExecuteCommand();
#region 根据版本号查询默认权限
var defaultData = await _db.Instance.Queryable <TTempPermissionsModel>()
.Where(p => p.TemplateId == SqlFunc.Subqueryable <TTemplatesModel>()
.Where(p1 => p1.isDefault && p1.VersionType == requestObject.PostData.VersionType)
.Select(p2 => p2.Id))
.ToListAsync();
List <TTenantPermissionsModel> tenantPermissions = new List <TTenantPermissionsModel>();
foreach (var item in defaultData)
{
tenantPermissions.Add(new TTenantPermissionsModel
{
TenantId = addModel.ID,
MenuId = item.MenuId,
ButtonIds = item.ButtonIds,
CreateId = currentUser.UserID
});
}
await _db.Instance.Insertable(tenantPermissions).ExecuteCommandAsync();
#endregion
#region 生成系统所需的字典类型及默认值
var dictionaryData = await _db.Instance.Queryable <TPMDictionaryInitInfoDbModel>().ToListAsync();
foreach (var item in dictionaryData)
{
var typeNameModel = new TBMDictionaryTypeDbModel
{
ID = 0,
TypeName = item.TypeName,
CompanyId = addModel.ID,
DeleteFlag = false,
IsSys = true
};
await _db.Instance.Insertable(typeNameModel).ExecuteCommandIdentityIntoEntityAsync();
var valueList = new List <TBMDictionaryDbModel>();
foreach (var v in item.TypeValues.Split(","))
{
if (string.IsNullOrEmpty(v))
{
continue;
}
valueList.Add(new TBMDictionaryDbModel
{
ID = 0,
TypeId = typeNameModel.ID,
DicCode = "",
DicValue = v,
Remark = "",
CreateId = currentUser.UserID,
CompanyId = addModel.ID,
DeleteFlag = false
});
}
await _db.Instance.Insertable(valueList).ExecuteCommandAsync();
}
#endregion
var palyloads = new Dictionary <string, object>
{
{ "UserID", currentUser.UserID },
{ "ID", Guid.NewGuid().ToString() },
{ "CompanyID", addModel.ID },
{ "UserName", currentUser.UserName }
};
token = TokenManager.CreateTokenByHandler(palyloads, 60 * 24);
}
_db.Instance.CommitTran();
//返回执行结果
return(ResponseUtil <string> .SuccessResult(token));
}
catch (Exception ex)
{
_db.Instance.RollbackTran();
//返回异常结果
return(ResponseUtil <string> .FailResult(null, ex.Message));
}
}
/// <summary>
/// 登录
/// </summary>
/// <param name="requestObject"></param>
/// <returns></returns>
public async Task <ResponseObject <TSMUserLoginResult> > LoginAsync(RequestPost <TSMUserAccountAddModel> requestObject)
{
try
{
TSMUserLoginResult tSMUserLoginResult = new TSMUserLoginResult();
if (string.IsNullOrEmpty(requestObject.PostData.TelAccount) &&
string.IsNullOrEmpty(requestObject.PostData.EmailAccount))
{
return(ResponseUtil <TSMUserLoginResult>
.FailResult(null, "手机号或邮箱号至少需要一个"));
}
//当前登录账户信息
var curr = requestObject.PostData;
//查询数据库是否有该账户
var dbModel = await _db.Instance.Queryable <TSMUserAccountDbModel>()
.Where(p => p.TelAccount == curr.TelAccount || p.EmailAccount == curr.EmailAccount)
.FirstAsync();
//如果没有该账户返回错误信息
if (dbModel == null)
{
return(ResponseUtil <TSMUserLoginResult>
.FailResult(null, "登录失败，账户不存在!"));
}
if (dbModel.Status != 1)
{
return(ResponseUtil <TSMUserLoginResult>
.FailResult(null, "登录失败，账户无效或过期"));
}
#region 如果登录三次以上需要提供手机验证码
var verification = CacheFactory.Instance(CacheType.Redis);
if (verification.ContainsKey(string.Format(CacheKeyString.LoginTimes, curr.TelAccount)))
{
string RedisValue = verification.GetValueByKey <string>(string.Format(CacheKeyString.LoginTimes, curr.TelAccount));
if (Convert.ToInt32(RedisValue) >= 3)
{
if (string.IsNullOrWhiteSpace(curr.VerificationCode))
{
return(ResponseUtil <TSMUserLoginResult> .FailResult(null, "登录失败，请输入验证码"));
}
if (curr.VerificationCode != verification.GetValueByKey <string>(string.Format(CacheKeyString.TimePassMsgCode, curr.TelAccount)))
{
return(ResponseUtil <TSMUserLoginResult> .FailResult(null, "登录失败，输入的验证码不一致"));
}
}
}
#endregion
//验证密码
var currPwd = EncryptUtil.DeAESbyKey(dbModel.Passwd, Encoding.UTF8, dbModel.Salt);
if (string.Equals(curr.Passwd, currPwd))
{
var dbUserInfo = await _db.Instance.Queryable <TSMUserInfoDbModel>()
.Where(p => p.ID == dbModel.UserInfoId)
.FirstAsync();
var rolesDbModel = _db.Instance.Queryable <TSMRoleUserRelationDbModel, TSMRolesDbModel>(
(t1, t2) => new object[]
{
JoinType.Left, t1.RoleId == t1.Id
}).Where((t1, t2) => t1.UserId == dbModel.ID).Select((t1, t2) => t2).First();
var palyloads = new Dictionary <string, object>
{
{ "UserID", dbModel.ID },
{ "ID", Guid.NewGuid().ToString() },
{ "CompanyID", dbModel.CompanyId == null?0:dbModel.CompanyId.Value },
{ "UserName", dbModel.AccountName }
};
var token = TokenManager.CreateTokenByHandler(palyloads, 60 * 24);
try
{
#region 缓存当前用户的个人信息到redis
var redis = CacheFactory.Instance(CacheType.Redis);
string key = string.Format(CacheKeyString.UserAccount, dbModel.ID);
if (redis.ContainsKey(key))
{
redis.RemoveKey(key);
}
SMUserInfo sMUserInfo = new SMUserInfo();
sMUserInfo.UserID = dbModel.ID;
sMUserInfo.CompanyId = dbModel.CompanyId;
sMUserInfo.EmailAccount = dbModel.EmailAccount;
sMUserInfo.TelAccount = dbModel.TelAccount;
sMUserInfo.AccountName = dbModel.AccountName;
sMUserInfo.RealName = dbUserInfo.RealName;
sMUserInfo.RoleName = rolesDbModel?.RoleName;
redis.AddKey <SMUserInfo>(key, sMUserInfo, 60 * 60 * 24);
#endregion
}
catch (Exception ex)
{
}
tSMUserLoginResult.Token = token;
tSMUserLoginResult.IsHavaCompany = dbModel.CompanyId == null ? false : true;
#region 登录成功删除【登录失败记录次数】
var Successredis = CacheFactory.Instance(CacheType.Redis);
if (Successredis.ContainsKey(string.Format(CacheKeyString.LoginTimes, curr.TelAccount)))
{
Successredis.RemoveKey(string.Format(CacheKeyString.LoginTimes, curr.TelAccount));
}
#endregion
//返回验证成功信息
return(ResponseUtil <TSMUserLoginResult>
.SuccessResult(tSMUserLoginResult));
}
#region 登录失败记录次数
var redisError = CacheFactory.Instance(CacheType.Redis);
string keyError = string.Format(CacheKeyString.LoginTimes, curr.TelAccount);
string RedisCode = redisError.GetValueByKey <string>(keyError);
redisError.AddOrUpdateKey <string>(keyError, RedisCode == "" ? "1" : (Convert.ToInt32(RedisCode) + 1).ToString(), 3600);
#endregion
//返回密码验证失败的错误信息
return(ResponseUtil <TSMUserLoginResult> .FailResult(null, "登录失败，密码错误"));
}
catch (Exception ex)
{
//返回异常信息
return(ResponseUtil <TSMUserLoginResult>
.FailResult(null, ex.Message));
}
}
