/// <summary>
/// 登录
/// </summary>
/// <param name="taskId">任务标识</param>
/// <param name="userInfo">用户</param>
/// <param name="companyName">单位名称</param>
/// <param name="userName">用户名</param>
/// <param name="password">密码</param>
/// <param name="openId">单点登录标识</param>
/// <param name="createOpenId">重新创建单点登录标识</param>
/// <param name="ipAddress">IP地址</param>
/// <returns>登录实体类</returns>
public UserLogOnResult LogOnByCompany(string taskId, BaseUserInfo userInfo, string companyName, string userName, string password, string openId, bool createOpenId)
{
UserLogOnResult result = new UserLogOnResult();
var parameter = ServiceInfo.Create(taskId, userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterWriteDb(userInfo, parameter, (dbHelper) =>
{
// 先侦测是否在线
// userLogOnManager.CheckOnLine();
// 再进行登录
var userManager = new BaseUserManager(userInfo);
userManager.CheckIsAdministrator = true;
result = userManager.LogOnByCompany(companyName, userName, password, openId, createOpenId, userInfo.SystemCode, GetRemoteIP());
// 张祈璟20130619添加
//if (returnUserInfo != null)
//{
// returnUserInfo.CloneData(userInfo);
// result.UserInfo = returnUserInfo;
//}
// 登录时会自动记录进行日志记录，所以不需要进行重复日志记录
// BaseLogManager.Instance.Add(result, this.serviceName, MethodBase.GetCurrentMethod());
});
return(result);
}
/// <summary>
/// 授予资源的权限
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="resourceCategory">资源分类</param>
/// <param name="resourceId">资源主键</param>
/// <param name="grantPermissionIds">权限主键</param>
/// <returns>影响的行数</returns>
public int GrantResourcePermission(BaseUserInfo userInfo, string resourceCategory, string resourceId, string[] grantPermissionIds)
{
var result = 0;
var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterWriteDb(userInfo, parameter, (dbHelper) =>
{
var manager = new BaseRoleScopeManager(dbHelper, userInfo);
// 小心异常，检查一下参数的有效性
if (grantPermissionIds != null)
{
var permissionManager = new BasePermissionManager(dbHelper, userInfo);
for (var i = 0; i < grantPermissionIds.Length; i++)
{
var resourcePermissionEntity = new BasePermissionEntity
{
ResourceCategory = resourceCategory,
ResourceId = resourceId,
PermissionId = grantPermissionIds[i],
Enabled = 1,
Deleted = 0
};
permissionManager.Add(resourcePermissionEntity);
result++;
}
}
});
return(result);
}
/// <summary>
/// 用户修改密码
/// </summary>
/// <param name="taskId">任务标识</param>
/// <param name="userInfo">用户</param>
/// <param name="oldPassword">原始密码</param>
/// <param name="newPassword">新密码</param>
/// <returns>影响行数</returns>
public UserLogOnResult ChangePassword(string taskId, BaseUserInfo userInfo, string oldPassword, string newPassword)
{
UserLogOnResult result = null;
var parameter = ServiceInfo.Create(taskId, userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterWriteDb(userInfo, parameter, (dbHelper) =>
{
// 事务开始
// dbHelper.BeginTransaction();
var userManager = new BaseUserManager(dbHelper, userInfo);
result = new UserLogOnResult();
result.UserInfo = userManager.ChangePassword(userInfo.Id, oldPassword, newPassword);
// 获取登录后信息
// result.Message = BaseParameterManager.GetParameterByCache("BaseNotice", "System", "LogOn", "Message");
// 获得状态消息
result.StatusCode = userManager.StatusCode;
result.StatusMessage = userManager.GetStateMessage();
// 事务提交
// dbHelper.CommitTransaction();
});
return(result);
}
/// <summary>
/// 更新组织机构
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="entity">实体</param>
/// <param name="statusCode">状态码</param>
/// <param name="statusMessage">状态信息</param>
/// <returns>影响行数</returns>
public int Update(BaseUserInfo userInfo, BaseOrganizeEntity entity, out string statusCode, out string statusMessage)
{
int result = 0;
string returnCode = string.Empty;
string returnMessage = string.Empty;
var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterWriteDb(userInfo, parameter, (dbHelper) =>
{
// 2015-12-19 吉日嘎拉 网络不稳定，数据获取不完整时，异常时，会引起重大隐患
var manager = new BaseOrganizeManager(dbHelper, userInfo);
// result = manager.Update(entity);
if (manager.StatusCode.Equals(Status.OKUpdate.ToString()))
{
// var folderManager = new BaseFolderManager(dbHelper, userInfo);
// result = folderManager.SetProperty(entity.Id.ToString(), new KeyValuePair<string, object>(BaseFolderEntity.FieldFolderName, entity.FullName));
}
returnCode = manager.StatusCode;
returnMessage = manager.StatusMessage;
});
statusCode = returnCode;
statusMessage = returnMessage;
return(result);
}
/// <summary>
/// 添加实体
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="entity">实体</param>
/// <param name="statusCode">返回状态码</param>
/// <param name="statusMessage">返回状态信息</param>
/// <returns>数据表</returns>
public string Add(BaseUserInfo userInfo, BaseItemsEntity entity, out string statusCode, out string statusMessage)
{
string result = string.Empty;
string returnCode = string.Empty;
string returnMessage = string.Empty;
var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterWriteDb(userInfo, parameter, (dbHelper) =>
{
string tableName = BaseItemsEntity.TableName;
if (userInfo != null && !string.IsNullOrEmpty(userInfo.SystemCode))
{
tableName = userInfo.SystemCode + "Items";
}
BaseItemsManager itemsManager = new BaseItemsManager(dbHelper, userInfo, tableName);
// 调用方法，并且返回运行结果
result = itemsManager.Add(entity, out returnCode);
returnMessage = itemsManager.GetStateMessage(returnCode);
});
statusCode = returnCode;
statusMessage = returnMessage;
return(result);
}
/// <summary>
/// 更新
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="entity">实体</param>
/// <param name="statusCode">状态码</param>
/// <param name="statusMessage">状态信息</param>
/// <returns>影响行数</returns>
public int Update(BaseUserInfo userInfo, BaseAreaEntity entity, out string statusCode, out string statusMessage)
{
int result = 0;
string returnCode = string.Empty;
string returnMessage = string.Empty;
var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterWriteDb(userInfo, parameter, (dbHelper) =>
{
var manager = new BaseAreaManager(dbHelper, userInfo);
result = manager.Update(entity, out returnCode);
returnMessage = manager.GetStateMessage(returnCode);
});
statusCode = returnCode;
statusMessage = returnMessage;
// 处理缓存优化性能
System.Web.Caching.Cache cache = HttpRuntime.Cache;
string cacheObject = string.Empty;
if (string.IsNullOrEmpty(entity.ParentId))
{
cacheObject = "AreaProvince";
}
else
{
cacheObject = "Area" + entity.ParentId;
}
cache.Remove(cacheObject);
return(result);
}
/// <summary>
/// 批量移出角色（按角色编号）
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="userId">用户主键</param>
/// <param name="systemCode">系统编号</param>
/// <param name="roleCode">角色编号</param>
/// <returns>影响的行数</returns>
public int RemoveUserFromRoleByCode(BaseUserInfo userInfo, string userId, string systemCode, string roleCode)
{
var result = 0;
var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterWriteDb(userInfo, parameter, (dbHelper) =>
{
if (string.IsNullOrWhiteSpace(systemCode))
{
systemCode = "Base";
}
if (!string.IsNullOrWhiteSpace(roleCode))
{
var roleId = string.Empty;
var tableName = systemCode + "Role";
var roleManager = new BaseRoleManager(userInfo, tableName);
roleId = roleManager.GetIdByCode(roleCode);
if (!string.IsNullOrWhiteSpace(roleId))
{
var userManager = new BaseUserManager(dbHelper, userInfo);
result += userManager.RemoveFromRole(systemCode, userId, roleId);
}
}
});
return(result);
}
/// <summary>
/// 添加实体
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="entity">实体</param>
/// <param name="status">状态</param>
/// <param name="statusMessage">状态信息</param>
/// <returns>主键</returns>
public string Add(BaseUserInfo userInfo, BaseOrganizationEntity entity, out Status status, out string statusMessage)
{
var result = string.Empty;
var returnCode = Status.Ok;
var returnMessage = string.Empty;
var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterWriteDb(userInfo, parameter, (dbHelper) =>
{
var manager = new BaseOrganizationManager(dbHelper, userInfo);
result = manager.UniqueAdd(entity, out returnCode);
//增加返回状态和信息Troy.Cui 2018-10-03
returnMessage = manager.StatusMessage;
//returnMessage = manager.GetStateMessage(returnCode);
if (returnCode.Equals(Status.OkAdd.ToString()))
{
entity.Id = int.Parse(result);
//Troy.Cui 2018-10-18去掉这里的Folder检查
//var folderManager = new BaseFolderManager(dbHelper, userInfo);
//folderManager.FolderCheck(entity.Id.ToString(), entity.Name);
}
});
status = returnCode;
statusMessage = returnMessage;
return(result);
}
/// <summary>
/// 批量设置删除
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="ids">主键数组</param>
/// <returns>影响行数</returns>
public int SetDeleted(BaseUserInfo userInfo, string[] ids)
{
var result = 0;
var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterWriteDb(userInfo, parameter, (dbHelper) =>
{
var userManager = new BaseUserManager(dbHelper, userInfo);
var staffManager = new BaseStaffManager(dbHelper, userInfo);
BaseStaffEntity staffEntity = null;
for (var i = 0; i < ids.Length; i++)
{
// 删除相应的用户
staffEntity = staffManager.GetEntity(ids[i]);
if (staffEntity != null && staffEntity.UserId > 0)
{
userManager.SetDeleted(staffEntity.UserId);
}
// 删除职员
result = staffManager.SetDeleted(ids[i], true, true);
}
});
return(result);
}
/// <summary>
/// 用户修改签名密码
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="oldPassword">原始密码</param>
/// <param name="newPassword">新密码</param>
/// <param name="statusCode">返回状态码</param>
/// <param name="statusMessage">返回状消息</param>
/// <returns>影响行数</returns>
public int ChangeSignedPassword(BaseUserInfo userInfo, string oldPassword, string newPassword, out string statusCode, out string statusMessage)
{
var parameter = ServiceParameter.CreateWithMessage(userInfo
, MethodBase.GetCurrentMethod()
, this.serviceName
, AppMessage.LogOnService_ChangeSignedPassword);
int result = 0;
string returnCode = string.Empty;
string returnMessage = string.Empty;
ServiceUtil.ProcessUserCenterWriteDb(parameter, (dbHelper) =>
{
// 事务开始
// dbHelper.BeginTransaction();
var userManager = new BaseUserLogOnManager(dbHelper, userInfo);
result = userManager.ChangeSignedPassword(oldPassword, newPassword, out returnCode);
// 获得状态消息
returnMessage = userManager.GetStateMessage(returnCode);
// 事务提交
// dbHelper.CommitTransaction();
});
statusCode = returnCode;
statusMessage = returnMessage;
return(result);
}
/// <summary>
/// 按公司获取员工列表
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="organizationId">组织主键</param>
/// <param name="containChildren">含子部门</param>
/// <returns>数据表</returns>
public DataTable GetDataTableByOrganization(BaseUserInfo userInfo, string organizationId, bool containChildren)
{
var dt = new DataTable(BaseStaffEntity.CurrentTableName);
var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterWriteDb(userInfo, parameter, (dbHelper) =>
{
// 用户已经不存在的需要整理干净，防止数据不完整。
var sql = "UPDATE BaseStaff SET UserId = NULL WHERE (UserId NOT IN (SELECT Id FROM BaseUser))";
dbHelper.ExecuteNonQuery(sql);
dbHelper.Close();
// 这里是读取的服务器连接
dbHelper.Open(BaseSystemInfo.UserCenterReadDbConnection);
var manager = new BaseStaffManager(dbHelper, userInfo);
if (containChildren)
{
dt = manager.GetChildrenStaffs(organizationId);
}
else
{
dt = manager.GetDataTableByOrganization(organizationId);
}
dt.TableName = BaseStaffEntity.CurrentTableName;
});
return(dt);
}
/// <summary>
/// 锁定用户
/// </summary>
/// <param name="taskId">任务标识</param>
/// <param name="userInfo">用户</param>
/// <param name="userName">用户名</param>
/// <returns>是否成功锁定</returns>
public bool LockUser(string taskId, BaseUserInfo userInfo, string userName)
{
bool result = false;
var parameter = ServiceInfo.Create(taskId, userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterWriteDb(userInfo, parameter, (dbHelper) =>
{
// BaseLogManager.Instance.Add(result, this.serviceName, AppMessage.LogOnService_LockUser, MethodBase.GetCurrentMethod());
var userManager = new BaseUserManager(userInfo);
List <KeyValuePair <string, object> > parameters = new List <KeyValuePair <string, object> >();
parameters.Add(new KeyValuePair <string, object>(BaseUserEntity.FieldUserName, userName));
parameters.Add(new KeyValuePair <string, object>(BaseUserEntity.FieldEnabled, 1));
parameters.Add(new KeyValuePair <string, object>(BaseUserEntity.FieldDeletionStateCode, 0));
BaseUserEntity userEntity = BaseEntity.Create <BaseUserEntity>(userManager.GetDataTable(parameters));
// 判断是否为空的
if (userEntity != null && !string.IsNullOrEmpty(userEntity.Id))
{
// 被锁定15分钟，不允许15分钟内登录，这时间是按服务器的时间来的。
var userLogOnManager = new BaseUserLogOnManager();
BaseUserLogOnEntity userLogOnEntity = userLogOnManager.GetObject(userEntity.Id);
userLogOnEntity.LockStartDate = DateTime.Now;
userLogOnEntity.LockEndDate = DateTime.Now.AddMinutes(BaseSystemInfo.PasswordErrorLockCycle);
result = userLogOnManager.UpdateObject(userLogOnEntity) > 0;
}
});
return(result);
}
/// <summary>
/// 获取在线用户列表
/// </summary>
/// <param name="userInfo">用户</param>
/// <returns>数据表</returns>
public DataTable GetOnLineState(BaseUserInfo userInfo)
{
var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterWriteDb(userInfo, parameter, (dbHelper) =>
{
var userLogOnManager = new BaseUserLogOnManager(dbHelper, userInfo);
// 设置为在线状态
userLogOnManager.OnLine(userInfo.Id);
if (MessageService.LaseOnLineStateCheck == DateTime.MinValue)
{
}
else
{
// 2008.01.23 JiRiGaLa 修正错误
TimeSpan timeSpan = DateTime.Now - MessageService.LaseOnLineStateCheck;
if ((timeSpan.Minutes * 60 + timeSpan.Seconds) >= BaseSystemInfo.OnLineCheck)
{
}
}
if (OnLineStateDT == null)
{
// 检查用户在线状态(服务器专用)
userLogOnManager.CheckOnLine();
// 获取在线状态列表
OnLineStateDT = userLogOnManager.GetOnLineStateDT();
OnLineStateDT.TableName = BaseUserEntity.TableName;
MessageService.LaseOnLineStateCheck = DateTime.Now;
}
});
return(InnerOrganizeDT);
}
/// <summary>
/// 按用户名登录(LDAP专用)
/// </summary>
/// <param name="taskId">任务标识</param>
/// <param name="systemCode">子系统编码</param>
/// <param name="userInfo">用户</param>
/// <param name="userName">用户名</param>
/// <returns>用户实体</returns>
public UserLogonResult LogonByUserName(string taskId, string systemCode, BaseUserInfo userInfo, string userName)
{
var result = new UserLogonResult();
var parameter = ServiceInfo.Create(taskId, userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterWriteDb(userInfo, parameter, (dbHelper) =>
{
// 先侦测是否在线
//userLogonManager.CheckOnline();
// 然后获取用户密码
var userManager = new BaseUserManager(userInfo);
// 是否从角色判断管理员
userManager.CheckIsAdministrator = true;
//根据用户名获取用户信息
var userEntity = userManager.GetByUserName(userName);
if (userEntity != null)
{
var baseUserLogonManager = new BaseUserLogonManager(userInfo);
//获取密码
var userLogonEntity = baseUserLogonManager.GetEntityByUserId(userEntity.Id);
var password = userLogonEntity.UserPassword;
//再进行登录，这里密码不能是AD的密码，所以不检验密码
result = userManager.LogonByUserName(userName, password, systemCode, null, null, null, false, false);
//可以登录，但不建议，没有登录日志等
//result = userManager.LogonByOpenId(openId, string.Empty, string.Empty);
}
// 登录时会自动记录进行日志记录，所以不需要进行重复日志记录
//BaseLogManager.Instance.Add(userInfo, this.serviceName, MethodBase.GetCurrentMethod());
});
return(result);
}
/// <summary>
/// 按用户名登录(LDAP专用)
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="userName">用户名</param>
/// <param name="statusCode">返回状态码</param>
/// <param name="statusMessage">返回状消息</param>
/// <returns>用户实体</returns>
public BaseUserInfo LogOnByUserName(BaseUserInfo userInfo, string userName, out string statusCode, out string statusMessage)
{
var parameter = ServiceParameter.CreateWithLog(userInfo
, MethodBase.GetCurrentMethod());
BaseUserInfo returnUserInfo = null;
string returnCode = string.Empty;
string returnMessage = string.Empty;
ServiceUtil.ProcessUserCenterWriteDb(userInfo, parameter, (dbHelper) =>
{
// 先侦测是否在线
userLogOnManager.CheckOnLine();
// 然后获取用户密码
var userManager = new BaseUserManager(userInfo);
// 是否从角色判断管理员
userManager.CheckIsAdministrator = true;
BaseUserEntity userEntity = userManager.GetByUserName(userName);
BaseUserLogOnEntity userLogOnEntity = userLogOnManager.GetObject(userEntity.Id);
string password = userLogOnEntity.UserPassword;
// 再进行登录
returnUserInfo = userManager.LogOnByUserName(userName, password, null, false, userInfo.IPAddress, userInfo.MACAddress, false);
returnCode = userManager.StatusCode;
returnMessage = userManager.GetStateMessage();
// 登录时会自动记录进行日志记录，所以不需要进行重复日志记录
// BaseLogManager.Instance.Add(userInfo, this.serviceName, MethodBase.GetCurrentMethod());
});
statusCode = returnCode;
statusMessage = returnMessage;
return(returnUserInfo);
}
/// <summary>
/// 写入日志
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="processId">服务</param>
/// <param name="processName">服务名称</param>
/// <param name="methodId">操作</param>
/// <param name="methodName">操作名称</param>
public void WriteLog(BaseUserInfo userInfo, string processId, string processName, string methodId, string methodName)
{
var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterWriteDb(userInfo, parameter, (dbHelper) =>
{
// BaseLogManager.Instance.Add(result, processName, methodName, processId, methodId, string.Empty);
});
}
/// <summary>
/// 全部清除日志
/// </summary>
/// <param name="userInfo">用户</param>
/// <returns>数据表</returns>
public void Truncate(BaseUserInfo userInfo)
{
var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterWriteDb(userInfo, parameter, (dbHelper) =>
{
// var manager = new BaseLogManager(dbHelper, result);
// manager.Truncate();
});
}
/// <summary>
/// 用户现在
/// </summary>
/// <param name="taskId">任务标识</param>
/// <param name="userInfo">用户</param>
/// <param name="onLineState">用户在线状态</param>
public void OnLine(string taskId, BaseUserInfo userInfo, int onLineState = 1)
{
var parameter = ServiceInfo.Create(taskId, userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterWriteDb(userInfo, parameter, (dbHelper) =>
{
BaseUserLogOnManager userLogOnManager = new BaseUserLogOnManager();
userLogOnManager.OnLine(userInfo.Id, onLineState);
});
}
/// <summary>
/// 用户离线(退出)
/// </summary>
/// <param name="taskId">任务标识</param>
/// <param name="userInfo">用户</param>
public void SignOut(string taskId, BaseUserInfo userInfo)
{
var parameter = ServiceInfo.Create(taskId, userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterWriteDb(userInfo, parameter, (dbHelper) =>
{
// 2015-12-14 吉日嘎拉 用户的登录日志不用重复写日志
BaseUserLogOnManager userLogOnManager = new BaseUserLogOnManager();
userLogOnManager.SignOut(userInfo.OpenId);
});
}
/// <summary>
/// 获取序列号
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="fullName">序列名称</param>
/// <param name="count">个数</param>
/// <returns>序列号</returns>
public string[] GetBatchSequence(BaseUserInfo userInfo, string fullName, int count)
{
string[] result = new string[0];
var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterWriteDb(userInfo, parameter, (dbHelper) =>
{
result = this.GetBatchSequence(dbHelper, userInfo, fullName, count);
});
return(result);
}
/// <summary>
/// 获取内部组织机构
/// </summary>
/// <param name="userInfo">用户</param>
/// <returns>数据表</returns>
public DataTable GetInnerOrganizeDT(BaseUserInfo userInfo)
{
var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterWriteDb(userInfo, parameter, (dbHelper) =>
{
var manager = new BaseOrganizeManager(dbHelper, userInfo);
if (MessageService.LaseInnerOrganizeCheck == DateTime.MinValue)
{
}
else
{
// 2008.01.23 JiRiGaLa 修正错误
TimeSpan timeSpan = DateTime.Now - MessageService.LaseInnerOrganizeCheck;
if ((timeSpan.Minutes * 60 + timeSpan.Seconds) >= BaseSystemInfo.OnLineCheck * 10)
{
}
}
if (OnLineStateDT == null)
{
string commandText = string.Empty;
if (BaseSystemInfo.OrganizeDynamicLoading)
{
commandText = " SELECT * "
+ " FROM " + BaseOrganizeEntity.TableName
+ " WHERE " + BaseOrganizeEntity.FieldDeletionStateCode + " = 0 "
+ " AND " + BaseOrganizeEntity.FieldIsInnerOrganize + " = 1 "
+ " AND " + BaseOrganizeEntity.FieldEnabled + " = 1 "
+ " AND (" + BaseOrganizeEntity.FieldParentId + " IS NULL "
+ " OR " + BaseOrganizeEntity.FieldParentId + " IN (SELECT " + BaseOrganizeEntity.FieldId + " FROM " + BaseOrganizeEntity.TableName + " WHERE " + BaseOrganizeEntity.FieldDeletionStateCode + " = 0 AND " + BaseOrganizeEntity.FieldIsInnerOrganize + " = 1 AND " + BaseOrganizeEntity.FieldEnabled + " = 1 AND " + BaseOrganizeEntity.FieldParentId + " IS NULL)) "
+ " ORDER BY " + BaseOrganizeEntity.FieldSortCode;
}
else
{
commandText = " SELECT * "
+ " FROM " + BaseOrganizeEntity.TableName
+ " WHERE " + BaseOrganizeEntity.FieldDeletionStateCode + " = 0 "
+ " AND " + BaseOrganizeEntity.FieldIsInnerOrganize + " = 1 "
+ " AND " + BaseOrganizeEntity.FieldEnabled + " = 1 "
+ " ORDER BY " + BaseOrganizeEntity.FieldSortCode;
}
InnerOrganizeDT = manager.Fill(commandText);
InnerOrganizeDT.TableName = BaseOrganizeEntity.TableName;
MessageService.LaseInnerOrganizeCheck = DateTime.Now;
}
// BaseLogManager.Instance.Add(result, this.serviceName, MethodBase.GetCurrentMethod());
});
return(InnerOrganizeDT);
}
/// <summary>
/// 清除全部异常
/// </summary>
/// <param name="userInfo">用户</param>
/// <returns>数据表</returns>
public int Truncate(BaseUserInfo userInfo)
{
var result = 0;
var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterWriteDb(userInfo, parameter, (dbHelper) =>
{
var manager = new BaseExceptionManager(dbHelper, userInfo);
manager.Truncate();
});
return(result);
}
/// <summary>
/// 移动数据
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="id">主键</param>
/// <param name="parentId">父主键</param>
/// <returns>影响行数</returns>
public int MoveTo(BaseUserInfo userInfo, string id, string parentId)
{
int result = 0;
var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterWriteDb(userInfo, parameter, (dbHelper) =>
{
var manager = new BaseDepartmentManager(dbHelper, userInfo);
result = manager.MoveTo(id, parentId);
});
return(result);
}
/// <summary>
/// 批量保存数据
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="result">数据表</param>
/// <returns>影响行数</returns>
public int BatchSave(BaseUserInfo userInfo, DataTable dt)
{
int result = 0;
var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterWriteDb(userInfo, parameter, (dbHelper) =>
{
var manager = new BaseDepartmentManager(dbHelper, userInfo);
result = manager.BatchSave(dt);
});
return(result);
}
/// <summary>
/// 批量保存
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="result">数据表</param>
/// <returns>影响行数</returns>
public int Save(BaseUserInfo userInfo, DataTable dt)
{
int result = 0;
var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterWriteDb(userInfo, parameter, (dbHelper) =>
{
var itemDetailsManager = new BaseItemDetailsManager(dbHelper, userInfo, dt.TableName);
result = itemDetailsManager.Save(dt);
});
return(result);
}
/// <summary>
/// 批量重新生成排序码
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="ids">主键数组</param>
/// <returns>影响行数</returns>
public int BatchSetSortCode(BaseUserInfo userInfo, string[] ids)
{
int result = 0;
var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterWriteDb(userInfo, parameter, (dbHelper) =>
{
var manager = new BaseOrganizeManager(dbHelper, userInfo);
result = manager.BatchSetSortCode(ids);
});
return(result);
}
/// <summary>
/// 批量打删除标志
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="ids">主键数组</param>
/// <returns>影响行数</returns>
public int SetDeleted(BaseUserInfo userInfo, string[] ids)
{
int result = 0;
var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterWriteDb(userInfo, parameter, (dbHelper) =>
{
var manager = new BaseLanguageManager(dbHelper, userInfo);
result = manager.SetDeleted(ids, true);
});
return(result);
}
/// <summary>
/// 给用户权限（分子系统）
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="systemCode">系统编号</param>
/// <param name="userId">用户主键</param>
/// <param name="permissionCode">权限编号</param>
/// <returns>主键</returns>
public string GrantUserPermission(BaseUserInfo userInfo, string systemCode, string userId, string permissionCode)
{
var result = string.Empty;
var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterWriteDb(userInfo, parameter, (ServiceUtil.ProcessFun)((dbHelper) =>
{
var userPermissionManager = new BasePermissionManager((IDbHelper)dbHelper, (BaseUserInfo)userInfo);
result = userPermissionManager.GrantByPermissionCode(systemCode, userId, permissionCode);
}));
return(result);
}
/// <summary>
/// 批量删除异常
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="ids">主键数组</param>
/// <returns>数据表</returns>
public int BatchDelete(BaseUserInfo userInfo, string[] ids)
{
var result = 0;
var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterWriteDb(userInfo, parameter, (dbHelper) =>
{
var manager = new BaseExceptionManager(dbHelper, userInfo);
result = manager.Delete(BaseExceptionEntity.FieldId, ids);
});
return(result);
}
/// <summary>
/// 按参数编号删除
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="categoryCode">分类编号</param>
/// <param name="parameterId">参数主键</param>
/// <param name="parameterCode">参数编号</param>
/// <returns>影响行数</returns>
public int DeleteByParameterCode(BaseUserInfo userInfo, string categoryCode, string parameterId, string parameterCode)
{
var result = 0;
var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterWriteDb(userInfo, parameter, (dbHelper) =>
{
var manager = new BaseParameterManager(dbHelper, userInfo);
result = manager.DeleteByParameterCode(categoryCode, parameterId, parameterCode);
});
return(result);
}
