/// <summary>
/// 修改密码
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public ResultEx UpdatePassword(AccountModel.ModifyPwd model)
{
using (var dbScope = _dbScopeFactory.Create())
{
try
{
var db = dbScope.DbContexts.Get <WebDbContext>();
var accountModel = this.GetModel(CurrentUser.User.UserName);
if (accountModel == null)
{
return(ResultEx.Init(false, "未能找到用户信息！"));
}
if (accountModel.Password != new MD5Encrtpy().encode(model.OldPwd))
{
return(ResultEx.Init(false, "原始密码错误！"));
}
accountModel.Password = new MD5Encrtpy().encode(model.NewPwd);
db.Entry(accountModel).State = EntityState.Modified;
db.SaveChanges();
return(ResultEx.Init());
}
catch (System.Exception ex)
{
return(ResultEx.Init(ex));
}
}
}
public IHttpActionResult Login(string userName, string password)
{
var response = GetUserToken(userName, password);
if (response.IsError)
{
return(Ok(ResultEx.Init(false, response.Error)));
}
var claims = new List <System.Security.Claims.Claim>();
var model = _AccountSvc.GetFullModel(userName);
if (model != null)
{
claims.Add(new System.Security.Claims.Claim("UserName", model.UserName));
claims.Add(new System.Security.Claims.Claim("UserType", model.UserType.ToString()));
claims.Add(new System.Security.Claims.Claim("UserTypeName", model.UserTypeName));
}
var tockenModel = new TokenModel
{
AccessToken = response.AccessToken,
ExpiresIn = response.ExpiresIn,
TokenType = response.TokenType,
Claims = claims
};
return(Ok(ResultEx.Init(true, "", tockenModel)));
}
/// <summary>
/// 删除角色
/// </summary>
/// <param name="ids"></param>
/// <returns></returns>
public ResultEx Delete(List <int> ids)
{
using (TransactionScope ts = new TransactionScope())
{
try
{
using (var dbScope = _dbScopeFactory.Create())
{
var db = dbScope.DbContexts.Get <WebDbContext>();
var query = from p in db.SysRoles
where ids.Contains(p.Id)
select p;
query.Delete();
//删除从表
db.SysRoleMenus.Where(p => ids.Contains(p.RoleId)).Delete();
db.SysRoleFunctions.Where(p => ids.Contains(p.RoleId)).Delete();
db.SaveChanges();
ts.Complete();
return(ResultEx.Init());
}
}
catch (Exception ex)
{
ts.Dispose();
return(ResultEx.Init(ex));
}
}
}
/// <summary>
/// 修改密码
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public ResultEx UpdatePassword(int userId, AccountModel.ModifyPwd model)
{
using (var dbScope = _dbScopeFactory.Create())
{
try
{
var db = dbScope.DbContexts.Get <WebDbContext>();
var accountModel = db.SysAccounts.Where(x => x.Id == userId).SingleOrDefault();
if (accountModel == null)
{
return(ResultEx.Init(false, "未能找到用户信息！"));
}
if (accountModel.Password != new MD5Encrtpy().encode(model.OldPwd))
{
return(ResultEx.Init(false, "原始密码错误！"));
}
db.SysAccounts.Where(x => x.Id == userId).Update(x => new SysAccount {
Password = new MD5Encrtpy().encode(model.NewPwd)
});
db.SaveChanges();
return(ResultEx.Init());
}
catch (System.Exception ex)
{
return(ResultEx.Init(ex));
}
}
}
/// <summary>
/// 用户角色保存
/// </summary>
/// <param name="userId"></param>
/// <param name="roleIds"></param>
/// <returns></returns>
public ResultEx SaveAccoutRole(int userId, List <int> roleIds)
{
using (TransactionScope ts = new TransactionScope())
{
using (var dbScope = _dbScopeFactory.Create())
{
try
{
var db = dbScope.DbContexts.Get <WebDbContext>();
db.SysAccountRoles.Where(x => x.UserId == userId).Delete();
foreach (var roleId in roleIds)
{
db.SysAccountRoles.Add(new Models.SysAccountRole {
RoleId = roleId, UserId = userId
});
}
db.SaveChanges();
ts.Complete();
return(ResultEx.Init());
}
catch (System.Exception ex)
{
ts.Dispose();
return(ResultEx.Init(ex));
}
}
}
}
/// <summary>
/// 删除
/// </summary>
/// <param name="ids">主键列表</param>
/// <returns></returns>
public ResultEx Delete(List <int> ids)
{
using (var dbScope = _dbScopeFactory.Create())
{
var db = dbScope.DbContexts.Get <WebDbContext>();
db.SysAccounts.Where(p => ids.Contains(p.Id)).Delete();
return(ResultEx.Init());
}
}
/// <summary>
/// 修改头像
/// </summary>
/// <param name="id"></param>
/// <param name="headPoint"></param>
/// <returns></returns>
public ResultEx UpdateHeadPoint(int id, string headPoint)
{
using (var dbScope = _dbScopeFactory.Create())
{
var db = dbScope.DbContexts.Get <WebDbContext>();
db.SysAccounts.Where(x => x.Id == id).Update(x => new SysAccount {
HeadPoint = headPoint
});
return(ResultEx.Init());
}
}
/// <summary>
/// 保存
/// </summary>
/// <param name="model"></param>
/// <param name="menuIDs"></param>
/// <param name="funcIDs"></param>
/// <returns></returns>
public ResultEx Save(SysRole model, List <int> menuIDs, List <int> funcIDs)
{
using (TransactionScope ts = new TransactionScope())
{
try
{
using (var dbScope = _dbScopeFactory.Create())
{
var db = dbScope.DbContexts.Get <WebDbContext>();
if (model.Id == 0)
{
db.SysRoles.Add(model);
}
else
{
db.Entry(model).State = System.Data.Entity.EntityState.Modified;
}
db.SaveChanges();
if (menuIDs != null)
{
db.SysRoleMenus.Where(p => p.RoleId == model.Id).Delete();
foreach (var item in menuIDs)
{
db.SysRoleMenus.Add(new SysRoleMenu {
MenuId = item, RoleId = model.Id
});
}
}
if (funcIDs != null)
{
db.SysRoleFunctions.Where(p => p.RoleId == model.Id).Delete();
foreach (var item in funcIDs)
{
db.SysRoleFunctions.Add(new SysRoleFunction {
FunctionId = item, RoleId = model.Id
});
}
}
db.SaveChanges();
ts.Complete();
return(ResultEx.Init());
}
}
catch (Exception ex)
{
ts.Dispose();
return(ResultEx.Init(ex));
}
}
}
/// <summary>
/// 批量删除菜单
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public ResultEx Deletes(List <int> ids)
{
using (var ts = new TransactionScope())
{
using (var dbScope = _dbScopeFactory.Create())
{
try
{
var db = dbScope.DbContexts.Get <WebDbContext>();
var list = db.SysMenus.ToList();
Func <int, List <int> > func = null;
func = new Func <int, List <int> >(p =>
{
var result = new List <int>();
var childList = list.Where(x => x.ParentId == p).ToList();
if (childList.Count > 0)
{
result.AddRange(childList.Select(x => x.Id).ToList());
}
foreach (var item in childList)
{
result.AddRange(func(item.Id));
}
return(result);
});
foreach (var id in ids)
{
var childIds = func(id);
if (childIds.Count > 0)
{
db.SysMenus.Where(x => childIds.Contains(x.Id)).Delete();
}
db.SysMenus.Where(x => x.Id == id).Delete();
db.SysMenuFunctions.Where(x => x.MenuId == id).Delete();
}
db.SaveChanges();
ts.Complete();
return(ResultEx.Init());
}
catch (Exception ex)
{
ts.Dispose();
return(ResultEx.Init(ex));
}
}
}
}
/// <summary>
/// 保存
/// </summary>
/// <param name="model">model</param>
/// <returns></returns>
public ResultEx Save(SysAccount model)
{
using (var dbScope = _dbScopeFactory.Create())
{
var db = dbScope.DbContexts.Get <WebDbContext>();
if (model.Id == 0)
{
db.SysAccounts.Add(model);
}
else
{
db.Entry(model).State = System.Data.Entity.EntityState.Modified;
}
return(ResultEx.Init(db.SaveChanges() > 0));
}
}
/// <summary>
/// 重置密码
/// </summary>
/// <param name="ids"></param>
/// <param name="password"></param>
/// <returns></returns>
public ResultEx ResetPassWord(List <int> ids, string password)
{
using (var dbScope = _dbScopeFactory.Create())
{
try
{
var db = dbScope.DbContexts.Get <WebDbContext>();
db.SysAccounts.Where(x => ids.Contains(x.Id)).Update(x => new SysAccount {
Password = password
});
return(ResultEx.Init());
}
catch (System.Exception ex)
{
return(ResultEx.Init(ex));
}
}
}
/// <summary>
/// 批量更新状态
/// </summary>
/// <param name="ids"></param>
/// <param name="flag"></param>
/// <returns></returns>
public ResultEx Enabled(List <int> ids, bool flag)
{
using (var dbScope = _dbScopeFactory.Create())
{
try
{
var db = dbScope.DbContexts.Get <WebDbContext>();
db.SysAccounts.Where(x => ids.Contains(x.Id)).Update(x => new SysAccount {
IsEnabled = !flag
});
return(ResultEx.Init());
}
catch (System.Exception ex)
{
return(ResultEx.Init(ex));
}
}
}
public void UpdatePasswordOldPwdNotRight()
{
var model = new AccountModel.ModifyPwd {
ConfirmPwd = "123456", NewPwd = "123456", OldPwd = "888888", UserID = 1
};
var accountService = new Mock <IAccountSvc>();
accountService
.Setup(c => c.UpdatePassword(model))
.Returns(ResultEx.Init());
// Target object
var presenter = new AccountPresenter(accountService.Object);
// Act
var result = presenter.UpdatePassword(model);
// Assert
Assert.NotNull(result);
Assert.True(result.flag);
Assert.Empty(result.msg);
}
public ResultEx ConnectTest(InstallSqlServerModel sqlServerModel)
{
var result = CheckSqlServerParameter(sqlServerModel);
if (result.Flag)
{
string connectionString;
if (sqlServerModel.ConnectionString != null)
{
sqlServerModel.ConnectionString = sqlServerModel.ConnectionString.Trim();
}
if (sqlServerModel.ConnectionType == ConnectionType.String)
{
connectionString = sqlServerModel.ConnectionString;
}
else
{
connectionString = CreateConnectionString(
sqlServerModel.AuthenticationType == AuthenticationType.Windows,
sqlServerModel.ServerName, sqlServerModel.DatabaseName, sqlServerModel.Username,
sqlServerModel.Password);
}
try
{
//通过连接数据库方式确定
using (var conn = new SqlConnection(connectionString))
{
conn.Open();
conn.Close();
}
return(ResultEx.Init(true));
}
catch (Exception ex)
{
return(ResultEx.Init(false, ex.Message));
}
}
return(result);
}
/// <summary>
/// 保存功能
/// </summary>
/// <param name="menuId"></param>
/// <param name="List"></param>
/// <returns></returns>
public ResultEx Save(int menuId, List <SysMenuFunction> List)
{
using (TransactionScope ts = new TransactionScope())
{
try
{
using (var dbScope = _dbScopeFactory.Create())
{
var db = dbScope.DbContexts.Get <WebDbContext>();
var notDeleteIds = List.Where(p => p.Id != 0).Select(p => p.Id).ToList();
if (notDeleteIds.Count > 0)
{
db.SysMenuFunctions.Where(p => !notDeleteIds.Contains(p.Id) && p.MenuId == menuId).Delete();
}
foreach (var item in List)
{
item.MenuId = menuId;
if (item.Id != 0)
{
db.Entry(item).State = System.Data.Entity.EntityState.Modified;
}
else
{
db.SysMenuFunctions.Add(item);
}
}
var rs = db.SaveChanges();
}
ts.Complete();
return(ResultEx.Init());
}
catch (Exception ex)
{
ts.Dispose();
return(ResultEx.Init(ex));
}
}
}
public async Task <ResultEx> SaveEntityAsync(Device entity)
{
//分站程序编号和序号保持一致
if (entity.DeviceType == DeviceTypeEnum.Substation)
{
if (entity.DeviceNum < 1 || entity.DeviceNum > 64)
{
return(ResultEx.Init(false, "分站编号只能为1~64"));
}
entity.SerialNum = entity.DeviceNum;
}
if (!(entity.DeviceType == DeviceTypeEnum.BaseStation || entity.DeviceType == DeviceTypeEnum.BeaconCard))
{
entity.SubstationId = null;
}
else
{
if (entity.DeviceNum < 1 || entity.DeviceNum > 65535)
{
return(ResultEx.Init(false, "基站编号只能为1~65535"));
}
if (entity.SerialNum.GetValueOrDefault(0) > 64 || entity.SerialNum.GetValueOrDefault(0) < 1)
{
return(ResultEx.Init(false, "设备序号只能为1~64的数字"));
}
}
if (entity.Id == Guid.Empty)
{
// 查看相同设备类型下的编号是否已经使用
var existEntity = await BaseRepository.TableNoTracking.FirstOrDefaultAsync(r =>
r.DeviceType == entity.DeviceType && r.DeviceNum == entity.DeviceNum);
if (existEntity != null)
{
return(ResultEx.Init(false, "该设备类型指定的编号已经存在,请使用其它编号"));
}
//查看基站和定位器序号是否已经使用
if (entity.DeviceType == DeviceTypeEnum.BaseStation || entity.DeviceType == DeviceTypeEnum.BeaconCard)
{
//基站和定位器编号不能重复
existEntity = await BaseRepository.TableNoTracking.FirstOrDefaultAsync(r =>
(r.DeviceType == DeviceTypeEnum.BaseStation || r.DeviceType == DeviceTypeEnum.BeaconCard) && r.DeviceNum == entity.DeviceNum);
if (existEntity != null)
{
return(ResultEx.Init(false, "编号在基站或者定位器中已使用，请换其他编号"));
}
//判断相同类型设备同一分站下序号是否重复
existEntity = await BaseRepository.TableNoTracking.FirstOrDefaultAsync(r =>
r.DeviceType == entity.DeviceType && r.SubstationId == entity.SubstationId && r.SerialNum == entity.SerialNum);
if (existEntity != null)
{
return(ResultEx.Init(false, "设备序号已经使用，请换其它序号"));
}
}
//基站和分站新增时状态处理为未知
if (entity.DeviceType == DeviceTypeEnum.BaseStation || entity.DeviceType == DeviceTypeEnum.Substation)
{
entity.DeviceState = -1;
}
entity.SysStartTime = DateTime.Now;
entity.SysEndTime = DateTime.MaxValue;
//新增
await BaseRepository.InsertAsync(entity);
var result = await _unitOfWork.SaveChangesAsync();
if (result <= 0)
{
return(ResultEx.Init(false, "保存失败"));
}
await _cacheProvider.RemoveAsync($"devices:{entity.DeviceNum}");
//新增时同步将数据推送到mqtt，下发到下位机，编辑时不下发
//因为保存进来的数据没有设备所属分站信息，所有这里需要从数据库重新查询一次
if (entity.SubstationId != null && entity.SubstationId != Guid.Empty)
{
entity.Substation = await BaseRepository.GetByKeys(entity.SubstationId);
}
#pragma warning disable 4014
_devicePublish.AddPublishAsync(entity);
#pragma warning restore 4014
}
else
{
//修改时候讲分站对象赋值空，否则，修改时候会循环多次修改相关数据
entity.Substation = null;
var newDevice = BaseRepository.Table.Update(entity);
//设备状态和设备状态监测时间是不能修改的
newDevice.Property(r => r.DeviceState).IsModified = false;
newDevice.Property(r => r.LastCheckTime).IsModified = false;
newDevice.Property(r => r.CreateDate).IsModified = false;
newDevice.Property(r => r.SysStartTime).IsModified = false;
newDevice.Property(r => r.SysEndTime).IsModified = false;
int result = await _unitOfWork.SaveChangesAsync();
if (result <= 0)
{
return(ResultEx.Init(false, "保存失败"));
}
}
return(ResultEx.Init());
}
public async Task <ResultEx> InitDataBase(InstallSqlServerModel sqlServerModel)
{
var result = CheckSqlServerParameter(sqlServerModel);
if (result.Flag)
{
_dataBaseName = result.Data.ToString();
string connectionString;
if (!string.IsNullOrEmpty(sqlServerModel.ConnectionString))
{
sqlServerModel.ConnectionString = sqlServerModel.ConnectionString.Trim();
}
if (sqlServerModel.ConnectionType == ConnectionType.String)
{
connectionString = sqlServerModel.ConnectionString;
}
else
{
connectionString = CreateConnectionString(
sqlServerModel.AuthenticationType == AuthenticationType.Windows,
sqlServerModel.ServerName, sqlServerModel.DatabaseName, sqlServerModel.Username,
sqlServerModel.Password);
}
//创建新的DBContext对象只是数据库创建操作
var builder = new DbContextOptionsBuilder();
builder.UseSqlServer(connectionString);
var dbContext = new Kj1012Context(builder.Options);
var dataBase = dbContext.Database;
var databaseCreator = dataBase.GetService <IRelationalDatabaseCreator>();
sqlServerModel.ConnectionString = connectionString;
var isCreateDatabase = false;
if (sqlServerModel.AlwaysCreate)
{
if (databaseCreator.Exists())
{
await databaseCreator.DeleteAsync();
}
await CreateDataBase(databaseCreator, dataBase);
isCreateDatabase = true;
}
else if (sqlServerModel.NotExistCreate)
{
if (!databaseCreator.Exists())
{
await CreateDataBase(databaseCreator, dataBase);
isCreateDatabase = true;
}
}
else
{
if (!databaseCreator.Exists())
{
return(ResultEx.Init(false, "数据库名称不存在，请核对"));
}
}
var version = GetSqlServerVersion(sqlServerModel.ConnectionString);
if (version < 10)
{
return(ResultEx.Init(false, "创建数据表失败，Sql Server 数据库版本至少需要Sql Server 2008及以上"));
}
if (version > 0)
{
//SQL Server2016 及以上执行2016脚本
if (version >= 13 && isCreateDatabase)
{
//执行2016脚本
ExecuteSqlScriptFromFile(dataBase, $"{SqlServerScriptPath}\\SqlServer_2016.sql");
}
//保存数据库配置信息
_appSettingService.SaveDataSetting(new DataSettings
{
DataProvider = DataProviderType.SqlServer,
Version = version,
ConnectionString = AesHelper.AesEncrypt(sqlServerModel.ConnectionString, ConstDefine.DataSettingAesKey)
});
}
else
{
return(ResultEx.Init(false, "创建数据表失败，未知SQL SERVER数据库版本"));
}
}
return(result);
}
