/// <summary>
/// 添加实体
/// </summary>
/// <param name="entity">实体</param>
public string AddObject(BaseAreaProvinceMarkEntity entity)
{
string sequence = string.Empty;
SQLBuilder sqlBuilder = new SQLBuilder(DbHelper, this.Identity, this.ReturnId);
sqlBuilder.BeginInsert(this.CurrentTableName, BaseAreaProvinceMarkEntity.FieldId);
if (!string.IsNullOrEmpty(entity.Id) || !this.Identity)
{
sqlBuilder.SetValue(BaseAreaProvinceMarkEntity.FieldId, entity.Id);
}
else
{
if (!this.ReturnId && (DbHelper.CurrentDbType == CurrentDbType.Oracle || DbHelper.CurrentDbType == CurrentDbType.DB2))
{
if (DbHelper.CurrentDbType == CurrentDbType.Oracle)
{
sqlBuilder.SetFormula(BaseAreaProvinceMarkEntity.FieldId, "SEQ_" + BaseAreaEntity.TableName + ".NEXTVAL ");
}
if (DbHelper.CurrentDbType == CurrentDbType.DB2)
{
sqlBuilder.SetFormula(BaseAreaProvinceMarkEntity.FieldId, "NEXT VALUE FOR SEQ_" + BaseAreaEntity.TableName.ToUpper());
}
}
else
{
if (this.Identity && (DbHelper.CurrentDbType == CurrentDbType.Oracle || DbHelper.CurrentDbType == CurrentDbType.DB2))
{
if (entity.Id == null)
{
if (string.IsNullOrEmpty(sequence))
{
BaseSequenceManager sequenceManager = new BaseSequenceManager(DbHelper, this.Identity);
sequence = sequenceManager.Increment(this.CurrentTableName);
}
entity.Id = sequence;
}
sqlBuilder.SetValue(BaseAreaEntity.FieldId, entity.Id);
}
}
}
this.SetObject(sqlBuilder, entity);
// 创建人信息
if (!string.IsNullOrEmpty(entity.CreateUserId))
{
sqlBuilder.SetValue(BaseAreaProvinceMarkEntity.FieldCreateUserId, entity.CreateUserId);
}
else
{
if (UserInfo != null)
{
sqlBuilder.SetValue(BaseAreaProvinceMarkEntity.FieldCreateUserId, UserInfo.Id);
}
}
if (!string.IsNullOrEmpty(entity.CreateBy))
{
sqlBuilder.SetValue(BaseAreaProvinceMarkEntity.FieldCreateBy, entity.CreateBy);
}
else
{
if (UserInfo != null)
{
sqlBuilder.SetValue(BaseAreaProvinceMarkEntity.FieldCreateBy, UserInfo.RealName);
}
}
if (entity.CreateOn.HasValue)
{
sqlBuilder.SetValue(BaseAreaProvinceMarkEntity.FieldCreateOn, entity.CreateOn);
}
else
{
sqlBuilder.SetDBNow(BaseAreaProvinceMarkEntity.FieldCreateOn);
}
// 修改人信息
if (!string.IsNullOrEmpty(entity.ModifiedUserId))
{
sqlBuilder.SetValue(BaseAreaProvinceMarkEntity.FieldModifiedUserId, entity.ModifiedUserId);
}
else
{
if (UserInfo != null)
{
sqlBuilder.SetValue(BaseAreaProvinceMarkEntity.FieldModifiedUserId, UserInfo.Id);
}
}
if (!string.IsNullOrEmpty(entity.ModifiedBy))
{
sqlBuilder.SetValue(BaseAreaProvinceMarkEntity.FieldModifiedBy, entity.ModifiedBy);
}
else
{
if (UserInfo != null)
{
sqlBuilder.SetValue(BaseAreaProvinceMarkEntity.FieldModifiedBy, UserInfo.RealName);
}
}
if (entity.ModifiedOn.HasValue)
{
sqlBuilder.SetValue(BaseAreaProvinceMarkEntity.FieldModifiedOn, entity.ModifiedOn);
}
else
{
sqlBuilder.SetDBNow(BaseAreaEntity.FieldModifiedOn);
}
if (DbHelper.CurrentDbType == CurrentDbType.SqlServer && this.Identity)
{
sequence = sqlBuilder.EndInsert().ToString();
}
else
{
sqlBuilder.EndInsert();
}
return(sequence);
}
/// <summary>
/// 添加实体
/// </summary>
/// <param name="workFlowActivityEntity">实体</param>
public string AddEntity(BaseWorkFlowStepEntity workFlowActivityEntity)
{
string sequence = string.Empty;
if (workFlowActivityEntity.SortCode == null || workFlowActivityEntity.SortCode == 0)
{
BaseSequenceManager sequenceManager = new BaseSequenceManager(DbHelper, this.Identity);
sequence = sequenceManager.GetSequence(this.CurrentTableName);
workFlowActivityEntity.SortCode = int.Parse(sequence);
}
SQLBuilder sqlBuilder = new SQLBuilder(DbHelper, this.Identity, this.ReturnId);
sqlBuilder.BeginInsert(this.CurrentTableName, BaseWorkFlowStepEntity.FieldId);
if (!this.Identity)
{
sqlBuilder.SetValue(BaseWorkFlowStepEntity.FieldId, workFlowActivityEntity.Id);
}
else
{
if (!this.ReturnId && (DbHelper.CurrentDbType == CurrentDbType.Oracle || DbHelper.CurrentDbType == CurrentDbType.DB2))
{
if (DbHelper.CurrentDbType == CurrentDbType.Oracle)
{
sqlBuilder.SetFormula(BaseWorkFlowStepEntity.FieldId, "SEQ_" + this.CurrentTableName.ToUpper() + ".NEXTVAL ");
}
if (DbHelper.CurrentDbType == CurrentDbType.DB2)
{
sqlBuilder.SetFormula(BaseWorkFlowStepEntity.FieldId, "NEXT VALUE FOR SEQ_" + this.CurrentTableName.ToUpper());
}
}
else
{
if (this.Identity && (DbHelper.CurrentDbType == CurrentDbType.Oracle || DbHelper.CurrentDbType == CurrentDbType.DB2))
{
if (workFlowActivityEntity.Id == null)
{
if (string.IsNullOrEmpty(sequence))
{
BaseSequenceManager sequenceManager = new BaseSequenceManager(DbHelper, this.Identity);
sequence = sequenceManager.GetSequence(this.CurrentTableName);
}
workFlowActivityEntity.Id = int.Parse(sequence);
}
sqlBuilder.SetValue(BaseWorkFlowStepEntity.FieldId, workFlowActivityEntity.Id);
}
}
}
this.SetEntity(sqlBuilder, workFlowActivityEntity);
if (UserInfo != null)
{
sqlBuilder.SetValue(BaseWorkFlowStepEntity.FieldCreateUserId, UserInfo.Id);
sqlBuilder.SetValue(BaseWorkFlowStepEntity.FieldCreateBy, UserInfo.RealName);
}
sqlBuilder.SetDBNow(BaseWorkFlowStepEntity.FieldCreateOn);
if (UserInfo != null)
{
sqlBuilder.SetValue(BaseWorkFlowStepEntity.FieldModifiedUserId, UserInfo.Id);
sqlBuilder.SetValue(BaseWorkFlowStepEntity.FieldModifiedBy, UserInfo.RealName);
}
sqlBuilder.SetDBNow(BaseWorkFlowStepEntity.FieldModifiedOn);
if (DbHelper.CurrentDbType == CurrentDbType.SqlServer && this.Identity)
{
sequence = sqlBuilder.EndInsert().ToString();
}
else
{
sqlBuilder.EndInsert();
}
return(sequence);
}
/// <summary>
/// 设置按省路由大头笔
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="dtAreaRouteMark">路由设置</param>
/// <returns>影响行数</returns>
public int SetAreaRouteMark(string areaId, DataTable dtAreaRouteMark)
{
int result = 0;
string areaName = string.Empty;
BaseAreaEntity areaEntity = BaseAreaManager.GetObjectByCache(areaId);
if (areaEntity != null)
{
areaName = areaEntity.FullName;
}
if (string.IsNullOrEmpty(areaName))
{
return(result);
}
IDbHelper dbHelper = DbHelperFactory.GetHelper(BaseSystemInfo.UserCenterDbType, BaseSystemInfo.UserCenterDbConnection);
foreach (DataRow dr in dtAreaRouteMark.Rows)
{
// BaseAreaProvinceMarkEntity entity = null;
if (string.IsNullOrWhiteSpace(dr["Id"].ToString()))
{
/*
* entity = new BaseAreaProvinceMarkEntity();
* BaseEntity.Create<BaseAreaProvinceMarkEntity>(dr);
* entity.Province = dr["AREANAME"].ToString();
* entity.ProvinceId = dr["AREAID"].ToString();
* entity.Mark = dr["MARK"].ToString();
* entity.Description = dr["DESCRIPTION"].ToString();
* entity.CreateBy = this.UserInfo.RealName;
* entity.CreateUserId = this.UserInfo.Id;
* entity.CreateOn = DateTime.Now;
* this.AddObject(entity);
*/
SQLBuilder sqlBuilder = new SQLBuilder(dbHelper);
sqlBuilder.BeginInsert("BASEAREA_PROVINCEMARK");
sqlBuilder.SetFormula("Id", "SEQ_BASEAREA_PROVINCEMARK.NEXTVAL");
sqlBuilder.SetValue("MARK", dr["MARK"].ToString());
sqlBuilder.SetValue("DESCRIPTION", dr["DESCRIPTION"].ToString());
sqlBuilder.SetValue("AREAID", areaId);
sqlBuilder.SetValue("AREA", areaName);
sqlBuilder.SetValue("ProvinceID", dr["AREAID"].ToString());
sqlBuilder.SetValue("Province", dr["AREANAME"].ToString());
sqlBuilder.SetValue("CreateUserId", this.UserInfo.Id);
sqlBuilder.SetValue("CreateBy", this.UserInfo.RealName);
sqlBuilder.SetDBNow("CreateOn");
sqlBuilder.SetValue("Enabled", 1);
sqlBuilder.EndInsert();
// sqlBuilder.PrepareCommand();
// dotNetService.AreaService.ExecuteNonQuery(UserInfo, sqlBuilder.CommandText, sqlBuilder.DbParameters, CommandType.Text.ToString());
}
else
{
/*
* if (string.IsNullOrWhiteSpace(dr["MARK"].ToString()) && string.IsNullOrWhiteSpace(dr["DESCRIPTION"].ToString()))
* {
* this.Delete(dr["Id"].ToString());
* }
* else
* {
* entity = this.GetObject(dr["Id"].ToString());
* // entity = BaseEntity.Create<BaseAreaProvinceMarkEntity>(dr);
* entity.Mark = dr["MARK"].ToString();
* entity.Description = dr["DESCRIPTION"].ToString();
* entity.ModifiedBy = this.UserInfo.RealName;
* entity.ModifiedUserId = this.UserInfo.Id;
* entity.ModifiedOn = DateTime.Now;
* this.Update(entity);
* }
*/
SQLBuilder sqlBuilder = new SQLBuilder(dbHelper);
if (string.IsNullOrWhiteSpace(dr["MARK"].ToString()) && string.IsNullOrWhiteSpace(dr["DESCRIPTION"].ToString()))
{
sqlBuilder.BeginDelete("BASEAREA_PROVINCEMARK");
sqlBuilder.SetWhere("Id", dr["Id"].ToString());
sqlBuilder.EndDelete();
// sqlBuilder.PrepareCommand();
// dotNetService.AreaService.ExecuteNonQuery(UserInfo, sqlBuilder.CommandText, sqlBuilder.DbParameters, CommandType.Text.ToString());
}
else
{
sqlBuilder.BeginUpdate("BASEAREA_PROVINCEMARK");
sqlBuilder.SetValue("MARK", dr["MARK"].ToString());
sqlBuilder.SetValue("DESCRIPTION", dr["DESCRIPTION"].ToString());
sqlBuilder.SetValue("ModifiedUserId", this.UserInfo.Id);
sqlBuilder.SetValue("ModifiedBy", this.UserInfo.RealName);
sqlBuilder.SetDBNow("ModifiedOn");
sqlBuilder.SetWhere("ID", dr["Id"].ToString());
sqlBuilder.EndUpdate();
// sqlBuilder.PrepareCommand();
// dotNetService.AreaService.ExecuteNonQuery(UserInfo, sqlBuilder.CommandText, sqlBuilder.DbParameters, CommandType.Text.ToString());
}
}
}
return(result);
}
//
// 授予权限的实现部分
//
#region public string Grant(string systemCode, string roleId, string permissionId, bool chekExists = true) 为了提高授权的运行速度
/// <summary>
/// 为了提高授权的运行速度
/// </summary>
/// <param name="systemCode">系统编号</param>
/// <param name="roleId">角色主键</param>
/// <param name="permissionId">权限主键</param>
/// <returns>主键</returns>
public string Grant(string systemCode, string roleId, string permissionId, bool chekExists = true)
{
string result = string.Empty;
string currentId = string.Empty;
this.CurrentTableName = systemCode + "Permission";
string tableName = systemCode + "Role";
// 判断是否已经存在这个权限，若已经存在就不重复增加了
if (chekExists)
{
List <KeyValuePair <string, object> > whereParameters = new List <KeyValuePair <string, object> >();
whereParameters.Add(new KeyValuePair <string, object>(BasePermissionEntity.FieldResourceCategory, tableName));
whereParameters.Add(new KeyValuePair <string, object>(BasePermissionEntity.FieldResourceId, roleId));
whereParameters.Add(new KeyValuePair <string, object>(BasePermissionEntity.FieldPermissionId, permissionId));
currentId = this.GetId(whereParameters);
if (!string.IsNullOrEmpty(currentId))
{
List <KeyValuePair <string, object> > parameters = new List <KeyValuePair <string, object> >();
parameters.Add(new KeyValuePair <string, object>(BasePermissionEntity.FieldEnabled, 1));
parameters.Add(new KeyValuePair <string, object>(BasePermissionEntity.FieldDeletionStateCode, 0));
parameters.Add(new KeyValuePair <string, object>(BasePermissionEntity.FieldModifiedUserId, this.UserInfo.Id));
parameters.Add(new KeyValuePair <string, object>(BasePermissionEntity.FieldModifiedBy, this.UserInfo.RealName));
parameters.Add(new KeyValuePair <string, object>(BasePermissionEntity.FieldModifiedOn, DateTime.Now));
// 更新状态，设置为有效、并取消删除标志，权限也不是天天变动的，所以可以更新一下
this.SetProperty(currentId, parameters);
}
}
if (string.IsNullOrEmpty(currentId))
{
BasePermissionEntity permissionEntity = new BasePermissionEntity();
permissionEntity.ResourceCategory = tableName;
permissionEntity.ResourceId = roleId;
permissionEntity.PermissionId = permissionId;
// 防止不允许为NULL的错误发生
permissionEntity.Enabled = 1;
permissionEntity.DeletionStateCode = 0;
BasePermissionManager permissionManager = new BasePermissionManager(DbHelper, UserInfo, this.CurrentTableName);
result = permissionManager.Add(permissionEntity);
}
// 2015-09-21 吉日嘎拉 这里增加变更日志
tableName = systemCode + ".Permission.Role";
SQLBuilder sqlBuilder = new SQLBuilder(this.DbHelper);
sqlBuilder.BeginInsert(BaseModifyRecordEntity.TableName);
sqlBuilder.SetValue(BaseModifyRecordEntity.FieldTableCode, tableName);
if (DbHelper.CurrentDbType == CurrentDbType.Oracle)
{
sqlBuilder.SetFormula(BaseModifyRecordEntity.FieldId, "SEQ_" + BaseModifyRecordEntity.TableName + ".NEXTVAL");
}
sqlBuilder.SetValue(BaseModifyRecordEntity.FieldRecordKey, roleId);
sqlBuilder.SetValue(BaseModifyRecordEntity.FieldColumnCode, "授权");
sqlBuilder.SetValue(BaseModifyRecordEntity.FieldColumnDescription, BaseModuleManager.GetNameByCache(systemCode, permissionId));
sqlBuilder.SetValue(BaseModifyRecordEntity.FieldOldValue, null);
sqlBuilder.SetValue(BaseModifyRecordEntity.FieldNewValue, permissionId);
sqlBuilder.SetValue(BaseModifyRecordEntity.FieldCreateUserId, this.UserInfo.Id);
sqlBuilder.SetValue(BaseModifyRecordEntity.FieldCreateBy, this.UserInfo.RealName);
sqlBuilder.SetDBNow(BaseModifyRecordEntity.FieldCreateOn);
sqlBuilder.SetValue(BaseModifyRecordEntity.FieldIPAddress, this.UserInfo.IPAddress);
sqlBuilder.EndInsert();
return(result);
}
/// <summary>
/// 添加实体
/// </summary>
/// <param name="newsEntity">实体</param>
public string AddEntity(BaseNewsEntity newsEntity)
{
string sequence = string.Empty;
sequence = newsEntity.Id;
if (newsEntity.SortCode == 0)
{
BaseSequenceManager sequenceManager = new BaseSequenceManager(DbHelper, this.Identity);
sequence = sequenceManager.GetSequence(this.CurrentTableName);
newsEntity.SortCode = int.Parse(sequence);
}
if (newsEntity.Id is string)
{
this.Identity = false;
}
SQLBuilder sqlBuilder = new SQLBuilder(DbHelper, this.Identity, this.ReturnId);
sqlBuilder.BeginInsert(this.CurrentTableName, BaseNewsEntity.FieldId);
if (!this.Identity)
{
sqlBuilder.SetValue(BaseNewsEntity.FieldId, newsEntity.Id);
}
else
{
if (!this.ReturnId && DbHelper.CurrentDbType == CurrentDbType.Oracle)
{
sqlBuilder.SetFormula(BaseNewsEntity.FieldId, "SEQ_" + this.CurrentTableName.ToUpper() + ".NEXTVAL ");
}
else
{
if (this.Identity && DbHelper.CurrentDbType == CurrentDbType.Oracle)
{
if (string.IsNullOrEmpty(newsEntity.Id))
{
if (string.IsNullOrEmpty(sequence))
{
BaseSequenceManager sequenceManager = new BaseSequenceManager(DbHelper, this.Identity);
sequence = sequenceManager.GetSequence(this.CurrentTableName);
}
newsEntity.Id = sequence;
}
sqlBuilder.SetValue(BaseNewsEntity.FieldId, newsEntity.Id);
}
}
}
this.SetEntity(sqlBuilder, newsEntity);
if (UserInfo != null)
{
newsEntity.CreateUserId = UserInfo.Id;
newsEntity.CreateBy = UserInfo.RealName;
sqlBuilder.SetValue(BaseNewsEntity.FieldCreateUserId, newsEntity.CreateUserId);
sqlBuilder.SetValue(BaseNewsEntity.FieldCreateBy, newsEntity.CreateBy);
newsEntity.ModifiedBy = UserInfo.RealName;
sqlBuilder.SetValue(BaseNewsEntity.FieldModifiedUserId, newsEntity.CreateUserId);
sqlBuilder.SetValue(BaseNewsEntity.FieldModifiedBy, newsEntity.CreateBy);
}
sqlBuilder.SetDBNow(BaseNewsEntity.FieldCreateOn);
sqlBuilder.SetDBNow(BaseNewsEntity.FieldModifiedOn);
/*
* if (UserInfo != null)
* {
* sqlBuilder.SetValue(BaseNewsEntity.FieldModifiedUserId, UserInfo.Id);
* sqlBuilder.SetValue(BaseNewsEntity.FieldModifiedBy, UserInfo.RealName);
* }
* sqlBuilder.SetDBNow(BaseNewsEntity.FieldModifiedOn);
*/
if (DbHelper.CurrentDbType == CurrentDbType.SqlServer && this.Identity)
{
sequence = sqlBuilder.EndInsert().ToString();
}
else
{
sqlBuilder.EndInsert();
}
return(sequence);
}
/// <summary>
/// 添加实体
/// </summary>
/// <param name="entity">实体</param>
public string AddObject(BaseUserEntity entity)
{
string result = string.Empty;
if (entity.SortCode == 0)
{
BaseSequenceManager sequenceManager = new BaseSequenceManager(DbHelper, this.Identity);
result = sequenceManager.Increment(this.CurrentTableName);
entity.SortCode = int.Parse(result);
}
// 2015-12-11 吉日嘎拉 全部小写，提高Oracle的效率
entity.QuickQuery = StringUtil.GetPinyin(entity.RealName).ToLower();
entity.SimpleSpelling = StringUtil.GetSimpleSpelling(entity.RealName).ToLower();
SQLBuilder sqlBuilder = new SQLBuilder(DbHelper, this.Identity, this.ReturnId);
sqlBuilder.BeginInsert(this.CurrentTableName, BaseUserEntity.FieldId);
if (DbHelper.CurrentDbType == CurrentDbType.MySql && string.IsNullOrEmpty(entity.Id))
{
entity.Id = Guid.NewGuid().ToString("N");
result = entity.Id;
}
if (!this.Identity || !string.IsNullOrEmpty(entity.Id))
{
sqlBuilder.SetValue(BaseUserEntity.FieldId, entity.Id);
result = entity.Id;
}
else
{
if (!this.ReturnId && (DbHelper.CurrentDbType == CurrentDbType.Oracle || DbHelper.CurrentDbType == CurrentDbType.DB2))
{
if (DbHelper.CurrentDbType == CurrentDbType.Oracle)
{
sqlBuilder.SetFormula(BaseUserEntity.FieldId, "SEQ_" + this.CurrentTableName.ToUpper() + ".NEXTVAL ");
}
if (DbHelper.CurrentDbType == CurrentDbType.DB2)
{
sqlBuilder.SetFormula(BaseUserEntity.FieldId, "NEXT VALUE FOR SEQ_" + this.CurrentTableName.ToUpper());
}
}
else
{
if (this.Identity && (DbHelper.CurrentDbType == CurrentDbType.Oracle || DbHelper.CurrentDbType == CurrentDbType.DB2))
{
if (entity.Id == null)
{
if (string.IsNullOrEmpty(result))
{
BaseSequenceManager sequenceManager = new BaseSequenceManager(DbHelper, this.Identity);
result = sequenceManager.Increment(this.CurrentTableName);
}
entity.Id = result;
}
sqlBuilder.SetValue(BaseUserEntity.FieldId, entity.Id);
}
}
}
this.SetObject(sqlBuilder, entity);
if (UserInfo != null)
{
sqlBuilder.SetValue(BaseUserEntity.FieldCreateUserId, UserInfo.Id);
sqlBuilder.SetValue(BaseUserEntity.FieldCreateBy, UserInfo.RealName);
}
sqlBuilder.SetDBNow(BaseUserEntity.FieldCreateOn);
if (UserInfo != null)
{
sqlBuilder.SetValue(BaseUserEntity.FieldModifiedUserId, UserInfo.Id);
sqlBuilder.SetValue(BaseUserEntity.FieldModifiedBy, UserInfo.RealName);
}
sqlBuilder.SetDBNow(BaseUserEntity.FieldModifiedOn);
// 2015-12-16 吉日嘎拉 优化返回值问题、提高自增Id导入的问题的效率，关联数据产生问题
if (this.Identity &&
(DbHelper.CurrentDbType == CurrentDbType.SqlServer || DbHelper.CurrentDbType == CurrentDbType.MySql))
{
result = sqlBuilder.EndInsert().ToString();
entity.Id = result;
}
else
{
sqlBuilder.EndInsert();
}
return(result);
}
/// <summary>
/// 更新密码
/// </summary>
/// <param name="userId">用户主键、方便外部系统调用，若能传递参数过来</param>
/// <param name="oldPassword">原密码</param>
/// <param name="newPassword">新密码</param>
/// <returns>影响行数</returns>
public virtual BaseUserInfo ChangePassword(string userId, string oldPassword, string newPassword)
{
#if (DEBUG)
int milliStart = Environment.TickCount;
#endif
string encryptOldPassword = oldPassword;
string encryptNewPassword = newPassword;
BaseUserInfo userInfo = null;
// 密码强度检查
if (BaseSystemInfo.CheckPasswordStrength)
{
if (String.IsNullOrEmpty(newPassword))
{
this.StatusCode = Status.PasswordCanNotBeNull.ToString();
return(userInfo);
}
}
// 判断输入原始密码是否正确
BaseUserLogOnEntity entity = new BaseUserLogOnManager(this.DbHelper, this.UserInfo).GetObject(UserInfo.Id);
if (entity.UserPassword == null)
{
entity.UserPassword = string.Empty;
}
// 加密密码
if (BaseSystemInfo.ServerEncryptPassword)
{
encryptOldPassword = this.EncryptUserPassword(oldPassword, entity.Salt);
}
// 密码错误
if (!entity.UserPassword.Equals(encryptOldPassword, StringComparison.CurrentCultureIgnoreCase))
{
this.StatusCode = Status.OldPasswordError.ToString();
return(userInfo);
}
// 对比是否最近2次用过这个密码
if (BaseSystemInfo.CheckPasswordStrength)
{
/*
* int i = 0;
* BaseParameterManager manager = new BaseParameterManager(this.DbHelper, this.UserInfo);
* var dt = manager.GetDataTableParameterCode("User", this.UserInfo.Id, "Password");
* foreach (DataRow dr in dt.Rows)
* {
* string parameter = dr[BaseParameterEntity.FieldParameterContent].ToString();
* if (parameter.Equals(newPassword))
* {
* this.StatusCode = Status.PasswordCanNotBeRepeat.ToString();
* return userInfo;
* }
* i++;
* {
* // 判断连续2个密码就是可以了
* if (i > 2)
* {
* break;
* }
* }
* }
*/
}
// 更改密码，同时修改密码的修改日期，这里需要兼容多数据库
string salt = string.Empty;
if (BaseSystemInfo.ServerEncryptPassword)
{
salt = BaseRandom.GetRandomString(20);
encryptNewPassword = this.EncryptUserPassword(newPassword, salt);
}
SQLBuilder sqlBuilder = new SQLBuilder(this.DbHelper);
sqlBuilder.BeginUpdate(BaseUserLogOnEntity.TableName);
if (BaseSystemInfo.ServerEncryptPassword)
{
sqlBuilder.SetValue(BaseUserLogOnEntity.FieldSalt, salt);
}
// 宋彪：此处增加更新密码强度级别
sqlBuilder.SetValue(BaseUserLogOnEntity.FieldPasswordStrength, SecretUtil.GetUserPassWordRate(newPassword));
sqlBuilder.SetValue(BaseUserLogOnEntity.FieldUserPassword, encryptNewPassword);
// 2015-08-04 吉日嘎拉 修改了密码后,把需要修改密码字段设置为 0
sqlBuilder.SetValue(BaseUserLogOnEntity.FieldNeedModifyPassword, 0);
sqlBuilder.SetDBNow(BaseUserLogOnEntity.FieldChangePasswordDate);
sqlBuilder.SetWhere(BaseUserLogOnEntity.FieldId, userId);
int result = sqlBuilder.EndUpdate();
if (result == 1)
{
// 2015-12-09 吉日嘎拉 确认已经记录了修改密码日志
// BaseLoginLogManager.AddLog(this.UserInfo, Status.ChangePassword.ToDescription());
// 2015-12-09 吉日嘎拉 增加日志功能、谁什么时候设置了谁的密码？
var record = new BaseModifyRecordEntity();
record.TableCode = BaseUserLogOnEntity.TableName.ToUpper();
record.TableDescription = "用户登录信息表";
record.ColumnCode = BaseUserLogOnEntity.FieldUserPassword;
record.ColumnDescription = "用户密码";
record.RecordKey = userId;
record.NewValue = "修改密码";
// record.OldValue = "";
if (this.UserInfo != null)
{
record.IPAddress = this.UserInfo.IPAddress;
record.CreateUserId = this.UserInfo.Id;
record.CreateOn = DateTime.Now;
}
BaseModifyRecordManager modifyRecordManager = new Business.BaseModifyRecordManager(this.UserInfo, BaseUserEntity.TableName + "_Log");
modifyRecordManager.Add(record, true, false);
/*
* // 若是强类型密码检查，那就保存密码修改历史，防止最近2-3次的密码相同的功能实现。
* if (BaseSystemInfo.CheckPasswordStrength)
* {
* BaseParameterManager parameterManager = new BaseParameterManager(this.DbHelper, this.UserInfo);
* BaseParameterEntity parameterEntity = new BaseParameterEntity();
* parameterEntity.CategoryCode = "User";
* parameterEntity.ParameterId = this.UserInfo.Id;
* parameterEntity.ParameterCode = "Password";
* parameterEntity.ParameterContent = newPassword;
* parameterEntity.DeletionStateCode = 0;
* parameterEntity.Enabled = true;
* parameterEntity.Worked = true;
* parameterManager.AddObject(parameterEntity);
* }
*/
userInfo = this.LogOnByOpenId(this.UserInfo.OpenId, this.UserInfo.SystemCode).UserInfo;
// 同步处理其他系统的密码修改动作
if (BaseSystemInfo.ServerEncryptPassword)
{
// AfterChangePassword(this.UserInfo.Id, salt, oldPassword, newPassword);
}
// 修改密码成功，写入状态
this.StatusCode = Status.ChangePasswordOK.ToString();
}
else
{
// 数据可能被删除
this.StatusCode = Status.ErrorDeleted.ToString();
}
return(userInfo);
}
/// <summary>
/// 获取一个操作权限的主键
/// 若不存在就自动增加一个
/// </summary>
/// <param name="permissionItemCode">操作权限编号</param>
/// <param name="permissionItemName">操作权限名称</param>
/// <returns>主键</returns>
public string GetIdByAdd(string permissionItemCode, string permissionItemName = null)
{
// 判断当前判断的权限是否存在，否则很容易出现前台设置了权限，后台没此项权限
// 需要自动的能把前台判断过的权限，都记录到后台来
List <KeyValuePair <string, object> > parameters = new List <KeyValuePair <string, object> >();
parameters.Add(new KeyValuePair <string, object>(BasePermissionItemEntity.FieldCode, permissionItemCode));
parameters.Add(new KeyValuePair <string, object>(BasePermissionItemEntity.FieldEnabled, 1));
parameters.Add(new KeyValuePair <string, object>(BasePermissionItemEntity.FieldDeletionStateCode, 0));
BasePermissionItemEntity permissionItemEntity = new BasePermissionItemEntity();
permissionItemEntity = new BasePermissionItemEntity(this.GetDataTable(parameters, BasePermissionItemEntity.FieldId));
string permissionItemId = string.Empty;
if (permissionItemEntity != null)
{
permissionItemId = permissionItemEntity.Id.ToString();
}
// 若是在调试阶段、有没在的权限被判断了，那就自动加入这个权限，不用人工加入权限了，工作效率会提高很多，
// 哪些权限是否有被调用什么的，还可以进行一些诊断
#if (DEBUG)
if (String.IsNullOrEmpty(permissionItemId))
{
// 这里需要进行一次加锁，方式并发冲突发生
lock (PermissionItemLock)
{
permissionItemEntity.Code = permissionItemCode;
if (string.IsNullOrEmpty(permissionItemName))
{
permissionItemEntity.FullName = permissionItemCode;
}
else
{
permissionItemEntity.FullName = permissionItemName;
}
permissionItemEntity.ParentId = null;
permissionItemEntity.IsScope = 0;
permissionItemEntity.AllowDelete = 1;
permissionItemEntity.AllowEdit = 1;
permissionItemEntity.Enabled = 1;
// 这里是防止主键重复？
// permissionEntity.ID = BaseBusinessLogic.NewGuid();
permissionItemId = this.AddEntity(permissionItemEntity);
}
}
else
{
// 更新最后一次访问日期，设置为当前服务器日期
SQLBuilder sqlBuilder = new SQLBuilder(DbHelper);
sqlBuilder.BeginUpdate(this.CurrentTableName);
sqlBuilder.SetDBNow(BasePermissionItemEntity.FieldLastCall);
sqlBuilder.SetWhere(BasePermissionItemEntity.FieldId, permissionItemId);
sqlBuilder.EndUpdate();
}
#endif
return(permissionItemId);
}
/// <summary>
/// 获取一个操作权限的主键
/// 若不存在就自动增加一个
/// </summary>
/// <param name="permissionCode">操作权限编号</param>
/// <param name="permissionItemName">操作权限名称</param>
/// <returns>主键</returns>
public string GetIdByAdd(string permissionCode, string permissionName = null)
{
// 判断当前判断的权限是否存在，否则很容易出现前台设置了权限，后台没此项权限
// 需要自动的能把前台判断过的权限，都记录到后台来
List <KeyValuePair <string, object> > parameters = new List <KeyValuePair <string, object> >();
parameters.Add(new KeyValuePair <string, object>(BaseModuleEntity.FieldCode, permissionCode));
parameters.Add(new KeyValuePair <string, object>(BaseModuleEntity.FieldEnabled, 1));
parameters.Add(new KeyValuePair <string, object>(BaseModuleEntity.FieldDeletionStateCode, 0));
BaseModuleEntity entity = BaseEntity.Create <BaseModuleEntity>(this.GetDataTable(parameters, BaseModuleEntity.FieldId));
string result = string.Empty;
if (entity != null)
{
result = entity.Id.ToString();
}
else
{
entity = new BaseModuleEntity();
}
// 若是在调试阶段、有没在的权限被判断了，那就自动加入这个权限，不用人工加入权限了，工作效率会提高很多，
// 哪些权限是否有被调用什么的，还可以进行一些诊断
// #if (DEBUG)
if (String.IsNullOrEmpty(result))
{
/*
* // 这里需要进行一次加锁，方式并发冲突发生
* lock (PermissionLock)
* {
* entity.Code = permissionCode;
* if (string.IsNullOrEmpty(permissionName))
* {
* entity.FullName = permissionCode;
* }
* else
* {
* entity.FullName = permissionName;
* }
* entity.ParentId = null;
* entity.IsScope = 0;
* entity.IsPublic = 0;
* // permissionEntity.CategoryCode = "Application";
* entity.IsMenu = 0;
* entity.IsVisible = 1;
* entity.DeletionStateCode = 0;
* entity.Enabled = 1;
* entity.AllowDelete = 1;
* entity.AllowEdit = 1;
* // 这里是防止主键重复？
* // permissionEntity.Id = BaseBusinessLogic.NewGuid();
* result = this.AddObject(entity);
* }
*/
}
else
{
// 更新最后一次访问日期，设置为当前服务器日期
SQLBuilder sqlBuilder = new SQLBuilder(DbHelper);
sqlBuilder.BeginUpdate(this.CurrentTableName);
sqlBuilder.SetDBNow(BaseModuleEntity.FieldLastCall);
sqlBuilder.SetWhere(BaseModuleEntity.FieldId, result);
sqlBuilder.EndUpdate();
}
// #endif
return(result);
}
/// <summary>
/// 添加实体
/// </summary>
/// <param name="baseMessageEntity">实体</param>
public string AddEntity(BaseMessageEntity baseMessageEntity)
{
string sequence = string.Empty;
this.Identity = false;
if (baseMessageEntity.SortCode == null || baseMessageEntity.SortCode == 0)
{
BaseSequenceManager sequenceManager = new BaseSequenceManager(DbHelper, this.Identity);
sequence = sequenceManager.GetSequence(this.CurrentTableName);
baseMessageEntity.SortCode = int.Parse(sequence);
}
if (baseMessageEntity.Id != null)
{
sequence = baseMessageEntity.Id.ToString();
}
SQLBuilder sqlBuilder = new SQLBuilder(DbHelper, this.Identity, this.ReturnId);
sqlBuilder.BeginInsert(this.CurrentTableName, BaseMessageEntity.FieldId);
if (!this.Identity)
{
if (string.IsNullOrEmpty(baseMessageEntity.Id))
{
sequence = BaseBusinessLogic.NewGuid();
baseMessageEntity.Id = sequence;
}
sqlBuilder.SetValue(BaseMessageEntity.FieldId, baseMessageEntity.Id);
}
else
{
if (!this.ReturnId && (DbHelper.CurrentDbType == CurrentDbType.Oracle || DbHelper.CurrentDbType == CurrentDbType.DB2))
{
if (DbHelper.CurrentDbType == CurrentDbType.Oracle)
{
sqlBuilder.SetFormula(BaseMessageEntity.FieldId, "SEQ_" + this.CurrentTableName.ToUpper() + ".NEXTVAL ");
}
if (DbHelper.CurrentDbType == CurrentDbType.DB2)
{
sqlBuilder.SetFormula(BaseMessageEntity.FieldId, "NEXT VALUE FOR SEQ_" + this.CurrentTableName.ToUpper());
}
}
else
{
if (this.Identity && (DbHelper.CurrentDbType == CurrentDbType.Oracle || DbHelper.CurrentDbType == CurrentDbType.DB2))
{
if (string.IsNullOrEmpty(baseMessageEntity.Id))
{
if (string.IsNullOrEmpty(sequence))
{
BaseSequenceManager sequenceManager = new BaseSequenceManager(DbHelper, this.Identity);
sequence = sequenceManager.GetSequence(this.CurrentTableName);
}
baseMessageEntity.Id = sequence;
}
sqlBuilder.SetValue(BaseMessageEntity.FieldId, baseMessageEntity.Id);
}
}
}
this.SetEntity(sqlBuilder, baseMessageEntity);
if (UserInfo != null)
{
sqlBuilder.SetValue(BaseMessageEntity.FieldCreateUserId, UserInfo.Id);
sqlBuilder.SetValue(BaseMessageEntity.FieldCreateBy, UserInfo.RealName);
}
sqlBuilder.SetDBNow(BaseMessageEntity.FieldCreateOn);
if (UserInfo != null)
{
sqlBuilder.SetValue(BaseMessageEntity.FieldModifiedUserId, UserInfo.Id);
sqlBuilder.SetValue(BaseMessageEntity.FieldModifiedBy, UserInfo.RealName);
}
sqlBuilder.SetDBNow(BaseMessageEntity.FieldModifiedOn);
if (this.Identity && (DbHelper.CurrentDbType == CurrentDbType.SqlServer || DbHelper.CurrentDbType == CurrentDbType.Access))
{
sequence = sqlBuilder.EndInsert().ToString();
}
else
{
sqlBuilder.EndInsert();
}
return(sequence);
}
/// <summary>
/// 添加实体
/// </summary>
/// <param name="entity">实体</param>
public string AddObject(HRCheckInEntity entity)
{
string key = string.Empty;
if (string.IsNullOrEmpty(entity.Id))
{
entity.Id = System.Guid.NewGuid().ToString("N");
}
key = entity.Id;
SQLBuilder sqlBuilder = new SQLBuilder(this.DbHelper, this.Identity, this.ReturnId);
sqlBuilder.BeginInsert(this.CurrentTableName, this.PrimaryKey);
if (!string.IsNullOrEmpty(entity.Id))
{
// 这里已经是指定了主键了，所以不需要返回主键了
sqlBuilder.ReturnId = false;
sqlBuilder.SetValue(this.PrimaryKey, entity.Id);
}
else
{
if ((DbHelper.CurrentDbType == CurrentDbType.Oracle || DbHelper.CurrentDbType == CurrentDbType.DB2))
{
if (DbHelper.CurrentDbType == CurrentDbType.Oracle)
{
sqlBuilder.SetFormula(this.PrimaryKey, "SEQ_BASE_LOGINLOG.NEXTVAL ");
}
if (DbHelper.CurrentDbType == CurrentDbType.DB2)
{
sqlBuilder.SetFormula(this.PrimaryKey, "NEXT VALUE FOR SEQ_" + this.CurrentTableName.ToUpper());
}
}
else
{
entity.Id = System.Guid.NewGuid().ToString("N");
sqlBuilder.SetValue(this.PrimaryKey, entity.Id);
}
}
this.SetObject(sqlBuilder, entity);
if (UserInfo != null)
{
sqlBuilder.SetValue(HRCheckInEntity.FieldCreateUserId, UserInfo.Id);
sqlBuilder.SetValue(HRCheckInEntity.FieldCreateBy, UserInfo.RealName);
sqlBuilder.SetValue(HRCheckInEntity.FieldModifiedUserId, UserInfo.Id);
sqlBuilder.SetValue(HRCheckInEntity.FieldModifiedBy, UserInfo.RealName);
}
sqlBuilder.SetDBNow(HRCheckInEntity.FieldCreateOn);
sqlBuilder.SetDBNow(HRCheckInEntity.FieldModifiedOn);
if (this.Identity && (DbHelper.CurrentDbType == CurrentDbType.SqlServer || DbHelper.CurrentDbType == CurrentDbType.Access))
{
key = sqlBuilder.EndInsert().ToString();
}
else
{
sqlBuilder.EndInsert();
}
if (this.Identity && (DbHelper.CurrentDbType == CurrentDbType.Oracle || DbHelper.CurrentDbType == CurrentDbType.DB2))
{
return(entity.Id.ToString());
}
return(key);
}
/// <summary>
/// 添加实体
/// </summary>
/// <param name="entity">实体</param>
public string AddObject(BaseModuleEntity entity)
{
string result = string.Empty;
if (entity.SortCode == null || entity.SortCode == 0)
{
BaseSequenceManager sequenceManager = new BaseSequenceManager(DbHelper, this.Identity);
result = sequenceManager.Increment(BaseModuleEntity.TableName);
entity.SortCode = int.Parse(result);
}
SQLBuilder sqlBuilder = new SQLBuilder(DbHelper, this.Identity, this.ReturnId);
sqlBuilder.BeginInsert(this.CurrentTableName, BaseModuleEntity.FieldId);
// 若是非空主键，表明已经指定了主键了
if (!string.IsNullOrEmpty(entity.Id))
{
// 这里已经是指定了主键了，所以不需要返回主键了
sqlBuilder.SetValue(BaseModuleEntity.FieldId, entity.Id);
result = entity.Id;
}
else
{
if (DbHelper.CurrentDbType == CurrentDbType.Oracle)
{
// 2015-12-23 吉日嘎拉 这里需要兼容一下以前的老的数据结构
sqlBuilder.SetFormula(this.PrimaryKey, "SEQ_" + BaseModuleEntity.TableName.ToUpper() + ".NEXTVAL ");
}
else
{
entity.Id = Guid.NewGuid().ToString("N");
result = entity.Id;
sqlBuilder.SetValue(BaseModuleEntity.FieldId, entity.Id);
}
}
this.SetObject(sqlBuilder, entity);
if (UserInfo != null)
{
sqlBuilder.SetValue(BaseModuleEntity.FieldCreateUserId, UserInfo.Id);
sqlBuilder.SetValue(BaseModuleEntity.FieldCreateBy, UserInfo.RealName);
}
sqlBuilder.SetDBNow(BaseModuleEntity.FieldCreateOn);
if (UserInfo != null)
{
sqlBuilder.SetValue(BaseModuleEntity.FieldModifiedUserId, UserInfo.Id);
sqlBuilder.SetValue(BaseModuleEntity.FieldModifiedBy, UserInfo.RealName);
}
sqlBuilder.SetDBNow(BaseModuleEntity.FieldModifiedOn);
if (this.Identity && (DbHelper.CurrentDbType == CurrentDbType.SqlServer || DbHelper.CurrentDbType == CurrentDbType.Access))
{
result = sqlBuilder.EndInsert().ToString();
}
else
{
sqlBuilder.EndInsert();
}
return(result);
}
/// <summary>
/// 添加实体
/// </summary>
/// <param name="entity">实体</param>
public string AddObject(BaseOrganizeScopeEntity entity)
{
string key = string.Empty;
SQLBuilder sqlBuilder = new SQLBuilder(DbHelper, this.Identity, this.ReturnId);
sqlBuilder.BeginInsert(this.CurrentTableName, this.PrimaryKey);
if (!this.Identity)
{
// 这里已经是指定了主键了，所以不需要返回主键了
sqlBuilder.ReturnId = false;
sqlBuilder.SetValue(this.PrimaryKey, entity.Id);
}
else
{
if (!this.ReturnId && (DbHelper.CurrentDbType == CurrentDbType.Oracle || DbHelper.CurrentDbType == CurrentDbType.DB2))
{
if (DbHelper.CurrentDbType == CurrentDbType.Oracle)
{
// 2015-09-25 吉日嘎拉 用一个序列就可以了，不用那么多序列了
sqlBuilder.SetFormula(this.PrimaryKey, "SEQ_" + BaseOrganizeScopeEntity.TableName.ToUpper() + ".NEXTVAL ");
// sqlBuilder.SetFormula(this.PrimaryKey, "SEQ_" + this.CurrentTableName.ToUpper() + ".NEXTVAL ");
}
if (DbHelper.CurrentDbType == CurrentDbType.DB2)
{
// sqlBuilder.SetFormula(this.PrimaryKey, "NEXT VALUE FOR SEQ_" + this.CurrentTableName.ToUpper());
sqlBuilder.SetFormula(this.PrimaryKey, "NEXT VALUE FOR SEQ_" + BaseOrganizeScopeEntity.TableName.ToUpper());
}
}
else
{
if (this.Identity && (DbHelper.CurrentDbType == CurrentDbType.Oracle || DbHelper.CurrentDbType == CurrentDbType.DB2))
{
// BaseSequenceManager sequenceManager = new BaseSequenceManager(DbHelper);
// entity.Id = int.Parse(sequenceManager.Increment(BasePermissionEntity.TableName));
// entity.Id = int.Parse(sequenceManager.Increment(this.CurrentTableName));
// sqlBuilder.SetValue(this.PrimaryKey, entity.Id);
sqlBuilder.SetFormula(this.PrimaryKey, "SEQ_" + BaseOrganizeScopeEntity.TableName.ToUpper() + ".NEXTVAL ");
}
}
}
this.SetObject(sqlBuilder, entity);
if (UserInfo != null)
{
sqlBuilder.SetValue(BaseOrganizeScopeEntity.FieldCreateUserId, UserInfo.Id);
sqlBuilder.SetValue(BaseOrganizeScopeEntity.FieldCreateBy, UserInfo.RealName);
}
sqlBuilder.SetDBNow(BaseOrganizeScopeEntity.FieldCreateOn);
if (UserInfo != null)
{
sqlBuilder.SetValue(BaseOrganizeScopeEntity.FieldModifiedUserId, UserInfo.Id);
sqlBuilder.SetValue(BaseOrganizeScopeEntity.FieldModifiedBy, UserInfo.RealName);
}
sqlBuilder.SetDBNow(BaseOrganizeScopeEntity.FieldModifiedOn);
if (this.Identity && (DbHelper.CurrentDbType == CurrentDbType.SqlServer || DbHelper.CurrentDbType == CurrentDbType.Access))
{
key = sqlBuilder.EndInsert().ToString();
}
else
{
sqlBuilder.EndInsert();
}
if (this.Identity && (DbHelper.CurrentDbType == CurrentDbType.Oracle || DbHelper.CurrentDbType == CurrentDbType.DB2))
{
return(entity.Id.ToString());
}
return(key);
}
/// <summary>
/// 添加实体
/// </summary>
/// <param name="entity">实体</param>
public string AddObject(UserByGUIDEntity entity)
{
string sequence = string.Empty;
if (entity.SortCode == null || entity.SortCode == 0)
{
BaseSequenceManager sequenceManager = new BaseSequenceManager(DbHelper, this.Identity);
sequence = sequenceManager.Increment(this.CurrentTableName);
entity.SortCode = int.Parse(sequence);
}
if (entity.UserId != null)
{
sequence = entity.UserId.ToString();
}
SQLBuilder sqlBuilder = new SQLBuilder(DbHelper, this.Identity, this.ReturnId);
sqlBuilder.BeginInsert(this.CurrentTableName, this.PrimaryKey);
if (!this.Identity)
{
// 这里已经是指定了主键了，所以不需要返回主键了
sqlBuilder.ReturnId = false;
sqlBuilder.SetValue(this.PrimaryKey, entity.UserId);
}
else
{
if (!this.ReturnId && (DbHelper.CurrentDbType == CurrentDbType.Oracle || DbHelper.CurrentDbType == CurrentDbType.DB2))
{
if (DbHelper.CurrentDbType == CurrentDbType.Oracle)
{
sqlBuilder.SetFormula(this.PrimaryKey, "SEQ_" + this.CurrentTableName.ToUpper() + ".NEXTVAL ");
}
if (DbHelper.CurrentDbType == CurrentDbType.DB2)
{
sqlBuilder.SetFormula(this.PrimaryKey, "NEXT VALUE FOR SEQ_" + this.CurrentTableName.ToUpper());
}
}
else
{
if (this.Identity && (DbHelper.CurrentDbType == CurrentDbType.Oracle || DbHelper.CurrentDbType == CurrentDbType.DB2))
{
sqlBuilder.SetValue(this.PrimaryKey, entity.UserId);
}
}
}
this.SetObject(sqlBuilder, entity);
if (UserInfo != null)
{
sqlBuilder.SetValue(UserByGUIDEntity.FieldCreateUserId, UserInfo.Id);
sqlBuilder.SetValue(UserByGUIDEntity.FieldCreateBy, UserInfo.Realname);
}
sqlBuilder.SetDBNow(UserByGUIDEntity.FieldCreateOn);
if (UserInfo != null)
{
sqlBuilder.SetValue(UserByGUIDEntity.FieldModifiedUserId, UserInfo.Id);
sqlBuilder.SetValue(UserByGUIDEntity.FieldModifiedBy, UserInfo.Realname);
}
sqlBuilder.SetDBNow(UserByGUIDEntity.FieldModifiedOn);
if (this.Identity && (DbHelper.CurrentDbType == CurrentDbType.SqlServer || DbHelper.CurrentDbType == CurrentDbType.Access))
{
sequence = sqlBuilder.EndInsert().ToString();
}
else
{
sqlBuilder.EndInsert();
}
return(sequence);
}
/// <summary>
/// 添加实体
/// </summary>
/// <param name="entity">实体</param>
public string AddObject(BaseItemsEntity entity)
{
string result = string.Empty;
if (entity.SortCode == 0)
{
BaseSequenceManager sequenceManager = new BaseSequenceManager(DbHelper, this.Identity);
result = sequenceManager.Increment(this.CurrentTableName);
entity.SortCode = int.Parse(result);
}
SQLBuilder sqlBuilder = new SQLBuilder(DbHelper, this.Identity, this.ReturnId);
sqlBuilder.BeginInsert(this.CurrentTableName, BaseItemsEntity.FieldId);
if (!this.Identity)
{
sqlBuilder.SetValue(BaseItemsEntity.FieldId, entity.Id);
}
else
{
if (!this.ReturnId && (DbHelper.CurrentDbType == CurrentDbType.Oracle || DbHelper.CurrentDbType == CurrentDbType.DB2))
{
if (DbHelper.CurrentDbType == CurrentDbType.Oracle)
{
// // 2015-09-25 吉日嘎拉 用一个序列就可以了，不用那么多序列了
// sqlBuilder.SetFormula(BaseItemsEntity.FieldId, "SEQ_" + this.CurrentTableName.ToUpper() + ".NEXTVAL ");
sqlBuilder.SetFormula(BaseItemsEntity.FieldId, "SEQ_" + BaseItemsEntity.TableName.ToUpper() + ".NEXTVAL ");
}
if (DbHelper.CurrentDbType == CurrentDbType.DB2)
{
// sqlBuilder.SetFormula(BaseItemsEntity.FieldId, "NEXT VALUE FOR SEQ_" + this.CurrentTableName.ToUpper());
sqlBuilder.SetFormula(BaseItemsEntity.FieldId, "NEXT VALUE FOR SEQ_" + BaseItemsEntity.TableName.ToUpper());
}
}
else
{
if (this.Identity && (DbHelper.CurrentDbType == CurrentDbType.Oracle || DbHelper.CurrentDbType == CurrentDbType.DB2))
{
if (string.IsNullOrEmpty(result))
{
BaseSequenceManager sequenceManager = new BaseSequenceManager(DbHelper, this.Identity);
result = sequenceManager.Increment(this.CurrentTableName);
}
entity.Id = int.Parse(result);
sqlBuilder.SetValue(BaseItemsEntity.FieldId, entity.Id);
}
}
}
this.SetObject(sqlBuilder, entity);
if (UserInfo != null)
{
sqlBuilder.SetValue(BaseItemsEntity.FieldCreateUserId, UserInfo.Id);
sqlBuilder.SetValue(BaseItemsEntity.FieldCreateBy, UserInfo.RealName);
}
sqlBuilder.SetDBNow(BaseItemsEntity.FieldCreateOn);
if (UserInfo != null)
{
sqlBuilder.SetValue(BaseItemsEntity.FieldModifiedUserId, UserInfo.Id);
sqlBuilder.SetValue(BaseItemsEntity.FieldModifiedBy, UserInfo.RealName);
}
sqlBuilder.SetDBNow(BaseItemsEntity.FieldModifiedOn);
if (DbHelper.CurrentDbType == CurrentDbType.SqlServer && this.Identity)
{
result = sqlBuilder.EndInsert().ToString();
}
else
{
sqlBuilder.EndInsert();
}
return(result);
}
/// <summary>
/// 添加实体
/// </summary>
/// <param name="entity">实体</param>
public string AddObject(BaseUserAddressEntity entity)
{
string sequence = string.Empty;
sequence = entity.Id;
if (entity.SortCode == 0)
{
BaseSequenceManager sequenceManager = new BaseSequenceManager(DbHelper, this.Identity);
sequence = sequenceManager.Increment(this.CurrentTableName);
entity.SortCode = int.Parse(sequence);
}
SQLBuilder sqlBuilder = new SQLBuilder(DbHelper, this.Identity, this.ReturnId);
sqlBuilder.BeginInsert(this.CurrentTableName, BaseUserAddressEntity.FieldId);
if (entity.Id is string)
{
this.Identity = false;
}
if (!this.Identity)
{
sqlBuilder.SetValue(BaseUserAddressEntity.FieldId, entity.Id);
}
else
{
if (!this.ReturnId && (DbHelper.CurrentDbType == CurrentDbType.Oracle || DbHelper.CurrentDbType == CurrentDbType.DB2))
{
if (DbHelper.CurrentDbType == CurrentDbType.Oracle)
{
sqlBuilder.SetFormula(BaseUserAddressEntity.FieldId, "SEQ_" + this.CurrentTableName.ToUpper() + ".NEXTVAL ");
}
if (DbHelper.CurrentDbType == CurrentDbType.DB2)
{
sqlBuilder.SetFormula(BaseUserAddressEntity.FieldId, "NEXT VALUE FOR SEQ_" + this.CurrentTableName.ToUpper());
}
}
else
{
if (this.Identity && (DbHelper.CurrentDbType == CurrentDbType.Oracle || DbHelper.CurrentDbType == CurrentDbType.DB2))
{
if (string.IsNullOrEmpty(entity.Id))
{
if (string.IsNullOrEmpty(sequence))
{
BaseSequenceManager sequenceManager = new BaseSequenceManager(DbHelper, this.Identity);
sequence = sequenceManager.Increment(this.CurrentTableName);
}
entity.Id = sequence;
}
sqlBuilder.SetValue(BaseUserAddressEntity.FieldId, entity.Id);
}
}
}
this.SetObject(sqlBuilder, entity);
if (UserInfo != null)
{
sqlBuilder.SetValue(BaseUserAddressEntity.FieldCreateUserId, UserInfo.Id);
sqlBuilder.SetValue(BaseUserAddressEntity.FieldCreateBy, UserInfo.RealName);
}
sqlBuilder.SetDBNow(BaseUserAddressEntity.FieldCreateOn);
if (UserInfo != null)
{
sqlBuilder.SetValue(BaseUserAddressEntity.FieldModifiedUserId, UserInfo.Id);
sqlBuilder.SetValue(BaseUserAddressEntity.FieldModifiedBy, UserInfo.RealName);
}
sqlBuilder.SetDBNow(BaseUserAddressEntity.FieldModifiedOn);
if (DbHelper.CurrentDbType == CurrentDbType.SqlServer && this.Identity)
{
sequence = sqlBuilder.EndInsert().ToString();
}
else
{
sqlBuilder.EndInsert();
}
return(sequence);
}
/// <summary>
/// 添加实体
/// </summary>
/// <param name="entity">实体</param>
public string AddObject(BaseParameterEntity entity)
{
string result = string.Empty;
//if (!entity.SortCode.HasValue)
//{
// BaseSequenceManager sequenceManager = new BaseSequenceManager(DbHelper, this.Identity);
// result = sequenceManager.Increment(this.CurrentTableName);
// entity.SortCode = int.Parse(result);
//}
SQLBuilder sqlBuilder = new SQLBuilder(DbHelper, this.Identity, this.ReturnId);
sqlBuilder.BeginInsert(this.CurrentTableName, BaseParameterEntity.FieldId);
if (!string.IsNullOrEmpty(entity.Id) || !this.Identity)
{
result = entity.Id;
sqlBuilder.SetValue(BaseParameterEntity.FieldId, entity.Id);
}
else
{
if (!this.ReturnId && (DbHelper.CurrentDbType == CurrentDbType.Oracle || DbHelper.CurrentDbType == CurrentDbType.DB2))
{
if (DbHelper.CurrentDbType == CurrentDbType.Oracle)
{
sqlBuilder.SetFormula(BaseParameterEntity.FieldId, "SEQ_" + BaseParameterEntity.TableName.ToUpper() + ".NEXTVAL ");
// sqlBuilder.SetFormula(BaseParameterEntity.FieldId, "SEQ_" + this.CurrentTableName.ToUpper() + ".NEXTVAL ");
}
if (DbHelper.CurrentDbType == CurrentDbType.DB2)
{
sqlBuilder.SetFormula(BaseParameterEntity.FieldId, "NEXT VALUE FOR SEQ_" + this.CurrentTableName.ToUpper());
}
}
else
{
if (this.Identity && (DbHelper.CurrentDbType == CurrentDbType.Oracle || DbHelper.CurrentDbType == CurrentDbType.DB2))
{
if (entity.Id == null)
{
if (string.IsNullOrEmpty(result))
{
BaseSequenceManager sequenceManager = new BaseSequenceManager(DbHelper, this.Identity);
result = sequenceManager.Increment(BaseParameterEntity.TableName);
// result = sequenceManager.Increment(this.CurrentTableName);
}
entity.Id = result;
}
sqlBuilder.SetValue(BaseParameterEntity.FieldId, entity.Id);
}
}
}
this.SetObject(sqlBuilder, entity);
// 创建人信息
if (!string.IsNullOrEmpty(entity.CreateUserId))
{
sqlBuilder.SetValue(BaseParameterEntity.FieldCreateUserId, entity.CreateUserId);
}
else
{
if (UserInfo != null)
{
sqlBuilder.SetValue(BaseParameterEntity.FieldCreateUserId, UserInfo.Id);
}
}
if (!string.IsNullOrEmpty(entity.CreateBy))
{
sqlBuilder.SetValue(BaseParameterEntity.FieldCreateBy, entity.CreateBy);
}
else
{
if (UserInfo != null)
{
sqlBuilder.SetValue(BaseParameterEntity.FieldCreateBy, UserInfo.RealName);
}
}
if (entity.CreateOn.HasValue)
{
sqlBuilder.SetValue(BaseParameterEntity.FieldCreateOn, entity.CreateOn);
}
else
{
sqlBuilder.SetDBNow(BaseParameterEntity.FieldCreateOn);
}
// 修改人信息
if (!string.IsNullOrEmpty(entity.ModifiedUserId))
{
sqlBuilder.SetValue(BaseParameterEntity.FieldModifiedUserId, entity.ModifiedUserId);
}
else
{
if (UserInfo != null)
{
sqlBuilder.SetValue(BaseParameterEntity.FieldModifiedUserId, UserInfo.Id);
}
}
if (!string.IsNullOrEmpty(entity.ModifiedBy))
{
sqlBuilder.SetValue(BaseParameterEntity.FieldModifiedBy, entity.ModifiedBy);
}
else
{
if (UserInfo != null)
{
sqlBuilder.SetValue(BaseParameterEntity.FieldModifiedBy, UserInfo.RealName);
}
}
if (entity.ModifiedOn.HasValue)
{
sqlBuilder.SetValue(BaseParameterEntity.FieldModifiedOn, entity.ModifiedOn);
}
else
{
sqlBuilder.SetDBNow(BaseParameterEntity.FieldModifiedOn);
}
if (DbHelper.CurrentDbType == CurrentDbType.SqlServer && this.Identity)
{
result = sqlBuilder.EndInsert().ToString();
}
else
{
sqlBuilder.EndInsert();
}
return(result);
}
