/// <summary>
/// 用户是否在某部门
/// </summary>
/// <param name="userId">用户主键</param>
/// <param name="organizationName">部门名称</param>
/// <returns>存在</returns>
public bool IsInOrganization(string userId, string organizationName)
{
var result = false;
// 把部门的主键找出来
var parameters = new List <KeyValuePair <string, object> >
{
new KeyValuePair <string, object>(BaseOrganizationEntity.FieldName, organizationName),
new KeyValuePair <string, object>(BaseOrganizationEntity.FieldEnabled, 1),
new KeyValuePair <string, object>(BaseOrganizationEntity.FieldDeleted, 0)
};
var organizationManager = new BaseOrganizationManager(UserInfo);
var organizationId = organizationManager.GetId(parameters);
if (string.IsNullOrEmpty(organizationId))
{
return(result);
}
// 用户组织机构关联关系
var organizationIds = GetAllOrganizationIds(userId);
if (organizationIds == null || organizationIds.Length == 0)
{
return(result);
}
// 用户的部门是否存在这些部门里
result = StringUtil.Exists(organizationIds, organizationId);
return(result);
}
/// <summary>
/// 获得列表
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="streetId">街道主键</param>
/// <returns>数据表</returns>
public DataTable GetDataTableByStreetId(BaseUserInfo userInfo, string streetId)
{
var result = new DataTable(BaseOrganizationEntity.CurrentTableName);
var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterReadDb(userInfo, parameter, (dbHelper) =>
{
// 这里可以缓存起来，提高效率
var manager = new BaseOrganizationManager(dbHelper, userInfo);
// 这里是条件字段
var parameters = new List <KeyValuePair <string, object> >
{
new KeyValuePair <string, object>(BaseOrganizationEntity.FieldStreetId, streetId),
new KeyValuePair <string, object>(BaseOrganizationEntity.FieldEnabled, 1),
new KeyValuePair <string, object>(BaseOrganizationEntity.FieldDeleted, 0)
};
// 获取列表，指定排序字段
result = manager.GetDataTable(parameters, BaseOrganizationEntity.FieldSortCode);
result.DefaultView.Sort = BaseOrganizationEntity.FieldSortCode;
result.TableName = BaseOrganizationEntity.CurrentTableName;
});
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="userId">用户主键</param>
/// <param name="permissionCode">数据权限编号</param>
/// <param name="childrens">获取子节点</param>
/// <returns>数据表</returns>
public DataTable GetOrganizationDTByPermission(BaseUserInfo userInfo, string userId, string permissionCode = "Resource.ManagePermission", bool childrens = true)
{
var dt = new DataTable(BaseOrganizationEntity.CurrentTableName);
var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterReadDb(userInfo, parameter, (dbHelper) =>
{
// 若权限是空的，直接返回所有数据
if (string.IsNullOrEmpty(permissionCode))
{
var organizationManager = new BaseOrganizationManager(dbHelper, userInfo);
dt = organizationManager.GetDataTable();
dt.DefaultView.Sort = BaseOrganizationEntity.FieldSortCode;
}
else
{
// 获得组织机构列表
var permissionScopeManager = new BasePermissionScopeManager(dbHelper, userInfo);
dt = permissionScopeManager.GetOrganizationDt(userInfo.SystemCode, userInfo.Id.ToString(), permissionCode, childrens);
dt.DefaultView.Sort = BaseOrganizationEntity.FieldSortCode;
}
dt.TableName = BaseOrganizationEntity.CurrentTableName;
});
return(dt);
}
/// <summary>
/// 缓存预热,强制重新缓存
/// </summary>
/// <returns>影响行数</returns>
public static int CachePreheating()
{
var result = 0;
// 把所有的组织机构都缓存起来的代码
var manager = new BaseOrganizationManager();
var dataReader = manager.ExecuteReader();
if (dataReader != null && !dataReader.IsClosed)
{
while (dataReader.Read())
{
var entity = BaseEntity.Create <BaseOrganizationEntity>(dataReader, false);
if (entity != null)
{
SetCache(entity);
result++;
Console.WriteLine(result + " : " + entity.Name);
}
}
dataReader.Close();
}
return(result);
}
/// <summary>
/// 设置缓存
/// 20151007 吉日嘎拉，需要在一个连接上进行大量的操作
/// 20160128 吉日嘎拉，一些空调间的判断。
/// </summary>
/// <param name="entity">用户实体</param>
public static void SetCache(BaseUserEntity entity)
{
var key = string.Empty;
if (entity != null && entity.Id > 0)
{
key = "User:"******"User:ByNickName:" + entity.NickName.ToLower();
CacheUtil.Set <string>(key, entity.Id.ToString());
}
if (!string.IsNullOrEmpty(entity.Code))
{
key = "User:ByCode:" + entity.Code;
CacheUtil.Set <string>(key, entity.Id.ToString());
key = "User:ByCompanyId:ByCode" + entity.CompanyId + ":" + entity.Code;
CacheUtil.Set <string>(key, entity.Id.ToString());
}
var companyCode = BaseOrganizationManager.GetCodeByCache(entity.CompanyId.ToString());
if (!string.IsNullOrEmpty(companyCode))
{
key = "User:ByCompanyCode:ByCode" + companyCode + ":" + entity.Code;
CacheUtil.Set <string>(key, entity.Id.ToString());
}
Console.WriteLine(entity.Id + " : " + entity.RealName);
}
}
/// <summary>
/// 更新组织机构
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="entity">实体</param>
/// <param name="status">状态</param>
/// <param name="statusMessage">状态信息</param>
/// <returns>影响行数</returns>
public int Update(BaseUserInfo userInfo, BaseOrganizationEntity entity, out Status status, out string statusMessage)
{
var result = 0;
var returnCode = Status.Ok;
var returnMessage = string.Empty;
var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterWriteDb(userInfo, parameter, (dbHelper) =>
{
// 2015-12-19 吉日嘎拉 网络不稳定，数据获取不完整时，异常时，会引起重大隐患
var manager = new BaseOrganizationManager(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.Name));
}
returnCode = manager.Status;
returnMessage = manager.StatusMessage;
});
status = returnCode;
statusMessage = returnMessage;
return(result);
}
/// <summary>
/// 根据公司编码和用户编码获取用户实体
/// </summary>
/// <param name="companyCode"></param>
/// <param name="userCode"></param>
/// <returns></returns>
public BaseUserEntity GetEntityByCompanyCodeByCode(string companyCode, string userCode)
{
BaseUserEntity result = null;
var organizationEntity = BaseOrganizationManager.GetEntityByCodeByCache(companyCode);
if (organizationEntity == null)
{
return(result);
}
var parameters = new List <KeyValuePair <string, object> >
{
new KeyValuePair <string, object>(BaseUserEntity.FieldCode, userCode),
new KeyValuePair <string, object>(BaseUserEntity.FieldCompanyId, organizationEntity.Id),
new KeyValuePair <string, object>(BaseUserEntity.FieldEnabled, 1),
new KeyValuePair <string, object>(BaseUserEntity.FieldDeleted, 0)
};
var dt = GetDataTable(parameters);
if (dt != null && dt.Rows.Count > 0)
{
result = BaseEntity.Create <BaseUserEntity>(dt);
}
return(result);
}
/// <summary>
/// 按名称获取实体
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="name">名称</param>
/// <returns>实体</returns>
public BaseOrganizationEntity GetEntityByName(BaseUserInfo userInfo, string name)
{
BaseOrganizationEntity entity = null;
var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterReadDb(userInfo, parameter, (dbHelper) =>
{
var manager = new BaseOrganizationManager(dbHelper, userInfo);
entity = manager.GetEntityByName(name);
});
return(entity);
}
/// <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)
{
var result = 0;
var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterWriteDb(userInfo, parameter, (dbHelper) =>
{
var manager = new BaseOrganizationManager(dbHelper, userInfo);
result = manager.MoveTo(id, parentId);
});
return(result);
}
/// <summary>
/// 批量重新生成排序码
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="ids">主键数组</param>
/// <returns>影响行数</returns>
public int BatchSetSortCode(BaseUserInfo userInfo, string[] ids)
{
var result = 0;
var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterWriteDb(userInfo, parameter, (dbHelper) =>
{
var manager = new BaseOrganizationManager(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)
{
var result = 0;
var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterWriteDb(userInfo, parameter, (dbHelper) =>
{
var manager = new BaseOrganizationManager(dbHelper, userInfo);
for (var i = 0; i < ids.Length; i++)
{
// 设置部门为删除状态
result += manager.SetDeleted(ids[i]);
// 相应的用户也需要处理
var userManager = new BaseUserManager(dbHelper, userInfo);
var parameters = new List <KeyValuePair <string, object> >
{
new KeyValuePair <string, object>(BaseUserEntity.FieldCompanyId, null),
new KeyValuePair <string, object>(BaseUserEntity.FieldCompanyName, null)
};
userManager.SetProperty(new KeyValuePair <string, object>(BaseUserEntity.FieldCompanyId, ids[i]), parameters);
parameters = new List <KeyValuePair <string, object> >
{
new KeyValuePair <string, object>(BaseUserEntity.FieldSubCompanyId, null),
new KeyValuePair <string, object>(BaseUserEntity.FieldSubCompanyName, null)
};
userManager.SetProperty(new KeyValuePair <string, object>(BaseUserEntity.FieldSubCompanyId, ids[i]), parameters);
parameters = new List <KeyValuePair <string, object> >
{
new KeyValuePair <string, object>(BaseUserEntity.FieldDepartmentId, null),
new KeyValuePair <string, object>(BaseUserEntity.FieldDepartmentName, null)
};
userManager.SetProperty(new KeyValuePair <string, object>(BaseUserEntity.FieldDepartmentId, ids[i]), parameters);
parameters = new List <KeyValuePair <string, object> >
{
new KeyValuePair <string, object>(BaseUserEntity.FieldWorkgroupId, null),
new KeyValuePair <string, object>(BaseUserEntity.FieldWorkgroupName, null)
};
userManager.SetProperty(new KeyValuePair <string, object>(BaseUserEntity.FieldWorkgroupId, ids[i]), parameters);
// 相应的员工也需要处理
var staffManager = new BaseStaffManager(dbHelper, userInfo);
staffManager.SetProperty(new KeyValuePair <string, object>(BaseStaffEntity.FieldCompanyId, ids[i]), new KeyValuePair <string, object>(BaseStaffEntity.FieldCompanyId, null));
staffManager.SetProperty(new KeyValuePair <string, object>(BaseStaffEntity.FieldSubCompanyId, ids[i]), new KeyValuePair <string, object>(BaseStaffEntity.FieldSubCompanyId, null));
staffManager.SetProperty(new KeyValuePair <string, object>(BaseStaffEntity.FieldDepartmentId, ids[i]), new KeyValuePair <string, object>(BaseStaffEntity.FieldDepartmentId, null));
staffManager.SetProperty(new KeyValuePair <string, object>(BaseStaffEntity.FieldWorkgroupId, ids[i]), new KeyValuePair <string, object>(BaseStaffEntity.FieldWorkgroupId, null));
}
//var folderManager = new BaseFolderManager(dbHelper, userInfo);
//folderManager.SetDeleted(ids);
});
return(result);
}
/// <summary>
/// 按主键数组获取列表
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="ids">组织机构主键</param>
/// <returns>数据表</returns>
public DataTable GetDataTableByIds(BaseUserInfo userInfo, string[] ids)
{
var dt = new DataTable(BaseOrganizationEntity.CurrentTableName);
var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterReadDb(userInfo, parameter, (dbHelper) =>
{
var manager = new BaseOrganizationManager(dbHelper, userInfo);
dt = manager.GetDataTable(BaseOrganizationEntity.FieldId, ids, BaseOrganizationEntity.FieldSortCode);
dt.TableName = BaseOrganizationEntity.CurrentTableName;
});
return(dt);
}
/// <summary>
/// 获得角色中的组织机构主键
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="roleId">角色主键</param>
/// <returns>组织机构主键</returns>
public string[] GetRoleOrganizationIds(BaseUserInfo userInfo, string roleId)
{
string[] result = null;
var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterReadDb(userInfo, parameter, (dbHelper) =>
{
var manager = new BaseOrganizationManager(dbHelper, userInfo);
result = manager.GetIdsInRole(userInfo.SystemCode, roleId);
});
return(result);
}
/// <summary>
/// 清除角色组织机构关联
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="roleId">角色主键</param>
/// <returns>影响行数</returns>
public int ClearOrganizationUser(BaseUserInfo userInfo, string roleId)
{
var result = 0;
var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterWriteDb(userInfo, parameter, (dbHelper) =>
{
var manager = new BaseOrganizationManager(dbHelper, userInfo);
result = manager.ClearOrganization(userInfo.SystemCode, roleId);
});
return(result);
}
/// <summary>
/// 按主键获取列表
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="ids">主键数组</param>
/// <returns>数据表</returns>
public List <BaseOrganizationEntity> GetListByIds(BaseUserInfo userInfo, string[] ids)
{
var result = new List <BaseOrganizationEntity>();
var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterReadDb(userInfo, parameter, (dbHelper) =>
{
var userManager = new BaseOrganizationManager(dbHelper, userInfo);
result = userManager.GetList <BaseOrganizationEntity>(BaseOrganizationEntity.FieldId, ids, BaseOrganizationEntity.FieldSortCode);
});
return(result);
}
/// <summary>
/// 同步数据
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="all">同步所有数据</param>
/// <returns>影响行数</returns>
public int Synchronous(BaseUserInfo userInfo, bool all = false)
{
var result = 0;
var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterWriteDb(userInfo, parameter, (dbHelper) =>
{
var manager = new BaseOrganizationManager(dbHelper, userInfo);
// result = manager.Synchronous(all);
});
return(result);
}
/// <summary>
/// 重新设置缓存（重新强制设置缓存）可以提供外部调用的
/// </summary>
/// <param name="id">主键</param>
/// <returns>用户信息</returns>
public static BaseOrganizationEntity SetCache(string id)
{
BaseOrganizationEntity result = null;
var manager = new BaseOrganizationManager();
result = manager.GetEntity(id);
if (result != null)
{
SetCache(result);
}
return(result);
}
/// <summary>
/// 批量移动数据
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="organizationIds">主键数组</param>
/// <param name="parentId">父节点主键</param>
/// <returns>影响行数</returns>
public int BatchMoveTo(BaseUserInfo userInfo, string[] organizationIds, string parentId)
{
var result = 0;
var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterWriteDb(userInfo, parameter, (dbHelper) =>
{
var manager = new BaseOrganizationManager(dbHelper, userInfo);
for (var i = 0; i < organizationIds.Length; i++)
{
result += manager.MoveTo(organizationIds[i], parentId);
}
});
return(result);
}
/// <summary>
/// 获取部门列表
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="parameters">参数</param>
/// <returns>数据表</returns>
public DataTable GetDataTable(BaseUserInfo userInfo, List <KeyValuePair <string, object> > parameters)
{
var dt = new DataTable(BaseOrganizationEntity.CurrentTableName);
var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterReadDb(userInfo, parameter, (dbHelper) =>
{
// 获得组织机构列表
var manager = new BaseOrganizationManager(dbHelper, userInfo);
dt = manager.GetDataTable(parameters, BaseOrganizationEntity.FieldSortCode);
dt.DefaultView.Sort = BaseOrganizationEntity.FieldSortCode;
dt.TableName = BaseOrganizationEntity.CurrentTableName;
});
return(dt);
}
/// <summary>
/// 获得列表
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="parentId">父亲节点主键</param>
/// <returns>数据表</returns>
public DataTable GetErrorDataTable(BaseUserInfo userInfo, string parentId)
{
var dt = new DataTable(BaseOrganizationEntity.CurrentTableName);
var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterReadDb(userInfo, parameter, (dbHelper) =>
{
// 这里可以缓存起来，提高效率
var manager = new BaseOrganizationManager(dbHelper, userInfo);
dt = manager.GetErrorDataTable(parentId);
dt.DefaultView.Sort = BaseOrganizationEntity.FieldSortCode;
dt.TableName = BaseOrganizationEntity.CurrentTableName;
});
return(dt);
}
/// <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 BaseOrganizationManager(dbHelper, userInfo);
result = manager.Delete(ids);
// 把公司文件夹也删除了
//var folderManager = new BaseFolderManager(dbHelper, userInfo);
//result = folderManager.Delete(ids);
});
return(result);
}
/// <summary>
/// 查询组织机构
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="organizationId">组织机构</param>
/// <param name="searchKey">查询</param>
/// <returns>数据表</returns>
public DataTable Search(BaseUserInfo userInfo, string organizationId, string searchKey)
{
var dt = new DataTable(BaseOrganizationEntity.CurrentTableName);
var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterReadDb(userInfo, parameter, (dbHelper) =>
{
// 获得组织机构列表
var manager = new BaseOrganizationManager(dbHelper, userInfo);
dt = manager.Search(searchKey, organizationId);
dt.DefaultView.Sort = BaseOrganizationEntity.FieldSortCode;
dt.TableName = BaseOrganizationEntity.CurrentTableName;
});
return(dt);
}
/// <summary>
/// 按部门获取部门用户,包括子部门的用户
/// </summary>
/// <param name="departmentId">部门主键</param>
/// <param name="searchKey">关键字</param>
/// <returns>数据表</returns>
public DataTable SearchByDepartment(string departmentId, string searchKey)
{
var sql = "SELECT " + BaseUserEntity.CurrentTableName + ".* "
+ " FROM " + BaseUserEntity.CurrentTableName;
sql += " WHERE (" + BaseUserEntity.CurrentTableName + "." + BaseUserEntity.FieldDeleted + " = 0 ";
sql += " AND " + BaseUserEntity.CurrentTableName + "." + BaseUserEntity.FieldEnabled + " = 1 ) ";
if (!string.IsNullOrEmpty(departmentId))
{
/*
* 用非递归调用的建议方法
* sql += " AND " + BaseUserEntity.CurrentTableName + "." + BaseUserEntity.FieldDepartmentId
+ " IN ( SELECT " + BaseOrganizationEntity.FieldId
+ " FROM " + BaseOrganizationEntity.CurrentTableName
+ " WHERE " + BaseOrganizationEntity.FieldId + " = " + departmentId + " OR " + BaseOrganizationEntity.FieldParentId + " = " + departmentId + ")";
*/
var organizationManager = new BaseOrganizationManager(DbHelper, UserInfo);
var organizationIds = organizationManager.GetChildrensId(BaseOrganizationEntity.FieldId, departmentId, BaseOrganizationEntity.FieldParentId);
if (organizationIds != null && organizationIds.Length > 0)
{
sql += " AND (" + BaseUserEntity.CurrentTableName + "." + BaseUserEntity.FieldCompanyId + " IN (" + StringUtil.ArrayToList(organizationIds) + ")"
+ " OR " + BaseUserEntity.CurrentTableName + "." + BaseUserEntity.FieldDepartmentId + " IN (" + StringUtil.ArrayToList(organizationIds) + ")"
+ " OR " + BaseUserEntity.CurrentTableName + "." + BaseUserEntity.FieldWorkgroupId + " IN (" + StringUtil.ArrayToList(organizationIds) + "))";
}
}
var dbParameters = new List <IDbDataParameter>();
searchKey = searchKey.Trim();
if (!string.IsNullOrEmpty(searchKey))
{
sql += " AND (" + BaseUserEntity.FieldUserName + " LIKE " + DbHelper.GetParameter(BaseUserEntity.FieldUserName);
sql += " OR " + BaseUserEntity.FieldCode + " LIKE " + DbHelper.GetParameter(BaseUserEntity.FieldCode);
sql += " OR " + BaseUserEntity.FieldRealName + " LIKE " + DbHelper.GetParameter(BaseUserEntity.FieldRealName);
sql += " OR " + BaseUserEntity.FieldDepartmentName + " LIKE " + DbHelper.GetParameter(BaseUserEntity.FieldDepartmentName) + ")";
if (searchKey.IndexOf("%") < 0)
{
searchKey = "%" + searchKey + "%";
}
dbParameters.Add(DbHelper.MakeParameter(BaseUserEntity.FieldUserName, searchKey));
dbParameters.Add(DbHelper.MakeParameter(BaseUserEntity.FieldCode, searchKey));
dbParameters.Add(DbHelper.MakeParameter(BaseUserEntity.FieldRealName, searchKey));
dbParameters.Add(DbHelper.MakeParameter(BaseUserEntity.FieldDepartmentName, searchKey));
}
sql += " ORDER BY " + BaseUserEntity.CurrentTableName + "." + BaseUserEntity.FieldSortCode;
return(DbHelper.Fill(sql, dbParameters.ToArray()));
}
/// <summary>
/// 将组织机构从角色中移除
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="roleId">角色主键</param>
/// <param name="organizationIds">组织机构主键</param>
/// <returns>影响行数</returns>
public int RemoveOrganizationFromRole(BaseUserInfo userInfo, string roleId, string[] organizationIds)
{
var result = 0;
var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterWriteDbWithTransaction(userInfo, parameter, (dbHelper) =>
{
var manager = new BaseOrganizationManager(dbHelper, userInfo);
if (organizationIds != null)
{
result += manager.RemoveFromRole(userInfo.SystemCode, organizationIds, roleId);
}
});
return(result);
}
/// <summary>
/// 组织机构添加到角色
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="roleId">角色主键</param>
/// <param name="organizationIds">组织机构主键</param>
/// <returns>影响行数</returns>
public int AddOrganizationToRole(BaseUserInfo userInfo, string roleId, string[] organizationIds)
{
var result = 0;
var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterWriteDb(userInfo, parameter, (dbHelper) =>
{
var manager = new BaseOrganizationManager(dbHelper, userInfo);
// 小心异常，检查一下参数的有效性
if (organizationIds != null)
{
result += manager.AddToRole(userInfo.SystemCode, organizationIds, roleId);
}
});
return(result);
}
/// <summary>
/// 获取下级的用户表
/// </summary>
/// <param name="organizationId"></param>
/// <returns></returns>
public DataTable GetChildrenUserDataTable(string organizationId)
{
string[] organizationIds = null;
var organizationManager = new BaseOrganizationManager(DbHelper, UserInfo);
switch (DbHelper.CurrentDbType)
{
case CurrentDbType.Access:
case CurrentDbType.SqlServer:
var organizationCode = organizationManager.GetCodeById(organizationId);
organizationIds = organizationManager.GetChildrensIdByCode(BaseOrganizationEntity.FieldCode, organizationCode);
break;
case CurrentDbType.Oracle:
organizationIds = organizationManager.GetChildrensId(BaseOrganizationEntity.FieldId, organizationId, BaseOrganizationEntity.FieldParentId);
break;
}
return(GetDataTableByOrganizations(organizationIds));
}
/// <summary>
/// 刷新缓存
/// </summary>
/// <param name="userId"></param>
/// <returns></returns>
public static int RefreshCache(string userId)
{
var result = 0;
// 刷新用户的缓存
var userEntity = GetEntityByCache(userId, true);
if (userEntity != null)
{
// 刷新用户的登录限制 用户名的限制
// 刷新用户的登录限制
ResetIpAddressByCache(userId);
ResetMacAddressByCache(userId);
// 刷新组织机构缓存
BaseOrganizationManager.GetEntityByCache(userEntity.CompanyId.ToString(), true);
// 2016-02-18 吉日嘎拉 刷新拒绝权限(把用户的权限放在一起方便直接移除、刷新)
var key = "User:IsAuthorized:" + userId;
CacheUtil.Remove(key);
// 2016-05-24 吉日嘎拉 解除登录限制的方法，防止一天都登录不上的问题发生
//if (!string.IsNullOrEmpty(userEntity.NickName))
//{
// key = "u:" + userEntity.NickName;
// PooledRedisHelper.CallLimitRemove(key);
//}
//if (!string.IsNullOrEmpty(userEntity.Code))
//{
// key = "u:" + userEntity.Code;
// PooledRedisHelper.CallLimitRemove(key);
//}
// 每个子系统都可以循环一次
var systemCodes = BaseSystemManager.GetSystemCodes();
foreach (var entity in systemCodes)
{
BasePermissionManager.ResetPermissionByCache(entity.ItemKey, userId, null);
}
}
return(result);
}
/// <summary>
/// 指定用户是否有指定组织编码的兼任
/// </summary>
/// <param name="userId">用户编号</param>
/// <param name="organizationCode">组织编码</param>
/// <param name="organizationCategoryCode">组织类型</param>
/// <returns>数据表</returns>
public bool Exists(string userId, string organizationCode, string organizationCategoryCode = "Company")
{
var result = false;
if (ValidateUtil.IsInt(userId))
{
var entity = new BaseOrganizationManager(UserInfo).GetEntityByCode(organizationCode);
if (entity != null)
{
var parameters = new List <KeyValuePair <string, object> >
{
new KeyValuePair <string, object>(BaseUserOrganizationEntity.FieldDeleted, 0),
new KeyValuePair <string, object>(BaseUserOrganizationEntity.FieldEnabled, 1),
new KeyValuePair <string, object>(BaseUserOrganizationEntity.FieldUserId, userId)
};
if (organizationCategoryCode.Equals("Company", StringComparison.OrdinalIgnoreCase))
{
parameters.Add(new KeyValuePair <string, object>(BaseUserOrganizationEntity.FieldCompanyId, entity.Id));
}
else if (organizationCategoryCode.Equals("SubCompany", StringComparison.OrdinalIgnoreCase))
{
parameters.Add(new KeyValuePair <string, object>(BaseUserOrganizationEntity.FieldSubCompanyId, entity.Id));
}
else if (organizationCategoryCode.Equals("Department", StringComparison.OrdinalIgnoreCase))
{
parameters.Add(new KeyValuePair <string, object>(BaseUserOrganizationEntity.FieldDepartmentId, entity.Id));
}
else if (organizationCategoryCode.Equals("SubDepartment", StringComparison.OrdinalIgnoreCase))
{
parameters.Add(new KeyValuePair <string, object>(BaseUserOrganizationEntity.FieldSubDepartmentId, entity.Id));
}
else if (organizationCategoryCode.Equals("Workgroup", StringComparison.OrdinalIgnoreCase))
{
parameters.Add(new KeyValuePair <string, object>(BaseUserOrganizationEntity.FieldWorkgroupId, entity.Id));
}
result = Exists(parameters);
}
}
return(result);
}
/// <summary>
/// 分页查询
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="recordCount">记录数</param>
/// <param name="pageNo">当前页</param>
/// <param name="pageSize">每页显示</param>
/// <param name="condition">条件</param>
/// <param name="dbParameters">参数</param>
/// <param name="order">排序</param>
/// <returns>数据表</returns>
public DataTable GetDataTableByPage(BaseUserInfo userInfo, out int recordCount, int pageNo, int pageSize, string condition, List <KeyValuePair <string, object> > dbParameters, string order = null)
{
var myRecordCount = 0;
var dt = new DataTable(BaseOrganizationEntity.CurrentTableName);
var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterReadDb(userInfo, parameter, (dbHelper) =>
{
if (SecretUtil.IsSqlSafe(condition))
{
var organizationManager = new BaseOrganizationManager(dbHelper, userInfo);
dt = organizationManager.GetDataTableByPage(out myRecordCount, pageNo, pageSize, condition, dbHelper.MakeParameters(dbParameters), order);
dt.TableName = BaseOrganizationEntity.CurrentTableName;
}
else
{
// 记录注入日志
LogUtil.WriteLog("userInfo:" + userInfo.Serialize() + " " + condition, "SqlSafe");
}
});
recordCount = myRecordCount;
return(dt);
}
