/// <summary>
/// 添加实体
/// </summary>
/// <param name="workFlowActivityEntity">实体</param>
public string AddObject(BaseWorkFlowStepEntity workFlowActivityEntity)
{
string sequence = string.Empty;
if (workFlowActivityEntity.SortCode == null || workFlowActivityEntity.SortCode == 0)
{
BaseSequenceManager sequenceManager = new BaseSequenceManager(DbHelper, this.Identity);
sequence = sequenceManager.Increment(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.Increment(this.CurrentTableName);
}
workFlowActivityEntity.Id = int.Parse(sequence);
}
sqlBuilder.SetValue(BaseWorkFlowStepEntity.FieldId, workFlowActivityEntity.Id);
}
}
}
this.SetObject(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="entity">实体</param>
private void SetObject(SQLBuilder sqlBuilder, BaseModuleEntity entity)
{
SetObjectExpand(sqlBuilder, entity);
sqlBuilder.SetValue(BaseModuleEntity.FieldParentId, entity.ParentId);
sqlBuilder.SetValue(BaseModuleEntity.FieldCode, entity.Code);
sqlBuilder.SetValue(BaseModuleEntity.FieldFullName, entity.FullName);
sqlBuilder.SetValue(BaseModuleEntity.FieldCategoryCode, entity.CategoryCode);
sqlBuilder.SetValue(BaseModuleEntity.FieldImageIndex, entity.ImageIndex);
sqlBuilder.SetValue(BaseModuleEntity.FieldSelectedImageIndex, entity.SelectedImageIndex);
sqlBuilder.SetValue(BaseModuleEntity.FieldNavigateUrl, entity.NavigateUrl);
sqlBuilder.SetValue(BaseModuleEntity.FieldImagUrl, entity.ImagUrl);
sqlBuilder.SetValue(BaseModuleEntity.FieldTarget, entity.Target);
sqlBuilder.SetValue(BaseModuleEntity.FieldFormName, entity.FormName);
sqlBuilder.SetValue(BaseModuleEntity.FieldAssemblyName, entity.AssemblyName);
// sqlBuilder.SetValue(BaseModuleEntity.FieldPermissionScopeTables, entity.PermissionScopeTables);
sqlBuilder.SetValue(BaseModuleEntity.FieldIsMenu, entity.IsMenu);
sqlBuilder.SetValue(BaseModuleEntity.FieldIsPublic, entity.IsPublic);
sqlBuilder.SetValue(BaseModuleEntity.FieldIsScope, entity.IsScope);
sqlBuilder.SetValue(BaseModuleEntity.FieldIsVisible, entity.IsVisible);
sqlBuilder.SetValue(BaseModuleEntity.FieldExpand, entity.Expand);
sqlBuilder.SetValue(BaseModuleEntity.FieldAllowEdit, entity.AllowEdit);
sqlBuilder.SetValue(BaseModuleEntity.FieldAllowDelete, entity.AllowDelete);
sqlBuilder.SetValue(BaseModuleEntity.FieldSortCode, entity.SortCode);
sqlBuilder.SetValue(BaseModuleEntity.FieldEnabled, entity.Enabled);
sqlBuilder.SetValue(BaseModuleEntity.FieldDeletionStateCode, entity.DeletionStateCode);
sqlBuilder.SetValue(BaseModuleEntity.FieldDescription, entity.Description);
}
/// <summary>
/// 设置实体
/// </summary>
/// <param name="baseContactEntity">实体</param>
private void SetEntity(SQLBuilder sqlBuilder, BaseContactEntity baseContactEntity)
{
sqlBuilder.SetValue(BaseContactEntity.FieldParentId, baseContactEntity.ParentId);
sqlBuilder.SetValue(BaseContactEntity.FieldTitle, baseContactEntity.Title);
sqlBuilder.SetValue(BaseContactEntity.FieldContents, baseContactEntity.Contents);
sqlBuilder.SetValue(BaseContactEntity.FieldPriority, baseContactEntity.Priority);
sqlBuilder.SetValue(BaseContactEntity.FieldSendCount, baseContactEntity.SendCount);
sqlBuilder.SetValue(BaseContactEntity.FieldReadCount, baseContactEntity.ReadCount);
sqlBuilder.SetValue(BaseContactEntity.FieldIsOpen, baseContactEntity.IsOpen);
sqlBuilder.SetValue(BaseContactEntity.FieldCommentUserId, baseContactEntity.CommentUserId);
sqlBuilder.SetValue(BaseContactEntity.FieldCommentUserRealName, baseContactEntity.CommentUserRealName);
sqlBuilder.SetValue(BaseContactEntity.FieldCommentDate, baseContactEntity.CommentDate);
sqlBuilder.SetValue(BaseContactEntity.FieldDeletionStateCode, baseContactEntity.DeletionStateCode);
sqlBuilder.SetValue(BaseContactEntity.FieldEnabled, baseContactEntity.Enabled);
sqlBuilder.SetValue(BaseContactEntity.FieldSortCode, baseContactEntity.SortCode);
sqlBuilder.SetValue(BaseContactEntity.FieldDescription, baseContactEntity.Description);
}
/// <summary>
/// 设置实体
/// </summary>
/// <param name="commentEntity">实体</param>
private void SetEntity(SQLBuilder sqlBuilder, BaseCommentEntity commentEntity)
{
sqlBuilder.SetValue(BaseCommentEntity.FieldDepartmentId, commentEntity.DepartmentId);
sqlBuilder.SetValue(BaseCommentEntity.FieldDepartmentName, commentEntity.DepartmentName);
sqlBuilder.SetValue(BaseCommentEntity.FieldParentId, commentEntity.ParentId);
sqlBuilder.SetValue(BaseCommentEntity.FieldCategoryCode, commentEntity.CategoryCode);
sqlBuilder.SetValue(BaseCommentEntity.FieldObjectId, commentEntity.ObjectId);
sqlBuilder.SetValue(BaseCommentEntity.FieldTargetURL, commentEntity.TargetURL);
sqlBuilder.SetValue(BaseCommentEntity.FieldTitle, commentEntity.Title);
sqlBuilder.SetValue(BaseCommentEntity.FieldContents, commentEntity.Contents);
sqlBuilder.SetValue(BaseCommentEntity.FieldIPAddress, commentEntity.IPAddress);
sqlBuilder.SetValue(BaseCommentEntity.FieldDeletionStateCode, commentEntity.DeletionStateCode);
sqlBuilder.SetValue(BaseCommentEntity.FieldEnabled, commentEntity.Enabled);
sqlBuilder.SetValue(BaseCommentEntity.FieldDescription, commentEntity.Description);
sqlBuilder.SetValue(BaseCommentEntity.FieldSortCode, commentEntity.SortCode);
SetEntityExpand(sqlBuilder, commentEntity);
}
/// <summary>
/// 添加实体
/// </summary>
/// <param name="entity">实体</param>
public string AddObject(BaseUserRoleEntity entity)
{
string result = string.Empty;
SQLBuilder sqlBuilder = new SQLBuilder(DbHelper, this.Identity, this.ReturnId);
sqlBuilder.BeginInsert(this.CurrentTableName, BaseUserRoleEntity.FieldId);
if (!this.Identity)
{
sqlBuilder.SetValue(BaseUserRoleEntity.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(BaseUserRoleEntity.FieldId, "SEQ_" + this.CurrentTableName.ToUpper() + ".NEXTVAL ");
sqlBuilder.SetFormula(BaseUserRoleEntity.FieldId, "SEQ_" + BaseRoleEntity.TableName.ToUpper() + ".NEXTVAL ");
}
if (DbHelper.CurrentDbType == CurrentDbType.DB2)
{
// sqlBuilder.SetFormula(BaseUserRoleEntity.FieldId, "NEXT VALUE FOR SEQ_" + this.CurrentTableName.ToUpper());
sqlBuilder.SetFormula(BaseUserRoleEntity.FieldId, "NEXT VALUE FOR SEQ_" + BaseRoleEntity.TableName.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(BaseRoleEntity.TableName);
}
entity.Id = int.Parse(result);
}
sqlBuilder.SetValue(BaseUserRoleEntity.FieldId, entity.Id);
}
}
}
this.SetObject(sqlBuilder, entity);
if (UserInfo != null)
{
sqlBuilder.SetValue(BaseUserRoleEntity.FieldCreateUserId, UserInfo.Id);
sqlBuilder.SetValue(BaseUserRoleEntity.FieldCreateBy, UserInfo.RealName);
}
sqlBuilder.SetDBNow(BaseUserRoleEntity.FieldCreateOn);
if (UserInfo != null)
{
sqlBuilder.SetValue(BaseUserRoleEntity.FieldModifiedUserId, UserInfo.Id);
sqlBuilder.SetValue(BaseUserRoleEntity.FieldModifiedBy, UserInfo.RealName);
}
sqlBuilder.SetDBNow(BaseUserRoleEntity.FieldModifiedOn);
if (DbHelper.CurrentDbType == CurrentDbType.SqlServer && this.Identity)
{
result = sqlBuilder.EndInsert().ToString();
}
else
{
sqlBuilder.EndInsert();
}
return(result);
}
/// <summary>
/// 设置实体
/// </summary>
/// <param name="baseWorkFlowBillTemplateEntity">实体</param>
private void SetObject(SQLBuilder sqlBuilder, BaseWorkFlowBillTemplateEntity baseWorkFlowBillTemplateEntity)
{
SetObjectExpand(sqlBuilder, baseWorkFlowBillTemplateEntity);
sqlBuilder.SetValue(BaseWorkFlowBillTemplateEntity.FieldTitle, baseWorkFlowBillTemplateEntity.Title);
sqlBuilder.SetValue(BaseWorkFlowBillTemplateEntity.FieldCode, baseWorkFlowBillTemplateEntity.Code);
sqlBuilder.SetValue(BaseWorkFlowBillTemplateEntity.FieldCategoryCode, baseWorkFlowBillTemplateEntity.CategoryCode);
sqlBuilder.SetValue(BaseWorkFlowBillTemplateEntity.FieldIntroduction, baseWorkFlowBillTemplateEntity.Introduction);
sqlBuilder.SetValue(BaseWorkFlowBillTemplateEntity.FieldContents, baseWorkFlowBillTemplateEntity.Contents);
sqlBuilder.SetValue(BaseWorkFlowBillTemplateEntity.FieldTemplateType, baseWorkFlowBillTemplateEntity.TemplateType);
sqlBuilder.SetValue(BaseWorkFlowBillTemplateEntity.FieldUseWorkFlow, baseWorkFlowBillTemplateEntity.UseWorkFlow);
sqlBuilder.SetValue(BaseWorkFlowBillTemplateEntity.FieldAddPage, baseWorkFlowBillTemplateEntity.AddPage);
sqlBuilder.SetValue(BaseWorkFlowBillTemplateEntity.FieldEditPage, baseWorkFlowBillTemplateEntity.EditPage);
sqlBuilder.SetValue(BaseWorkFlowBillTemplateEntity.FieldShowPage, baseWorkFlowBillTemplateEntity.ShowPage);
sqlBuilder.SetValue(BaseWorkFlowBillTemplateEntity.FieldListPage, baseWorkFlowBillTemplateEntity.ListPage);
sqlBuilder.SetValue(BaseWorkFlowBillTemplateEntity.FieldAdminPage, baseWorkFlowBillTemplateEntity.AdminPage);
sqlBuilder.SetValue(BaseWorkFlowBillTemplateEntity.FieldAuditStatus, baseWorkFlowBillTemplateEntity.AuditStatus);
sqlBuilder.SetValue(BaseWorkFlowBillTemplateEntity.FieldDeletionStateCode, baseWorkFlowBillTemplateEntity.DeletionStateCode);
sqlBuilder.SetValue(BaseWorkFlowBillTemplateEntity.FieldDescription, baseWorkFlowBillTemplateEntity.Description);
sqlBuilder.SetValue(BaseWorkFlowBillTemplateEntity.FieldEnabled, baseWorkFlowBillTemplateEntity.Enabled);
sqlBuilder.SetValue(BaseWorkFlowBillTemplateEntity.FieldSortCode, baseWorkFlowBillTemplateEntity.SortCode);
}
/// <summary>
/// 设置实体
/// </summary>
/// <param name="entity">实体</param>
private void SetEntity(SQLBuilder sqlBuilder, BaseContactDetailsEntity entity)
{
sqlBuilder.SetValue(BaseContactDetailsEntity.FieldContactId, entity.ContactId);
sqlBuilder.SetValue(BaseContactDetailsEntity.FieldCategory, entity.Category);
sqlBuilder.SetValue(BaseContactDetailsEntity.FieldReceiverId, entity.ReceiverId);
sqlBuilder.SetValue(BaseContactDetailsEntity.FieldReceiverRealName, entity.ReceiverRealName);
sqlBuilder.SetValue(BaseContactDetailsEntity.FieldIsNew, entity.IsNew);
sqlBuilder.SetValue(BaseContactDetailsEntity.FieldNewComment, entity.NewComment);
sqlBuilder.SetValue(BaseContactDetailsEntity.FieldReplied, entity.Replied);
sqlBuilder.SetValue(BaseContactDetailsEntity.FieldLastViewIP, entity.LastViewIP);
sqlBuilder.SetValue(BaseContactDetailsEntity.FieldLastViewDate, entity.LastViewDate);
sqlBuilder.SetValue(BaseContactDetailsEntity.FieldEnabled, entity.Enabled);
sqlBuilder.SetValue(BaseContactDetailsEntity.FieldDeletionStateCode, entity.DeletionStateCode);
sqlBuilder.SetValue(BaseContactDetailsEntity.FieldSortCode, entity.SortCode);
sqlBuilder.SetValue(BaseContactDetailsEntity.FieldDescription, entity.Description);
}
/// <summary>
/// 设置实体
/// </summary>
/// <param name="organizeEntity">实体</param>
partial void SetEntityExpand(SQLBuilder sqlBuilder, BaseOrganizeEntity organizeEntity)
{
sqlBuilder.SetValue(BaseOrganizeEntity.FieldLayer, organizeEntity.Layer);
}
/// <summary>
/// 添加实体
/// </summary>
/// <param name="entity">实体</param>
public string AddObject(BaseHolidaysEntity entity)
{
string sequence = string.Empty;
SQLBuilder sqlBuilder = new SQLBuilder(DbHelper, this.Identity, this.ReturnId);
sqlBuilder.BeginInsert(this.CurrentTableName, BaseHolidaysEntity.FieldId);
if (entity.Id != null || !this.Identity)
{
// 这里已经是指定了主键了，所以不需要返回主键了
sqlBuilder.ReturnId = false;
sqlBuilder.SetValue(BaseHolidaysEntity.FieldId, entity.Id);
}
else
{
if (!this.ReturnId && (DbHelper.CurrentDbType == CurrentDbType.Oracle || DbHelper.CurrentDbType == CurrentDbType.DB2))
{
if (DbHelper.CurrentDbType == CurrentDbType.Oracle)
{
sqlBuilder.SetFormula(BaseHolidaysEntity.FieldId, "SEQ_" + this.CurrentTableName.ToUpper() + ".NEXTVAL ");
}
if (DbHelper.CurrentDbType == CurrentDbType.DB2)
{
sqlBuilder.SetFormula(BaseHolidaysEntity.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(sequence))
{
BaseSequenceManager sequenceManager = new BaseSequenceManager(DbHelper, this.Identity);
sequence = sequenceManager.Increment(this.CurrentTableName);
}
entity.Id = int.Parse(sequence);
}
sqlBuilder.SetValue(BaseHolidaysEntity.FieldId, entity.Id);
}
}
}
this.SetObject(sqlBuilder, entity);
if (UserInfo != null)
{
sqlBuilder.SetValue(BaseHolidaysEntity.FieldCreateUserId, UserInfo.Id);
sqlBuilder.SetValue(BaseHolidaysEntity.FieldCreateBy, UserInfo.RealName);
}
sqlBuilder.SetDBNow(BaseHolidaysEntity.FieldCreateOn);
if (UserInfo != null)
{
sqlBuilder.SetValue(BaseHolidaysEntity.FieldModifiedUserId, UserInfo.Id);
sqlBuilder.SetValue(BaseHolidaysEntity.FieldModifiedBy, UserInfo.RealName);
}
sqlBuilder.SetDBNow(BaseHolidaysEntity.FieldModifiedOn);
if (DbHelper.CurrentDbType == CurrentDbType.SqlServer && this.Identity)
{
sequence = sqlBuilder.EndInsert().ToString();
}
else
{
sqlBuilder.EndInsert();
}
return(sequence);
}
/// <summary>
/// 设置实体
/// </summary>
/// <param name="baseWorkFlowCurrentEntity">实体</param>
private void SetEntity(SQLBuilder sqlBuilder, BaseWorkFlowCurrentEntity baseWorkFlowCurrentEntity)
{
SetEntityExpand(sqlBuilder, baseWorkFlowCurrentEntity);
sqlBuilder.SetValue(BaseWorkFlowCurrentEntity.FieldCategoryCode, baseWorkFlowCurrentEntity.CategoryCode);
sqlBuilder.SetValue(BaseWorkFlowCurrentEntity.FieldCategoryFullName, baseWorkFlowCurrentEntity.CategoryFullName);
sqlBuilder.SetValue(BaseWorkFlowCurrentEntity.FieldObjectId, baseWorkFlowCurrentEntity.ObjectId);
sqlBuilder.SetValue(BaseWorkFlowCurrentEntity.FieldObjectFullName, baseWorkFlowCurrentEntity.ObjectFullName);
sqlBuilder.SetValue(BaseWorkFlowCurrentEntity.FieldWorkFlowId, baseWorkFlowCurrentEntity.WorkFlowId);
sqlBuilder.SetValue(BaseWorkFlowCurrentEntity.FieldActivityId, baseWorkFlowCurrentEntity.ActivityId);
sqlBuilder.SetValue(BaseWorkFlowCurrentEntity.FieldActivityFullName, baseWorkFlowCurrentEntity.ActivityFullName);
sqlBuilder.SetValue(BaseWorkFlowCurrentEntity.FieldToDepartmentId, baseWorkFlowCurrentEntity.ToDepartmentId);
sqlBuilder.SetValue(BaseWorkFlowCurrentEntity.FieldToDepartmentName, baseWorkFlowCurrentEntity.ToDepartmentName);
sqlBuilder.SetValue(BaseWorkFlowCurrentEntity.FieldToUserId, baseWorkFlowCurrentEntity.ToUserId);
sqlBuilder.SetValue(BaseWorkFlowCurrentEntity.FieldToUserRealName, baseWorkFlowCurrentEntity.ToUserRealName);
sqlBuilder.SetValue(BaseWorkFlowCurrentEntity.FieldToRoleId, baseWorkFlowCurrentEntity.ToRoleId);
sqlBuilder.SetValue(BaseWorkFlowCurrentEntity.FieldToRoleRealName, baseWorkFlowCurrentEntity.ToRoleRealName);
sqlBuilder.SetValue(BaseWorkFlowCurrentEntity.FieldAuditUserId, baseWorkFlowCurrentEntity.AuditUserId);
sqlBuilder.SetValue(BaseWorkFlowCurrentEntity.FieldAuditUserCode, baseWorkFlowCurrentEntity.AuditUserCode);
sqlBuilder.SetValue(BaseWorkFlowCurrentEntity.FieldAuditUserRealName, baseWorkFlowCurrentEntity.AuditUserRealName);
sqlBuilder.SetValue(BaseWorkFlowCurrentEntity.FieldSendDate, baseWorkFlowCurrentEntity.SendDate);
sqlBuilder.SetValue(BaseWorkFlowCurrentEntity.FieldAuditDate, baseWorkFlowCurrentEntity.AuditDate);
sqlBuilder.SetValue(BaseWorkFlowCurrentEntity.FieldAuditIdea, baseWorkFlowCurrentEntity.AuditIdea);
sqlBuilder.SetValue(BaseWorkFlowCurrentEntity.FieldAuditStatus, baseWorkFlowCurrentEntity.AuditStatus);
sqlBuilder.SetValue(BaseWorkFlowCurrentEntity.FieldAuditStatusName, baseWorkFlowCurrentEntity.AuditStatusName);
sqlBuilder.SetValue(BaseWorkFlowCurrentEntity.FieldSortCode, baseWorkFlowCurrentEntity.SortCode);
sqlBuilder.SetValue(BaseWorkFlowCurrentEntity.FieldEnabled, baseWorkFlowCurrentEntity.Enabled);
sqlBuilder.SetValue(BaseWorkFlowCurrentEntity.FieldDeletionStateCode, baseWorkFlowCurrentEntity.DeletionStateCode);
sqlBuilder.SetValue(BaseWorkFlowCurrentEntity.FieldDescription, baseWorkFlowCurrentEntity.Description);
}
/// <summary>
/// 设置实体
/// </summary>
/// <param name="BaseFileEntity">实体</param>
private void SetEntity(SQLBuilder sqlBuilder, BaseFileEntity fileEntity)
{
sqlBuilder.SetValue(BaseFileEntity.FieldFolderId, fileEntity.FolderId);
sqlBuilder.SetValue(BaseFileEntity.FieldFileName, fileEntity.FileName);
sqlBuilder.SetValue(BaseFileEntity.FieldFilePath, fileEntity.FilePath);
sqlBuilder.SetValue(BaseFileEntity.FieldContents, fileEntity.Contents);
if (fileEntity.Contents != null)
{
sqlBuilder.SetValue(BaseFileEntity.FieldFileSize, fileEntity.Contents.Length);
}
else
{
sqlBuilder.SetValue(BaseFileEntity.FieldFileSize, fileEntity.FileSize);
}
sqlBuilder.SetValue(BaseFileEntity.FieldReadCount, fileEntity.ReadCount);
sqlBuilder.SetValue(BaseFileEntity.FieldDeletionStateCode, fileEntity.DeletionStateCode);
sqlBuilder.SetValue(BaseFileEntity.FieldDescription, fileEntity.Description);
sqlBuilder.SetValue(BaseFileEntity.FieldEnabled, fileEntity.Enabled);
sqlBuilder.SetValue(BaseFileEntity.FieldSortCode, fileEntity.SortCode);
SetEntityExpand(sqlBuilder, fileEntity);
}
/// <summary>
/// 设置实体
/// </summary>
/// <param name="entity">实体</param>
private void SetObject(SQLBuilder sqlBuilder, BaseOrganizeExpressEntity entity)
{
SetObjectExpand(sqlBuilder, entity);
sqlBuilder.SetValue(BaseOrganizeExpressEntity.FieldNotDispatchRange, entity.NotDispatchRange);
sqlBuilder.SetValue(BaseOrganizeExpressEntity.FieldScanSelect, entity.ScanSelect);
sqlBuilder.SetValue(BaseOrganizeExpressEntity.FieldSitePrior, entity.SitePrior);
sqlBuilder.SetValue(BaseOrganizeExpressEntity.FieldPrivateRemark, entity.PrivateRemark);
sqlBuilder.SetValue(BaseOrganizeExpressEntity.FieldPublicRemark, entity.PublicRemark);
sqlBuilder.SetValue(BaseOrganizeExpressEntity.FieldDispatchTimeLimit, entity.DispatchTimeLimit);
sqlBuilder.SetValue(BaseOrganizeExpressEntity.FieldAgentMoneyLimited, entity.AgentMoneyLimited);
sqlBuilder.SetValue(BaseOrganizeExpressEntity.FieldDefaultSendPlace, entity.DefaultSendPlace);
sqlBuilder.SetValue(BaseOrganizeExpressEntity.FieldDispatchRange, entity.DispatchRange);
sqlBuilder.SetValue(BaseOrganizeExpressEntity.FieldAllowToPayment, entity.AllowToPayment);
sqlBuilder.SetValue(BaseOrganizeExpressEntity.FieldAllowAgentMoney, entity.AllowAgentMoney);
sqlBuilder.SetValue(BaseOrganizeExpressEntity.FieldDispatchOutRangeFee, entity.DispatchOutRangeFee);
sqlBuilder.SetValue(BaseOrganizeExpressEntity.FieldCurrency, entity.Currency);
sqlBuilder.SetValue(BaseOrganizeExpressEntity.FieldDispatchRangeFee, entity.DispatchRangeFee);
sqlBuilder.SetValue(BaseOrganizeExpressEntity.FieldDispatchMoneyDesc, entity.DispatchMoneyDesc);
sqlBuilder.SetValue(BaseOrganizeExpressEntity.FieldWebSiteName, entity.WebSiteName);
sqlBuilder.SetValue(BaseOrganizeExpressEntity.FieldWebEnabled, entity.WebEnabled);
sqlBuilder.SetValue(BaseOrganizeExpressEntity.FieldInternalDispatch, entity.InternalDispatch);
sqlBuilder.SetValue(BaseOrganizeExpressEntity.FieldIsTransferCenter, entity.IsTransferCenter);
sqlBuilder.SetValue(BaseOrganizeExpressEntity.FieldIsErpOpen, entity.IsErpOpen);
sqlBuilder.SetValue(BaseOrganizeExpressEntity.FieldIsReceiveOrder, entity.IsReceiveOrder);
sqlBuilder.SetValue(BaseOrganizeExpressEntity.FieldIsReceiveComplain, entity.IsReceiveComplain);
}
/// <summary>
/// 设置实体
/// </summary>
/// <param name="entity">实体</param>
private void SetObject(SQLBuilder sqlBuilder, BaseUserIdentityAuditEntity entity)
{
SetObjectExpand(sqlBuilder, entity);
sqlBuilder.SetValue(BaseUserIdentityAuditEntity.FieldModifiedOn, entity.ModifiedOn);
sqlBuilder.SetValue(BaseUserIdentityAuditEntity.FieldIdcardPhotoHand, entity.IdcardPhotoHand);
sqlBuilder.SetValue(BaseUserIdentityAuditEntity.FieldOrganizeFullname, entity.OrganizeFullname);
sqlBuilder.SetValue(BaseUserIdentityAuditEntity.FieldCreateOn, entity.CreateOn);
sqlBuilder.SetValue(BaseUserIdentityAuditEntity.FieldAuditDate, entity.AuditDate);
sqlBuilder.SetValue(BaseUserIdentityAuditEntity.FieldAuditStatus, entity.AuditStatus);
sqlBuilder.SetValue(BaseUserIdentityAuditEntity.FieldNickName, entity.NickName);
sqlBuilder.SetValue(BaseUserIdentityAuditEntity.FieldUserRealName, entity.UserRealName);
sqlBuilder.SetValue(BaseUserIdentityAuditEntity.FieldIdcard, entity.Idcard);
sqlBuilder.SetValue(BaseUserIdentityAuditEntity.FieldAuditUserId, entity.AuditUserId);
sqlBuilder.SetValue(BaseUserIdentityAuditEntity.FieldAuditIdea, entity.AuditIdea);
sqlBuilder.SetValue(BaseUserIdentityAuditEntity.FieldAuditUserRealName, entity.AuditUserRealName);
sqlBuilder.SetValue(BaseUserIdentityAuditEntity.FieldOrganizeId, entity.OrganizeId);
sqlBuilder.SetValue(BaseUserIdentityAuditEntity.FieldAuditUserNickName, entity.AuditUserNickName);
sqlBuilder.SetValue(BaseUserIdentityAuditEntity.FieldIdcardPhotoFront, entity.IdcardPhotoFront);
}
//
// 授予权限的实现部分
//
#region public string Grant(string systemCode, string userId, string permissionId, bool chekExists = true) 为了提高授权的运行速度
/// <summary>
/// 为了提高授权的运行速度
/// </summary>
/// <param name="systemCode">系统编号</param>
/// <param name="userId">用户主键</param>
/// <param name="result">权限主键</param>
/// <param name="chekExists">判断是否存在</param>
/// <returns>主键</returns>
public string Grant(string systemCode, string userId, string permissionId, bool chekExists = true)
{
string result = string.Empty;
if (String.IsNullOrEmpty(userId) && String.IsNullOrEmpty(permissionId))
{
return(result);
}
this.CurrentTableName = systemCode + "Permission";
string currentId = string.Empty;
// 判断是否已经存在这个权限，若已经存在就不重复增加了
if (chekExists)
{
List <KeyValuePair <string, object> > whereParameters = new List <KeyValuePair <string, object> >();
whereParameters.Add(new KeyValuePair <string, object>(BasePermissionEntity.FieldResourceCategory, BaseUserEntity.TableName));
whereParameters.Add(new KeyValuePair <string, object>(BasePermissionEntity.FieldResourceId, userId));
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);
result = currentId;
}
}
if (string.IsNullOrEmpty(currentId))
{
BasePermissionEntity permissionEntity = new BasePermissionEntity();
permissionEntity.ResourceCategory = BaseUserEntity.TableName;
permissionEntity.ResourceId = userId;
permissionEntity.PermissionId = permissionId;
permissionEntity.Enabled = 1;
// 2015-07-03 吉日嘎拉 若是没有公司相关的信息，就把公司区分出来，每个公司可以看每个公司的数据
if (string.IsNullOrEmpty(permissionEntity.CompanyId))
{
BaseUserEntity entity = BaseUserManager.GetObjectByCache(userId);
if (entity != null)
{
permissionEntity.CompanyId = entity.CompanyId;
permissionEntity.CompanyName = entity.CompanyName;
}
}
BasePermissionManager permissionManager = new BasePermissionManager(DbHelper, UserInfo, this.CurrentTableName);
result = permissionManager.Add(permissionEntity);
}
// 2015-09-21 吉日嘎拉 这里增加变更日志
string tableName = systemCode + ".Permission.User";
SQLBuilder sqlBuilder = new SQLBuilder(this.DbHelper);
sqlBuilder.BeginInsert(BaseModifyRecordEntity.TableName);
sqlBuilder.SetValue(BaseModifyRecordEntity.FieldTableCode, tableName);
if (this.DbHelper.CurrentDbType == CurrentDbType.Oracle)
{
sqlBuilder.SetFormula(BaseModifyRecordEntity.FieldId, "SEQ_" + BaseModifyRecordEntity.TableName + ".NEXTVAL");
}
sqlBuilder.SetValue(BaseModifyRecordEntity.FieldRecordKey, userId);
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="BaseWorkFlowStepEntity">实体</param>
private void SetObject(SQLBuilder sqlBuilder, BaseWorkFlowStepEntity BaseWorkFlowStepEntity)
{
sqlBuilder.SetValue(BaseWorkFlowStepEntity.FieldCategoryCode, BaseWorkFlowStepEntity.CategoryCode);
sqlBuilder.SetValue(BaseWorkFlowStepEntity.FieldObjectId, BaseWorkFlowStepEntity.ObjectId);
sqlBuilder.SetValue(BaseWorkFlowStepEntity.FieldProcessId, BaseWorkFlowStepEntity.ProcessId);
sqlBuilder.SetValue(BaseWorkFlowStepEntity.FieldActivityId, BaseWorkFlowStepEntity.ActivityId);
sqlBuilder.SetValue(BaseWorkFlowStepEntity.FieldCode, BaseWorkFlowStepEntity.Code);
sqlBuilder.SetValue(BaseWorkFlowStepEntity.FieldFullName, BaseWorkFlowStepEntity.FullName);
sqlBuilder.SetValue(BaseWorkFlowStepEntity.FieldAuditDepartmentId, BaseWorkFlowStepEntity.AuditDepartmentId);
sqlBuilder.SetValue(BaseWorkFlowStepEntity.FieldAuditDepartmentName, BaseWorkFlowStepEntity.AuditDepartmentName);
sqlBuilder.SetValue(BaseWorkFlowStepEntity.FieldAuditUserId, BaseWorkFlowStepEntity.AuditUserId);
sqlBuilder.SetValue(BaseWorkFlowStepEntity.FieldAuditUserCode, BaseWorkFlowStepEntity.AuditUserCode);
sqlBuilder.SetValue(BaseWorkFlowStepEntity.FieldAuditUserRealName, BaseWorkFlowStepEntity.AuditUserRealName);
sqlBuilder.SetValue(BaseWorkFlowStepEntity.FieldAuditRoleId, BaseWorkFlowStepEntity.AuditRoleId);
sqlBuilder.SetValue(BaseWorkFlowStepEntity.FieldAuditRoleRealName, BaseWorkFlowStepEntity.AuditRoleRealName);
sqlBuilder.SetValue(BaseWorkFlowStepEntity.FieldActivityType, BaseWorkFlowStepEntity.ActivityType);
sqlBuilder.SetValue(BaseWorkFlowStepEntity.FieldAllowPrint, BaseWorkFlowStepEntity.AllowPrint);
sqlBuilder.SetValue(BaseWorkFlowStepEntity.FieldAllowEditDocuments, BaseWorkFlowStepEntity.AllowEditDocuments);
sqlBuilder.SetValue(BaseWorkFlowStepEntity.FieldSortCode, BaseWorkFlowStepEntity.SortCode);
sqlBuilder.SetValue(BaseWorkFlowStepEntity.FieldEnabled, BaseWorkFlowStepEntity.Enabled);
sqlBuilder.SetValue(BaseWorkFlowStepEntity.FieldDeletionStateCode, BaseWorkFlowStepEntity.DeletionStateCode);
sqlBuilder.SetValue(BaseWorkFlowStepEntity.FieldDescription, BaseWorkFlowStepEntity.Description);
}
/// <summary>
/// 设置实体
/// </summary>
/// <param name="entity">实体</param>
private void SetObject(SQLBuilder sqlBuilder, BaseNewsEntity entity)
{
if (entity.Contents == null)
{
entity.FileSize = 0;
}
else
{
entity.FileSize = entity.Contents.Length;
}
sqlBuilder.SetValue(BaseNewsEntity.FieldCompanyId, entity.CompanyId);
sqlBuilder.SetValue(BaseNewsEntity.FieldCompanyName, entity.CompanyName);
sqlBuilder.SetValue(BaseNewsEntity.FieldDepartmentId, entity.DepartmentId);
sqlBuilder.SetValue(BaseNewsEntity.FieldDepartmentName, entity.DepartmentName);
sqlBuilder.SetValue(BaseNewsEntity.FieldFolderId, entity.FolderId);
sqlBuilder.SetValue(BaseNewsEntity.FieldCategoryCode, entity.CategoryCode);
sqlBuilder.SetValue(BaseNewsEntity.FieldCode, entity.Code);
sqlBuilder.SetValue(BaseNewsEntity.FieldTitle, entity.Title);
sqlBuilder.SetValue(BaseNewsEntity.FieldFilePath, entity.FilePath);
sqlBuilder.SetValue(BaseNewsEntity.FieldIntroduction, entity.Introduction);
sqlBuilder.SetValue(BaseNewsEntity.FieldContents, entity.Contents);
sqlBuilder.SetValue(BaseNewsEntity.FieldSource, entity.Source);
sqlBuilder.SetValue(BaseNewsEntity.FieldKeywords, entity.Keywords);
sqlBuilder.SetValue(BaseNewsEntity.FieldFileSize, entity.FileSize);
sqlBuilder.SetValue(BaseNewsEntity.FieldImageUrl, entity.ImageUrl);
sqlBuilder.SetValue(BaseNewsEntity.FieldHomePage, entity.HomePage);
sqlBuilder.SetValue(BaseNewsEntity.FieldSubPage, entity.SubPage);
sqlBuilder.SetValue(BaseNewsEntity.FieldAuditStatus, entity.AuditStatus);
sqlBuilder.SetValue(BaseNewsEntity.FieldReadCount, entity.ReadCount);
sqlBuilder.SetValue(BaseNewsEntity.FieldDeletionStateCode, entity.DeletionStateCode);
sqlBuilder.SetValue(BaseNewsEntity.FieldDescription, entity.Description);
sqlBuilder.SetValue(BaseNewsEntity.FieldEnabled, entity.Enabled);
sqlBuilder.SetValue(BaseNewsEntity.FieldSortCode, entity.SortCode);
SetObjectExpand(sqlBuilder, entity);
}
/// <summary>
/// 添加实体
/// </summary>
/// <param name="userRoleEntity">实体</param>
public string AddEntity(BaseUserRoleEntity userRoleEntity)
{
string sequence = string.Empty;
SQLBuilder sqlBuilder = new SQLBuilder(DbHelper, this.Identity, this.ReturnId);
sqlBuilder.BeginInsert(this.CurrentTableName, BaseUserRoleEntity.FieldId);
if (!this.Identity)
{
sqlBuilder.SetValue(BaseUserRoleEntity.FieldId, userRoleEntity.Id);
}
else
{
if (!this.ReturnId && (DbHelper.CurrentDbType == CurrentDbType.Oracle || DbHelper.CurrentDbType == CurrentDbType.DB2))
{
if (DbHelper.CurrentDbType == CurrentDbType.Oracle)
{
sqlBuilder.SetFormula(BaseUserRoleEntity.FieldId, "SEQ_" + this.CurrentTableName.ToUpper() + ".NEXTVAL ");
}
if (DbHelper.CurrentDbType == CurrentDbType.DB2)
{
sqlBuilder.SetFormula(BaseUserRoleEntity.FieldId, "NEXT VALUE FOR SEQ_" + this.CurrentTableName.ToUpper());
}
}
else
{
if (this.Identity && (DbHelper.CurrentDbType == CurrentDbType.Oracle || DbHelper.CurrentDbType == CurrentDbType.DB2))
{
if (userRoleEntity.Id == null)
{
if (string.IsNullOrEmpty(sequence))
{
BaseSequenceManager sequenceManager = new BaseSequenceManager(DbHelper, this.Identity);
sequence = sequenceManager.GetSequence(this.CurrentTableName);
}
userRoleEntity.Id = int.Parse(sequence);
}
sqlBuilder.SetValue(BaseUserRoleEntity.FieldId, userRoleEntity.Id);
}
}
}
this.SetEntity(sqlBuilder, userRoleEntity);
if (UserInfo != null)
{
sqlBuilder.SetValue(BaseUserRoleEntity.FieldCreateUserId, UserInfo.Id);
sqlBuilder.SetValue(BaseUserRoleEntity.FieldCreateBy, UserInfo.RealName);
}
sqlBuilder.SetDBNow(BaseUserRoleEntity.FieldCreateOn);
if (UserInfo != null)
{
sqlBuilder.SetValue(BaseUserRoleEntity.FieldModifiedUserId, UserInfo.Id);
sqlBuilder.SetValue(BaseUserRoleEntity.FieldModifiedBy, UserInfo.RealName);
}
sqlBuilder.SetDBNow(BaseUserRoleEntity.FieldModifiedOn);
if (DbHelper.CurrentDbType == CurrentDbType.SqlServer && this.Identity)
{
sequence = sqlBuilder.EndInsert().ToString();
}
else
{
sqlBuilder.EndInsert();
}
return(sequence);
}
/// <summary>
/// 添加实体
/// </summary>
/// <param name="parameterEntity">实体对象</param>
/// <returns>主键</returns>
public string AddEntity(BaseParameterEntity parameterEntity)
{
if (string.IsNullOrEmpty(parameterEntity.Id))
{
parameterEntity.Id = Guid.NewGuid().ToString();
}
SQLBuilder sqlBuilder = new SQLBuilder(DbHelper);
sqlBuilder.BeginInsert(this.CurrentTableName);
sqlBuilder.SetValue(BaseParameterEntity.FieldId, parameterEntity.Id);
sqlBuilder.SetValue(BaseParameterEntity.FieldCategoryId, parameterEntity.CategoryId);
sqlBuilder.SetValue(BaseParameterEntity.FieldParameterId, parameterEntity.ParameterId);
sqlBuilder.SetValue(BaseParameterEntity.FieldParameterCode, parameterEntity.ParameterCode);
sqlBuilder.SetValue(BaseParameterEntity.FieldWorked, parameterEntity.Worked ? 1 : 0);
sqlBuilder.SetValue(BaseParameterEntity.FieldParameterContent, parameterEntity.ParameterContent);
sqlBuilder.SetValue(BaseParameterEntity.FieldEnabled, parameterEntity.Enabled ? 1 : 0);
sqlBuilder.SetValue(BaseParameterEntity.FieldDeletionStateCode, parameterEntity.DeletionStateCode);
sqlBuilder.SetValue(BaseParameterEntity.FieldDescription, parameterEntity.Description);
if (UserInfo != null)
{
sqlBuilder.SetValue(BaseParameterEntity.FieldCreateUserId, UserInfo.Id);
sqlBuilder.SetValue(BaseParameterEntity.FieldCreateBy, UserInfo.RealName);
}
sqlBuilder.SetDBNow(BaseParameterEntity.FieldCreateOn);
return(sqlBuilder.EndInsert() > 0 ? parameterEntity.Id : string.Empty);
}
/// <summary>
/// 添加实体
/// </summary>
/// <param name="entity">实体</param>
public string AddEntity(BaseContactDetailsEntity 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(BaseContactDetailsEntity.TableName, BaseContactDetailsEntity.FieldId);
if (entity.Id is string)
{
this.Identity = false;
}
if (!this.Identity)
{
sqlBuilder.SetValue(BaseContactDetailsEntity.FieldId, entity.Id);
}
else
{
if (!this.ReturnId && DbHelper.CurrentDbType == CurrentDbType.Oracle)
{
sqlBuilder.SetFormula(BaseContactDetailsEntity.FieldId, "SEQ_" + this.CurrentTableName.ToUpper() + ".NEXTVAL ");
}
else
{
if (this.Identity && DbHelper.CurrentDbType == CurrentDbType.Oracle)
{
if (string.IsNullOrEmpty(sequence))
{
BaseSequenceManager sequenceManager = new BaseSequenceManager(DbHelper, this.Identity);
sequence = sequenceManager.Increment(this.CurrentTableName);
}
entity.Id = sequence;
sqlBuilder.SetValue(BaseContactDetailsEntity.FieldId, entity.Id);
}
}
}
this.SetEntity(sqlBuilder, entity);
if (UserInfo != null)
{
sqlBuilder.SetValue(BaseContactDetailsEntity.FieldCreateUserId, UserInfo.Id);
sqlBuilder.SetValue(BaseContactDetailsEntity.FieldCreateBy, UserInfo.RealName);
}
sqlBuilder.SetDBNow(BaseContactDetailsEntity.FieldCreateOn);
if (UserInfo != null)
{
sqlBuilder.SetValue(BaseContactDetailsEntity.FieldModifiedUserId, UserInfo.Id);
sqlBuilder.SetValue(BaseContactDetailsEntity.FieldModifiedBy, UserInfo.RealName);
}
sqlBuilder.SetDBNow(BaseContactDetailsEntity.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(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="baseCommentEntity">实体</param>
public string AddEntity(BaseCommentEntity baseCommentEntity)
{
string sequence = string.Empty;
this.Identity = false;
if (baseCommentEntity.SortCode == null || baseCommentEntity.SortCode == 0)
{
BaseSequenceManager sequenceManager = new BaseSequenceManager(DbHelper, this.Identity);
sequence = sequenceManager.GetSequence(this.CurrentTableName);
baseCommentEntity.SortCode = int.Parse(sequence);
}
if (baseCommentEntity.Id != null)
{
sequence = baseCommentEntity.Id.ToString();
}
SQLBuilder sqlBuilder = new SQLBuilder(DbHelper, this.Identity, this.ReturnId);
sqlBuilder.BeginInsert(this.CurrentTableName, BaseCommentEntity.FieldId);
if (!this.Identity)
{
if (string.IsNullOrEmpty(baseCommentEntity.Id))
{
sequence = BaseBusinessLogic.NewGuid();
baseCommentEntity.Id = sequence;
}
sqlBuilder.SetValue(BaseCommentEntity.FieldId, baseCommentEntity.Id);
}
else
{
if (!this.ReturnId && (DbHelper.CurrentDbType == CurrentDbType.Oracle || DbHelper.CurrentDbType == CurrentDbType.DB2))
{
if (DbHelper.CurrentDbType == CurrentDbType.Oracle)
{
sqlBuilder.SetFormula(BaseCommentEntity.FieldId, "SEQ_" + this.CurrentTableName.ToUpper() + ".NEXTVAL ");
}
if (DbHelper.CurrentDbType == CurrentDbType.DB2)
{
sqlBuilder.SetFormula(BaseCommentEntity.FieldId, "NEXT VALUE FOR SEQ_" + this.CurrentTableName.ToUpper());
}
}
else
{
if (this.Identity && (DbHelper.CurrentDbType == CurrentDbType.Oracle || DbHelper.CurrentDbType == CurrentDbType.DB2))
{
if (string.IsNullOrEmpty(baseCommentEntity.Id))
{
if (string.IsNullOrEmpty(sequence))
{
BaseSequenceManager sequenceManager = new BaseSequenceManager(DbHelper, this.Identity);
sequence = sequenceManager.GetSequence(this.CurrentTableName);
}
baseCommentEntity.Id = sequence;
}
sqlBuilder.SetValue(BaseCommentEntity.FieldId, baseCommentEntity.Id);
}
}
}
this.SetEntity(sqlBuilder, baseCommentEntity);
if (UserInfo != null)
{
sqlBuilder.SetValue(BaseCommentEntity.FieldCreateUserId, UserInfo.Id);
sqlBuilder.SetValue(BaseCommentEntity.FieldCreateBy, UserInfo.RealName);
}
sqlBuilder.SetDBNow(BaseCommentEntity.FieldCreateOn);
if (UserInfo != null)
{
sqlBuilder.SetValue(BaseCommentEntity.FieldModifiedUserId, UserInfo.Id);
sqlBuilder.SetValue(BaseCommentEntity.FieldModifiedBy, UserInfo.RealName);
}
sqlBuilder.SetDBNow(BaseCommentEntity.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>
private void SetObject(SQLBuilder sqlBuilder, BaseOrganizeScopeEntity entity)
{
SetObjectExpand(sqlBuilder, entity);
sqlBuilder.SetValue(BaseOrganizeScopeEntity.FieldResourceCategory, entity.ResourceCategory);
sqlBuilder.SetValue(BaseOrganizeScopeEntity.FieldResourceId, entity.ResourceId);
sqlBuilder.SetValue(BaseOrganizeScopeEntity.FieldPermissionId, entity.PermissionId);
sqlBuilder.SetValue(BaseOrganizeScopeEntity.FieldAllData, entity.AllData);
sqlBuilder.SetValue(BaseOrganizeScopeEntity.FieldProvince, entity.Province);
sqlBuilder.SetValue(BaseOrganizeScopeEntity.FieldCity, entity.City);
sqlBuilder.SetValue(BaseOrganizeScopeEntity.FieldDistrict, entity.District);
sqlBuilder.SetValue(BaseOrganizeScopeEntity.FieldStreet, entity.Street);
sqlBuilder.SetValue(BaseOrganizeScopeEntity.FieldUserCompany, entity.UserCompany);
sqlBuilder.SetValue(BaseOrganizeScopeEntity.FieldUserSubCompany, entity.UserSubCompany);
sqlBuilder.SetValue(BaseOrganizeScopeEntity.FieldUserDepartment, entity.UserDepartment);
sqlBuilder.SetValue(BaseOrganizeScopeEntity.FieldUserSubDepartment, entity.UserSubDepartment);
sqlBuilder.SetValue(BaseOrganizeScopeEntity.FieldUserWorkgroup, entity.UserWorkgroup);
sqlBuilder.SetValue(BaseOrganizeScopeEntity.FieldOnlyOwnData, entity.OnlyOwnData);
sqlBuilder.SetValue(BaseOrganizeScopeEntity.FieldNotAllowed, entity.NotAllowed);
sqlBuilder.SetValue(BaseOrganizeScopeEntity.FieldByDetails, entity.ByDetails);
sqlBuilder.SetValue(BaseOrganizeScopeEntity.FieldContainChild, entity.ContainChild);
sqlBuilder.SetValue(BaseOrganizeScopeEntity.FieldEnabled, entity.Enabled);
sqlBuilder.SetValue(BaseOrganizeScopeEntity.FieldDeletionStateCode, entity.DeletionStateCode);
sqlBuilder.SetValue(BaseOrganizeScopeEntity.FieldDescription, entity.Description);
}
/// <summary>
/// 设置实体
/// </summary>
/// <param name="entity">实体</param>
private void SetObject(SQLBuilder sqlBuilder, BasePermissionScopeEntity entity)
{
sqlBuilder.SetValue(BasePermissionScopeEntity.FieldResourceCategory, entity.ResourceCategory);
sqlBuilder.SetValue(BasePermissionScopeEntity.FieldResourceId, entity.ResourceId);
sqlBuilder.SetValue(BasePermissionScopeEntity.FieldTargetCategory, entity.TargetCategory);
sqlBuilder.SetValue(BasePermissionScopeEntity.FieldTargetId, entity.TargetId);
sqlBuilder.SetValue(BasePermissionScopeEntity.FieldPermissionId, entity.PermissionId);
sqlBuilder.SetValue(BasePermissionScopeEntity.FieldContainChild, entity.ContainChild);
sqlBuilder.SetValue(BasePermissionScopeEntity.FieldPermissionConstraint, entity.PermissionConstraint);
sqlBuilder.SetValue(BasePermissionScopeEntity.FieldStartDate, entity.StartDate);
sqlBuilder.SetValue(BasePermissionScopeEntity.FieldEndDate, entity.EndDate);
sqlBuilder.SetValue(BasePermissionScopeEntity.FieldEnabled, entity.Enabled);
sqlBuilder.SetValue(BasePermissionScopeEntity.FieldDeletionStateCode, entity.DeletionStateCode);
sqlBuilder.SetValue(BasePermissionScopeEntity.FieldDescription, entity.Description);
SetObjectExpand(sqlBuilder, entity);
}
/// <summary>
/// 添加实体
/// </summary>
/// <param name="entity">实体</param>
public string AddObject(BaseServicesLicenseEntity entity)
{
string result = string.Empty;
SQLBuilder sqlBuilder = new SQLBuilder(DbHelper, this.Identity, this.ReturnId);
sqlBuilder.BeginInsert(this.CurrentTableName, BaseServicesLicenseEntity.FieldId);
if (!string.IsNullOrEmpty(entity.Id) || !this.Identity)
{
result = entity.Id;
sqlBuilder.SetValue(BaseServicesLicenseEntity.FieldId, entity.Id);
}
else
{
if (!this.ReturnId && (DbHelper.CurrentDbType == CurrentDbType.Oracle || DbHelper.CurrentDbType == CurrentDbType.DB2))
{
if (DbHelper.CurrentDbType == CurrentDbType.Oracle)
{
sqlBuilder.SetFormula(BaseServicesLicenseEntity.FieldId, "SEQ_" + BaseServicesLicenseEntity.TableName.ToUpper() + ".NEXTVAL ");
}
if (DbHelper.CurrentDbType == CurrentDbType.DB2)
{
sqlBuilder.SetFormula(BaseServicesLicenseEntity.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(BaseServicesLicenseEntity.TableName);
}
entity.Id = result;
}
sqlBuilder.SetValue(BaseServicesLicenseEntity.FieldId, entity.Id);
}
}
}
this.SetObject(sqlBuilder, entity);
// 创建人信息
if (!string.IsNullOrEmpty(entity.CreateUserId))
{
sqlBuilder.SetValue(BaseServicesLicenseEntity.FieldCreateUserId, entity.CreateUserId);
}
else
{
if (UserInfo != null)
{
sqlBuilder.SetValue(BaseServicesLicenseEntity.FieldCreateUserId, UserInfo.Id);
}
}
if (!string.IsNullOrEmpty(entity.CreateBy))
{
sqlBuilder.SetValue(BaseServicesLicenseEntity.FieldCreateBy, entity.CreateBy);
}
else
{
if (UserInfo != null)
{
sqlBuilder.SetValue(BaseServicesLicenseEntity.FieldCreateBy, UserInfo.RealName);
}
}
if (entity.CreateOn.HasValue)
{
sqlBuilder.SetValue(BaseServicesLicenseEntity.FieldCreateOn, entity.CreateOn);
}
else
{
sqlBuilder.SetDBNow(BaseServicesLicenseEntity.FieldCreateOn);
}
// 修改人信息
if (!string.IsNullOrEmpty(entity.ModifiedUserId))
{
sqlBuilder.SetValue(BaseServicesLicenseEntity.FieldModifiedUserId, entity.ModifiedUserId);
}
else
{
if (UserInfo != null)
{
sqlBuilder.SetValue(BaseServicesLicenseEntity.FieldModifiedUserId, UserInfo.Id);
}
}
if (!string.IsNullOrEmpty(entity.ModifiedBy))
{
sqlBuilder.SetValue(BaseServicesLicenseEntity.FieldModifiedBy, entity.ModifiedBy);
}
else
{
if (UserInfo != null)
{
sqlBuilder.SetValue(BaseServicesLicenseEntity.FieldModifiedBy, UserInfo.RealName);
}
}
if (entity.ModifiedOn.HasValue)
{
sqlBuilder.SetValue(BaseServicesLicenseEntity.FieldModifiedOn, entity.ModifiedOn);
}
else
{
sqlBuilder.SetDBNow(BaseServicesLicenseEntity.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(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="baseWorkFlowProcessEntity">实体</param>
private void SetEntity(SQLBuilder sqlBuilder, BaseWorkFlowProcessEntity baseWorkFlowProcessEntity)
{
sqlBuilder.SetValue(BaseWorkFlowProcessEntity.FieldUserId, baseWorkFlowProcessEntity.UserId);
sqlBuilder.SetValue(BaseWorkFlowProcessEntity.FieldOrganizeId, baseWorkFlowProcessEntity.OrganizeId);
sqlBuilder.SetValue(BaseWorkFlowProcessEntity.FieldBillTemplateId, baseWorkFlowProcessEntity.BillTemplateId);
sqlBuilder.SetValue(BaseWorkFlowProcessEntity.FieldAuditCategoryCode, baseWorkFlowProcessEntity.AuditCategoryCode);
sqlBuilder.SetValue(BaseWorkFlowProcessEntity.FieldCallBackClass, baseWorkFlowProcessEntity.CallBackClass);
sqlBuilder.SetValue(BaseWorkFlowProcessEntity.FieldCallBackTable, baseWorkFlowProcessEntity.CallBackTable);
sqlBuilder.SetValue(BaseWorkFlowProcessEntity.FieldCategoryCode, baseWorkFlowProcessEntity.CategoryCode);
sqlBuilder.SetValue(BaseWorkFlowProcessEntity.FieldCode, baseWorkFlowProcessEntity.Code);
sqlBuilder.SetValue(BaseWorkFlowProcessEntity.FieldFullName, baseWorkFlowProcessEntity.FullName);
sqlBuilder.SetValue(BaseWorkFlowProcessEntity.FieldContents, baseWorkFlowProcessEntity.Contents);
sqlBuilder.SetValue(BaseWorkFlowProcessEntity.FieldSortCode, baseWorkFlowProcessEntity.SortCode);
sqlBuilder.SetValue(BaseWorkFlowProcessEntity.FieldEnabled, baseWorkFlowProcessEntity.Enabled);
sqlBuilder.SetValue(BaseWorkFlowProcessEntity.FieldDeletionStateCode, baseWorkFlowProcessEntity.DeletionStateCode);
sqlBuilder.SetValue(BaseWorkFlowProcessEntity.FieldDescription, baseWorkFlowProcessEntity.Description);
}
/// <summary>
/// 设置实体
/// </summary>
/// <param name="entity">实体</param>
private void SetObject(SQLBuilder sqlBuilder, TAB_EMPLOYEEEntity entity)
{
SetObjectExpand(sqlBuilder, entity);
sqlBuilder.SetValue(TAB_EMPLOYEEEntity.Field_OWNER_SITE, entity.OWNER_SITE);
sqlBuilder.SetValue(TAB_EMPLOYEEEntity.Field_TRANSFER_ADD_FEE, entity.TRANSFER_ADD_FEE);
sqlBuilder.SetValue(TAB_EMPLOYEEEntity.Field_EMPLOYEE_CODE, entity.EMPLOYEE_CODE);
sqlBuilder.SetValue(TAB_EMPLOYEEEntity.Field_OWNER_RANGE, entity.OWNER_RANGE);
sqlBuilder.SetValue(TAB_EMPLOYEEEntity.Field_CARDNUM, entity.CARDNUM);
sqlBuilder.SetValue(TAB_EMPLOYEEEntity.Field_BL_DISPATCH_GAIN, entity.BL_DISPATCH_GAIN);
sqlBuilder.SetValue(TAB_EMPLOYEEEntity.Field_BL_SEND_GAIN, entity.BL_SEND_GAIN);
sqlBuilder.SetValue(TAB_EMPLOYEEEntity.Field_ID_CARD, entity.ID_CARD);
sqlBuilder.SetValue(TAB_EMPLOYEEEntity.Field_UPDATETIME, entity.UPDATETIME);
sqlBuilder.SetValue(TAB_EMPLOYEEEntity.Field_BAR_PASSWORD, entity.BAR_PASSWORD);
sqlBuilder.SetValue(TAB_EMPLOYEEEntity.Field_EMPLOYEE_TYPE, entity.EMPLOYEE_TYPE);
sqlBuilder.SetValue(TAB_EMPLOYEEEntity.Field_DISPATCH__ADD_FEE, entity.DISPATCH__ADD_FEE);
sqlBuilder.SetValue(TAB_EMPLOYEEEntity.Field_DEPT_NAME, entity.DEPT_NAME);
sqlBuilder.SetValue(TAB_EMPLOYEEEntity.Field_ADDRESS, entity.ADDRESS);
sqlBuilder.SetValue(TAB_EMPLOYEEEntity.Field_PHONE, entity.PHONE);
sqlBuilder.SetValue(TAB_EMPLOYEEEntity.Field_EMPLOYEE_NAME, entity.EMPLOYEE_NAME);
sqlBuilder.SetValue(TAB_EMPLOYEEEntity.Field_DELETIONSTATECODE, entity.DELETIONSTATECODE);
sqlBuilder.SetValue(TAB_EMPLOYEEEntity.Field_GROUP_NAME, entity.GROUP_NAME);
sqlBuilder.SetValue(TAB_EMPLOYEEEntity.Field_DISPATCH_ADD_FEE_OPERA, entity.DISPATCH_ADD_FEE_OPERA);
sqlBuilder.SetValue(TAB_EMPLOYEEEntity.Field_TRANSFER_ADD_FEE_OPERA, entity.TRANSFER_ADD_FEE_OPERA);
}
/// <summary>
/// 设置实体
/// </summary>
/// <param name="organizeEntity">实体</param>
partial void SetObjectExpand(SQLBuilder sqlBuilder, BaseOrganizeEntity entity)
{
sqlBuilder.SetValue(BaseOrganizeEntity.FieldStatisticalName, entity.StatisticalName);
sqlBuilder.SetValue(BaseOrganizeEntity.FieldWeightRatio, entity.WeightRatio);
sqlBuilder.SetValue(BaseOrganizeEntity.FieldSendAir, entity.SendAir);
sqlBuilder.SetValue(BaseOrganizeEntity.FieldCalculateComeFee, entity.CalculateComeFee);
sqlBuilder.SetValue(BaseOrganizeEntity.FieldCalculateReceiveFee, entity.CalculateReceiveFee);
sqlBuilder.SetValue(BaseOrganizeEntity.FieldBillBalanceSite, entity.BillBalanceSite);
sqlBuilder.SetValue(BaseOrganizeEntity.FieldLevelTwoTransferCenter, entity.LevelTwoTransferCenter);
sqlBuilder.SetValue(BaseOrganizeEntity.FieldProvinceSite, entity.ProvinceSite);
sqlBuilder.SetValue(BaseOrganizeEntity.FieldBigArea, entity.BigArea);
sqlBuilder.SetValue(BaseOrganizeEntity.FieldSendFee, entity.SendFee);
sqlBuilder.SetValue(BaseOrganizeEntity.FieldLevelTwoTransferFee, entity.LevelTwoTransferFee);
sqlBuilder.SetValue(BaseOrganizeEntity.FieldBillSubsidy, entity.BillSubsidy);
sqlBuilder.SetValue(BaseOrganizeEntity.FieldMaster, entity.Master);
sqlBuilder.SetValue(BaseOrganizeEntity.FieldMasterMobile, entity.MasterMobile);
sqlBuilder.SetValue(BaseOrganizeEntity.FieldMasterQQ, entity.MasterQQ);
sqlBuilder.SetValue(BaseOrganizeEntity.FieldManager, entity.Manager);
sqlBuilder.SetValue(BaseOrganizeEntity.FieldManagerMobile, entity.ManagerMobile);
sqlBuilder.SetValue(BaseOrganizeEntity.FieldManagerQQ, entity.ManagerQQ);
sqlBuilder.SetValue(BaseOrganizeEntity.FieldEmergencyCall, entity.EmergencyCall);
sqlBuilder.SetValue(BaseOrganizeEntity.FieldBusinessPhone, entity.BusinessPhone);
}
