lpf/SGGL_SHJ
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

1

Browse Source
This commit is contained in:
高飞
2026-03-06 17:58:48 +08:00
parent 393e451064
commit adedb7e83d
102 changed files with 13691 additions and 271 deletions
Download Patch File Download Diff File Expand all files Collapse all files
SGGL/BLL/BLL.csproj
+10
View File
@@ -276,7 +276,14 @@
<Compile Include="BaseInfo\UnitTypeService.cs" />
<Compile Include="BaseInfo\WorkPostService.cs" />
<Compile Include="BaseInfo\WorkStageService.cs" />
<Compile Include="Common\DataCleanupMergeHelper.cs" />
<Compile Include="CQMS\ProjectHighlightsSite\ProjectHighlightsSiteService.cs" />
<Compile Include="DataShare\APIDataShareSyncService.cs" />
<Compile Include="DataShare\HSSE\APICheckSpecialSyncService.cs" />
<Compile Include="DataShare\HSSE\APIHazardRegisterSyncService.cs" />
<Compile Include="DataShare\HSSE\APILicenseSyncService.cs" />
<Compile Include="DataShare\HSSE\APIMeetingSyncService.cs" />
<Compile Include="DataShare\HSSE\APIPersonSyncService.cs" />
<Compile Include="HJGL\BaseInfo\Base_MaterialColorService.cs" />
<Compile Include="CLGL\TwArrivalStatisticsService.cs" />
<Compile Include="CLGL\TwConst.cs" />
@@ -580,6 +587,7 @@
<Compile Include="HSSE\Solution\ExpertArgumentService.cs" />
<Compile Include="HSSE\Solution\LargerHazardService.cs" />
<Compile Include="HSSE\Solution\SolutionTemplateService.cs" />
<Compile Include="HSSE\Solution\TemporaryElectricityService.cs" />
<Compile Include="HSSE\Technique\EmergencyService.cs" />
<Compile Include="HSSE\Technique\HazardListService.cs" />
<Compile Include="HSSE\Technique\HazardListTypeService.cs" />
@@ -833,6 +841,8 @@
<Compile Include="ZHGL\Supervise\SuperviseCheckRectifyService.cs" />
<Compile Include="ZHGL\Supervise\SuperviseCheckReportItemService.cs" />
<Compile Include="ZHGL\Supervise\SuperviseCheckReportService.cs" />
<Compile Include="ZHGL\Supervise\UnitHazardRegisterItemService.cs" />
<Compile Include="ZHGL\Supervise\UnitHazardRegisterService.cs" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\Model\Model.csproj">
SGGL/BLL/BaseInfo/SuperviseCheckTypeService.cs
+19
View File
@@ -100,5 +100,24 @@ namespace BLL
Funs.FineUIPleaseSelect(dropName);
}
}
/// <summary>
/// 根据检查大类和检查类别代码获取检查类别名称
/// </summary>
/// <param name="checkMainType">检查大类（0=安全，1=质量）</param>
/// <param name="checkTypeCode">检查类别代码</param>
/// <returns>检查类别名称</returns>
public static string GetCheckTypeName(string checkMainType, string checkTypeCode)
{
if (string.IsNullOrEmpty(checkMainType) || string.IsNullOrEmpty(checkTypeCode))
{
return string.Empty;
}
var checkType = Funs.DB.Base_SuperviseCheckType
.FirstOrDefault(x => x.CheckMainType == checkMainType && x.CheckTypeCode == checkTypeCode);
return checkType?.CheckTypeName ?? string.Empty;
}
}
}
SGGL/BLL/Common/Const.cs
+41 -12
View File
@@ -1601,18 +1601,6 @@ namespace BLL
#endregion
#region 企业安全大检查
/// <summary>
/// 安全监督检查报告
/// </summary>
public const string SuperviseCheckReportMenuId = "40387C48-95A0-435C-82FB-57AF0A81B9D4";
/// <summary>
/// 安全监督检查整改
/// </summary>
public const string SuperviseCheckRectifyMenuId = "55976B16-2C33-406E-B514-2FE42D031071";
#endregion
#region 集团安全监督
/// <summary>
/// 企业上报监督检查报告
@@ -3354,6 +3342,10 @@ namespace BLL
/// </summary>
public const string CheckSpecialTemplateUrl = "File\\Excel\\DataIn\\专项检查导入模板.xls";
/// <summary>
/// 专项检查明细导入模板
/// </summary>
public const string CheckSpecialDetailTemplateUrl = "File\\Excel\\DataIn\\专项检查明细导入模板.xls";
/// <summary>
/// 综合检查导入模板
/// </summary>
public const string CheckColligationTemplateUrl = "File\\Excel\\DataIn\\综合检查导入模板.xls";
@@ -5280,5 +5272,42 @@ namespace BLL
/// 重点工程项目质量专项整治行动开展情况台账
/// </summary>
public const string DCGLKeyProjectRectificationSituationLedgerMenuId = "35BA8E89-4575-4A3F-9C22-98B323E67DA1";
/// <summary>
/// 临时用电
/// </summary>
public const string ProjectTemporaryElectricityListMenuId = "09B2A0A6-A693-4F1D-A4F5-D5DEA803D771";
#region 企业安全大检查
/// <summary>
/// 安全监督检查报告
/// </summary>
public const string SuperviseCheckReportMenuId = "40387C48-95A0-435C-82FB-57AF0A81B9D4";
/// <summary>
/// 安全监督检查整改
/// </summary>
public const string SuperviseCheckRectifyMenuId = "A02E0365-383C-49A0-BF1A-B3E42052959B";
/// <summary>
/// 企业安全检查菜单ID
/// </summary>
public const string UnitHazardRegisterMenu_Safety = "C46C007E-A100-4A52-9317-3B885442E130";
/// <summary>
/// 企业质量检查菜单ID
/// </summary>
public const string UnitHazardRegisterMenu_Quality = "FDA7722C-383E-4BB1-B29D-BB0BF87AA942";
/// <summary>
/// 企业安全检查菜单记录ID
/// </summary>
public const string UnitHazardRegisterMenuRecord_Safety = "73283863-CF67-44CA-9DF8-67071734A528";
/// <summary>
/// 企业质量检查菜单记录ID
/// </summary>
public const string UnitHazardRegisterMenuRecord_Quality = "15511354-9822-4A21-AB24-2483D889FDB8";
#endregion
}
}
SGGL/BLL/Common/DataCleanupMergeHelper.cs
+71
View File
@@ -0,0 +1,71 @@
using System;
using System.Collections.Generic;
using System.Linq;
namespace BLL
{
/// <summary>
/// 数据合并清理
/// </summary>
public class DataCleanupMergeHelper
{
/// <summary>
/// 数据合并清理
/// </summary>
/// <param name="exTable">排除操作数据表</param>
/// <param name="columType">替换字段（模糊匹配）</param>
/// <param name="mergeDataIds">需要替换的数据值</param>
/// <param name="dataId">新的字段数据值</param>
/// <returns></returns>
public static bool DataCleanupMerge(string exTable, string columType, List<string> mergeDataIds, string dataId, ref string msg)
{
bool result = false;
try
{
Model.SGGLDB db = Funs.DB;
var clist = db.DataIdMove.Where(x => x.ColumType == columType && x.NewIds == dataId).ToList();
db.DataIdMove.DeleteAllOnSubmit(clist);
db.SubmitChanges();
List<Model.DataIdMove> list = new List<Model.DataIdMove>();
foreach (var mergeId in mergeDataIds)
{
list.Add(new Model.DataIdMove { OldId = mergeId.Trim(), NewIds = dataId.Trim(), ColumType = columType });
}
db.DataIdMove.InsertAllOnSubmit(list);
db.SubmitChanges();
//SP_DataIdMove[排除操作数据表，替换字段（模糊匹配），字段数据值]
string strSql = $"exec SP_DataIdMove '{exTable}','{columType}','{dataId}'";
result = BLL.SQLHelper.ExecuteSql(strSql);
//SqlParameter[] parameters = {
// new SqlParameter("@exTable", exTable),
// new SqlParameter("@colums", columType),
// new SqlParameter("@trueId", dataId),
// new SqlParameter("@returnVal", SqlDbType.Int)
//};
//BLL.SQLHelper.ExecuteNonQueryStoredProcedure("SP_DataIdMove", parameters);
//int succ = BLL.SQLHelper.ExecuteProcedure("SP_DataIdMove", parameters);
//Thread.Sleep(30000); // 等待30秒，30000毫秒等于30秒
if (result)
{
db.DataIdMove.DeleteAllOnSubmit(list);
db.SubmitChanges();
msg = "数据合并成功！";
}
else
{
msg = "数据合并失败，请稍后再试！";
}
}
catch (Exception ex)
{
msg = ex.Message;
result = false;
}
return result;
}
}
}
SGGL/BLL/DataShare/APIDataShareSyncService.cs
+615
View File
@@ -0,0 +1,615 @@
using System.Linq;
using System;
using System.Collections.Generic;
using System.Configuration;
using System.IO;
using System.Net.Http;
using System.Threading.Tasks;
namespace BLL
{
/// <summary>
/// 数据共享互通辅助服务
/// </summary>
public class APIDataShareSyncService
{
#region 班组
/// <summary>
/// 获取班组Id
/// </summary>
/// <param name="TeamGroupName"></param>
/// <param name="projectId"></param>
/// <param name="unitId"></param>
/// <returns></returns>
public static string GetTeamGroupId(string TeamGroupName, string projectId, string unitId)
{
string TeamGroupId = null;
if (!string.IsNullOrEmpty(TeamGroupName))
{
var tg = Funs.DB.ProjectData_TeamGroup.Where(x =>
x.TeamGroupName == TeamGroupName && x.ProjectId == projectId && x.UnitId == unitId).ToList();
if (tg.Count == 0)
{
Model.ProjectData_TeamGroup newTeamGroup = new Model.ProjectData_TeamGroup
{
TeamGroupId = SQLHelper.GetNewID(typeof(Model.ProjectData_TeamGroup)),
ProjectId = projectId,
UnitId = unitId,
TeamGroupName = TeamGroupName,
Remark = "分包数据同步导入"
};
TeamGroupService.AddTeamGroup(newTeamGroup);
TeamGroupId = newTeamGroup.TeamGroupId;
}
else
{
TeamGroupId = tg.FirstOrDefault().TeamGroupId;
}
}
return TeamGroupId;
}
#endregion
#region 作业票许可证类型
/// <summary>
/// 获取作业票许可证类型Id
/// </summary>
/// <param name="LicenseTypeId"></param>
/// <param name="LicenseTypeCode"></param>
/// <param name="LicenseTypeName"></param>
/// <returns></returns>
public static string GetLicenseTypeId(string LicenseTypeId, string LicenseTypeCode, string LicenseTypeName)
{
string Id = null;
if (!string.IsNullOrEmpty(LicenseTypeName))
{
var obj = Funs.DB.Base_LicenseType.Where(x => x.LicenseTypeName == LicenseTypeName).ToList();
if (obj.Count == 0)
{
string newId = LicenseTypeId;
var type = Funs.DB.Base_LicenseType.Where(x => x.LicenseTypeId == LicenseTypeId).FirstOrDefault();
if (type == null)
{
newId = SQLHelper.GetNewID(typeof(Model.Base_LicenseType));
}
Model.Base_LicenseType newModel = new Model.Base_LicenseType
{
LicenseTypeId = newId,
LicenseTypeCode = LicenseTypeCode,
LicenseTypeName = LicenseTypeName,
Remark = "分包数据同步导入"
};
LicenseTypeService.AddLicenseType(newModel);
Id = newId;
}
else
{
Id = obj.FirstOrDefault().LicenseTypeId;
}
}
return Id;
}
#endregion
#region 获取作业区域
/// <summary>
/// 作业区域
/// </summary>
/// <param name="UnitWorkName"></param>
/// <param name="projectId"></param>
/// <returns></returns>
public static string getUnitWorkId(string UnitWorkName, string projectId)
{
string UnitWorkId = null;
if (!string.IsNullOrEmpty(UnitWorkName))
{
var uw = Funs.DB.WBS_UnitWork.Where(x =>
x.UnitWorkName == UnitWorkName && x.ProjectId == projectId && x.SuperUnitWork == null).ToList();
if (uw.Count == 0)
{
Model.WBS_UnitWork newUnitWork = new Model.WBS_UnitWork
{
UnitWorkId = SQLHelper.GetNewID(typeof(Model.WBS_UnitWork)),
ProjectId = projectId,
UnitWorkName = UnitWorkName,
};
UnitWorkService.AddUnitWork(newUnitWork);
UnitWorkId = newUnitWork.UnitWorkId;
}
else
{
UnitWorkId = uw.FirstOrDefault().UnitWorkId;
}
}
return UnitWorkId;
}
#endregion
#region 获取系统用户
/// <summary>
/// 获取系统用户
/// </summary>
/// <param name="userName"></param>
/// <returns></returns>
public static string getUserId(string userName)
{
string UserId = null;
if (!string.IsNullOrEmpty(userName))
{
var u = Funs.DB.Person_Persons.Where(x =>
x.PersonName == userName).ToList();
if (u.Count == 0)
{
Model.Person_Persons newUser = new Model.Person_Persons
{
PersonId = SQLHelper.GetNewID(typeof(Model.Person_Persons)),
PersonName = userName,
// Remark = "导入",
};
Person_PersonsService.AddPerson(newUser);
UserId = newUser.PersonId;
}
else
{
UserId = u.FirstOrDefault().PersonId;
}
}
return UserId;
}
#endregion
#region 获取检查类别
/// <summary>
/// 获取检查类别
/// </summary>
/// <param name="userName"></param>
/// <returns></returns>
public static string getCheckItemSetId(string checkItemName)
{
string CheckItemSetId = null;
if (!string.IsNullOrEmpty(checkItemName))
{
var cis = Funs.DB.Technique_CheckItemSet.Where(x =>
x.CheckItemName == checkItemName && x.CheckType == "2").ToList();
if (cis.Count == 0)
{
Model.Technique_CheckItemSet newCheckItemSet = new Model.Technique_CheckItemSet
{
CheckItemSetId = SQLHelper.GetNewID(typeof(Model.Technique_CheckItemSet)),
CheckItemName = checkItemName,
SupCheckItem = "0",
CheckType = "2",
};
Technique_CheckItemSetService.AddCheckItemSet(newCheckItemSet);
CheckItemSetId = newCheckItemSet.CheckItemSetId;
}
else
{
CheckItemSetId = cis.FirstOrDefault().CheckItemSetId;
}
}
return CheckItemSetId;
}
#endregion
#region 获取巡检问题类型
/// <summary>
/// 获取巡检问题类型
/// </summary>
/// <param name="RegisterTypesName"></param>
/// <returns></returns>
public static string getRegisterTypesId(string RegisterTypesName)
{
string RegisterTypesId = null;
if (!string.IsNullOrEmpty(RegisterTypesName))
{
var ht = Funs.DB.HSSE_Hazard_HazardRegisterTypes.Where(x =>
x.RegisterTypesName == RegisterTypesName && x.HazardRegisterType == "1").ToList();
if (ht.Count == 0)
{
Model.HSSE_Hazard_HazardRegisterTypes newHazardRegisterTypes = new Model.HSSE_Hazard_HazardRegisterTypes
{
RegisterTypesId = SQLHelper.GetNewID(typeof(Model.HSSE_Hazard_HazardRegisterTypes)),
RegisterTypesName = RegisterTypesName,
HazardRegisterType = "1",
Remark = "导入",
};
HSSE_Hazard_HazardRegisterTypesService.AddHazardRegisterTypes(newHazardRegisterTypes);
RegisterTypesId = newHazardRegisterTypes.RegisterTypesId;
}
else
{
RegisterTypesId = ht.FirstOrDefault().RegisterTypesId;
}
}
return RegisterTypesId;
}
#endregion
#region 获取特岗证书
/// <summary>
/// 特岗证书
/// </summary>
/// <param name="CertificateName"></param>
/// <returns></returns>
public static Model.CertificateItem GetPersonQualityByPersonId(string personId)
{
Model.CertificateItem item = new Model.CertificateItem();
var personQuality = PersonQualityService.GetPersonQualityByPersonId(personId);
if (personQuality != null)
{
item.PersonQualityId = personQuality.PersonQualityId;//主键
item.CertificateId = personQuality.CertificateId;
item.CertificateName = personQuality.CertificateName;
item.CertificateNo = personQuality.CertificateNo;
item.CertificateLimitDate = personQuality.LimitDate;
}
return item;
}
#endregion
#region 保存或修改特岗证书数据
public static void ProcessPersonQualityData(Model.CertificateItem item, string personId)
{
using (Model.SGGLDB db = new Model.SGGLDB(Funs.ConnString))
{
if (item == null)
{
return;
}
if (!string.IsNullOrEmpty(item.CertificateId))
{
var personQuality = BLL.PersonQualityService.GetPersonQualityByPersonId(personId);
var certificate =
db.Base_Certificate.FirstOrDefault(e => e.CertificateId == item.CertificateId);
var CertificateId = string.Empty;
if (certificate != null)
{
CertificateId = certificate.CertificateId;
}
else
{
Model.Base_Certificate newCertificate = new Model.Base_Certificate
{
CertificateId = SQLHelper.GetNewID(typeof(Model.Base_Certificate)),
CertificateName = item.CertificateName,
Remark = "导入"
};
db.Base_Certificate.InsertOnSubmit(newCertificate);
db.SubmitChanges();
// BLL.CertificateService.AddCertificate(newCertificate);
CertificateId = newCertificate.CertificateId;
}
if (personQuality != null)
{
personQuality.CertificateId = CertificateId;
personQuality.CertificateName = item.CertificateName;
personQuality.CertificateNo = item.CertificateNo;
personQuality.LimitDate = item.CertificateLimitDate;
BLL.PersonQualityService.UpdatePersonQuality(personQuality);
}
else
{
Model.QualityAudit_PersonQuality newPersonQuality = new Model.QualityAudit_PersonQuality
{
PersonQualityId = SQLHelper.GetNewID(typeof(Model.QualityAudit_PersonQuality)),
PersonId = personId,
};
newPersonQuality.CertificateId = CertificateId;
newPersonQuality.CertificateName = item.CertificateName;
newPersonQuality.CertificateNo = item.CertificateNo;
newPersonQuality.LimitDate = item.CertificateLimitDate;
BLL.PersonQualityService.AddPersonQuality(newPersonQuality);
}
}
}
}
#endregion
#region 岗位
/// <summary>
/// 岗位
/// </summary>
/// <param name="WorkPostName"></param>
/// <returns></returns>
public static string getWorkPostId(string WorkPostName, string PostType, string IsHsse, string IsCQMS)
{
string WorkPostId = null;
if (!string.IsNullOrEmpty(WorkPostName))
{
var wp = Funs.DB.Base_WorkPost.Where(x => x.WorkPostName == WorkPostName).ToList();
if (wp.Count == 0)
{
Model.Base_WorkPost newWorkPost = new Model.Base_WorkPost
{
WorkPostId = SQLHelper.GetNewID(typeof(Model.Base_WorkPost)),
WorkPostName = WorkPostName,
PostType = PostType,
IsHsse = Convert.ToBoolean(IsHsse),
IsCQMS = Convert.ToBoolean(IsCQMS),
Remark = "导入"
};
WorkPostService.AddWorkPost(newWorkPost);
WorkPostId = newWorkPost.WorkPostId;
}
else
{
WorkPostId = wp.FirstOrDefault().WorkPostId;
}
}
return WorkPostId;
}
#endregion
#region 单位工程
/// <summary>
/// 单位工程
/// </summary>
/// <param name="WorkAreaName"></param>
/// <param name="projectId"></param>
/// <returns></returns>
public static string getWorkAreaId(string WorkAreaName, string projectId)
{
string WorkAreaId = null;
if (!string.IsNullOrEmpty(WorkAreaName))
{
var names = WorkAreaName.Split(',');
List<string> workAreaIdList = new List<string>();
foreach (var name in names)
{
var uw = Funs.DB.WBS_UnitWork.Where(x =>
x.UnitWorkName == name && x.ProjectId == projectId).ToList();
if (uw.Count == 0)
{
Model.WBS_UnitWork newUnitWork = new Model.WBS_UnitWork
{
UnitWorkId = SQLHelper.GetNewID(typeof(Model.WBS_UnitWork)),
ProjectId = projectId,
UnitWorkName = name,
};
UnitWorkService.AddUnitWork(newUnitWork);
workAreaIdList.Add(newUnitWork.UnitWorkId);
}
else
{
workAreaIdList.Add(uw.FirstOrDefault().UnitWorkId);
}
}
WorkAreaId = string.Join(",", workAreaIdList);
}
return WorkAreaId;
}
#endregion
#region 获取根据id获取单位工程名称
/// <summary>
/// 获取根据id获取单位工程名称
/// </summary>
/// <param name="WorkAreaId"></param>
/// <param name="projectId"></param>
/// <returns></returns>
public static string GetWorkAreaNames(string WorkAreaId, string projectId)
{
string WorkAreaNames = string.Empty;
if (!string.IsNullOrEmpty(WorkAreaId))
{
var workAreas = WorkAreaId.Split(',');
//创建一个数组集合
List<string> workAreaNameList = new List<string>();
foreach (var workArea in workAreas)
{
var WorkAreaName = Funs.DB.WBS_UnitWork
.First(x => x.UnitWorkId == workArea && x.ProjectId == projectId)
.UnitWorkName;
workAreaNameList.Add(WorkAreaName);
}
WorkAreaNames = string.Join(",", workAreaNameList);
}
return WorkAreaNames;
}
#endregion
#region 根据地址获取base64的文件
public static async Task<byte[]> DownloadHeadImageAsync(string webUrl, string photoUrl)
{
byte[] b = null;
try
{
if (!string.IsNullOrEmpty(photoUrl))
{
string localRoot = ConfigurationManager.AppSettings["localRoot"]; // 物理路径
// 先下载到本地（异步等待完成）
DownloadAndSaveFileWithRetryAsync(webUrl, photoUrl, localRoot);
b = AttachFileService.SetImageToByteArray(localRoot + photoUrl.Split(',')[0]);
}
}
catch (Exception ex)
{
throw ex;
}
return b;
}
#endregion
#region 向AttachFile文件表中添加或修改数据
public static async Task OperationAttachFile(string webUrl, string tokeyId, string menuId, string attachFileUrl)
{
using (Model.SGGLDB db = new Model.SGGLDB(Funs.ConnString))
{
if (!string.IsNullOrEmpty(attachFileUrl))
{
string localRoot = ConfigurationManager.AppSettings["localRoot"]; //物理路径
//attachFileUrl可能是多个
string[] attachFileUrls = attachFileUrl.Split(',');
var attachFile = db.AttachFile.FirstOrDefault(x => x.ToKeyId == tokeyId && x.MenuId == menuId);
if (attachFile != null)
{
if (attachFile.AttachUrl != attachFileUrl)
{
string[] oldAttachFileUrls = attachFile.AttachUrl.Split(',');
foreach (var oldFileUrl in oldAttachFileUrls)
{
//删除之前的
UploadFileService.DeleteFile(localRoot, oldFileUrl);
}
foreach (var fileUrl in attachFileUrls)
{
DownloadAndSaveFileWithRetryAsync(webUrl, fileUrl, localRoot);
}
UploadFileService.SaveAttachUrl(
UploadFileService.GetSourceByAttachUrl(attachFileUrl, 10, null),
attachFileUrl, menuId, tokeyId);
}
}
else
{
foreach (var fileUrl in attachFileUrls)
{
DownloadAndSaveFileWithRetryAsync(webUrl, fileUrl, localRoot);
}
UploadFileService.SaveAttachUrl(
UploadFileService.GetSourceByAttachUrl(attachFileUrl, 10, null),
attachFileUrl, menuId, tokeyId);
}
}
}
}
public static async Task DownloadAndSaveFileAsync(string webUrl, string attachFileUrl, string localPath)
{
// 验证输入参数
if (string.IsNullOrEmpty(webUrl) || string.IsNullOrEmpty(attachFileUrl) || string.IsNullOrEmpty(localPath))
{
BLL.ErrLogInfo.WriteLog(
$"下载文件参数无效: webUrl={webUrl}, attachFileUrl={attachFileUrl}, localPath={localPath}");
return;
}
try
{
// 构造完整的远程文件 URL
string fullRemoteUrl = $"{webUrl.TrimEnd('/')}/{attachFileUrl.TrimStart('/')}";
// 构造本地文件路径
string localFilePath = Path.Combine(localPath, attachFileUrl);
// 确保本地目录存在
string directoryPath = Path.GetDirectoryName(localFilePath);
if (!string.IsNullOrEmpty(directoryPath) && !Directory.Exists(directoryPath))
{
Directory.CreateDirectory(directoryPath);
}
// 使用独立的HttpClient实例并配置不捕获同步上下文
using (var httpClient = new HttpClient())
{
// 设置合理的超时时间
httpClient.Timeout = TimeSpan.FromMinutes(3);
// 下载文件字节（使用ConfigureAwait(false)避免上下文问题）
byte[] fileBytes = await httpClient.GetByteArrayAsync(fullRemoteUrl).ConfigureAwait(false);
// 写入文件（同样使用ConfigureAwait(false)）
await Task.Run(() => File.WriteAllBytes(localFilePath, fileBytes)).ConfigureAwait(false);
}
}
catch (HttpRequestException httpEx)
{
BLL.ErrLogInfo.WriteLog($"HTTP请求失败 - URL: {webUrl}/{attachFileUrl}", httpEx);
// 不抛出异常，让调用方继续处理
}
catch (DirectoryNotFoundException dirEx)
{
BLL.ErrLogInfo.WriteLog($"目录创建失败 - 路径: {localPath}", dirEx);
}
catch (UnauthorizedAccessException authEx)
{
BLL.ErrLogInfo.WriteLog($"文件访问权限不足 - 路径: {Path.Combine(localPath, attachFileUrl)}", authEx);
}
catch (Exception ex)
{
BLL.ErrLogInfo.WriteLog($"下载文件失败 - URL: {webUrl}/{attachFileUrl}", ex);
// 不重新抛出异常，避免中断整个流程
}
}
// 添加重试机制的下载方法
public static async Task<bool> DownloadAndSaveFileWithRetryAsync(string webUrl, string attachFileUrl,
string localPath, int maxRetries = 3)
{
for (int attempt = 0; attempt < maxRetries; attempt++)
{
try
{
await DownloadAndSaveFileAsync(webUrl, attachFileUrl, localPath);
return true; // 成功下载
}
catch (HttpRequestException)
{
if (attempt == maxRetries - 1)
{
BLL.ErrLogInfo.WriteLog($"下载失败，已重试{maxRetries}次 - URL: {webUrl}/{attachFileUrl}");
return false;
}
// 等待后重试
await Task.Delay(TimeSpan.FromSeconds(Math.Pow(2, attempt)));
}
}
return false;
}
#endregion
}
}
SGGL/BLL/DataShare/HSSE/APICheckSpecialSyncService.cs
+537
View File
@@ -0,0 +1,537 @@
using Newtonsoft.Json.Linq;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Configuration;
using System.IO;
using System.Net.Http;
using System.Threading.Tasks;
using Model;
using Newtonsoft.Json;
using RestSharp;
using System.Net;
namespace BLL
{
public class APICheckSpecialSyncService
{
#region 根据项目、单位获取专项检查列表
public static List<Model.CheckSpecialSyncItem> GetCheckSpecialLitsByprojectIdUnitId(string projectId,
string unitId, string dataId = "")
{
using (Model.SGGLDB db = new Model.SGGLDB(Funs.ConnString))
{
var list = from x in db.Check_CheckSpecial where x.ProjectId == projectId select x;
if (!string.IsNullOrEmpty(unitId))
{
// 通过关联明细表来筛选包含指定单位的主表数据
var specialIdsWithUnit = (from detail in db.Check_CheckSpecialDetail
where detail.UnitId == unitId
select detail.CheckSpecialId).Distinct();
list = list.Where(x => specialIdsWithUnit.Contains(x.CheckSpecialId));
}
if (!string.IsNullOrEmpty(dataId))
{
list = list.Where(x => x.CheckSpecialId == dataId);
}
var dataList = (from x in list
join cis in db.Technique_CheckItemSet on x.CheckItemSetId equals cis.CheckItemSetId into cisTemp
from cis in cisTemp.DefaultIfEmpty()
join att in db.AttachFile on x.CheckSpecialId equals att.ToKeyId into attTemp
from att in attTemp.DefaultIfEmpty()
select new CheckSpecialSyncItem
{
CheckSpecialId = x.CheckSpecialId,
CheckSpecialCode = x.CheckSpecialCode,
ProjectId = x.ProjectId,
CheckPerson = x.CheckPerson,
CheckTime = x.CheckTime,
ScanUrl = x.ScanUrl,
DaySummary = x.DaySummary,
PartInUnits = x.PartInUnits,
PartInPersons = x.PartInPersons,
CheckAreas = x.CheckAreas,
States = x.States,
CompileMan = x.CompileMan,
CheckType = x.CheckType,
PartInPersonIds = x.PartInPersonIds,
PartInPersonNames = x.PartInPersonNames,
CheckItemSetId = x.CheckItemSetId,
CheckItemName = cis.CheckItemName,
AttachFileId1 = att.AttachFileId,
ToKeyId1 = att.ToKeyId,
AttachSource1 = att.AttachSource,
AttachUrl1 = att.AttachUrl,
CheckSpecialDetails = GetCheckSpecialDetailLists(x.CheckSpecialId),
}).ToList();
return dataList;
}
}
//根据专项检查id获取专项检查明细数据
public static List<Model.CheckSpecialDetailSyncItem> GetCheckSpecialDetailLists(string checkSpecialId)
{
var detailLists = (from x in Funs.DB.Check_CheckSpecialDetail
join ht in Funs.DB.HSSE_Hazard_HazardRegisterTypes on x.CheckItem equals ht.RegisterTypesId into htTemp
from ht in htTemp.DefaultIfEmpty()
join uw in Funs.DB.WBS_UnitWork on x.CheckArea equals uw.UnitWorkId into uwTemp
from uw in uwTemp.DefaultIfEmpty()
//join u1 in Funs.DB.Sys_User on x.HSEManage equals u1.UserId into u1Temp
//from u1 in u1Temp.DefaultIfEmpty()
join att in Funs.DB.AttachFile on x.CheckSpecialDetailId equals att.ToKeyId into attTemp
from att in attTemp.DefaultIfEmpty()
where x.CheckSpecialId == checkSpecialId
select new CheckSpecialDetailSyncItem
{
CheckSpecialDetailId = x.CheckSpecialDetailId,
CheckSpecialId = x.CheckSpecialId,
CheckItem = x.CheckItem,
CheckItemName = ht.RegisterTypesName,
CheckItemType = x.CheckItemType,
Unqualified = x.Unqualified,
CheckArea = x.CheckArea,
CheckAreaName = uw.UnitWorkName,
UnitId = x.UnitId,
CompleteStatus = x.CompleteStatus,
LimitedDate = x.LimitedDate,
CompletedDate = x.CompletedDate,
Suggestions = x.Suggestions,
HandleStep = x.HandleStep,
RectifyNoticeId = x.RectifyNoticeId,
CheckContent = x.CheckContent,
WorkArea = x.WorkArea,
DataId = x.DataId,
DataType = x.DataType,
SortIndex = x.SortIndex,
HiddenHazardType = x.HiddenHazardType,
//HSEManage = x.HSEManage,
HSEManage="",
//HSEManageName = u1.UserName,
HSEManageName = "",
RiskLevel = x.HiddenHazardType,
//LimitDate = x.LimitDate,
//AttachUrl = x.AttachUrl,
//HandleWay = x.HandleWay,
//RectifyOpinion = x.RectifyOpinion,
RectifyOpinion = x.HandleStep,
//RectifyDate = x.RectifyDate,
//ReAttachUrl = x.ReAttachUrl,
//State = x.State,
//ProposeUnitId = x.ProposeUnitId,
//SaveHandleMan = x.SaveHandleMan,
AttachFileId1 = att.AttachFileId,
ToKeyId1 = att.ToKeyId,
AttachSource1 = att.AttachSource,
AttachUrl1 = att.AttachUrl,
})
.ToList();
return detailLists;
}
#endregion
#region 拉取项目专项检查数据
public static async Task<string> getCheckSpecialLists(string projectId = "")
{
int code = 0;
string message = "";
try
{
string CollCropCode = string.Empty;
string unitId = string.Empty;
var thisUnit = CommonService.GetIsThisUnit(); //当前单位
if (thisUnit != null)
{
CollCropCode = thisUnit.CollCropCode; //社会统一信用代码
unitId = thisUnit.UnitId;
}
var ProjectList = (from x in Funs.DB.Base_Project
where x.SubjectUnit != null &&
x.SubjectProject != null
select x).ToList();
if (!string.IsNullOrEmpty(projectId))
{
ProjectList = ProjectList.Where(x => x.ProjectId == projectId).ToList();
}
if (ProjectList.Count > 0)
{
foreach (var project in ProjectList)
{
string SubjectUnitId = project.SubjectUnit; //集团的单位id
string SubjectProjectId = project.SubjectProject; //集团的单位id
//获取对应单位的apiurl地址
var Url = BLL.UnitService.getUnitApiUrlByUnitId(SubjectUnitId);
var ApiUrl = "";
var WebUrl = "";
if (!string.IsNullOrEmpty(Url))
{
var urls = Url.Split(',');
ApiUrl = urls[0];
if (urls.Length > 1)
{
WebUrl = urls[1];
}
}
// CollCropCode = "913404001520228377Y"; //三化建 测试使用
// SubjectProjectId = "B409A8D7-48C7-486E-84C7-E3E7B2C0E5B7";//测试使用
string url = "/api/CheckSpecialSync/getCheckSpecialListByProjectIdAndCollCropCode?projectId=" +
SubjectProjectId + "&collCropCode=" + CollCropCode;
string baseurl = ApiUrl + url;
string contenttype = "application/json;charset=unicode";
var strJosn = APIGetHttpService.Http(baseurl, "GET", contenttype, null, null);
if (!string.IsNullOrEmpty(strJosn))
{
JObject obj = JObject.Parse(strJosn);
code = Funs.GetNewIntOrZero(obj["code"].ToString());
message = obj["message"].ToString();
if (code == 1)
{
var getData =
JsonConvert.DeserializeObject<List<CheckSpecialSyncItem>>(obj["data"].ToString());
if (getData.Count() > 0)
{
ProcessCheckSpecialData(getData, project.ProjectId, unitId, WebUrl);
}
message = "获取成功：同步专项检查数" + getData.Count().ToString() + "条";
}
}
}
}
}
catch (Exception ex)
{
message = "获取失败：" + ex.Message;
ErrLogInfo.WriteLog("专项检查获取！", ex);
}
return message;
}
#endregion
#region 推送专项检查数据
public static ReturnData pushCheckSpecialLists(string projectId, string dataId = "")
{
Model.ReturnData responeData = new Model.ReturnData();
responeData.code = 0;
responeData.message = string.Empty;
try
{
var project = Funs.DB.Base_Project.FirstOrDefault(x => x.ProjectId == projectId);
if (project != null)
{
//获取专项检查数据
var items = GetCheckSpecialLitsByprojectIdUnitId(projectId, "", dataId);
//总包地址推送
if (items.Count() > 0)
{
var thisUnit = CommonService.GetIsThisUnit(); //当前单位
var apiurl = "/api/CheckSpecialSync/SaveCheckSpecialSyncData";
//总包单位接口地址
var Url = BLL.UnitService.getUnitApiUrlByUnitId(project.SubjectUnit);
var ApiUrl = "";
var WebUrl = "";
if (!string.IsNullOrEmpty(Url))
{
var urls = Url.Split(',');
ApiUrl = urls[0];
if (urls.Length > 1)
{
WebUrl = urls[1];
}
}
// thisUnit.CollCropCode = "913404001520228377Y";//测试使用
// project.SubjectProject = "B409A8D7-48C7-486E-84C7-E3E7B2C0E5B7";//测试使用
var pushData = new CheckSpecialSyncData
{
CollCropCode = thisUnit.CollCropCode, //分包单位社会统一信用码
ProjectId = project.SubjectProject, //主包项目Id
UnitDomain = Funs.SGGLUrl, //分包单位域名地址【文件存储地址】
Items = items //专项检查数据
};
var pushContent = JsonConvert.SerializeObject(pushData);
string baseurl = ApiUrl + apiurl;
string contenttype = "application/json;charset=unicode";
var returndata = APIGetHttpService.Http(baseurl, "Post", contenttype, null, pushContent);
if (!string.IsNullOrEmpty(returndata))
{
JObject obj = JObject.Parse(returndata);
string code = obj["code"].ToString();
string message = obj["message"].ToString();
responeData.code = int.Parse(code);
responeData.message = message;
}
}
else
{
responeData.code = 0;
responeData.message = "当前没有项目专项检查数据";
}
}
}
catch (Exception ex)
{
responeData.message = "同步到总包单位失败！";
ErrLogInfo.WriteLog("【项目专项检查】同步到总包单位失败！", ex);
}
return responeData;
}
#endregion
#region 接收保存项目专项检查数据
public static async Task<string> SaveCheckSpecialSyncData(Model.CheckSpecialSyncData items)
{
int code = 0;
string message = "";
try
{
if (items.Items.Count > 0 || items.Items.Count > 0)
{
//获取CollCropCode
var CollCropCode = items.CollCropCode;
var ProjectId = items.ProjectId;
var UnitDomain = items.UnitDomain; //分包单位域名地址【文件存储地址】
//根据CollCropCode获取单位id
var unit = Funs.DB.Base_Unit.FirstOrDefault(x => x.CollCropCode == CollCropCode);
if (unit == null)
{
message = "总包单位不存在本单位，请登录总包系统检查维护本单位信息！";
}
else
{
//2、判断主包项目是否存在
var porject = BLL.ProjectService.GetProjectByProjectId(ProjectId);
if (porject == null)
{
message = "总包单位不存在本项目，请检查总包项目关联是否正确！";
}
else
{
ProcessCheckSpecialData(items.Items, ProjectId, unit.UnitId, UnitDomain);
message = "数据推送成功！";
}
}
}
else
{
message = "暂无项目专项检查数据！";
}
}
catch (Exception ex)
{
throw ex;
}
return message;
}
#endregion
#region 处理单项目专项检查数据的新增或更新逻辑
/// <summary>
/// 处理单项目专项检查数据的新增或更新逻辑
/// </summary>
/// <param name="item">专项检查数据项</param>
/// <param name="projectId">项目id</param>
/// <param name="unitId">单位ID</param>
/// <param name="WebUrl">Web地址</param>
private static void ProcessCheckSpecialData(List<Model.CheckSpecialSyncItem> getData, string projectId,
string unitId, string WebUrl)
{
using (Model.SGGLDB db = new Model.SGGLDB(Funs.ConnString))
{
foreach (var item in getData)
{
var model = db.Check_CheckSpecial.FirstOrDefault(e => e.CheckSpecialId == item.CheckSpecialId);
if (model == null)
{
Model.Check_CheckSpecial newModel = new Model.Check_CheckSpecial
{
CheckSpecialId = item.CheckSpecialId,
CheckSpecialCode = item.CheckSpecialCode,
ProjectId = projectId,
CheckPerson = item.CheckPerson,
CheckTime = item.CheckTime,
ScanUrl = item.ScanUrl,
DaySummary = item.DaySummary,
PartInUnits = item.PartInUnits,
PartInPersons = item.PartInPersons,
CheckAreas = item.CheckAreas,
States = item.States,
CompileMan = item.CompileMan,
CheckType = item.CheckType,
PartInPersonIds = item.PartInPersonIds,
PartInPersonNames = item.PartInPersonNames,
CheckItemSetId = APIDataShareSyncService.getCheckItemSetId(item.CheckItemName),
};
db.Check_CheckSpecial.InsertOnSubmit(newModel);
db.SubmitChanges();
}
else
{
model.CheckSpecialId = item.CheckSpecialId;
model.CheckSpecialCode = item.CheckSpecialCode;
model.ProjectId = projectId;
model.CheckPerson = item.CheckPerson;
model.CheckTime = item.CheckTime;
model.ScanUrl = item.ScanUrl;
model.DaySummary = item.DaySummary;
model.PartInUnits = item.PartInUnits;
model.PartInPersons = item.PartInPersons;
model.CheckAreas = item.CheckAreas;
model.States = item.States;
model.CompileMan = item.CompileMan;
model.CheckType = item.CheckType;
model.PartInPersonIds = item.PartInPersonIds;
model.PartInPersonNames = item.PartInPersonNames;
model.CheckItemSetId = APIDataShareSyncService.getCheckItemSetId(item.CheckItemName);
db.SubmitChanges();
}
if (!string.IsNullOrEmpty(item.AttachUrl1)) //主表附件
{
APIDataShareSyncService.OperationAttachFile(WebUrl, item.CheckSpecialId,
BLL.Const.ProjectCheckSpecialMenuId, item.AttachUrl1);
}
//处理专项检查明细数据
ProcessCheckSpecialDetailData(item.CheckSpecialDetails, projectId, unitId, WebUrl);
}
}
}
#endregion
#region 处理单项目专项检查明细数据的新增或更新逻辑
/// <summary>
/// 处理单项目专项检查明细数据的新增或更新逻辑
/// </summary>
/// <param name="item">专项检查数据项</param>
/// <param name="projectId">项目id</param>
/// <param name="unitId">单位ID</param>
/// <param name="WebUrl">Web地址</param>
private static void ProcessCheckSpecialDetailData(List<Model.CheckSpecialDetailSyncItem> getData,
string projectId,
string unitId, string WebUrl)
{
using (Model.SGGLDB db = new Model.SGGLDB(Funs.ConnString))
{
foreach (var item in getData)
{
var model = db.Check_CheckSpecialDetail.FirstOrDefault(e =>
e.CheckSpecialDetailId == item.CheckSpecialDetailId);
if (model == null)
{
Model.Check_CheckSpecialDetail newModel = new Model.Check_CheckSpecialDetail
{
CheckSpecialDetailId = item.CheckSpecialDetailId,
CheckSpecialId = item.CheckSpecialId,
CheckItem = APIDataShareSyncService.getRegisterTypesId(item.CheckItemName),
CheckItemType = item.CheckItemType,
Unqualified = item.Unqualified,
CheckArea = APIDataShareSyncService.getUnitWorkId(item.CheckAreaName, projectId),
UnitId = unitId,
CompleteStatus = item.CompleteStatus,
LimitedDate = item.LimitedDate,
CompletedDate = item.CompletedDate,
Suggestions = item.Suggestions,
HandleStep = item.HandleStep,
RectifyNoticeId = item.RectifyNoticeId,
CheckContent = item.CheckContent,
WorkArea = item.WorkArea,
DataId = item.DataId,
DataType = item.DataType,
SortIndex = item.SortIndex,
HiddenHazardType = item.HiddenHazardType,
//HSEManage = APIDataShareSyncService.getUserId(item.HSEManageName),
//RiskLevel = item.RiskLevel,
//LimitDate = item.LimitDate,
//AttachUrl = item.AttachUrl,
//HandleWay = item.HandleWay,
//RectifyOpinion = item.RectifyOpinion,
//HandleStep= item.RectifyOpinion,
//RectifyDate = item.RectifyDate,
//ReAttachUrl = item.ReAttachUrl,
//State = item.State,
//ProposeUnitId = item.ProposeUnitId,
//SaveHandleMan = item.SaveHandleMan,
};
db.Check_CheckSpecialDetail.InsertOnSubmit(newModel);
db.SubmitChanges();
}
else
{
// model.CheckSpecialDetailId = item.CheckSpecialDetailId;
model.CheckSpecialId = item.CheckSpecialId;
model.CheckItem = APIDataShareSyncService.getRegisterTypesId(item.CheckItemName);
model.CheckItemType = item.CheckItemType;
model.Unqualified = item.Unqualified;
model.CheckArea = APIDataShareSyncService.getUnitWorkId(item.CheckAreaName, projectId);
model.UnitId = unitId;
model.CompleteStatus = item.CompleteStatus;
model.LimitedDate = item.LimitedDate;
model.CompletedDate = item.CompletedDate;
model.Suggestions = item.Suggestions;
model.HandleStep = item.HandleStep;
model.RectifyNoticeId = item.RectifyNoticeId;
model.CheckContent = item.CheckContent;
model.WorkArea = item.WorkArea;
model.DataId = item.DataId;
model.DataType = item.DataType;
model.SortIndex = item.SortIndex;
model.HiddenHazardType = item.HiddenHazardType;
//model.HSEManage = APIDataShareSyncService.getUserId(item.HSEManageName);
//model.RiskLevel = item.RiskLevel;
model.HiddenHazardType = item.RiskLevel;
//model.LimitDate = item.LimitDate;
//model.AttachUrl = item.AttachUrl;
//model.HandleWay = item.HandleWay;
//model.RectifyOpinion = item.RectifyOpinion;
//model.RectifyDate = item.RectifyDate;
//model.ReAttachUrl = item.ReAttachUrl;
//model.State = item.State;
//model.ProposeUnitId = item.ProposeUnitId;
//model.SaveHandleMan = item.SaveHandleMan;
db.SubmitChanges();
}
if (!string.IsNullOrEmpty(item.AttachUrl1)) //整改前图片
{
APIDataShareSyncService.OperationAttachFile(WebUrl, item.CheckSpecialDetailId,
BLL.Const.ProjectCheckSpecialMenuId, item.AttachUrl1);
}
}
}
}
#endregion
}
}
SGGL/BLL/DataShare/HSSE/APIHazardRegisterSyncService.cs
+468
View File
@@ -0,0 +1,468 @@
using Newtonsoft.Json.Linq;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Configuration;
using System.IO;
using System.Net.Http;
using System.Threading.Tasks;
using Model;
using Newtonsoft.Json;
using RestSharp;
using System.Net;
namespace BLL
{
public class APIHazardRegisterSyncService
{
#region 根据项目、单位获取安全检查列表分页
public static List<Model.HazardRegisterSyncItem> GetHazardRegisterLitsByprojectIdUnitIdPage(string projectId,
string unitId, string dataId = "")
{
using (Model.SGGLDB db = new Model.SGGLDB(Funs.ConnString))
{
var list = from x in db.HSSE_Hazard_HazardRegister where x.ProjectId == projectId select x;
if (!string.IsNullOrEmpty(unitId))
{
list = list.Where(x => x.ResponsibleUnit == unitId);
}
if (!string.IsNullOrEmpty(dataId))
{
list = list.Where(x => x.HazardRegisterId == dataId);
}
var dataList = (from x in list
join ht in db.HSSE_Hazard_HazardRegisterTypes on x.RegisterTypesId equals ht.RegisterTypesId into htTemp
from ht in htTemp.DefaultIfEmpty()
join uw in db.WBS_UnitWork on x.Place equals uw.UnitWorkId into uwTemp
from uw in uwTemp.DefaultIfEmpty()
join u1 in db.Person_Persons on x.ResponsibleMan equals u1.PersonId into u1Temp
from u1 in u1Temp.DefaultIfEmpty()
join u2 in db.Person_Persons on x.CheckManId equals u2.PersonId into u2Temp
from u2 in u2Temp.DefaultIfEmpty()
join u3 in db.Person_Persons on x.ConfirmMan equals u3.PersonId into u3Temp
from u3 in u3Temp.DefaultIfEmpty()
join u4 in db.Person_Persons on x.ResponsibleMan2 equals u4.PersonId into u4Temp
from u4 in u4Temp.DefaultIfEmpty()
select new HazardRegisterSyncItem
{
HazardRegisterId = x.HazardRegisterId,
HazardCode = x.HazardCode,
RegisterDate = x.RegisterDate,
RegisterDef = x.RegisterDef,
Rectification = x.Rectification,
Place = x.Place,
PlaceName = uw.UnitWorkName,
ResponsibleUnit = x.ResponsibleUnit,
Observer = x.Observer,
RectifiedDate = x.RectifiedDate,
AttachUrl = x.AttachUrl,
ProjectId = x.ProjectId,
States = x.States,
IsEffective = x.IsEffective,
ResponsibleMan = x.ResponsibleMan,
ResponsibleManName = u1.PersonName,
CheckManId = x.CheckManId,
CheckManName = u2.PersonName,
CheckTime = x.CheckTime,
RectificationPeriod = x.RectificationPeriod,
ImageUrl = x.ImageUrl,
RectificationImageUrl = x.RectificationImageUrl,
RectificationTime = x.RectificationTime,
ConfirmMan = x.ConfirmMan,
ConfirmManName = u3.PersonName,
ConfirmDate = x.ConfirmDate,
HandleIdea = x.HandleIdea,
CutPayment = x.CutPayment,
ProblemTypes = x.ProblemTypes,
RegisterTypesId = x.RegisterTypesId,
RegisterTypesName = ht.RegisterTypesName,
CheckCycle = x.CheckCycle,
CheckItemDetailId = x.CheckItemDetailId,
SupCheckItemSetId = x.SupCheckItemSetId,
CheckItemSetId = x.CheckItemSetId,
CheckSpecialId = x.CheckSpecialId,
InstallationId = x.InstallationId,
SafeSupervisionId = x.SafeSupervisionId,
ResponsibleMan2 = x.ResponsibleMan2,
ResponsibleMan2Name = u4.PersonName,
SafeSupervisionIsOK = x.SafeSupervisionIsOK,
GpsLocation = x.GpsLocation,
IsWx = x.IsWx,
DIC_ID = x.DIC_ID,
CCManIds = x.CCManIds,
ResultType = x.ResultType,
ResultId = x.ResultId,
Requirements = x.Requirements,
Risk_Level = x.HazardValue,
ControlId = x.ControlId,
DataSource = "1",
}).ToList();
return dataList;
}
}
#endregion
#region 拉取项目安全检查数据
public static string getHazardRegisterLists(string projectId = "")
{
int code = 0;
string message = "";
try
{
string CollCropCode = string.Empty;
string unitId = string.Empty;
var thisUnit = CommonService.GetIsThisUnit(); //当前单位
if (thisUnit != null)
{
CollCropCode = thisUnit.CollCropCode; //社会统一信用代码
unitId = thisUnit.UnitId;
}
var ProjectList = (from x in Funs.DB.Base_Project
where x.SubjectUnit != null &&
x.SubjectProject != null
select x).ToList();
if (!string.IsNullOrEmpty(projectId))
{
ProjectList = ProjectList.Where(x => x.ProjectId == projectId).ToList();
}
if (ProjectList.Count > 0)
{
foreach (var project in ProjectList)
{
string SubjectUnitId = project.SubjectUnit; //集团的单位id
string SubjectProjectId = project.SubjectProject; //集团的项目id
//获取对应单位的apiurl地址
var Url = BLL.UnitService.getUnitApiUrlByUnitId(SubjectUnitId);
var ApiUrl = "";
var WebUrl = "";
if (!string.IsNullOrEmpty(Url))
{
var urls = Url.Split(',');
ApiUrl = urls[0];
if (urls.Length > 1)
{
WebUrl = urls[1];
}
}
// CollCropCode = "91420000177570439L"; //三化建 测试使用
// SubjectProjectId = "c7ade79e-7646-4c59-a8fd-020a7e3138c6";//测试使用
string url =
"/api/HazardRegisterSync/getHazardRegisterListByProjectIdAndCollCropCode?projectId=" +
SubjectProjectId + "&collCropCode=" + CollCropCode;
string baseurl = ApiUrl + url;
string contenttype = "application/json;charset=unicode";
var strJosn = APIGetHttpService.Http(baseurl, "GET", contenttype, null, null);
if (!string.IsNullOrEmpty(strJosn))
{
JObject obj = JObject.Parse(strJosn);
code = Funs.GetNewIntOrZero(obj["code"].ToString());
message = obj["message"].ToString();
if (code == 1)
{
var getData =
JsonConvert.DeserializeObject<List<HazardRegisterSyncItem>>(obj["data"].ToString());
if (getData.Count() > 0)
{
ProcessHazardRegisterData(getData, project.ProjectId, unitId, WebUrl, "pull");
}
message = "获取成功：同步安全检查数" + getData.Count().ToString() + "条";
}
}
}
}
}
catch (Exception ex)
{
message = "获取失败：" + ex.Message;
ErrLogInfo.WriteLog("安全检查获取！", ex);
}
return message;
}
#endregion
#region 推送安全检查数据
public static ReturnData pushHazardRegisterLists(string projectId, string dataId = "")
{
Model.ReturnData responeData = new Model.ReturnData();
responeData.code = 0;
responeData.message = string.Empty;
var project = Funs.DB.Base_Project.FirstOrDefault(x => x.ProjectId == projectId);
try
{
if (project != null)
{
//获取安全检查数据
var items = GetHazardRegisterLitsByprojectIdUnitIdPage(projectId, "", dataId);
//总包地址推送
if (items.Count() > 0)
{
var thisUnit = CommonService.GetIsThisUnit(); //当前单位
var apiurl = "/api/HazardRegisterSync/SaveHazardRegisterSyncData";
//总包单位接口地址
var Url = BLL.UnitService.getUnitApiUrlByUnitId(project.SubjectUnit);
var ApiUrl = "";
var WebUrl = "";
if (!string.IsNullOrEmpty(Url))
{
var urls = Url.Split(',');
ApiUrl = urls[0];
if (urls.Length > 1)
{
WebUrl = urls[1];
}
}
// thisUnit.CollCropCode = "913404001520228377Y";//测试使用
// project.SubjectProject = "B409A8D7-48C7-486E-84C7-E3E7B2C0E5B7";//测试使用
var pushData = new HazardRegisterSyncData
{
CollCropCode = thisUnit.CollCropCode, //分包单位社会统一信用码
// CollCropCode = "91420000177570439L", //分包单位社会统一信用码
// ProjectId = "c7ade79e-7646-4c59-a8fd-020a7e3138c6", //主包项目Id
ProjectId = project.SubjectProject, //主包项目Id
UnitDomain = Funs.SGGLUrl, //分包单位域名地址【文件存储地址】
Items = items //安全检查数据
};
var pushContent = JsonConvert.SerializeObject(pushData);
string baseurl = ApiUrl + apiurl;
string contenttype = "application/json;charset=unicode";
var returndata = APIGetHttpService.Http(baseurl, "Post", contenttype, null, pushContent);
if (!string.IsNullOrEmpty(returndata))
{
JObject obj = JObject.Parse(returndata);
string code = obj["code"].ToString();
string message = obj["message"].ToString();
responeData.code = int.Parse(code);
responeData.message = message;
}
}
else
{
responeData.code = 0;
responeData.message = "当前没有项目安全检查数据";
}
}
}
catch (Exception ex)
{
responeData.message = "同步到总包单位失败！";
ErrLogInfo.WriteLog("【安全检查】同步到总包单位失败！", ex);
}
return responeData;
}
#endregion
#region 接收保存项目安全检查数据
public static string SaveHazardRegisterSyncData(Model.HazardRegisterSyncData items)
{
int code = 0;
string message = "";
try
{
if (items.Items.Count > 0 || items.Items.Count > 0)
{
var CollCropCode = items.CollCropCode; //分包单位社会统一信用码
var ProjectId = items.ProjectId; //总包项目Id
var UnitDomain = items.UnitDomain; //分包单位域名地址【文件存储地址】
var unit = Funs.DB.Base_Unit.FirstOrDefault(x => x.CollCropCode == CollCropCode); //根据CollCropCode获取单位id
if (unit == null)
{
message = "总包单位不存在本单位，请登录总包系统检查维护本单位信息！";
}
else
{
//2、判断主包项目是否存在
var porject = BLL.ProjectService.GetProjectByProjectId(ProjectId);
if (porject == null)
{
message = "总包单位不存在本项目，请检查总包项目关联是否正确！";
}
else
{
ProcessHazardRegisterData(items.Items, ProjectId, unit.UnitId, UnitDomain, "push");
message = "数据推送成功！";
}
}
}
else
{
message = "暂无项目安全检查数据！";
}
}
catch (Exception ex)
{
throw ex;
}
return message;
}
#endregion
#region 处理单个安全检查数据的新增或更新逻辑
/// <summary>
/// 处理单个安全检查数据的新增或更新逻辑
/// </summary>
/// <param name="item">安全检查数据项</param>
/// <param name="projectId">项目id</param>
/// <param name="unitId">单位ID</param>
/// <param name="WebUrl">Web地址</param>
private static void ProcessHazardRegisterData(List<Model.HazardRegisterSyncItem> getData, string projectId,
string unitId, string WebUrl, string type)
{
using (Model.SGGLDB db = new Model.SGGLDB(Funs.ConnString))
{
foreach (var item in getData)
{
Model.HSSE_Hazard_HazardRegister model =
db.HSSE_Hazard_HazardRegister.FirstOrDefault(x => x.HazardRegisterId == item.HazardRegisterId);
if (model == null)
{
Model.HSSE_Hazard_HazardRegister newModel = new Model.HSSE_Hazard_HazardRegister
{
HazardRegisterId = item.HazardRegisterId,
HazardCode = item.HazardCode,
RegisterDate = item.RegisterDate,
RegisterDef = item.RegisterDef,
Rectification = item.Rectification,
Place = APIDataShareSyncService.getUnitWorkId(item.PlaceName, projectId),
ResponsibleUnit = unitId,
Observer = item.Observer,
AttachUrl = item.AttachUrl,
ProjectId = projectId,
States = item.States,
IsEffective = item.IsEffective,
ResponsibleMan = APIDataShareSyncService.getUserId(item.ResponsibleManName),
CheckManId = APIDataShareSyncService.getUserId(item.CheckManName),
CheckTime = item.CheckTime,
RectificationPeriod = item.RectificationPeriod,
ImageUrl = item.ImageUrl,
RectificationImageUrl = item.RectificationImageUrl,
RectificationTime = item.RectificationTime,
ConfirmMan = APIDataShareSyncService.getUserId(item.ConfirmManName),
ConfirmDate = item.ConfirmDate,
HandleIdea = item.HandleIdea,
CutPayment = item.CutPayment,
ProblemTypes = item.ProblemTypes,
RegisterTypesId = APIDataShareSyncService.getRegisterTypesId(item.RegisterTypesName),
CheckCycle = item.CheckCycle,
CheckItemDetailId = item.CheckItemDetailId,
SupCheckItemSetId = item.SupCheckItemSetId,
CheckItemSetId = item.CheckItemSetId,
CheckSpecialId = item.CheckSpecialId,
InstallationId = item.InstallationId,
SafeSupervisionId = item.SafeSupervisionId,
ResponsibleMan2 = APIDataShareSyncService.getUserId(item.ResponsibleMan2Name),
SafeSupervisionIsOK = item.SafeSupervisionIsOK,
GpsLocation = item.GpsLocation,
IsWx = item.IsWx,
DIC_ID = item.DIC_ID,
CCManIds = item.CCManIds,
ResultType = item.ResultType,
ResultId = item.ResultId,
Requirements = item.Requirements,
HazardValue = item.Risk_Level,
ControlId = item.ControlId,
};
if (type == "pull")
{
newModel.DataSource = item.DataSource;
}
db.HSSE_Hazard_HazardRegister.InsertOnSubmit(newModel);
db.SubmitChanges();
}
else
{
// model.HazardRegisterId = item.HazardRegisterId;
model.HazardCode = item.HazardCode;
model.RegisterDate = item.RegisterDate;
model.RegisterDef = item.RegisterDef;
model.Rectification = item.Rectification;
model.Place = APIDataShareSyncService.getUnitWorkId(item.PlaceName, projectId);
model.ResponsibleUnit = unitId;
model.Observer = item.Observer;
model.AttachUrl = item.AttachUrl;
model.ProjectId = projectId;
model.States = item.States;
model.IsEffective = item.IsEffective;
model.ResponsibleMan = APIDataShareSyncService.getUserId(item.ResponsibleManName);
model.CheckManId = APIDataShareSyncService.getUserId(item.CheckManName);
model.CheckTime = item.CheckTime;
model.RectificationPeriod = item.RectificationPeriod;
model.ImageUrl = item.ImageUrl;
model.RectificationImageUrl = item.RectificationImageUrl;
model.RectificationTime = item.RectificationTime;
model.ConfirmMan = APIDataShareSyncService.getUserId(item.ConfirmManName);
model.ConfirmDate = item.ConfirmDate;
model.HandleIdea = item.HandleIdea;
model.CutPayment = item.CutPayment;
model.ProblemTypes = item.ProblemTypes;
model.RegisterTypesId = APIDataShareSyncService.getRegisterTypesId(item.RegisterTypesName);
model.CheckCycle = item.CheckCycle;
model.CheckItemDetailId = item.CheckItemDetailId;
model.SupCheckItemSetId = item.SupCheckItemSetId;
model.CheckItemSetId = item.CheckItemSetId;
model.CheckSpecialId = item.CheckSpecialId;
model.InstallationId = item.InstallationId;
model.SafeSupervisionId = item.SafeSupervisionId;
model.ResponsibleMan2 = APIDataShareSyncService.getUserId(item.ResponsibleMan2Name);
model.SafeSupervisionIsOK = item.SafeSupervisionIsOK;
model.GpsLocation = item.GpsLocation;
model.IsWx = item.IsWx;
model.DIC_ID = item.DIC_ID;
model.CCManIds = item.CCManIds;
model.ResultType = item.ResultType;
model.ResultId = item.ResultId;
model.Requirements = item.Requirements;
model.HazardValue = item.Risk_Level;
model.ControlId = item.ControlId;
if (type == "pull")
{
model.DataSource = item.DataSource;
}
db.SubmitChanges();
}
if (!string.IsNullOrEmpty(item.ImageUrl))
{
APIDataShareSyncService.OperationAttachFile(WebUrl, item.HazardRegisterId,
BLL.Const.HSSE_HiddenRectificationListMenuId, item.ImageUrl);
}
if (!string.IsNullOrEmpty(item.RectificationImageUrl))
{
APIDataShareSyncService.OperationAttachFile(WebUrl, item.HazardRegisterId + "-R",
BLL.Const.HSSE_HiddenRectificationListMenuId, item.RectificationImageUrl);
}
}
}
}
#endregion
}
}
SGGL/BLL/DataShare/HSSE/APILicenseSyncService.cs
+265
View File
@@ -0,0 +1,265 @@
using Model;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System;
using System.Collections;
using System.Linq;
using System.Runtime.InteropServices.ComTypes;
namespace BLL
{
/// <summary>
/// 作业票数据共享互通
/// </summary>
public class APILicenseSyncService
{
#region 分包单位推送数据到总包单位
/// <summary>
/// 推送分包作业票定稿数据
/// </summary>
/// <param name="projectId">项目Id</param>
/// <param name="dataId">作业票定稿数据Id（为空的时候推送全部）</param>
/// <returns></returns>
public static ReturnData PushLicenseManagerLists(string projectId, string dataId = "")
{
Model.ReturnData responeData = new Model.ReturnData();
responeData.code = 0;
responeData.message = string.Empty;
using (Model.SGGLDB db = new Model.SGGLDB(Funs.ConnString))
{
try
{
var list = from x in db.View_License_LicenseManager where x.ProjectId == projectId select x;
if (!string.IsNullOrWhiteSpace(dataId))
{
list = list.Where(x => x.LicenseManagerId == dataId);
}
var dataList = (from x in list
join blt in db.Base_LicenseType on x.LicenseTypeId equals blt.LicenseTypeId into bltGroup
from blt in bltGroup.DefaultIfEmpty()
join su in db.Person_Persons on x.CompileMan equals su.PersonId into sUser
from su in sUser.DefaultIfEmpty()
//join uw in db.WBS_UnitWork on x.WorkAreaId equals uw.UnitWorkId into uwGroup
//from uw in uwGroup.DefaultIfEmpty()
join att in db.AttachFile on x.LicenseManagerId equals att.ToKeyId into attTemp
from att in attTemp.DefaultIfEmpty()
join att1 in db.AttachFile on (x.LicenseManagerId + "_GB") equals att1.ToKeyId into att1Temp
from att1 in att1Temp.DefaultIfEmpty()
orderby x.CompileDate descending
select new LicenseManagerItem
{
ProjectId = x.ProjectId,
UnitId = x.UnitId,
LicenseManagerId = x.LicenseManagerId,
LicenseManagerCode = x.LicenseManagerCode,
LicenseManageName = x.LicenseManageName,
LicenseTypeId = x.LicenseTypeId,
LicenseTypeCode = blt.LicenseTypeCode,
LicenseTypeName = blt.LicenseTypeName,
LicenseManageContents = x.LicenseManageContents,
CompileMan = x.CompileMan,
CompileManName = su.PersonName,
CompileDate = x.CompileDate,
States = x.States,
WorkAreaId = x.WorkAreaId,
//UnitWorkCode = uw.UnitWorkCode,
//UnitWorkName = uw.UnitWorkName,
UnitWorkName = x.WorkAreaName,
StartDate = x.StartDate,
EndDate = x.EndDate,
ApplicantMan = x.ApplicantMan,
WorkStates = x.WorkStates,
IsHighRisk = x.IsHighRisk,
LicenseCodes = x.LicenseCodes,
SourceDes = x.SourceDes,
//AttachUrl = AttachFileService.getFileUrl(x.LicenseManagerId),//附件
//AttachUrl1 = AttachFileService.getFileUrl(x.LicenseManagerId + "_GB"),//关闭附件
AttachFileId = att.AttachFileId,
ToKeyId = att.ToKeyId,
AttachSource = att.AttachSource,
AttachUrl = att.AttachUrl,
AttachFileId1 = att1.AttachFileId,
ToKeyId1 = att1.ToKeyId,
AttachSource1 = att1.AttachSource,
AttachUrl1 = att1.AttachUrl,
}).ToList();
if (dataList.Count() > 0)
{
var thisUnit = CommonService.GetIsThisUnit();
var porject = BLL.ProjectService.GetProjectByProjectId(projectId);
var pushData = new LicenseManagerData
{
CollCropCode = thisUnit.CollCropCode,//分包单位社会统一信用码
UnitId = thisUnit.UnitId,//分包单位Id
UnitName = thisUnit.UnitName,//分包单位名称
ShortUnitName = thisUnit.ShortUnitName,//分包单位简称
UnitDomain = Funs.SGGLUrl,//分包单位域名地址【文件存储地址】
SubjectUnit = porject.SubjectUnit,//主包单位Id
SubjectProject = porject.SubjectProject,//主包项目Id
Items = dataList//数据
};
var pushContent = JsonConvert.SerializeObject(pushData);
//获取总包单位接口apiurl地址
var Url = BLL.UnitService.getUnitApiUrlByUnitId(porject.SubjectUnit);
var ApiUrl = string.Empty;
var WebUrl = string.Empty;
if (Url != null)
{
var urls = Url.Split(',');
ApiUrl = urls[0];
if (urls.Length > 1)
{
WebUrl = urls[1];
}
}
var baseurl = $"{ApiUrl}/api/LicenseSync/ReceiveSaveProjectLicenseManagerData";
string contenttype = "application/json;charset=unicode";
//Hashtable newToken = new Hashtable
//{
// { "token", ServerService.GetToken().Token }
//};
//ErrLogInfo.WriteLog($"【班前会推送数据】接口地址：{baseurl}；{pushContent}");
var returndata = APIGetHttpService.Http(baseurl, "Post", contenttype, null, pushContent);
if (!string.IsNullOrEmpty(returndata))
{
ErrLogInfo.WriteLog($"【作业票返回结果】接口地址：{baseurl}；{returndata}");
JObject obj = JObject.Parse(returndata);
string mess = obj["message"].ToString();
string code = obj["code"].ToString();
}
}
else
{
responeData.message = "当前项目没有作业票定稿数据";
}
}
catch (Exception ex)
{
responeData.message = "同步到总包单位失败！";
ErrLogInfo.WriteLog("【作业票定稿】同步到总包单位失败！", ex);
}
}
return responeData;
}
#endregion
#region 总包单位接收分包单位推送数据
/// <summary>
/// 总包单位接收保存分包单位推送的作业票定稿数据
/// </summary>
/// <param name="data"></param>
/// <returns></returns>
public static string ReceiveSaveProjectLicenseManagerData(LicenseManagerData data)
{
using (Model.SGGLDB db = new Model.SGGLDB(Funs.ConnString))
{
string result = string.Empty;
if (data.Items.Count() > 0)
{
//var jsonData = JsonConvert.SerializeObject(data);
//ErrLogInfo.WriteLog($"【作业票定稿接收数据】{jsonData}");
//1、判断分包单位是否存在
var unit = UnitService.getUnitByCollCropCodeUnitName(data.CollCropCode, data.UnitName);
if (unit == null)
{
result = "总包单位不存在本单位，请登录总包系统检查维护本单位信息！";
}
else
{
//2、判断主包项目是否存在
var porject = BLL.ProjectService.GetProjectByProjectId(data.SubjectProject);
if (porject == null)
{
result = "总包单位不存在本项目，请检查总包项目关联是否正确！";
}
else
{
int succ = 0;
//3、保存数据
foreach (var item in data.Items)
{
try
{
var model = db.License_LicenseManager.FirstOrDefault(e => e.LicenseManagerId == item.LicenseManagerId);
if (model != null)
{//编辑
model.ProjectId = data.SubjectProject;
model.UnitId = unit.UnitId;
model.LicenseManagerCode = item.LicenseManagerCode;
model.LicenseManageName = item.LicenseManageName;
//model.LicenseTypeId = item.LicenseTypeId;
model.LicenseTypeId = APIDataShareSyncService.GetLicenseTypeId(item.LicenseTypeId, item.LicenseTypeCode, item.LicenseTypeName);
//model.LicenseManageContents = HttpUtility.HtmlEncode(item.LicenseManageContents);
model.LicenseManageContents = item.LicenseManageContents;
model.States = item.States;
model.StartDate = item.StartDate;
model.EndDate = item.EndDate;
model.ApplicantMan = item.ApplicantMan;
model.IsHighRisk = item.IsHighRisk;
model.WorkStates = item.WorkStates;
model.SourceDes = $"{(!string.IsNullOrWhiteSpace(data.ShortUnitName) ? data.ShortUnitName : data.UnitName)}#{item.CompileManName}#单位工程：{item.UnitWorkName}";
model.CompileDate = item.CompileDate;
//model.CompileMan = item.CompileMan;
db.SubmitChanges();
}
else
{//新增
Model.License_LicenseManager newModel = new Model.License_LicenseManager();
newModel.LicenseManagerId = item.LicenseManagerId;
newModel.ProjectId = data.SubjectProject;
newModel.UnitId = unit.UnitId;
newModel.LicenseManagerCode = item.LicenseManagerCode;
newModel.LicenseManageName = item.LicenseManageName;
//newModel.LicenseTypeId = item.LicenseTypeId;
newModel.LicenseTypeId = APIDataShareSyncService.GetLicenseTypeId(item.LicenseTypeId, item.LicenseTypeCode, item.LicenseTypeName);
//newModel.LicenseManageContents = HttpUtility.HtmlEncode(item.LicenseManageContents);
newModel.LicenseManageContents = item.LicenseManageContents;
newModel.States = item.States;
newModel.StartDate = item.StartDate;
newModel.EndDate = item.EndDate;
newModel.ApplicantMan = item.ApplicantMan;
newModel.IsHighRisk = item.IsHighRisk;
newModel.WorkStates = item.WorkStates;
newModel.SourceDes = $"{(!string.IsNullOrWhiteSpace(data.ShortUnitName) ? data.ShortUnitName : data.UnitName)}#{item.CompileManName}#单位工程：{item.UnitWorkName}";
newModel.CompileDate = item.CompileDate;
//newModel.CompileMan = item.CompileMan;
db.License_LicenseManager.InsertOnSubmit(newModel);
db.SubmitChanges();
}
succ++;
//ErrLogInfo.WriteLog($"【作业票定稿接收数据——内容附件】UnitDomain：{data.UnitDomain}；AttachFileId：{item.AttachFileId}；ToKeyId：{item.ToKeyId}；AttachSource：{item.AttachSource}；AttachUrl：{item.AttachUrl}");
//附件处理：附件
BLL.FileInsertService.SaveAttachFileRecords(data.UnitDomain, item.AttachFileId, item.ToKeyId, item.AttachSource, item.AttachUrl);
//附件处理：关闭附件
BLL.FileInsertService.SaveAttachFileRecords(data.UnitDomain, item.AttachFileId1, item.ToKeyId1, item.AttachSource1, item.AttachUrl1);
}
catch (Exception ex)
{
BLL.ErrLogInfo.WriteLog($"【{porject.ProjectName}】作业票定稿数据推送总包失败", ex.Message);
continue;
}
}
result = $"推送成功：总数{data.Items.Count()}条，成功{succ}条";
}
}
}
else
{
result = "推送数据对象为空！";
}
return result;
}
}
#endregion
}
}
SGGL/BLL/DataShare/HSSE/APIMeetingSyncService.cs
+277
View File
@@ -0,0 +1,277 @@
using Model;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System;
using System.Collections;
using System.Linq;
namespace BLL
{
/// <summary>
/// 安全会议数据共享互通
/// </summary>
public class APIMeetingSyncService
{
#region 分包单位推送数据到总包单位
/// <summary>
/// 推送分包班前会数据
/// </summary>
/// <param name="projectId">项目Id</param>
/// <param name="dataId">班前会数据Id（为空的时候推送全部）</param>
/// <returns></returns>
public static ReturnData PushClassMeetingLists(string projectId, string dataId = "")
{
Model.ReturnData responeData = new Model.ReturnData();
responeData.code = 0;
responeData.message = string.Empty;
using (Model.SGGLDB db = new Model.SGGLDB(Funs.ConnString))
{
try
{
var list = from x in db.Meeting_ClassMeeting where x.ProjectId == projectId select x;
if (!string.IsNullOrWhiteSpace(dataId))
{
list = list.Where(x => x.ClassMeetingId == dataId);
}
var dataList = (from x in list
join ptg in db.ProjectData_TeamGroup on x.TeamGroupId equals ptg.TeamGroupId into ptGroup
from ptg in ptGroup.DefaultIfEmpty()
join su in db.Person_Persons on x.CompileMan equals su.PersonId into sUser
from su in sUser.DefaultIfEmpty()
join att in db.AttachFile on x.ClassMeetingId equals att.ToKeyId into attTemp
from att in attTemp.DefaultIfEmpty()
join att1 in db.AttachFile on (x.ClassMeetingId + "#1") equals att1.ToKeyId into att1Temp
from att1 in att1Temp.DefaultIfEmpty()
join att2 in db.AttachFile on (x.ClassMeetingId + "#2") equals att2.ToKeyId into att2Temp
from att2 in att2Temp.DefaultIfEmpty()
orderby x.CompileDate descending
select new ClassMeetingItem
{
ProjectId = x.ProjectId,
UnitId = x.UnitId,
ClassMeetingId = x.ClassMeetingId,
ClassMeetingCode = x.ClassMeetingCode,
ClassMeetingName = x.ClassMeetingName,
ClassMeetingDate = x.ClassMeetingDate,
ClassMeetingContents = x.ClassMeetingContents,
CompileMan = x.CompileMan,
CompileManName = su.PersonName,
TeamGroupId = x.TeamGroupId,
TeamGroupName = ptg.TeamGroupName,
CompileDate = x.CompileDate,
States = x.States,
MeetingPlace = x.MeetingPlace,
MeetingHours = x.MeetingHours,
MeetingHostMan = x.MeetingHostMan,
AttentPerson = x.AttentPerson,
AttentPersonNum = x.AttentPersonNum,
//MeetingHostManOther = x.MeetingHostManOther,
MeetingHostManOther = string.Empty,
Remark = x.Remark,
//AttachUrl = AttachFileService.getFileUrl(x.ClassMeetingId),//内容
//AttachUrl1 = AttachFileService.getFileUrl(x.ClassMeetingId + "#1"),//签到表
//AttachUrl2 = AttachFileService.getFileUrl(x.ClassMeetingId + "#2"),//会议过程
AttachFileId = att.AttachFileId,
ToKeyId = att.ToKeyId,
AttachSource = att.AttachSource,
AttachUrl = att.AttachUrl,
AttachFileId1 = att1.AttachFileId,
ToKeyId1 = att1.ToKeyId,
AttachSource1 = att1.AttachSource,
AttachUrl1 = att1.AttachUrl,
AttachFileId2 = att2.AttachFileId,
ToKeyId2 = att2.ToKeyId,
AttachSource2 = att2.AttachSource,
AttachUrl2 = att2.AttachUrl,
}).ToList();
if (dataList.Count() > 0)
{
var thisUnit = CommonService.GetIsThisUnit();
var porject = BLL.ProjectService.GetProjectByProjectId(projectId);
var pushData = new ClassMeetingData
{
CollCropCode = thisUnit.CollCropCode,//分包单位社会统一信用码
UnitId = thisUnit.UnitId,//分包单位Id
UnitName = thisUnit.UnitName,//分包单位名称
ShortUnitName = thisUnit.ShortUnitName,//分包单位简称
UnitDomain = Funs.SGGLUrl,//分包单位域名地址【文件存储地址】
SubjectUnit = porject.SubjectUnit,//主包单位Id
SubjectProject = porject.SubjectProject,//主包项目Id
Items = dataList//会议数据
};
var pushContent = JsonConvert.SerializeObject(pushData);
//获取总包单位接口apiurl地址
var Url = BLL.UnitService.getUnitApiUrlByUnitId(porject.SubjectUnit);
var ApiUrl = string.Empty;
var WebUrl = string.Empty;
if (Url != null)
{
var urls = Url.Split(',');
ApiUrl = urls[0];
if (urls.Length > 1)
{
WebUrl = urls[1];
}
}
var baseurl = $"{ApiUrl}/api/MeetingSync/ReceiveSaveProjectClassMeetingData";
string contenttype = "application/json;charset=unicode";
//Hashtable newToken = new Hashtable
//{
// { "token", ServerService.GetToken().Token }
//};
ErrLogInfo.WriteLog($"【班前会推送数据】接口地址：{baseurl}；{pushContent}");
var returndata = APIGetHttpService.Http(baseurl, "Post", contenttype, null, pushContent);
if (!string.IsNullOrEmpty(returndata))
{
ErrLogInfo.WriteLog($"【班前会返回结果】接口地址：{baseurl}；{returndata}");
JObject obj = JObject.Parse(returndata);
string code = obj["code"].ToString();
string message = obj["message"].ToString();
responeData.code = int.Parse(code);
responeData.message = message;
}
}
else
{
responeData.message = "当前项目没有班前会数据";
}
}
catch (Exception ex)
{
responeData.message = "同步到总包单位失败！";
ErrLogInfo.WriteLog("【班前会】同步到总包单位失败！", ex);
}
}
return responeData;
}
#endregion
#region 总包单位接收分包单位推送数据
/// <summary>
/// 总包单位接收保存分包单位推送的班前会数据
/// </summary>
/// <param name="data"></param>
/// <returns></returns>
public static string ReceiveSaveProjectClassMeetingData(ClassMeetingData data)
{
using (Model.SGGLDB db = new Model.SGGLDB(Funs.ConnString))
{
string result = string.Empty;
if (data.Items.Count() > 0)
{
//1、判断分包单位是否存在
var unit = UnitService.getUnitByCollCropCodeUnitName(data.CollCropCode, data.UnitName);
if (unit == null)
{
result = "总包单位不存在本单位，请登录总包系统检查维护本单位信息！";
}
else
{
//2、判断主包项目是否存在
var porject = BLL.ProjectService.GetProjectByProjectId(data.SubjectProject);
if (porject == null)
{
result = "总包单位不存在本项目，请检查总包项目关联是否正确！";
}
else
{
int succ = 0;
//3、保存数据
foreach (var item in data.Items)
{
try
{
var model = db.Meeting_ClassMeeting.FirstOrDefault(e => e.ClassMeetingId == item.ClassMeetingId);
if (model != null)
{//编辑
model.ProjectId = data.SubjectProject;
model.UnitId = unit.UnitId;
model.ClassMeetingCode = item.ClassMeetingCode;
model.ClassMeetingName = item.ClassMeetingName;
model.ClassMeetingDate = item.ClassMeetingDate;
model.AttentPersonNum = item.AttentPersonNum;
//model.TeamGroupId = item.TeamGroupId;
model.TeamGroupId = APIDataShareSyncService.GetTeamGroupId(item.TeamGroupName, data.SubjectProject, unit.UnitId);
model.AttentPersonNum = item.AttentPersonNum;
//model.ClassMeetingContents = HttpUtility.HtmlEncode(item.ClassMeetingContents);
model.ClassMeetingContents = item.ClassMeetingContents;
//model.States = item.States;
model.States = BLL.Const.State_2; ;//分包推送过来的班前会数据默认已完成
model.MeetingPlace = item.MeetingPlace;
model.MeetingHours = item.MeetingHours;
model.MeetingHostMan = item.MeetingHostMan;
model.AttentPerson = item.AttentPerson;
model.AttentPersonNum = item.AttentPersonNum;
//model.MeetingHostManOther = item.MeetingHostManOther;
//model.Remark = item.Remark;
model.Remark = $"{(!string.IsNullOrWhiteSpace(data.ShortUnitName) ? data.ShortUnitName : data.UnitName)}#{item.CompileManName}";
model.CompileDate = item.CompileDate;
model.CompileMan = item.CompileMan;
db.SubmitChanges();
}
else
{//新增
Model.Meeting_ClassMeeting newModel = new Model.Meeting_ClassMeeting();
newModel.ClassMeetingId = item.ClassMeetingId;
newModel.ProjectId = data.SubjectProject;
newModel.UnitId = unit.UnitId;
newModel.ClassMeetingCode = item.ClassMeetingCode;
newModel.ClassMeetingName = item.ClassMeetingName;
newModel.ClassMeetingDate = item.ClassMeetingDate;
newModel.AttentPersonNum = item.AttentPersonNum;
//newModel.TeamGroupId = item.TeamGroupId;
newModel.TeamGroupId = APIDataShareSyncService.GetTeamGroupId(item.TeamGroupName, data.SubjectProject, unit.UnitId);
newModel.AttentPersonNum = item.AttentPersonNum;
//newModel.ClassMeetingContents = HttpUtility.HtmlEncode(item.ClassMeetingContents);
newModel.ClassMeetingContents = item.ClassMeetingContents;
//newModel.States = item.States;
newModel.States = BLL.Const.State_2; ;//分包推送过来的班前会数据默认已完成
newModel.MeetingPlace = item.MeetingPlace;
newModel.MeetingHours = item.MeetingHours;
newModel.MeetingHostMan = item.MeetingHostMan;
newModel.AttentPerson = item.AttentPerson;
newModel.AttentPersonNum = item.AttentPersonNum;
//newModel.MeetingHostManOther = item.MeetingHostManOther;
//newModel.Remark = item.Remark;
newModel.Remark = $"{(!string.IsNullOrWhiteSpace(data.ShortUnitName) ? data.ShortUnitName : data.UnitName)}#{item.CompileManName}";
newModel.CompileDate = item.CompileDate;
newModel.CompileMan = item.CompileMan;
db.Meeting_ClassMeeting.InsertOnSubmit(newModel);
db.SubmitChanges();
}
succ++;
//附件处理：内容附件
BLL.FileInsertService.SaveAttachFileRecords(data.UnitDomain, item.AttachFileId, item.ToKeyId, item.AttachSource, item.AttachUrl);
//附件处理：签到表
BLL.FileInsertService.SaveAttachFileRecords(data.UnitDomain, item.AttachFileId1, item.ToKeyId1, item.AttachSource1, item.AttachUrl1);
//附件处理：会议过程
BLL.FileInsertService.SaveAttachFileRecords(data.UnitDomain, item.AttachFileId2, item.ToKeyId2, item.AttachSource2, item.AttachUrl2);
}
catch (Exception ex)
{
BLL.ErrLogInfo.WriteLog($"【{porject.ProjectName}】班前会数据推送总包失败", ex.Message);
continue;
}
}
result = $"推送成功：总数{data.Items.Count()}条，成功{succ}条";
}
}
}
else
{
result = "推送数据对象为空！";
}
return result;
}
}
#endregion
}
}
SGGL/BLL/DataShare/HSSE/APIPersonSyncService.cs
+575
View File
@@ -0,0 +1,575 @@
using Newtonsoft.Json.Linq;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Configuration;
using System.IO;
using System.Net.Http;
using System.Threading.Tasks;
using Model;
using Newtonsoft.Json;
using RestSharp;
using System.Net;
namespace BLL
{
public class APIPersonSyncService
{
#region 根据项目、单位获取人员列表分页
public static List<Model.PersonSyncItem> GetPersonLitsByProjectIdAndUnitId(string projectId, string unitId,
string dataId = "")
{
using (Model.SGGLDB db = new Model.SGGLDB(Funs.ConnString))
{
var list = from x in db.SitePerson_Person where x.ProjectId == projectId select x;
if (!string.IsNullOrEmpty(unitId))
{
list = list.Where(x => x.UnitId == unitId);
}
if (!string.IsNullOrEmpty(dataId))
{
list = list.Where(x => x.PersonId == dataId);
}
var personList = (from x in list
join wp in db.Base_WorkPost on x.WorkPostId equals wp.WorkPostId into wpTemp
from wp in wpTemp.DefaultIfEmpty()
join tg in db.ProjectData_TeamGroup on x.TeamGroupId equals tg.TeamGroupId into tgTemp
from tg in tgTemp.DefaultIfEmpty()
join c in db.Base_Certificate on x.CertificateId equals c.CertificateId into cTemp
from c in cTemp.DefaultIfEmpty()
join att1 in db.AttachFile on (x.PersonId + "#1") equals att1.ToKeyId into att1Temp
from att1 in att1Temp.DefaultIfEmpty()
join att2 in db.AttachFile on (x.PersonId + "#2") equals att2.ToKeyId into att2Temp
from att2 in att2Temp.DefaultIfEmpty()
join att3 in db.AttachFile on (x.PersonId + "#3") equals att3.ToKeyId into att3Temp
from att3 in att3Temp.DefaultIfEmpty()
join att4 in db.AttachFile on (x.PersonId + "#4") equals att4.ToKeyId into att4Temp
from att4 in att4Temp.DefaultIfEmpty()
join att5 in db.AttachFile on (x.PersonId + "#5") equals att5.ToKeyId into att5Temp
from att5 in att5Temp.DefaultIfEmpty()
select new Model.PersonSyncItem
{
PersonId = x.PersonId,
CardNo = x.CardNo,
PersonName = x.PersonName,
//Sex = x.Sex,
IdentityCard = x.IdentityCard,
//Address = x.Address,
ProjectId = x.ProjectId,
UnitId = x.UnitId,
TeamGroupId = x.TeamGroupId,
WorkAreaId = x.WorkAreaId,
WorkPostId = x.WorkPostId,
InTime = x.InTime,
OutTime = x.OutTime,
OutResult = x.OutResult,
//Telephone = x.Telephone,
// x.PositionId,//职务
// x.PostTitleId,//职称
//PhotoUrl = x.PhotoUrl,
//IsUsed = x.IsUsed,
//IsCardUsed = x.IsCardUsed,
//PersonIndex = x.PersonIndex,
// x.DepartId,//部门
CertificateId = x.CertificateId,
CertificateItem = APIDataShareSyncService.GetPersonQualityByPersonId(x.PersonId), //特岗证书
CertificateCode = x.CertificateCode,
CertificateName = c.CertificateName,
CertificateLimitTime = x.CertificateLimitTime,
//QualificationCertificateUrl = x.QualificationCertificateUrl,
//TrainingCertificateUrl = x.TrainingCertificateUrl,
//QRCodeAttachUrl = x.QRCodeAttachUrl,
//Password = x.Password,
//FromPersonId = x.FromPersonId,
// x.AuditorId,审核人
AuditorDate = x.AuditorDate,
ExchangeTime = x.ExchangeTime,
ExchangeTime2 = x.ExchangeTime2,
//IDCardUrl = x.IDCardUrl,
//IsForeign = x.IsForeign,
//IsOutside = x.IsOutside,
//EduLevel = x.EduLevel,
//MaritalStatus = x.MaritalStatus,
Isprint = x.Isprint,
//MainCNProfessionalId = x.MainCNProfessionalId,
//ViceCNProfessionalId = x.ViceCNProfessionalId,
//Birthday = x.Birthday,
//IdcardType = x.IdcardType,
//IdcardStartDate = x.IdcardStartDate,
//IdcardEndDate = x.IdcardEndDate,
//IdcardForever = x.IdcardForever,
//PoliticsStatus = x.PoliticsStatus,
//IdcardAddress = x.IdcardAddress,
//Nation = x.Nation,
//CountryCode = x.CountryCode,
IsSafetyMonitoring = x.IsSafetyMonitoring,
//ProvinceCode = x.ProvinceCode,
//IsCardNoOK = x.IsCardNoOK,
// AttachUrl1 = AttachFileService.getFileUrl(x.PersonId + "#1"),
// AttachUrl2 = AttachFileService.getFileUrl(x.PersonId + "#2"),
// AttachUrl3 = AttachFileService.getFileUrl(x.PersonId + "#3"),
// AttachUrl4 = AttachFileService.getFileUrl(x.PersonId + "#4"),
// AttachUrl5 = AttachFileService.getFileUrl(x.PersonId + "#5"),
AttachUrl1 = att1.AttachUrl,
AttachUrl2 = att2.AttachUrl,
AttachUrl3 = att3.AttachUrl,
AttachUrl4 = att4.AttachUrl,
AttachUrl5 = att5.AttachUrl,
WorkPostName = wp.WorkPostName, //岗位名称
PostType = wp.PostType, //岗位诶类型
IsHsse = wp.IsHsse, //岗位是否是安管人员
IsCQMS = wp.IsCQMS, //岗位是否是质量管理
TeamGroupName = tg.TeamGroupName,
WorkAreaName = APIDataShareSyncService.GetWorkAreaNames(x.WorkAreaId, projectId)
}).ToList();
return personList;
}
}
#endregion
#region 拉取项目人员数据
public static async Task<string> getPersonLists()
{
int code = 0;
string message = "";
try
{
string CollCropCode = string.Empty;
string unitId = string.Empty;
var thisUnit = CommonService.GetIsThisUnit(); //当前单位
if (thisUnit != null)
{
CollCropCode = thisUnit.CollCropCode; //社会统一信用代码
unitId = thisUnit.UnitId;
}
var ProjectList = (from x in Funs.DB.Base_Project
where x.SubjectUnit != null &&
x.SubjectProject != null
select x).ToList();
if (ProjectList.Count > 0)
{
foreach (var project in ProjectList)
{
string SubjectUnitId = project.SubjectUnit; //集团的单位id
string SubjectProjectId = project.SubjectProject; //集团的单位id
//获取对应单位的apiurl地址
var Url = BLL.UnitService.getUnitApiUrlByUnitId(SubjectUnitId);
var ApiUrl = "";
var WebUrl = "";
if (!string.IsNullOrEmpty(Url))
{
var urls = Url.Split(',');
ApiUrl = urls[0];
if (urls.Length > 1)
{
WebUrl = urls[1];
}
}
// CollCropCode = "913404001520228377Y";//测试使用
// SubjectProjectId = "B409A8D7-48C7-486E-84C7-E3E7B2C0E5B7";//测试使用
// unitId = "aaa9e72b-e3a6-441e-a7bb-afc008adebc9";//测试使用
string url = "/api/PersonSync/getPersonListByProjectIdAndCollCropCode?projectId=" +
SubjectProjectId + "&collCropCode=" + CollCropCode;
string baseurl = ApiUrl + url;
string contenttype = "application/json;charset=unicode";
var strJosn = "";
using (HttpClient client = new HttpClient())
{
client.Timeout = TimeSpan.FromMinutes(5); // 设置超时时间为5分钟
client.DefaultRequestHeaders.Add("token",
"AF17168B-87BD-4GLY-1111-F0A0A1158F9B"); // 前提是所有二级单位都有sysGLY账号且id是AF17168B-87BD-4GLY-1111-F0A0A1158F9B可作为token
strJosn = await client.GetStringAsync(baseurl);
}
// var strJosn = APIGetHttpService.Http(baseurl, "GET", contenttype, null, null);
if (!string.IsNullOrEmpty(strJosn))
{
JObject obj = JObject.Parse(strJosn);
code = Funs.GetNewIntOrZero(obj["code"].ToString());
message = obj["message"].ToString();
if (code == 1)
{
var getData =
JsonConvert.DeserializeObject<List<PersonSyncItem>>(obj["data"].ToString());
if (getData.Count() > 0)
{
ProcessPersonData(getData, project.ProjectId, unitId, WebUrl);
}
message = "获取成功：同步人员数" + getData.Count().ToString() + "条";
}
}
}
}
}
catch (Exception ex)
{
message = "获取失败：" + ex.Message;
ErrLogInfo.WriteLog("人员获取！", ex);
}
return message;
}
#endregion
#region 推送人员数据
public static ReturnData pushPersonLists(string projectId, string dataId)
{
Model.ReturnData responeData = new Model.ReturnData();
responeData.code = 0;
responeData.message = string.Empty;
try
{
var project = Funs.DB.Base_Project.FirstOrDefault(x => x.ProjectId == projectId);
if (project != null)
{
//获取人员数据
var items = GetPersonLitsByProjectIdAndUnitId(projectId, "", dataId);
//总包地址推送
if (items.Count() > 0)
{
var thisUnit = CommonService.GetIsThisUnit(); //当前单位
var apiurl = "/api/PersonSync/SavePersonSyncData";
//总包单位接口地址
var Url = BLL.UnitService.getUnitApiUrlByUnitId(project.SubjectUnit);
var ApiUrl = "";
var WebUrl = "";
if (!string.IsNullOrEmpty(Url))
{
var urls = Url.Split(',');
ApiUrl = urls[0];
if (urls.Length > 1)
{
WebUrl = urls[1];
}
}
// thisUnit.CollCropCode = "913404001520228377Y"; //分包单位社会统一信用码 测试使用
// project.SubjectProject = "B409A8D7-48C7-486E-84C7-E3E7B2C0E5B7";//测试使用
var pushData = new PersonSyncData
{
CollCropCode = thisUnit.CollCropCode, //分包单位社会统一信用码
ProjectId = project.SubjectProject, //主包项目Id
UnitDomain = Funs.SGGLUrl, //分包单位域名地址【文件存储地址】
Items = items //人员数据
};
var pushContent = JsonConvert.SerializeObject(pushData);
string baseurl = ApiUrl + apiurl;
string contenttype = "application/json;charset=unicode";
var returndata = APIGetHttpService.Http(baseurl, "Post", contenttype, null, pushContent);
if (!string.IsNullOrEmpty(returndata))
{
JObject obj = JObject.Parse(returndata);
string code = obj["code"].ToString();
string message = obj["message"].ToString();
responeData.code = int.Parse(code);
responeData.message = message;
}
}
else
{
responeData.code = 0;
responeData.message = "当前没有项目人员数据";
}
}
}
catch (Exception ex)
{
responeData.message = "同步到总包单位失败！";
ErrLogInfo.WriteLog("【项目人员】同步到总包单位失败！", ex);
}
return responeData;
}
#endregion
#region 接收保存项目人员数据
public static async Task<string> SavePersonSyncData(Model.PersonSyncData items)
{
int code = 0;
string message = "";
try
{
if (items.Items.Count > 0)
{
//获取分包单位CollCropCode
var CollCropCode = items.CollCropCode;
var ProjectId = items.ProjectId;
var UnitDomain = items.UnitDomain; //分包单位域名地址【文件存储地址】
//1、判断分包单位是否存在
//根据分包单位CollCropCode获取单位id
var unit = Funs.DB.Base_Unit.FirstOrDefault(x => x.CollCropCode == CollCropCode);
if (unit == null)
{
message = "总包单位不存在本单位，请登录总包系统检查维护本单位信息！";
}
else
{
//2、判断主包项目是否存在
var porject = BLL.ProjectService.GetProjectByProjectId(ProjectId);
if (porject == null)
{
message = "总包单位不存在本项目，请检查总包项目关联是否正确！";
}
else
{
ProcessPersonData(items.Items, ProjectId, unit.UnitId, UnitDomain);
message = "数据推送成功！";
}
}
}
else
{
message = "暂无项目人员数据！";
}
}
catch (Exception ex)
{
throw ex;
}
return message;
}
#endregion
#region 处理单项目人员数据的新增或更新逻辑
/// <summary>
/// 处理单项目人员数据的新增或更新逻辑
/// </summary>
/// <param name="item">人员数据项</param>
/// <param name="projectId">项目id</param>
/// <param name="unitId">单位ID</param>
/// <param name="WebUrl">Web地址</param>
private static async void ProcessPersonData(List<Model.PersonSyncItem> getData, string projectId, string unitId,
string WebUrl)
{
using (Model.SGGLDB db = new Model.SGGLDB(Funs.ConnString))
{
foreach (var item in getData)
{
try
{
string IdentityCard = item.IdentityCard;
var model = db.SitePerson_Person.FirstOrDefault(e => e.IdentityCard == IdentityCard && e.ProjectId == projectId);
if (model == null)
{
Model.SitePerson_Person newModel = new Model.SitePerson_Person
{
PersonId = item.PersonId,
CardNo = item.CardNo,
PersonName = item.PersonName,
//Sex = item.Sex,
IdentityCard = item.IdentityCard,
//Address = item.Address,
ProjectId = projectId,
UnitId = unitId,
TeamGroupId = APIDataShareSyncService.GetTeamGroupId(item.TeamGroupName, projectId, unitId),
WorkAreaId = APIDataShareSyncService.getWorkAreaId(item.WorkAreaName, projectId),
WorkPostId = APIDataShareSyncService.getWorkPostId(item.WorkPostName, item.PostType,
item.IsHsse.ToString(), item.IsCQMS.ToString()),
InTime = item.InTime,
OutTime = item.OutTime,
OutResult = item.OutResult,
//Telephone = item.Telephone,
//PhotoUrl = item.PhotoUrl,
// 异步安全的头像下载
//HeadImage = await SafeDownloadHeadImageAsync(WebUrl, item.PhotoUrl),
//IsUsed = item.IsUsed,
//IsCardUsed = item.IsCardUsed,
//PersonIndex = item.PersonIndex,
CertificateId = item.CertificateId,
CertificateCode = item.CertificateCode,
CertificateLimitTime = item.CertificateLimitTime,
//QualificationCertificateUrl = item.QualificationCertificateUrl,
//TrainingCertificateUrl = item.TrainingCertificateUrl,
//QRCodeAttachUrl = item.QRCodeAttachUrl,
//Password = item.Password,
//FromPersonId = item.FromPersonId,
AuditorDate = item.AuditorDate,
ExchangeTime = item.ExchangeTime,
ExchangeTime2 = item.ExchangeTime2,
//IDCardUrl = item.IDCardUrl,
//IsForeign = item.IsForeign,
//IsOutside = item.IsOutside,
//EduLevel = item.EduLevel,
//MaritalStatus = item.MaritalStatus,
Isprint = item.Isprint,
//MainCNProfessionalId = item.MainCNProfessionalId,
//ViceCNProfessionalId = item.ViceCNProfessionalId,
//Birthday = item.Birthday,
//IdcardType = item.IdcardType,
//IdcardStartDate = item.IdcardStartDate,
//IdcardEndDate = item.IdcardEndDate,
//IdcardForever = item.IdcardForever,
//PoliticsStatus = item.PoliticsStatus,
//IdcardAddress = item.IdcardAddress,
//Nation = item.Nation,
//CountryCode = item.CountryCode,
IsSafetyMonitoring = item.IsSafetyMonitoring,
//ProvinceCode = item.ProvinceCode,
//IsCardNoOK = item.IsCardNoOK
};
db.SitePerson_Person.InsertOnSubmit(newModel);
db.SubmitChanges();
}
else
{
// 更新现有记录
UpdatePersonModel(model, item, projectId, unitId, WebUrl);
db.SubmitChanges();
}
// 异步安全的附件处理
await ProcessPersonAttachmentsAsync(WebUrl, item);
if (item.CertificateItem != null)
{
APIDataShareSyncService.ProcessPersonQualityData(item.CertificateItem, item.PersonId);
}
}
catch (Exception ex)
{
// 记录异常但不中断整个批处理
BLL.ErrLogInfo.WriteLog($"处理人员数据时出错 PersonId: {item?.PersonId}, 错误: {ex.Message}");
continue; // 继续处理下一个记录
}
}
}
}
// 安全的头像下载方法
public static async Task<byte[]> SafeDownloadHeadImageAsync(string webUrl, string photoUrl)
{
try
{
if (string.IsNullOrEmpty(photoUrl))
return null;
return await APIDataShareSyncService.DownloadHeadImageAsync(webUrl, photoUrl);
}
catch (Exception ex)
{
BLL.ErrLogInfo.WriteLog($"下载头像失败: {photoUrl}, 错误: {ex.Message}");
return null;
}
}
// 更新人员模型的辅助方法
private static void UpdatePersonModel(Model.SitePerson_Person model, PersonSyncItem item, string projectId,
string unitId, string webUrl)
{
// model.PersonId = item.PersonId;
model.CardNo = item.CardNo;
model.PersonName = item.PersonName;
//model.Sex = item.Sex;
model.IdentityCard = item.IdentityCard;
//model.Address = item.Address;
model.ProjectId = projectId;
model.UnitId = unitId;
model.TeamGroupId = APIDataShareSyncService.GetTeamGroupId(item.TeamGroupName, projectId, unitId);
model.WorkAreaId = APIDataShareSyncService.getWorkAreaId(item.WorkAreaName, projectId);
model.WorkPostId = APIDataShareSyncService.getWorkPostId(item.WorkPostName, item.PostType,
item.IsHsse.ToString(), item.IsCQMS.ToString());
model.InTime = item.InTime;
model.OutTime = item.OutTime;
model.OutResult = item.OutResult;
//model.Telephone = item.Telephone;
//model.PhotoUrl = item.PhotoUrl;
// 异步操作需要特殊处理
Task.Run(async () =>
{
try
{
//model.HeadImage = await APIDataShareSyncService.DownloadHeadImageAsync(webUrl, item.PhotoUrl);
}
catch (Exception ex)
{
BLL.ErrLogInfo.WriteLog($"更新头像失败: {ex.Message}");
}
});
//model.IsUsed = item.IsUsed;
//model.IsCardUsed = item.IsCardUsed;
//model.PersonIndex = item.PersonIndex;
model.CertificateId = item.CertificateId;
model.CertificateCode = item.CertificateCode;
model.CertificateLimitTime = item.CertificateLimitTime;
//model.QualificationCertificateUrl = item.QualificationCertificateUrl;
//model.TrainingCertificateUrl = item.TrainingCertificateUrl;
//model.QRCodeAttachUrl = item.QRCodeAttachUrl;
//model.Password = item.Password;
//model.FromPersonId = item.FromPersonId;
model.AuditorDate = item.AuditorDate;
model.ExchangeTime = item.ExchangeTime;
model.ExchangeTime2 = item.ExchangeTime2;
//model.IDCardUrl = item.IDCardUrl;
//model.IsForeign = item.IsForeign;
//model.IsOutside = item.IsOutside;
//model.EduLevel = item.EduLevel;
//model.MaritalStatus = item.MaritalStatus;
model.Isprint = item.Isprint;
//model.MainCNProfessionalId = item.MainCNProfessionalId;
//model.ViceCNProfessionalId = item.ViceCNProfessionalId;
//model.Birthday = item.Birthday;
//model.IdcardType = item.IdcardType;
//model.IdcardStartDate = item.IdcardStartDate;
//model.IdcardEndDate = item.IdcardEndDate;
//model.IdcardForever = item.IdcardForever;
//model.PoliticsStatus = item.PoliticsStatus;
//model.IdcardAddress = item.IdcardAddress;
//model.Nation = item.Nation;
//model.CountryCode = item.CountryCode;
model.IsSafetyMonitoring = item.IsSafetyMonitoring;
//model.ProvinceCode = item.ProvinceCode;
//model.IsCardNoOK = item.IsCardNoOK;
}
// 异步安全的附件处理
private static async Task ProcessPersonAttachmentsAsync(string webUrl, PersonSyncItem item)
{
try
{
var attachmentTasks = new List<Task>
{
APIDataShareSyncService.OperationAttachFile(webUrl, item.PersonId + "#1", BLL.Const.PersonListMenuId,
item.AttachUrl1),
APIDataShareSyncService.OperationAttachFile(webUrl, item.PersonId + "#2", BLL.Const.PersonListMenuId,
item.AttachUrl2),
APIDataShareSyncService.OperationAttachFile(webUrl, item.PersonId + "#3", BLL.Const.PersonListMenuId,
item.AttachUrl3),
APIDataShareSyncService.OperationAttachFile(webUrl, item.PersonId + "#4", BLL.Const.PersonListMenuId,
item.AttachUrl4),
APIDataShareSyncService.OperationAttachFile(webUrl, item.PersonId + "#5", BLL.Const.PersonListMenuId,
item.AttachUrl5)
};
await Task.WhenAll(attachmentTasks);
}
catch (Exception ex)
{
BLL.ErrLogInfo.WriteLog($"处理人员附件失败 PersonId: {item.PersonId}, 错误: {ex.Message}");
}
}
#endregion
}
}
SGGL/BLL/HSSE/QualityAudit/PersonQualityService.cs
+10
View File
@@ -200,5 +200,15 @@ namespace BLL
db.SubmitChanges();
}
}
/// <summary>
/// 根据主键获取特殊岗位人员资质
/// </summary>
/// <param name="personQualityId"></param>
/// <returns></returns>
public static Model.QualityAudit_PersonQuality GetPersonQualityByPersonId(string personId)
{
return Funs.DB.QualityAudit_PersonQuality.FirstOrDefault(e => e.PersonId == personId);
}
}
}
SGGL/BLL/HSSE/Solution/TemporaryElectricityService.cs
+72
View File
@@ -0,0 +1,72 @@
using System.Collections.Generic;
using System.Linq;
using System.Web.UI.WebControls;
namespace BLL
{
public class TemporaryElectricityService
{
/// <summary>
/// 获取临时用电方案信息
/// </summary>
/// <param name="UnitWorkId"></param>
/// <returns></returns>
public static Model.Solution_TemporaryElectricity GetTemporaryElectricityByTemporaryElectricityId(string TemporaryElectricityId)
{
return Funs.DB.Solution_TemporaryElectricity.FirstOrDefault(e => e.TemporaryElectricityId == TemporaryElectricityId);
}
/// <summary>
/// 添加临时用电方案信息
/// </summary>
/// <param name="model"></param>
public static void AddTemporaryElectricity(Model.Solution_TemporaryElectricity TemporaryElectricity)
{
Model.SGGLDB db = Funs.DB;
Model.Solution_TemporaryElectricity newTemporaryElectricity = new Model.Solution_TemporaryElectricity();
newTemporaryElectricity.TemporaryElectricityId = TemporaryElectricity.TemporaryElectricityId;
newTemporaryElectricity.ProjectId = TemporaryElectricity.ProjectId;
newTemporaryElectricity.Code = TemporaryElectricity.Code;
newTemporaryElectricity.Name = TemporaryElectricity.Name;
newTemporaryElectricity.Content = TemporaryElectricity.Content;
newTemporaryElectricity.Remark = TemporaryElectricity.Remark;
newTemporaryElectricity.CompileMan = TemporaryElectricity.CompileMan;
newTemporaryElectricity.CompileDate = TemporaryElectricity.CompileDate;
db.Solution_TemporaryElectricity.InsertOnSubmit(newTemporaryElectricity);
db.SubmitChanges();
}
/// <summary>
/// 修改临时用电方案信息
/// </summary>
/// <param name="model"></param>
public static void UpdateTemporaryElectricity(Model.Solution_TemporaryElectricity TemporaryElectricity)
{
Model.SGGLDB db = Funs.DB;
Model.Solution_TemporaryElectricity newTemporaryElectricity = db.Solution_TemporaryElectricity.FirstOrDefault(e => e.TemporaryElectricityId == TemporaryElectricity.TemporaryElectricityId);
if (newTemporaryElectricity != null)
{
newTemporaryElectricity.Code = TemporaryElectricity.Code;
newTemporaryElectricity.Name = TemporaryElectricity.Name;
newTemporaryElectricity.Content = TemporaryElectricity.Content;
newTemporaryElectricity.Remark = TemporaryElectricity.Remark;
newTemporaryElectricity.CompileMan = TemporaryElectricity.CompileMan;
newTemporaryElectricity.CompileDate = TemporaryElectricity.CompileDate;
db.SubmitChanges();
}
}
/// <summary>
/// 根据主键删除临时用电方案信息
/// </summary>
/// <param name="checkerId"></param>
public static void DeleteTemporaryElectricityById(string TemporaryElectricityId)
{
Model.SGGLDB db = Funs.DB;
Model.Solution_TemporaryElectricity TemporaryElectricity = db.Solution_TemporaryElectricity.FirstOrDefault(e => e.TemporaryElectricityId == TemporaryElectricityId);
if (TemporaryElectricity != null)
{
db.Solution_TemporaryElectricity.DeleteOnSubmit(TemporaryElectricity);
db.SubmitChanges();
}
}
}
}
SGGL/BLL/OpenService/FileInsertService.cs
+108 -53
View File
@@ -1,5 +1,6 @@
using System;
using System.Collections.Generic;
using System.Configuration;
using System.IO;
using System.Linq;
using System.Net;
@@ -19,35 +20,45 @@ namespace BLL
{
List<byte[]> bytes = new List<byte[]>();
var strs = attachUrl.Trim().Split(',');
try
{
foreach (var fileUrl in strs)
{
string filepath = $"{fileHost}{fileUrl}";
// 创建WebClient实例
using (WebClient webClient = new WebClient())
string path = ConfigurationManager.AppSettings["localRoot"] + fileUrl;
if (!File.Exists(path))
{
// 下载图片并保存到内存流
using (MemoryStream ms = new MemoryStream(webClient.DownloadData(filepath)))
//BLL.ErrLogInfo.WriteLog($"不存在则新增，附件地址：{path}");
string filepath = $"{fileHost}{fileUrl}";
//BLL.ErrLogInfo.WriteLog($"不存在则新增，责任单位附件地址：{filepath}");
// 创建WebClient实例
using (WebClient webClient = new WebClient())
{
// 将MemoryStream转换为byte数组
byte[] imageBytes = ms.ToArray();
bytes.Add(imageBytes);
//// 使用byte数组（例如，保存到文件或进行其他处理）
//File.WriteAllBytes("localImage.jpg", imageBytes);
// 下载图片并保存到内存流
using (MemoryStream ms = new MemoryStream(webClient.DownloadData(filepath)))
{
// 将MemoryStream转换为byte数组
byte[] imageBytes = ms.ToArray();
bytes.Add(imageBytes);
//// 使用byte数组（例如，保存到文件或进行其他处理）
//File.WriteAllBytes("localImage.jpg", imageBytes);
}
}
}
//else
//{
// BLL.ErrLogInfo.WriteLog($"已存在附件地址：{path}");
//}
}
}
catch (Exception ex)
{
Console.WriteLine("Error: " + ex.Message);
BLL.ErrLogInfo.WriteLog($"服务器图片转换异常：{fileHost}；图片地址：{attachUrl}", ex.Message);
}
return bytes;
}
/// <summary>
/// 获取附件数据流类
/// </summary>
@@ -89,55 +100,38 @@ namespace BLL
/// <returns></returns>
public static void FileMoreInsert(List<byte[]> fileContextList, string attachUrl)
{
if (fileContextList != null && fileContextList.Count() > 0)
if (fileContextList.Count > 0)
{
if (fileContextList.Count > 0)
string[] strs = attachUrl.Trim().Split(',');
int i = 0;
string physicalpath = ConfigurationManager.AppSettings["localRoot"];
foreach (var item in fileContextList)
{
string[] strs = attachUrl.Trim().Split(',');
int i = 0;
foreach (var item in fileContextList)
//HttpContext.Current.Request.PhysicalApplicationPath;
string fullPath = (physicalpath + strs[i]).Replace('/', '\\');
if (!File.Exists(fullPath))
{
if (strs.Count() > i)
byte[] fileContext = item;
int index = fullPath.LastIndexOf("\\");
string filePath = fullPath.Substring(0, index);
if (!Directory.Exists(filePath))
{
string physicalpath = Funs.AttachRootPath;
string fpath = strs[i];
string fullPath = physicalpath + fpath;
if (!File.Exists(fullPath))
{
byte[] fileContext = item;
string fileName = Regex.Match(fullPath, @"[^/\\?]+(\?.*)?$").Value;
string filePath = fullPath.Replace(fileName, "");
//int index = fullPath.LastIndexOf("\\");
//string filePath = fullPath.Substring(0, index) ;
//string filePath = index > 0 ? fullPath.Substring(0, index) : fullPath;
Directory.CreateDirectory(filePath);
}
//string savePath = fullPath + fileName;
try
{
if (!Directory.Exists(filePath))
{
Directory.CreateDirectory(filePath);
}
}
catch (Exception ex)
{
ErrLogInfo.WriteLog($"附件【{filePath}】获取异常！");
//continue;
}
//string savePath = fullPath + fileName;
//文件读写模式
System.IO.FileMode fileMode = System.IO.FileMode.Create;
//文件读写模式
System.IO.FileMode fileMode = System.IO.FileMode.Create;
//写入文件
using (System.IO.FileStream fs = new System.IO.FileStream(fullPath, fileMode, System.IO.FileAccess.Write))
{
fs.Write(fileContext, 0, fileContext.Length);
}
}
i++;
//写入文件
using (System.IO.FileStream fs = new System.IO.FileStream(fullPath, fileMode, System.IO.FileAccess.Write))
{
fs.Write(fileContext, 0, fileContext.Length);
}
}
i++;
}
}
}
@@ -223,5 +217,66 @@ namespace BLL
}
}
/// <summary>
/// 保存其他单位附件同步处理
/// </summary>
/// <param name="domain">单位域名地址</param>
/// <param name="attachFileId">附件id</param>
/// <param name="tokeyId">附件keyid</param>
/// <param name="attachSource">附件json信息</param>
/// <param name="attachUrl">附件地址</param>
public static void SaveAttachFileRecords(string domain, string attachFileId, string tokeyId, string attachSource, string attachUrl)
{
if (!string.IsNullOrEmpty(attachFileId) && !string.IsNullOrEmpty(attachSource) && !string.IsNullOrEmpty(attachUrl))
{
List<byte[]> FileContext = new List<byte[]>();
if (!string.IsNullOrWhiteSpace(domain) && !string.IsNullOrWhiteSpace(attachUrl))
{
FileContext = FilePathTransStream(domain, attachUrl);
}
InsertAttachFilesRecord(attachFileId, tokeyId, attachSource, attachUrl, FileContext);
}
}
/// <summary>
/// 数据和附件插入到多附件表
/// </summary>
public static void InsertAttachFilesRecord(string attachFileId, string dataId, string attachSource, string attachUrl, List<byte[]> fileContext)
{
if (!string.IsNullOrEmpty(attachFileId))
{
//多附件
var attachFile = Funs.DB.AttachFile.FirstOrDefault(x => x.ToKeyId == dataId);
if (attachFile == null)
{
////插入附件文件
BLL.FileInsertService.FileMoreInsert(fileContext, attachUrl);
Model.AttachFile newAttachFile = new Model.AttachFile
{
AttachFileId = attachFileId,
ToKeyId = dataId,
AttachSource = attachSource,
AttachUrl = attachUrl
};
Funs.DB.AttachFile.InsertOnSubmit(newAttachFile);
Funs.DB.SubmitChanges();
}
else
{
if (attachFile.AttachUrl != attachUrl)
{
/////删除附件文件
//BLL.UploadAttachmentService.DeleteFile(ConfigurationManager.AppSettings["localRoot"], attachFile.AttachUrl);
////插入附件文件
BLL.FileInsertService.FileMoreInsert(fileContext, attachUrl);
attachFile.AttachSource = attachSource;
attachFile.AttachUrl = attachUrl;
Funs.DB.SubmitChanges();
}
}
}
}
}
}
SGGL/BLL/Person/Person_PersonsService.cs
+85
View File
@@ -1482,5 +1482,90 @@ namespace BLL
return list;
}
}
/// <summary>
/// 用户下拉框
/// </summary>
/// <param name="dropName">下拉框名字</param>
/// <param name="projectId">项目id</param>
/// <param name="isShowPlease">是否显示请选择</param>
public static void InitUserDropDownList(FineUIPro.DropDownList dropName, string projectId, bool isShowPlease, string UnitId)
{
dropName.DataValueField = "Value";
dropName.DataTextField = "Text";
if (!string.IsNullOrWhiteSpace(UnitId))
{
dropName.DataSource = GetUserByUnitId(projectId, UnitId);
}
else
{
dropName.DataSource = GetMainUserList(projectId);
}
dropName.DataBind();
if (isShowPlease)
{
Funs.FineUIPleaseSelect(dropName);
}
}
/// <summary>
/// 获取项目总包用户
/// </summary>
/// <param name="projectId"></param>
/// <returns></returns>
public static ListItem[] GetMainUserList(string projectId)
{
using (Model.SGGLDB db = new Model.SGGLDB(Funs.ConnString))
{
//var user = (from x in db.Sys_User
// join y in db.Project_ProjectUser on x.UserId equals y.UserId
// join z in db.Project_ProjectUnit on x.UnitId equals z.UnitId
// where x.IsPost == true && y.ProjectId == projectId && z.ProjectId == projectId && z.UnitType == Const.ProjectUnitType_1
// orderby x.UserId
// select x).ToList();
var user = (from x in db.SitePerson_Person
join y in db.Person_Persons on x.PersonId equals y.PersonId
join z in db.Project_ProjectUnit on x.UnitId equals z.UnitId
where y.IsPost == true && x.ProjectId == projectId && z.ProjectId == projectId && z.UnitType == Const.ProjectUnitType_1 && x.RoleIds != null && x.RoleIds != string.Empty
orderby x.PersonId
select new
{
UserName = y.PersonName,
UserId = x.PersonId
}).Distinct().ToList();
ListItem[] lis = new ListItem[user.Count()];
for (int i = 0; i < user.Count(); i++)
{
lis[i] = new ListItem(user[i].UserName ?? "", user[i].UserId.ToString());
}
return lis;
}
}
/// <summary>
/// 获取在岗用户下拉选项
/// </summary>
/// <returns></returns>
public static List<Model.Person_Persons> GetProjectUserListByProjectId(string projectId)
{
using (Model.SGGLDB db = new Model.SGGLDB(Funs.ConnString))
{
var users = (from x in db.Person_Persons
where x.IsPost == true && x.PersonId != Const.hfnbdId && x.PersonId != Const.sedinId && x.RoleIds != null && x.RoleIds != string.Empty
orderby x.PersonName
select x).ToList();
if (!string.IsNullOrEmpty(projectId))
{
users = (from x in users
join y in db.SitePerson_Person on x.PersonId equals y.PersonId
where y.ProjectId == projectId
orderby x.PersonName
select x).ToList();
}
return users;
}
}
}
}
SGGL/BLL/ProjectData/ProjectService.cs
+55
View File
@@ -127,6 +127,9 @@
ProjectRealCode = project.ProjectRealCode,
IsCNCECShow = project.IsCNCECShow,
MasterSysId = project.MasterSysId,
SubjectUnit = project.SubjectUnit,
SubjectProject = project.SubjectProject,
};
db.Base_Project.InsertOnSubmit(newProject);
db.SubmitChanges();
@@ -174,6 +177,8 @@
newProject.ProjectRealCode = project.ProjectRealCode;
newProject.IsCNCECShow = project.IsCNCECShow;
newProject.MasterSysId = project.MasterSysId;
newProject.SubjectUnit = project.SubjectUnit;
newProject.SubjectProject = project.SubjectProject;
db.SubmitChanges();
HSEDataCollectService.ProjectHSEDataCollectSubmission(newProject);
@@ -731,5 +736,55 @@
Funs.FineUIPleaseSelect(dropName);
}
}
/// <summary>
/// 项目表下拉框
/// </summary>
/// <param name="dropName">下拉框名字</param>
/// <param name="isShowPlease">是否显示请选择</param>
public static void InitProjectDropDownList(FineUIPro.DropDownList dropName, string unitId, bool isShowPlease)
{
var IsThisUnit = BLL.Const.UnitId_SEDIN == unitId ? true : false;
dropName.DataValueField = "ProjectId";
dropName.DataTextField = "ProjectName";
if (IsThisUnit)
{
dropName.DataSource = BLL.ProjectService.GetProjectWorkList();
}
else
{
dropName.DataSource = BLL.ProjectService.GetProjectWorkList(unitId);
}
dropName.DataBind();
if (isShowPlease)
{
Funs.FineUIPleaseSelect(dropName);
}
}
/// <summary>
/// 获取施工中项目集合
/// </summary>
/// <returns></returns>
public static List<Model.Base_Project> GetProjectWorkList(string unitId)
{
var getDatas = from x in Funs.DB.Base_Project
where (x.ProjectState == null || x.ProjectState == BLL.Const.ProjectState_1)
select x;
if (unitId == BLL.Const.UnitId_SEDIN)
{
getDatas = getDatas.Where(x => x.UnitId == unitId || x.UnitId == null);
}
else
{
getDatas = getDatas.Where(x => x.UnitId == unitId);
}
var list = getDatas.OrderBy(x => x.ProjectName).ToList();
return list;
}
}
}
SGGL/BLL/SQLHelper.cs
+34
View File
@@ -422,6 +422,40 @@ namespace BLL
}
}
/// <summary>
/// 执行SQL语句
/// </summary>
/// <param name="sql">sql语句</param>
public static bool ExecuteSql(string sql)
{
bool result = false;
using (SqlConnection Connection = new SqlConnection(connectionString))
{
try
{
result = true;
Connection.Open();
SqlCommand command = new SqlCommand(sql, Connection)
{
CommandTimeout = 0,
CommandType = CommandType.Text
};
command.ExecuteNonQuery();
}
catch (Exception ex)
{
result = false;
ErrLogInfo.WriteLog($"【执行SQL语句报错】{sql}；【错误信息】{ex.Message}");
}
finally
{
Connection.Close();
}
return result;
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Creates a DataSet by running the stored procedure and placing the results
SGGL/BLL/SysManage/UnitService.cs
+185
View File
@@ -1,5 +1,7 @@
using Model;
using Newtonsoft.Json.Linq;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Web.UI.WebControls;
@@ -825,5 +827,188 @@ namespace BLL
Funs.FineUIPleaseSelect(dropName);
}
}
#region 获取集团单位列表
/// <summary>
/// 获取集团单位列表
/// </summary>
/// <returns></returns>
public static List<Model.BaseInfoItem> getUnitLists()
{
var responeData = new Model.ResponeData();
List<Model.BaseInfoItem> list = new List<Model.BaseInfoItem>();
try
{
string baseurl = $"{SysConstSetService.CNCECPath}/api/Unit/getUnitLists";
// string baseurl = "http://localhost:7143/api/Unit/getUnitLists";
string contenttype = "application/json;charset=unicode";
Hashtable newToken = new Hashtable
{
{ "token", ServerService.GetToken().Token }
};
var strJosn = APIGetHttpService.Http(baseurl, "GET", contenttype, newToken, null);
if (!string.IsNullOrEmpty(strJosn))
{
JObject obj = JObject.Parse(strJosn);
responeData.code = Funs.GetNewIntOrZero(obj["code"].ToString());
responeData.message = obj["message"].ToString();
if (responeData.code == 1)
{
JArray getData = JArray.Parse(obj["data"].ToString());
if (getData.Count() > 0)
{
foreach (var item in getData)
{
var q = new Model.BaseInfoItem();
q.BaseInfoId = item["BaseInfoId"].ToString();
q.BaseInfoName = item["BaseInfoName"].ToString();
q.BaseInfoCode = item["BaseInfoCode"].ToString();
list.Add(q);
}
}
responeData.message = "获取成功：集团单位数" + getData.Count().ToString() + "条";
}
}
}
catch (Exception ex)
{
responeData.code = 0;
responeData.message = "获取失败：" + ex.Message;
ErrLogInfo.WriteLog("获取集团单位列表！", ex);
}
return list;
}
#endregion
#region 根据单位获取项目列表
/// <summary>
/// 获取集团单位列表
/// </summary>
/// <returns></returns>
public static List<Model.BaseInfoItem> getProjectListByUnitId(string userId)
{
var responeData = new Model.ResponeData();
List<Model.BaseInfoItem> list = new List<Model.BaseInfoItem>();
try
{
string baseurl = $"{SysConstSetService.CNCECPath}/api/Unit/getProjectListByUnitId?unitId=" + userId + "&projectName=" + "&pageIndex=0";
// string baseurl = "http://localhost:7143/api/Unit/getProjectListByUnitId?unitId=" + userId + "&projectName=" + "&pageIndex=0" ;
string contenttype = "application/json;charset=unicode";
Hashtable newToken = new Hashtable
{
{ "token", ServerService.GetToken().Token }
};
var strJosn = APIGetHttpService.Http(baseurl, "GET", contenttype, newToken, null);
if (!string.IsNullOrEmpty(strJosn))
{
JObject obj = JObject.Parse(strJosn);
responeData.code = Funs.GetNewIntOrZero(obj["code"].ToString());
responeData.message = obj["message"].ToString();
if (responeData.code == 1)
{
JArray getData = JArray.Parse(obj["data"].ToString());
if (getData.Count() > 0)
{
foreach (var item in getData)
{
var q = new Model.BaseInfoItem();
q.BaseInfoId = item["BaseInfoId"].ToString();
q.BaseInfoName = item["BaseInfoName"].ToString();
q.BaseInfoCode = item["BaseInfoCode"].ToString();
list.Add(q);
}
}
responeData.message = "获取成功：集团项目数" + getData.Count().ToString() + "条";
}
}
}
catch (Exception ex)
{
responeData.code = 0;
responeData.message = "获取失败：" + ex.Message;
ErrLogInfo.WriteLog("获取集团项目数！", ex);
}
return list;
}
#endregion
#region 根据单位id获取单位信息列表
/// <summary>
/// 获取集团单位列表
/// </summary>
/// <returns></returns>
public static string getUnitApiUrlByUnitId(string userId)
{
string url = "";
try
{
string baseurl = $"{SysConstSetService.CNCECPath}/api/Unit/getUnitApiUrlByUnitId?unitId=" + userId;
// string baseurl = "http://localhost:7143/api/Unit/getUnitApiUrlByUnitId?unitId=" + userId;
string contenttype = "application/json;charset=unicode";
Hashtable newToken = new Hashtable
{
{ "token", ServerService.GetToken().Token }
};
var strJosn = APIGetHttpService.Http(baseurl, "GET", contenttype, newToken, null);
if (!string.IsNullOrEmpty(strJosn))
{
JObject obj = JObject.Parse(strJosn);
if (Funs.GetNewIntOrZero(obj["code"].ToString()) == 1)
{
if (obj["data"] != null)
{
JObject dataObj = obj["data"] as JObject;
if (dataObj != null && dataObj["BaseInfoCode"] != null)
{
url = dataObj["BaseInfoCode"].ToString();
}
}
}
}
}
catch (Exception ex)
{
ErrLogInfo.WriteLog("获取失败！", ex);
}
return url;
}
#endregion
/// <summary>
/// 获取分公司表下拉框
/// </summary>
/// <param name="dropName"></param>
/// <param name="isShowPlease"></param>
public static void InitBranchUnitDropDownList(FineUIPro.DropDownList dropName, bool isShowPlease)
{
dropName.DataValueField = "UnitId";
dropName.DataTextField = "UnitName";
dropName.DataSource = BLL.UnitService.GetMainAndSubUnitList();
dropName.DataBind();
if (isShowPlease)
{
Funs.FineUIPleaseSelect(dropName);
}
}
/// <summary>
/// 获取当前单位下分公司拉选项
/// </summary>
/// <returns></returns>
public static List<Model.Base_Unit> GetMainAndSubUnitList()
{
return (from x in Funs.DB.Base_Unit where x.UnitId == BLL.Const.UnitId_SEDIN || x.IsBranch == true select x).ToList();
}
}
}
SGGL/BLL/ZHGL/Supervise/UnitHazardRegisterItemService.cs
+338
View File
@@ -0,0 +1,338 @@
using System;
using Model;
using System.Collections.Generic;
using System.Linq;
namespace BLL
{
/// <summary>
/// 企业级检查明细服务
/// </summary>
public static class UnitHazardRegisterItemService
{
#region Methods
/// <summary>
/// 添加明细记录
/// </summary>
/// <param name="item">明细记录</param>
public static void AddUnitHazardRegisterItem(Model.Supervise_UnitHazardRegisterItem item)
{
Funs.DB.Supervise_UnitHazardRegisterItem.InsertOnSubmit(item);
Funs.DB.SubmitChanges();
}
/// <summary>
/// 根据主表ID删除所有明细
/// </summary>
/// <param name="registerId">主表ID</param>
public static void DeleteItemsByRegisterId(string registerId)
{
var items = (from x in Funs.DB.Supervise_UnitHazardRegisterItem
where x.UnitHazardRegisterId == registerId
select x).ToList();
if (items.Count > 0)
{
Funs.DB.Supervise_UnitHazardRegisterItem.DeleteAllOnSubmit(items);
Funs.DB.SubmitChanges();
}
}
/// <summary>
/// 删除明细记录
/// </summary>
/// <param name="itemId">明细ID</param>
public static void DeleteUnitHazardRegisterItemById(string itemId)
{
Model.Supervise_UnitHazardRegisterItem item =
Funs.DB.Supervise_UnitHazardRegisterItem.FirstOrDefault(e => e.UnitHazardRegisterItemId == itemId);
if (item != null)
{
Funs.DB.Supervise_UnitHazardRegisterItem.DeleteOnSubmit(item);
Funs.DB.SubmitChanges();
}
}
/// <summary>
/// 根据风险级别获取明细数量
/// </summary>
/// <param name="registerId">主表ID</param>
/// <param name="riskLevel">风险级别</param>
/// <returns>明细数量</returns>
public static int GetCountByRiskLevel(string registerId, string riskLevel)
{
return (from x in Funs.DB.Supervise_UnitHazardRegisterItem
where x.UnitHazardRegisterId == registerId && x.RiskLevel == riskLevel
select x).Count();
}
/// <summary>
/// 获取已完成的明细数量
/// </summary>
/// <param name="registerId">主表ID</param>
/// <returns>已完成数量</returns>
public static int GetFinishedCount(string registerId)
{
return (from x in Funs.DB.Supervise_UnitHazardRegisterItem
where x.UnitHazardRegisterId == registerId && x.CompleteStatus == 1
select x).Count();
}
/// <summary>
/// 根据主表ID获取明细列表
/// </summary>
/// <param name="registerId">主表ID</param>
/// <returns>明细列表</returns>
public static List<Model.Supervise_UnitHazardRegisterItem> GetItemsByRegisterId(string registerId)
{
return (from x in Funs.DB.Supervise_UnitHazardRegisterItem
where x.UnitHazardRegisterId == registerId
orderby x.SortIndex
select x).ToList();
}
/// <summary>
/// 获取主单的整改状态
/// </summary>
/// <param name="registerId">主单ID</param>
/// <returns>整改状态：0=全部未整改，1=部分整改，2=全部整改</returns>
public static int GetRectifyStatus(string registerId)
{
var items = GetItemsByRegisterId(registerId);
if (items.Count == 0)
{
return 0; // 无明细，视为全部未整改
}
int finishedCount = items.Count(x => x.CompleteStatus == 1);
int totalCount = items.Count;
if (finishedCount == 0)
{
return 0; // 全部未整改
}
else if (finishedCount < totalCount)
{
return 1; // 部分整改
}
else
{
return 2; // 全部整改
}
}
/// <summary>
/// 获取整改状态文本
/// </summary>
/// <param name="registerId">主单ID</param>
/// <returns>状态文本</returns>
public static string GetRectifyStatusText(string registerId)
{
int status = GetRectifyStatus(registerId);
switch (status)
{
case 0:
return "全部未整改";
case 1:
return "部分整改";
case 2:
return "全部整改";
default:
return "未知";
}
}
/// <summary>
/// 获取未完成的明细数量
/// </summary>
/// <param name="registerId">主表ID</param>
/// <returns>未完成数量</returns>
public static int GetUnfinishedCount(string registerId)
{
return (from x in Funs.DB.Supervise_UnitHazardRegisterItem
where x.UnitHazardRegisterId == registerId && (x.CompleteStatus == null || x.CompleteStatus == 0)
select x).Count();
}
/// <summary>
/// 根据明细ID获取明细记录
/// </summary>
/// <param name="itemId">明细ID</param>
/// <returns>明细记录</returns>
public static Model.Supervise_UnitHazardRegisterItem GetUnitHazardRegisterItemById(string itemId)
{
return Funs.DB.Supervise_UnitHazardRegisterItem.FirstOrDefault(e => e.UnitHazardRegisterItemId == itemId);
}
/// <summary>
/// 获取企业级检查明细列表（使用input对象，返回总数）
/// </summary>
/// <param name="input">查询条件</param>
/// <param name="pageIndex">页码（从0开始）</param>
/// <param name="pageSize">每页大小</param>
/// <param name="returnAll">是否返回所有数据（不分页）</param>
/// <param name="totalCount">总记录数</param>
/// <returns>检查明细列表</returns>
public static List<UnitHazardRegisterItemOutput> GetUnitHazardRegisterItems(
UnitHazardRegisterItemInput input,
int pageIndex,
int pageSize,
bool returnAll,
out int totalCount)
{
var db = Funs.DB;
var query = from i in db.Supervise_UnitHazardRegisterItem
join r in db.Supervise_UnitHazardRegister
on i.UnitHazardRegisterId equals r.UnitHazardRegisterId
join ct in db.Base_SuperviseCheckType
on new { MainType = r.CheckMainType, TypeCode = r.CheckType }
equals new { MainType = ct.CheckMainType, TypeCode = ct.CheckTypeCode } into ctGroup
from ct in ctGroup.DefaultIfEmpty()
join u in db.Base_Unit
on r.CheckUnitId equals u.UnitId into uGroup
from u in uGroup.DefaultIfEmpty()
join user in db.Person_Persons on r.InsResponsibleUserId equals user.PersonId into userGroup
from user in userGroup.DefaultIfEmpty()
select new UnitHazardRegisterItemOutput
{
UnitHazardRegisterItemId = i.UnitHazardRegisterItemId,
UnitHazardRegisterCode = r.UnitHazardRegisterCode,
CheckDate = r.CheckDate,
CheckMainTypeName = r.CheckMainType == "0" ? "安全" : "质量",
CheckTypeName = ct.CheckTypeName,
ProblemDescription = i.ProblemDescription,
ProblemType = i.ProblemType,
RiskLevel = i.RiskLevel,
RectifyRequirement = i.RectifyRequirement,
StatesName = UnitHazardRegisterService.ConvertState(r.States.Value),
CheckTeam = r.CheckTeam,
ProjectId = r.ProjectId,
CheckUnitName = u.UnitName,
States = r.States,
ProblemStatesName = i.CompleteStatus==1 ? "已整改":"未整改",
ProblemStates = i.CompleteStatus,
InsResponsibleUserId = r.InsResponsibleUserId,
InsResponsibleUserName= user.PersonName
};
// 应用检查大类过滤
if (input != null && !string.IsNullOrEmpty(input.CheckMainType))
{
query = query.Where(x => x.CheckMainTypeName.Contains(input.CheckMainType == "0" ? "安全" : "质量"));
}
// 项目id过滤
if (input != null && !string.IsNullOrEmpty(input.ProjectId))
{
query = query.Where(x => x.ProjectId.Contains(input.ProjectId));
}
// 检查组/人搜索
if (input != null && !string.IsNullOrEmpty(input.CheckTeam))
{
query = query.Where(x => x.CheckTeam.Contains(input.CheckTeam));
}
// 检查类别搜索
if (input != null && !string.IsNullOrEmpty(input.CheckType))
{
query = query.Where(x => x.CheckTypeName != null && x.CheckTypeName.Contains(input.CheckType));
}
// 问题描述搜索
if (input != null && !string.IsNullOrEmpty(input.Problem))
{
query = query.Where(x => x.ProblemDescription.Contains(input.Problem));
}
// 检查时间范围
if (input != null && input.StartTime.HasValue)
{
query = query.Where(x => x.CheckDate >= input.StartTime.Value);
}
if (input != null && input.EndTime.HasValue)
{
query = query.Where(x => x.CheckDate <= input.EndTime.Value);
}
// 风险级别过滤
if (input != null && !string.IsNullOrEmpty(input.RiskLevel) && input.RiskLevel != "null")
{
query = query.Where(x => x.RiskLevel == input.RiskLevel);
}
// 状态过滤
if (input != null && input.States != null)
{
query = query.Where(x => x.States == input.States);
}
// 问题整改状态过滤
if (input != null && input.ProblemStates != null)
{
query = query.Where(x => x.ProblemStates == input.ProblemStates);
}
// 单位权限过滤
if (input != null && !string.IsNullOrEmpty(input.UnitId))
{
var thisUnit = BLL.CommonService.GetIsThisUnit();
if (thisUnit.UnitId != input.UnitId)
{
// 先获取用户有权限的项目ID列表
var projectIds = (from p in Funs.DB.Base_Project
where p.UnitId == input.UnitId
select p.ProjectId).ToList();
// 过滤查询结果
query = query.Where(x => Funs.DB.Supervise_UnitHazardRegister
.Any(r => Funs.DB.Supervise_UnitHazardRegisterItem
.Any(i => i.UnitHazardRegisterItemId == x.UnitHazardRegisterItemId &&
i.UnitHazardRegisterId == r.UnitHazardRegisterId &&
projectIds.Contains(r.ProjectId))));
}
}
// 获取总数
totalCount = query.Count();
// 排序和分页
var orderedQuery = query.OrderByDescending(x => x.CheckDate);
if (returnAll)
{
return orderedQuery.ToList();
}
return orderedQuery
.Skip(pageIndex * pageSize)
.Take(pageSize)
.ToList();
}
/// <summary>
/// 更新明细记录
/// </summary>
/// <param name="item">明细记录</param>
public static void UpdateUnitHazardRegisterItem(Model.Supervise_UnitHazardRegisterItem item)
{
Model.Supervise_UnitHazardRegisterItem oldItem =
Funs.DB.Supervise_UnitHazardRegisterItem.FirstOrDefault(e => e.UnitHazardRegisterItemId == item.UnitHazardRegisterItemId);
if (oldItem != null)
{
oldItem.ProblemDescription = item.ProblemDescription;
oldItem.ProblemType = item.ProblemType;
oldItem.RiskLevel = item.RiskLevel;
oldItem.RectifyRequirement = item.RectifyRequirement;
oldItem.CompleteStatus = item.CompleteStatus;
oldItem.CompletedDate = item.CompletedDate;
oldItem.SortIndex = item.SortIndex;
Funs.DB.SubmitChanges();
}
}
#endregion Methods
}
}
SGGL/BLL/ZHGL/Supervise/UnitHazardRegisterService.cs
+301
View File
@@ -0,0 +1,301 @@
using System;
using Model;
using System.Collections.Generic;
using System.Linq;
namespace BLL
{
/// <summary>
/// 企业级检查主表服务
/// </summary>
public static class UnitHazardRegisterService
{
#region Fields
public static Dictionary<string, int> StateMap = new Dictionary<string, int>
{
{ "待提交" ,(int)StateInt.待提交},
{ "待整改" ,(int)StateInt.待整改},
{ "部分整改" ,(int)StateInt.部分整改},
{ "已闭环" ,(int)StateInt.已闭环},
};
#endregion Fields
#region Enums
public enum StateInt : int
{
待提交 = 0,
待整改= 1,
部分整改 = 2,
已闭环 = 3,
}
#endregion Enums
#region Methods
/// <summary>
/// 添加企业级检查记录
/// </summary>
/// <param name="register">企业级检查记录</param>
public static void AddUnitHazardRegister(Model.Supervise_UnitHazardRegister register)
{
using (Model.SGGLDB db = new Model.SGGLDB(Funs.ConnString))
{
Model.Supervise_UnitHazardRegister newRegister = new Model.Supervise_UnitHazardRegister
{
UnitHazardRegisterId = register.UnitHazardRegisterId,
UnitHazardRegisterCode = register.UnitHazardRegisterCode,
CheckDate = register.CheckDate,
CheckMainType = register.CheckMainType,
CheckType = register.CheckType,
ProjectId = register.ProjectId,
CheckUnitId = register.CheckUnitId,
CheckTeam = register.CheckTeam,
CheckManIds = register.CheckManIds,
CheckManNames = register.CheckManNames,
InsResponsibleUserId = register.InsResponsibleUserId,
EvaluationResult = register.EvaluationResult,
AttachUrl = register.AttachUrl,
States = register.States??0,
CompileMan = register.CompileMan,
CreateDate = DateTime.Now
};
db.Supervise_UnitHazardRegister.InsertOnSubmit(newRegister);
db.SubmitChanges();
}
}
public static string ConvertState(int state)
{
string result = string.Empty;
result = StateMap.First(c => c.Value == state).Key;
return result;
}
/// <summary>
/// 删除企业级检查记录
/// </summary>
/// <param name="registerId">检查记录ID</param>
public static void DeleteUnitHazardRegisterById(string registerId)
{
using (Model.SGGLDB db = new Model.SGGLDB(Funs.ConnString))
{
var register = db.Supervise_UnitHazardRegister.FirstOrDefault(e => e.UnitHazardRegisterId == registerId);
if (register != null)
{
// 删除附件
if (!string.IsNullOrEmpty(register.AttachUrl))
{
BLL.UploadFileService.DeleteFile(Funs.AttachRootPath, register.AttachUrl);
}
// 删除编码记录
BLL.CodeRecordsService.DeleteCodeRecordsByDataId(registerId);
// 删除附件
BLL.CommonService.DeleteAttachFileById(registerId);
// 删除流程
BLL.CommonService.DeleteFlowOperateByID(registerId);
db.Supervise_UnitHazardRegister.DeleteOnSubmit(register);
db.SubmitChanges();
}
}
}
/// <summary>
/// 根据项目和时间段获取检查数量
/// </summary>
/// <param name="projectId">项目ID</param>
/// <param name="startTime">开始时间</param>
/// <param name="endTime">结束时间</param>
/// <returns>检查数量</returns>
public static int GetCount(string projectId, DateTime startTime, DateTime endTime)
{
return (from x in Funs.DB.Supervise_UnitHazardRegister
where x.ProjectId == projectId && x.CheckDate >= startTime && x.CheckDate <= endTime
select x).Count();
}
public static int GetCount(string checkMainType)
{
return (from x in Funs.DB.Supervise_UnitHazardRegister
where x.CheckMainType ==checkMainType
select x.UnitHazardRegisterId).Count();
}
/// <summary>
/// 根据ID获取企业级检查记录
/// </summary>
/// <param name="registerId">检查记录ID</param>
/// <returns>企业级检查记录</returns>
public static Model.Supervise_UnitHazardRegister GetUnitHazardRegisterById(string registerId)
{
return Funs.DB.Supervise_UnitHazardRegister.FirstOrDefault(e => e.UnitHazardRegisterId == registerId);
}
/// <summary>
/// 判断是否可以删除检查记录
/// </summary>
/// <param name="registerId">检查记录ID</param>
/// <returns>true=可以删除，false=不能删除</returns>
public static bool CanDeleteRegister(string registerId)
{
var register = GetUnitHazardRegisterById(registerId);
if (register == null)
{
return false;
}
// 只有"待提交"状态可以删除，其他状态不能删除
return register.States <= (int)StateInt.待提交;
}
/// <summary>
/// 获取企业级检查列表（使用input对象，返回总数）
/// </summary>
/// <param name="input">查询条件</param>
/// <param name="pageIndex">页码（从0开始）</param>
/// <param name="pageSize">每页大小</param>
/// <param name="returnAll">是否返回所有数据（不分页）</param>
/// <param name="totalCount">总记录数</param>
/// <returns>检查记录列表</returns>
public static List<UnitHazardRegisterOutput> GetUnitHazardRegisters(
UnitHazardRegisterInput input,
int pageIndex,
int pageSize,
bool returnAll,
out int totalCount)
{
var db = Funs.DB;
// 使用JOIN一次性获取所有数据，解决N+1查询问题
var query = from x in db.Supervise_UnitHazardRegister
join ct in db.Base_SuperviseCheckType
on new { MainType = x.CheckMainType, TypeCode = x.CheckType }
equals new { MainType = ct.CheckMainType, TypeCode = ct.CheckTypeCode } into ctGroup
from ct in ctGroup.DefaultIfEmpty()
join u in db.Base_Unit
on x.CheckUnitId equals u.UnitId into uGroup
from u in uGroup.DefaultIfEmpty()
join p in db.Base_Project on x.ProjectId equals p.ProjectId into pGroup
from p in pGroup.DefaultIfEmpty()
select new UnitHazardRegisterOutput
{
UnitHazardRegisterId = x.UnitHazardRegisterId,
UnitHazardRegisterCode = x.UnitHazardRegisterCode,
CheckDate = x.CheckDate,
ProjectId = x.ProjectId,
CheckMainTypeName = x.CheckMainType == "0" ? "安全" : "质量",
CheckType = x.CheckType,
CheckTypeName = ct.CheckTypeName,
CheckObjectText = p.ProjectName,
CheckUnitName = u.UnitName,
CheckTeam = x.CheckTeam,
EvaluationResult = x.EvaluationResult,
StatesName = ConvertState(x.States.Value),
AttachUrl = x.AttachUrl,
};
// 应用检查大类过滤
if (input != null && !string.IsNullOrEmpty(input.CheckMainType))
{
query = query.Where(x => x.CheckMainTypeName.Contains(input.CheckMainType == "0" ? "安全" : "质量"));
}
// 应用文本搜索
if (input != null && !string.IsNullOrEmpty(input.SearchText))
{
query = query.Where(x => x.UnitHazardRegisterCode.Contains(input.SearchText) ||
x.CheckObjectText.Contains(input.SearchText) ||
x.CheckTeam.Contains(input.SearchText) ||
x.EvaluationResult.Contains(input.SearchText));
}
// 应用检查类别过滤
if (input != null && !string.IsNullOrEmpty(input.CheckType) && input.CheckType != BLL.Const._Null)
{
query = query.Where(x => x.CheckType == input.CheckType);
}
// 项目权限过滤
if (input != null && !string.IsNullOrEmpty(input.ProjectId))
{
query = query.Where(x => x.ProjectId != null && x.ProjectId == input.ProjectId);
}
// 获取总数
totalCount = query.Count();
// 排序和分页
var orderedQuery = query.OrderByDescending(x => x.CheckDate);
if (returnAll)
{
return orderedQuery.ToList();
}
return orderedQuery
.Skip(pageIndex * pageSize)
.Take(pageSize)
.ToList();
}
/// <summary>
/// 更新企业级检查记录
/// </summary>
/// <param name="register">企业级检查记录</param>
public static void UpdateUnitHazardRegister(Model.Supervise_UnitHazardRegister register)
{
using (Model.SGGLDB db = new Model.SGGLDB(Funs.ConnString))
{
Model.Supervise_UnitHazardRegister newRegister =
db.Supervise_UnitHazardRegister.FirstOrDefault(e => e.UnitHazardRegisterId == register.UnitHazardRegisterId);
if (newRegister != null)
{
newRegister.UnitHazardRegisterCode = register.UnitHazardRegisterCode;
newRegister.CheckDate = register.CheckDate;
newRegister.CheckMainType = register.CheckMainType;
newRegister.CheckType = register.CheckType;
newRegister.ProjectId = register.ProjectId;
newRegister.CheckUnitId = register.CheckUnitId;
newRegister.CheckTeam = register.CheckTeam;
newRegister.CheckManIds = register.CheckManIds;
newRegister.CheckManNames = register.CheckManNames;
newRegister.EvaluationResult = register.EvaluationResult;
newRegister.AttachUrl = register.AttachUrl;
newRegister.States = register.States;
newRegister.InsResponsibleUserId = register.InsResponsibleUserId;
newRegister.UpdateDate = DateTime.Now;
db.SubmitChanges();
}
}
}
/// <summary>
/// 更新主单状态（根据明细的整改情况）
/// </summary>
public static void UpdateRegisterStatus(string registerId)
{
// 获取主单的所有明细的整改状态
int rectifyStatus = BLL.UnitHazardRegisterItemService.GetRectifyStatus(registerId);
var register = BLL.UnitHazardRegisterService.GetUnitHazardRegisterById(registerId);
if (register != null)
{
// 根据整改状态更新主单状态
switch (rectifyStatus)
{
case 0: // 全部未整改
register.States = (int)UnitHazardRegisterService.StateInt.待整改; // 待整改
break;
case 1: // 部分整改
register.States = (int)UnitHazardRegisterService.StateInt.部分整改; ; // 待整改
break;
case 2: // 全部整改
register.States = (int)UnitHazardRegisterService.StateInt.已闭环; ; // 已完成
break;
}
BLL.UnitHazardRegisterService.UpdateUnitHazardRegister(register);
}
}
#endregion Methods
}
}