Files
Web_AuthorityManagement_Mvc…/Services/Manager/SyncHotelServer.cs

1753 lines
81 KiB
C#
Raw Normal View History

2025-11-20 09:50:21 +08:00
using Models;
using Models.ModelItems;
using Models.View;
using MySqlConnector;
using Newtonsoft.Json;
using Org.BouncyCastle.Asn1.Pkcs;
using Org.BouncyCastle.Ocsp;
using Services.Cache;
using Services.Tool;
using SqlSugar;
using StackExchange.Redis;
using System;
using System.Collections.Generic;
using System.Configuration;
using System.Data;
using System.Data.Entity;
using System.Data.SqlClient;
using System.IO;
using System.Linq;
using System.Security.Cryptography;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using UH_CENTER;
using UtilsSharp;
using static Services.Cache.CacheHelp;
namespace Services.Manager
{
//从HotelService工程复制过来目标是合并两个同步功能。
public class SyncAllFromOutterDB
{
public class SQLSERVER_Helper
{
public static String StrConnSqlServer = "Data Source=boonlive-rcu.com;Initial Catalog=CRICS;Persist Security Info=True;User ID=blw;Password=blw@#$;";
public static DataTable GetDatatable(string con, string sql, params SqlParameter[] par)
{
using (SqlConnection connection = new SqlConnection(con))
{
using (SqlDataAdapter sda = new SqlDataAdapter(sql, connection))
{
if (par != null && par.Length > 0)
{
sda.SelectCommand.Parameters.AddRange(par);
}
DataTable dt = new DataTable();
sda.Fill(dt);
sda.SelectCommand.Parameters.Clear();
return dt;
}
}
}
public static int ExecuteSql(string con, string SQLString)
{
using (SqlConnection connection = new SqlConnection(con))
{
using (SqlCommand cmd = new SqlCommand(SQLString, connection))
{
try
{
connection.Open();
int rows = cmd.ExecuteNonQuery();
return rows;
}
catch (SqlException e)
{
connection.Close();
throw e;
}
}
}
}
}
public static class GlobalSyncLockTest
{
public static bool isInProcessing = false;
public static object testLock = new object();
public static string recentErrMsg = "";
public static int gSyncSeq = 1;
public static DateTime lastStartTime = new DateTime();
}
public static class SYNC_DATA
{
public static DateTime? SX = null; //上一次同步时间
public static bool SYNC_DATA_ALL(int stepid = 0)
{
if (SYNC_DATA.SX != null && DateTime.Now - SYNC_DATA.SX <= TimeSpan.FromMinutes(0))
{
GlobalSyncLockTest.recentErrMsg = "同步失败,同步任务忙";
return false;
}
//排队测试并抢flag.
//只有第一个能通过测试,并抢到。
//后面的都不能通过测试。
lock (GlobalSyncLockTest.testLock)
{
if (GlobalSyncLockTest.isInProcessing)
{
GlobalSyncLockTest.recentErrMsg = "同步失败,同步任务忙";
return false;
}
GlobalSyncLockTest.isInProcessing = true;
}
GlobalSyncLockTest.gSyncSeq++;
DateTime startTime = DateTime.Now;
GlobalSyncLockTest.lastStartTime = startTime;
try
{
SYNC_DATA.SX = DateTime.Now;
DbLogServer.WriteDbLog($"同步[{GlobalSyncLockTest.gSyncSeq}], 0/10 同步开始");
//获取连接字符串
var db = SqlSugarBase.RcuDb;
DbLogServer.WriteDbLog($"同步[{GlobalSyncLockTest.gSyncSeq}], 1/10 取到mysql的SqlSugarDB");
SyncHotelAll(db, startTime, true);
DbLogServer.WriteDbLog($"同步[{GlobalSyncLockTest.gSyncSeq}], 2/10 同步酒店表完成");
SyncHotelGroupAll(db, startTime, true);
DbLogServer.WriteDbLog($"同步[{GlobalSyncLockTest.gSyncSeq}], 3/10 同步酒店组表完成");
SyncRoomTypeAll(db, startTime);
DbLogServer.WriteDbLog($"同步[{GlobalSyncLockTest.gSyncSeq}], 4/10 同步房型表完成");
SyncMainDeviceAll(db, startTime);
DbLogServer.WriteDbLog($"同步[{GlobalSyncLockTest.gSyncSeq}], 5/10 同步主机表完成");
SyncSeasonAll(db, startTime);
DbLogServer.WriteDbLog($"同步[{GlobalSyncLockTest.gSyncSeq}], 6/10 同步季度表完成");
SyncHotelSeasonAll(db, startTime);
DbLogServer.WriteDbLog($"同步[{GlobalSyncLockTest.gSyncSeq}], 7/10 同步酒店季度表完成");
//同步用户
SyncUserInfoAll(db, startTime);
SyncOrgUserInfoAll(db, startTime);
DbLogServer.WriteDbLog($"同步[{GlobalSyncLockTest.gSyncSeq}], 8/10 同步人员信息完成");
//删除不存在的酒店的无效授权
ClearNotExistHotelAuto(db, startTime);
//重新生成所有用户的 用户酒店json数据到用户表的 Hotel_Data 字段
UH_CENTER_Help.Sel_Hotel_All();//更新到正确的酒店,但是自动授权的用户新增的酒店没有正确的统计次数
DbLogServer.WriteDbLog($"同步[{GlobalSyncLockTest.gSyncSeq}], 9/10 重新生成所有人员的用户酒店json数据完成");
//使用授权表再次更新自动授权的用户的jsondata,更新到正确的统计次数
// UH_CENTER_Help.Sel_Hotel_JSON_All_ByAutoAutho();
//清除redis缓存
//重新生成 redis 缓存字段
//重新授权到授权表
RecreateUserCache();
//重新刷新redis cache
//CacheHelp.Removesys(CacheHelp.syskey.sysUserInfoListKey);
//List<View_UserInfo> usrViewList = CacheHelp.cacheSysUserInfo;
DbLogServer.WriteDbLog($"同步[{GlobalSyncLockTest.gSyncSeq}], 10/10 自动授权人员信息完成");
GlobalSyncLockTest.isInProcessing = false;
GlobalSyncLockTest.recentErrMsg = "同步成功";
return true;
}
catch (Exception ex)
{
GlobalSyncLockTest.isInProcessing = false;
GlobalSyncLockTest.recentErrMsg = "同步失败,触发异常:" + ex.ToString();
DbLogServer.WriteDbLog($"同步[{GlobalSyncLockTest.gSyncSeq}]数据。。。异常{ex.ToString()}");
return false;
}
}//end of SYNC_DATA_ALL()
#region
public static void SyncHotelAll(SqlSugarScope db, DateTime stTime, bool isSyncToAuthDB = false)
{
//0. 取到酒店,酒店组,房型,主机,季度,酒店季度,用户信息表上次最晚记录的记录自己的更新时间
string lastRecTime = "2023-10-08";
//使用数据库阿里云服务器 blv_rcu_db 数据库 new_table_update_time_mark表
List<new_table_update_time_mark> itList = db.Queryable<new_table_update_time_mark>()
.Where(it => it.NEW_DB_TABLE_NAME == "TBL_HOTEL_BASIC_INFO")
.ToList();
if (itList.Count > 0)
{
if (itList[0].LAST_LATESTREC_TIME == null)
{
lastRecTime = "2023-10-08";
}
else
{
var timeRec = Convert.ToDateTime(itList[0].LAST_LATESTREC_TIME);
if (timeRec.Year < 2023)
{
lastRecTime = "2023-10-08";
}
else
{
lastRecTime = timeRec.ToString("yyyy-MM-dd HH:mm:ss.fff");
}
}
}
//1. 取到巫工数据库最新记录
List<TBL_HOTEL_BASIC_INFO> hoteldata = DataTableHelper.ToEntities<TBL_HOTEL_BASIC_INFO>(
SQLSERVER_Helper.GetDatatable(SQLSERVER_Helper.StrConnSqlServer, $@"select
IDOLD = b.id,
LOG_IMAGE = b.LogoPath,
HOTEL_NAME_CN = b.[name],
SORT = b.sort,
HOTEL_NAME_EN = b.ename,
KEY_IN_DATETIME = b.createddate,
[IsApprove] = b.IsApprove,
VALID_DATETIME = b.ValidateDate,
PROJECT_NUMBER = b.[code],
[STATUS] = b.[STATUS],
[KEY_Name] = CreatedBy,
DETAIL_ADD = b.[Address],
HOTEL_CONTACT_PHONE = b.[Phone],
HOTEL_OLD_GROUP = b.SysHotelGroupID,
REMARK = b.Remark,
IsDel = b.IsDeleted,
UPDATE_TIMEMARK = GETDATE(),
APPROVE_DATE = b.Last_Modified_Time
from tb_Sys_Hotels b where Last_Modified_Time > '{lastRecTime}' order by Last_Modified_Time asc;")
);
//APPROVE_DATE 是为了取到最后一条记录的时间。不要更新到新表去。
//2. 从巫工数据库更新到我们的数据库
if (hoteldata.Count > 0)
{
//从SQL server数据库取到的最新记录的记录时间
//冲掉
//从时间戳表里面取的上次记录的时间
DateTime dtLastRecTime = Convert.ToDateTime(hoteldata[0].APPROVE_DATE);
//记日志
string retStr = "";
for (int i = 0; i < hoteldata.Count; i++)
{
retStr += "编号:" + hoteldata[i].IDOLD + "名字:" + hoteldata[i].HOTEL_NAME_CN;
}
DbLogServer.WriteDbLog($"同步[{GlobalSyncLockTest.gSyncSeq}], 酒店表如下记录有更新:" + retStr);
//找出更新,插入的记录
List<TBL_HOTEL_BASIC_INFO> updatelist = new List<TBL_HOTEL_BASIC_INFO>();
List<TBL_HOTEL_BASIC_INFO> insertlist = new List<TBL_HOTEL_BASIC_INFO>();
//联系键:
//那边的主键b.id == 这边的IDOLD
//使用数据库阿里云服务器 blv_rcu_db 数据库 tbl_hotel_basic_info表
var listIds = db.Queryable<TBL_HOTEL_BASIC_INFO>()
.Select(it => new
{
mainID = it.HOTEL_ID,
outerMainID = it.IDOLD
})
.ToList().GroupBy(X => X.outerMainID).Select(X => X.First()).ToDictionary(p => p.outerMainID);
//.ToDictionary(p => p.outerMainID);
//表名实体 ,动态条件
foreach (var p in hoteldata)
{
if (listIds.ContainsKey(p.IDOLD))
{
p.HOTEL_ID = listIds[p.IDOLD].mainID;//SQL sugar默认是按主键更新所以主键要正确赋值
updatelist.Add(p);
}
else
insertlist.Add(p);
}
//更新指定列。 只更新取到的那些列
//"HOTEL_OLD_GROUP", "LOG_IMAGE", "HOTEL_NAME_CN", "SORT", "HOTEL_NAME_EN", "KEY_IN_DATETIME", "IsApprove", "VALID_DATETIME",
//"PROJECT_NUMBER", "STATUS", "KEY_Name", "DETAIL_ADD", "HOTEL_CONTACT_PHONE", "HOTEL_GROUP", "UPDATE_TIMEMARK"
var affectResult = db.Updateable(updatelist).UpdateColumns(it => new
{
//it.IDOLD, //不用更新,这个再老表里面已经有正确的值了,
it.HOTEL_OLD_GROUP,
it.LOG_IMAGE,
it.HOTEL_NAME_CN,
it.SORT,
it.HOTEL_NAME_EN,
it.KEY_IN_DATETIME,
it.IsApprove,
it.VALID_DATETIME,
it.PROJECT_NUMBER,
it.STATUS,
it.KEY_Name,
it.DETAIL_ADD,
it.HOTEL_CONTACT_PHONE,
it.HOTEL_GROUP,
it.IsDel,
it.UPDATE_TIMEMARK
})
.ExecuteCommand();
//插入
var iAffectResult = db.Insertable(insertlist).ExecuteCommand();
if (isSyncToAuthDB)
{
List<Hotels> updateauthlist = new List<Hotels>();
List<Hotels> insertauthlist = new List<Hotels>();
//联系键:
//那边的主键b.id == 这边的IDOLD
var listauthIds = SqlSugarBase.Db.Queryable<Hotels>()
.Select(it => it.Id)
.ToList();
//SqlSugarBase.Db is AuthorityDB
foreach (var p in hoteldata)
{
Hotels tmpAuthObj = new Hotels();
tmpAuthObj.Id = p.IDOLD;
tmpAuthObj.Name = p.HOTEL_NAME_CN;
tmpAuthObj.Status = p.STATUS;
tmpAuthObj.Desc = p.REMARK;
tmpAuthObj.CreateTime = p.KEY_IN_DATETIME;
tmpAuthObj.GroupId = p.HOTEL_OLD_GROUP;
tmpAuthObj.IsApprove = p.IsApprove ? 1 : 0;
tmpAuthObj.Code = p.PROJECT_NUMBER;
if (listauthIds.Contains(p.IDOLD))
{
updateauthlist.Add(tmpAuthObj);
}
else
{
insertauthlist.Add(tmpAuthObj);
}
}
var affectauthResult = SqlSugarBase.Db.Updateable(updateauthlist).UpdateColumns(it => new
{
//it.Id, //不用更新,这个在老表里面已经有正确的值了,
it.Name,
it.Status,
it.Desc,
it.CreateTime,
it.GroupId,
it.IsApprove,
it.Code
})
.ExecuteCommand();
if (insertauthlist.Count > 0)
{
//因为在实体类里面声明了 Id 是主键所以生成的insert没有 Id 列。
//但实际上数据表是没有主键的Id 是一个普通列,所以我们必须插入的时候也要设定 Id 的值
//但是有因为sqlsugar内部生成机制会检查实体类里面的主键所以必须手写sql代码来实现插入。
string insSql = "INSERT INTO hotels (Id, `Name`, `Desc`, GroupId, `Code`, `Status`, IsApprove, CreateTime) VALUES ";
int curPos = 0;
int lastPos = insertauthlist.Count - 1;
foreach (var it in insertauthlist)
{
insSql += String.Format("({0},{1},{2},{3},{4},{5},{6},{7})",
it.Id,
"'" + it.Name + "'",
"'" + it.Desc + "'",
it.GroupId,
"'" + it.Code + "'",
it.Status,
it.IsApprove,
"'" + it.CreateTime + "'"
);
if (curPos == lastPos)
insSql += " ;";
else
insSql += ", ";
curPos++;
}
SqlSugarBase.Db.Ado.ExecuteCommand(insSql);
}
}
//更新成功,记录这次更新时间。
itList[0].LAST_UPDATE_TIME = stTime;
itList[0].LAST_LATESTREC_TIME = dtLastRecTime;
db.Updateable(itList[0]).UpdateColumns(it => new { it.LAST_UPDATE_TIME, it.LAST_LATESTREC_TIME }).ExecuteCommand();
}
}
public static void SyncHotelGroupAll(SqlSugarScope db, DateTime stTime, bool isSyncToAuthDB = false)
{
//0. 取到酒店,酒店组,房型,主机,季度,酒店季度,用户信息表上次最晚记录的记录自己的更新时间
string lastRecTime = "2023-10-08";
//使用数据库阿里云服务器 blv_rcu_db 数据库 new_table_update_time_mark表
List<new_table_update_time_mark> itList = db.Queryable<new_table_update_time_mark>()
.Where(it => it.NEW_DB_TABLE_NAME == "TBL_HOTEL_GROUP_INFO")
.ToList();
if (itList.Count > 0)
{
if (itList[0].LAST_LATESTREC_TIME == null)
{
lastRecTime = "2023-10-08";
}
else
{
var timeRec = Convert.ToDateTime(itList[0].LAST_LATESTREC_TIME);
if (timeRec.Year < 2023)
{
lastRecTime = "2023-10-08";
}
else
{
lastRecTime = timeRec.ToString("yyyy-MM-dd HH:mm:ss.fff");
}
}
}
//1. 取到巫工数据库最新记录
List<TBL_HOTEL_GROUP_INFO> hoteldata = DataTableHelper.ToEntities<TBL_HOTEL_GROUP_INFO>(
SQLSERVER_Helper.GetDatatable(SQLSERVER_Helper.StrConnSqlServer, $@"select
HOTEL_GROUP_OLD_ID = b.id,
HOTEL_GROUP_NAME = b.[Name] ,
SORT = b.SORT,
PARENT_OLD_ID = b.ParentID,
KEY_IN_DATETIME = b.[Last_Modified_Time],
IsDel = b.IsDeleted,
UPDATE_TIMEMARK = GETDATE()
from tb_Sys_HotelGroups b where Last_Modified_Time > '{lastRecTime}' order by Last_Modified_Time asc;")
);
//DESC
//2. 从巫工数据库更新到我们的数据库
if (hoteldata.Count > 0)
{
//从SQL server数据库取到的最新记录的记录时间
//冲掉
//从时间戳表里面取的上次记录的时间
DateTime dtLastRecTime = Convert.ToDateTime(hoteldata[0].KEY_IN_DATETIME);
//记日志
string retStr = "";
for (int i = 0; i < hoteldata.Count; i++)
{
retStr += "编号:" + hoteldata[i].HOTEL_GROUP_OLD_ID + "名字:" + hoteldata[i].HOTEL_GROUP_NAME;
}
DbLogServer.WriteDbLog($"同步[{GlobalSyncLockTest.gSyncSeq}], 酒店组表如下记录有更新:" + retStr);
List<TBL_HOTEL_GROUP_INFO> updatelist = new List<TBL_HOTEL_GROUP_INFO>();
List<TBL_HOTEL_GROUP_INFO> insertlist = new List<TBL_HOTEL_GROUP_INFO>();
//联系键:
//那边的主键 b.id == 这边的 HOTEL_GROUP_OLD_ID
//使用数据库阿里云服务器 blv_rcu_db 数据库 tbl_hotel_group_info表
var listIds = db.Queryable<TBL_HOTEL_GROUP_INFO>()
.Select(it => new
{
mainID = it.HOTEL_GROUP_ID,
outerMainID = it.HOTEL_GROUP_OLD_ID
})
.ToList().GroupBy(X => X.outerMainID).Select(X => X.First()).ToDictionary(p => p.outerMainID);
//.ToDictionary(p => p.outerMainID);
//表名实体 ,动态条件
foreach (var p in hoteldata)
{
if (listIds.ContainsKey(p.HOTEL_GROUP_OLD_ID))
{
p.HOTEL_GROUP_ID = listIds[p.HOTEL_GROUP_OLD_ID].mainID;//SQL sugar默认是按主键更新所以主键要正确赋值
updatelist.Add(p);
}
else
insertlist.Add(p);
}
//更新指定列。 只更新取到的那些列
var affectResult = db.Updateable(updatelist).UpdateColumns(it => new
{
//it.HOTEL_GROUP_OLD_ID, //不用更新,这个再老表里面已经有正确的值了,
it.HOTEL_GROUP_NAME,
it.PARENT_OLD_ID,
it.PARENT_ID,
it.SORT,
it.IsDel,
it.UPDATE_TIMEMARK
})
.ExecuteCommand();
//插入所有列
var iAffectResult = db.Insertable(insertlist).ExecuteCommand();
if (isSyncToAuthDB)
{
List<HotelGroups> updateauthlist = new List<HotelGroups>();
List<HotelGroups> insertauthlist = new List<HotelGroups>();
//联系键:
//那边的主键b.id == 这边的ID
//阿里云服务器 AuthorityDB数据库 hotelgroups表
var listauthIds = SqlSugarBase.Db.Queryable<HotelGroups>()
.Select(it => it.Id)
.ToList();
//SqlSugarBase.Db is AuthorityDB
foreach (var p in hoteldata)
{
HotelGroups tmpAuthObj = new HotelGroups();
tmpAuthObj.Id = p.HOTEL_GROUP_OLD_ID;
tmpAuthObj.Name = p.HOTEL_GROUP_NAME;
tmpAuthObj.ParentId = p.PARENT_OLD_ID;
tmpAuthObj.Desc = "";
tmpAuthObj.CreateTime = p.KEY_IN_DATETIME;
tmpAuthObj.IsDel = p.IsDel;
if (listauthIds.Contains(p.HOTEL_GROUP_OLD_ID))
{
updateauthlist.Add(tmpAuthObj);
}
else
{
insertauthlist.Add(tmpAuthObj);
}
}
var affectauthResult = SqlSugarBase.Db.Updateable(updateauthlist).UpdateColumns(it => new
{
//it.Id, //不用更新,这个在老表里面已经有正确的值了,
it.Name,
it.ParentId,
it.Desc,
it.CreateTime,
it.IsDel
})
.ExecuteCommand();
if (insertauthlist.Count > 0)
{
//因为在实体类里面声明了 Id 是主键所以生成的insert没有 Id 列。
//但实际上数据表是没有主键的Id 是一个普通列,所以我们必须插入的时候也要设定 Id 的值
//但是有因为sqlsugar内部生成机制会检查实体类里面的主键所以必须手写sql代码来实现插入。
string insSql = "INSERT INTO hotelgroups (Id, `Name`, ParentId, `Desc`, CreateTime, IsDel) VALUES ";
int curPos = 0;
int lastPos = insertauthlist.Count - 1;
foreach (var it in insertauthlist)
{
insSql += String.Format("({0},{1},{2},{3},{4},{5})",
it.Id,
"'" + it.Name + "'",
it.ParentId,
"'" + it.Desc + "'",
"'" + it.CreateTime + "'",
it.IsDel
);
if (curPos == lastPos)
insSql += " ;";
else
insSql += ", ";
curPos++;
}
SqlSugarBase.Db.Ado.ExecuteCommand(insSql);
}
}
//更新成功,记录这次更新时间。
itList[0].LAST_UPDATE_TIME = stTime;
itList[0].LAST_LATESTREC_TIME = dtLastRecTime;
db.Updateable(itList[0]).UpdateColumns(it => new { it.LAST_UPDATE_TIME, it.LAST_LATESTREC_TIME }).ExecuteCommand();
}
}
/// <summary>
/// 同步房型
/// </summary>
/// <param name="db"></param>
/// <param name="stTime"></param>
public static void SyncRoomTypeAll(SqlSugarScope db, DateTime stTime)
{
//0. 取到酒店,酒店组,房型,主机,季度,酒店季度,用户信息表上次最晚记录的记录自己的更新时间
string lastRecTime = "2023-10-08";
List<new_table_update_time_mark> itList = db.Queryable<new_table_update_time_mark>()
.Where(it => it.NEW_DB_TABLE_NAME == "TBL_ROOM_TYPE_LIST")
.ToList();
if (itList.Count > 0)
{
if (itList[0].LAST_LATESTREC_TIME == null)
{
lastRecTime = "2023-10-08";
}
else
{
var timeRec = Convert.ToDateTime(itList[0].LAST_LATESTREC_TIME);
if (timeRec.Year < 2023)
{
lastRecTime = "2023-10-08";
}
else
{
lastRecTime = timeRec.ToString("yyyy-MM-dd HH:mm:ss.fff");
}
}
}
//1. 取到巫工数据库最新记录
List<TBL_ROOM_TYPE_LIST> hoteldata = DataTableHelper.ToEntities<TBL_ROOM_TYPE_LIST>(
SQLSERVER_Helper.GetDatatable(SQLSERVER_Helper.StrConnSqlServer, $@"select
ROOM_TYPE_OLD_ID = B.ID,
HOTEL_OLD_ID = b.[HOTELID] ,
ROOM_TYPE_NAME = b.[NAME],
IsDel = b.IsDeleted,
UPDATE_TIMEMARK = b.Last_Modified_Time,
Creation_Time = GETDATE()
from TB_ROOMTYPE b where Last_Modified_Time > '{lastRecTime}' order by Last_Modified_Time asc;")
);
//2. 从巫工数据库更新到我们的数据库
if (hoteldata.Count > 0)
{
//从SQL server数据库取到的最新记录的记录时间
//冲掉
//从时间戳表里面取的上次记录的时间
DateTime dtLastRecTime = Convert.ToDateTime(hoteldata[0].UPDATE_TIMEMARK);
//记日志
string retStr = "";
for (int i = 0; i < hoteldata.Count; i++)
{
retStr += "编号:" + hoteldata[i].ROOM_TYPE_OLD_ID + "名字:" + hoteldata[i].ROOM_TYPE_NAME;
}
DbLogServer.WriteDbLog($"同步[{GlobalSyncLockTest.gSyncSeq}], 房型表如下记录有更新:" + retStr);
List<TBL_ROOM_TYPE_LIST> updatelist = new List<TBL_ROOM_TYPE_LIST>();
List<TBL_ROOM_TYPE_LIST> insertlist = new List<TBL_ROOM_TYPE_LIST>();
//联系键:
//那边的主键 b.id == 这边的 ROOM_TYPE_OLD_ID
var listIds = db.Queryable<TBL_ROOM_TYPE_LIST>()
.Select(it => new
{
mainID = it.ROOM_TYPE_ID,
outerMainID = it.ROOM_TYPE_OLD_ID
})
.ToList().GroupBy(X => X.outerMainID).Select(X => X.First()).ToDictionary(p => p.outerMainID);
//.ToDictionary(p => p.outerMainID);
//表名实体 ,动态条件
foreach (var p in hoteldata)
{
if (listIds.ContainsKey(p.ROOM_TYPE_OLD_ID))
{
p.ROOM_TYPE_ID = listIds[p.ROOM_TYPE_OLD_ID].mainID;//SQL sugar默认是按主键更新所以主键要正确赋值
updatelist.Add(p);
}
else
insertlist.Add(p);
}
//更新指定列。 只更新取到的那些列
var affectResult = db.Updateable(updatelist).UpdateColumns(it => new
{
//it.ROOM_TYPE_OLD_ID, //不用更新,这个再老表里面已经有正确的值了,
it.HOTEL_OLD_ID,
it.ROOM_TYPE_NAME,
it.Creation_Time,
it.IsDel,
it.UPDATE_TIMEMARK
})
.ExecuteCommand();
//插入所有列
var iAffectResult = db.Insertable(insertlist).ExecuteCommand();
//更新成功,记录这次更新时间。
itList[0].LAST_UPDATE_TIME = stTime;
itList[0].LAST_LATESTREC_TIME = dtLastRecTime;
db.Updateable(itList[0]).UpdateColumns(it => new { it.LAST_UPDATE_TIME, it.LAST_LATESTREC_TIME }).ExecuteCommand();
}
}
//那边的主机表对应这边的房间房间配置表和rcu表
/// <summary>
/// 同步主机
/// </summary>
/// <param name="db"></param>
/// <param name="stTime"></param>
public static void SyncMainDeviceAll(SqlSugarScope db, DateTime stTime)
{
// 主机表,对应这边房间表
//0. 取到酒店,酒店组,房型,主机,季度,酒店季度,用户信息表上次最晚记录的记录自己的更新时间
string lastRecTime = "2023-10-08";
List<new_table_update_time_mark> itList = db.Queryable<new_table_update_time_mark>()
.Where(it => it.NEW_DB_TABLE_NAME == "TBL_ROOM_BASIC_INFO")
.ToList();
if (itList.Count > 0)
{
if (itList[0].LAST_LATESTREC_TIME == null)
{
lastRecTime = "2023-10-08";
}
else
{
var timeRec = Convert.ToDateTime(itList[0].LAST_LATESTREC_TIME);
if (timeRec.Year < 2023)
{
lastRecTime = "2023-10-08";
}
else
{
lastRecTime = timeRec.ToString("yyyy-MM-dd HH:mm:ss.fff");
}
}
}
//1. 取到巫工数据库最新记录
List<Host_> hoteldata = DataTableHelper.ToEntities<Host_>(
SQLSERVER_Helper.GetDatatable(SQLSERVER_Helper.StrConnSqlServer,
$@"select * from tb_Hosts b where LAST_MODIFIED_TIME > '{lastRecTime}' order by Last_Modified_Time asc;")
);
//2. 从巫工数据库更新到我们的数据库
if (hoteldata.Count > 0)
{
//从SQL server数据库取到的最新记录的记录时间
//冲掉
//从时间戳表里面取的上次记录的时间
DateTime dtLastRecTime = Convert.ToDateTime(hoteldata[0].Last_Modified_Time);
//记日志
string retStr = "";
for (int i = 0; i < hoteldata.Count; i++)
{
retStr += "编号:" + hoteldata[i].ID + "酒店编号:" + hoteldata[i].HOTELID + "房间名字:" + hoteldata[i].RoomNumber;
}
DbLogServer.WriteDbLog($"同步[{GlobalSyncLockTest.gSyncSeq}], 主机表如下记录有更新:" + retStr);
#region
List<TBL_ROOM_BASIC_INFO> updatelist = new List<TBL_ROOM_BASIC_INFO>();
List<TBL_ROOM_BASIC_INFO> insertlist = new List<TBL_ROOM_BASIC_INFO>();
//联系键:
//那边的主键 b.id == 这边的 ROOM_OLD_ID
//var rooms
var listIds = db.Queryable<TBL_ROOM_BASIC_INFO>()
.Select(it => new
{
mainID = it.ROOM_ID,
outerMainID = it.ROOM_OLD_ID
})
.ToList()
.GroupBy(X => X.outerMainID).Select(X => X.First()).ToDictionary(p => p.outerMainID);
//var listIds = rooms.ToDictionary(p => p.outerMainID);
foreach (var p in hoteldata)
{
TBL_ROOM_BASIC_INFO tmpObj = new TBL_ROOM_BASIC_INFO();
tmpObj.ROOM_OLD_ID = p.ID;
tmpObj.RoomStatusID = p.RoomStatusID;
tmpObj.MAC = p.MAC;
tmpObj.AUTH_DATETIME = p.ExpireTime;
tmpObj.REMARK = p.Remark;
tmpObj.ROOM_NUMBER = p.RoomNumber;
tmpObj.ROOM_TYPE_OLD_ID = p.RoomTypeID;
tmpObj.HOTEL_OLD_ID = p.HOTELID;
tmpObj.IsDel = p.IsDeleted;
tmpObj.UPDATE_TIMEMARK = DateTime.Now;
if (listIds.ContainsKey(p.ID))
{
tmpObj.ROOM_ID = listIds[p.ID].mainID;//SQL sugar默认是按主键更新所以主键要正确赋值
updatelist.Add(tmpObj);
}
else
{
insertlist.Add(tmpObj);
}
}
//更新指定列。 只更新取到的那些列
var affectResult = db.Updateable(updatelist).UpdateColumns(it => new
{
//it.ROOM_OLD_ID, //不用更新,这个在老表里面已经有正确的值了,
it.RoomStatusID,
it.MAC,
it.AUTH_DATETIME,
it.REMARK,
it.ROOM_NUMBER,
it.ROOM_TYPE_OLD_ID,
it.HOTEL_OLD_ID,
it.IsDel,
it.UPDATE_TIMEMARK
})
.ExecuteCommand();
//插入所有列
var iAffectResult = db.Insertable(insertlist).ExecuteCommand();
#endregion
#region
List<TBL_ROOM_SET_CONFIG> updatecfglist = new List<TBL_ROOM_SET_CONFIG>();
List<TBL_ROOM_SET_CONFIG> insertcfglist = new List<TBL_ROOM_SET_CONFIG>();
//联系键:
//那边的主键 b.id == 这边的 ROOM_OLD_ID
//var listcfgidstupm
var listcfgIds = db.Queryable<TBL_ROOM_SET_CONFIG>()
.Select(it => new
{
mainID = it.ID,
outerMainID = it.ROOM_OLD_ID
})
.ToList()
.GroupBy(X => X.outerMainID).Select(X => X.First()).ToDictionary(p => p.outerMainID);
//var listcfgIds = listcfgidstupm.ToDictionary(p => p.outerMainID);
foreach (var p in hoteldata)
{
TBL_ROOM_SET_CONFIG tmpcfgObj = new TBL_ROOM_SET_CONFIG();
tmpcfgObj.ROOM_OLD_ID = p.ID;
tmpcfgObj.RCU_ROOM = p.RoomNumber;
tmpcfgObj.PRODUCT_CODE = p.HostNumber;
tmpcfgObj.FW_VER = p.Version;
tmpcfgObj.CONFIG_VER = p.ConfigVersion;
tmpcfgObj.RCU_SUB_MASK = p.SubnetMask;
tmpcfgObj.RCU_CLOUD_SVR_IP = p.ServerIP;
tmpcfgObj.RCU_CLOUD_SVR_PORT_MODE = p.ServerPort.ToString();
tmpcfgObj.RCU_LOCAL_IP = p.LanIP;
tmpcfgObj.RCU_LOCAL_PORT = p.LanPort.ToString();
tmpcfgObj.RCU_GETWAY = p.Gateway;
tmpcfgObj.RCU_DNS_SERVER = p.DNS;
tmpcfgObj.REMARK = p.Remark;
tmpcfgObj.IPType = p.IPType;
tmpcfgObj.RCU_CLOUD_SVR_PORT = p.ServerPort.ToString();
tmpcfgObj.IsDel = p.IsDeleted;
tmpcfgObj.UPDATE_TIMEMARK = DateTime.Now;
if (listcfgIds.ContainsKey(p.ID))
{
tmpcfgObj.ID = listcfgIds[p.ID].mainID;//SQL sugar默认是按主键更新所以主键要正确赋值
updatecfglist.Add(tmpcfgObj);
}
else
{
insertcfglist.Add(tmpcfgObj);
}
}
//更新指定列。 只更新取到的那些列
var affectcfgResult = db.Updateable(updatecfglist).UpdateColumns(it => new
{
//it.ROOM_OLD_ID, //不用更新,这个在老表里面已经有正确的值了,
it.RCU_ROOM,
it.PRODUCT_CODE,
it.FW_VER,
it.CONFIG_VER,
it.RCU_SUB_MASK,
it.RCU_CLOUD_SVR_IP,
it.RCU_CLOUD_SVR_PORT_MODE,
it.RCU_LOCAL_IP,
it.RCU_LOCAL_PORT,
it.RCU_GETWAY,
it.RCU_DNS_SERVER,
it.REMARK,
it.IPType,
it.RCU_CLOUD_SVR_PORT,
it.IsDel,
it.UPDATE_TIMEMARK
})
.ExecuteCommand();
//插入所有列
var iAffectcfgResult = db.Insertable(insertcfglist).ExecuteCommand();
#endregion
//更新成功,记录这次更新时间。
itList[0].LAST_UPDATE_TIME = stTime;
itList[0].LAST_LATESTREC_TIME = dtLastRecTime;
db.Updateable(itList[0]).UpdateColumns(it => new { it.LAST_UPDATE_TIME, it.LAST_LATESTREC_TIME }).ExecuteCommand();
#region mac
List<TBL_RCU_BASIC_INFO> updaterculist = new List<TBL_RCU_BASIC_INFO>();
List<TBL_RCU_BASIC_INFO> insertrculist = new List<TBL_RCU_BASIC_INFO>();
try
{
//处理没有mac地址的信息
foreach (var item in hoteldata)
{
if (item.MAC==null || item.MAC.Length < 0)
{
item.MAC= " ";
}
}
var macdata = hoteldata.Select(x => new { MAC = x.MAC.ToUpper(), x.RegisterDate });
//联系键:
//那边的主键 b.id == 这边的 ROOM_OLD_ID
var listrcuIds = db.Queryable<TBL_RCU_BASIC_INFO>()
.Where(x => x.IsImport == 1)
.Select(it => new
{
mainID = it.RCU_ID,
outerMainID = it.MAC.ToUpper()
})
.ToList()
.GroupBy(X => X.outerMainID).Select(X => X.First()).ToDictionary(p => p.outerMainID);
foreach (var item in macdata)
{
if (item.MAC.Length < 0)
continue;
TBL_RCU_BASIC_INFO tmprcuObj = new TBL_RCU_BASIC_INFO();
tmprcuObj.MAC = item.MAC;
tmprcuObj.REGISTER_DATE = item.RegisterDate;
if (listrcuIds.ContainsKey(item.MAC))
{
tmprcuObj.RCU_ID = listrcuIds[item.MAC].mainID;
updaterculist.Add(tmprcuObj);
}
else
{
tmprcuObj.IsImport = 1;
insertrculist.Add(tmprcuObj);
}
}
}
catch (Exception ex)
{
throw;
}
//更新指定列。 只更新取到的那些列
var affectrcuResult = db.Updateable(updaterculist).UpdateColumns(it => new
{
//it.MAC, //不用更新,这个在老表里面已经有正确的值了,
//it.IsImport//不用更新,这个在老表里面已经有正确的值了,
it.REGISTER_DATE
})
.ExecuteCommand();
//插入所有列
var iAffectrcuResult = db.Insertable(insertrculist).ExecuteCommand();
#endregion
}
}
/// <summary>
/// 同步季度
/// </summary>
/// <param name="db"></param>
/// <param name="stTime"></param>
public static void SyncSeasonAll(SqlSugarScope db, DateTime stTime)
{
//1. 取到巫工数据库最新记录
//暂时使用永远更新的方式因为只有4条记录并且两边记录格式个数完全一样。
List<TBL_SEASON> hoteldata = DataTableHelper.ToEntities<TBL_SEASON>(
SQLSERVER_Helper.GetDatatable(SQLSERVER_Helper.StrConnSqlServer, $@"select * from tb_Season b")
);
//2. 从巫工数据库更新到我们的数据库
if (hoteldata.Count > 0)
{
//记日志
string retStr = "";
for (int i = 0; i < hoteldata.Count; i++)
{
retStr += "编号:" + hoteldata[i].ID + "名字:" + hoteldata[i].NAME;
}
DbLogServer.WriteDbLog($"同步[{GlobalSyncLockTest.gSyncSeq}], 季度表总是更新所有记录:" + retStr);
//两个表完全一致,包括主键
var affectResult = db.Updateable(hoteldata).ExecuteCommand();
//更新成功,记录这次更新时间。
List<new_table_update_time_mark> itList = db.Queryable<new_table_update_time_mark>()
.Where(it => it.NEW_DB_TABLE_NAME == "TBL_SEASON")
.ToList();
if (itList.Count > 0)
{
itList[0].LAST_UPDATE_TIME = stTime;
//itList[0].LAST_LATESTREC_TIME = stTime; //巫工那边没有last update date字段
db.Updateable(itList[0]).UpdateColumns(it => new { it.LAST_UPDATE_TIME }).ExecuteCommand();
}
}
}
/// <summary>
/// 同步酒店季度
/// </summary>
/// <param name="db"></param>
/// <param name="stTime"></param>
public static void SyncHotelSeasonAll(SqlSugarScope db, DateTime stTime)
{
//1. 取到巫工数据库最新记录
List<TBL_HOTEL_SEASON> hoteldata = DataTableHelper.ToEntities<TBL_HOTEL_SEASON>(
SQLSERVER_Helper.GetDatatable(SQLSERVER_Helper.StrConnSqlServer, $@"select * from tb_HotelSeason b")
);
//2. 从巫工数据库更新到我们的数据库
if (hoteldata.Count > 0)
{
//记日志
string retStr = "";
for (int i = 0; i < hoteldata.Count; i++)
{
retStr += "编号:" + hoteldata[i].ID + "酒店id" + hoteldata[i].HOTELID;
}
DbLogServer.WriteDbLog($"同步[{GlobalSyncLockTest.gSyncSeq}], 酒店季度表总是更新所有记录:" + retStr);
//找出更新,插入的记录
List<TBL_HOTEL_SEASON> updatelist = new List<TBL_HOTEL_SEASON>();
List<TBL_HOTEL_SEASON> insertlist = new List<TBL_HOTEL_SEASON>();
//联系键:
//那边的主键 ID == 这边的 ID
var listIds = db.Queryable<TBL_HOTEL_SEASON>().Select(it => it.ID).ToList();
//表名实体 ,动态条件
foreach (var p in hoteldata)
{
if (listIds.Contains(p.ID))
{
//p.ID ;//SQL sugar默认是按主键更新所以主键要正确赋值
updatelist.Add(p);
}
else
insertlist.Add(p);
}
//更新指定列。 只更新取到的那些列
var affectResult = db.Updateable(updatelist).UpdateColumns(it => new
{
//it.ID, //不用更新,这个再老表里面已经有正确的值了,
it.MONTH1,
it.MONTH2,
it.MONTH3,
it.MONTH4,
it.MONTH5,
it.MONTH6,
it.MONTH7,
it.MONTH8,
it.MONTH9,
it.MONTH10,
it.MONTH11,
it.MONTH12
})
.ExecuteCommand();
//插入
var iAffectResult = db.Insertable(insertlist).ExecuteCommand();
//更新成功,记录这次更新时间。
List<new_table_update_time_mark> itList = db.Queryable<new_table_update_time_mark>()
.Where(it => it.NEW_DB_TABLE_NAME == "TBL_HOTEL_SEASON")
.ToList();
if (itList.Count > 0)
{
itList[0].LAST_UPDATE_TIME = stTime;
//itList[0].LAST_LATESTREC_TIME = stTime; //巫工那边没有last update date字段
db.Updateable(itList[0]).UpdateColumns(it => new { it.LAST_UPDATE_TIME }).ExecuteCommand();
}
}
}
/// <summary>
/// 同步人员信息
/// </summary>
/// <param name="db"></param>
/// <param name="stTime"></param>
public static void SyncUserInfoAll(SqlSugarScope db, DateTime stTime)
{
//0. 取到酒店,酒店组,房型,主机,季度,酒店季度,用户信息表上次最晚记录的记录自己的更新时间
string lastRecTime = "2023-10-08";
List<new_table_update_time_mark> itList = db.Queryable<new_table_update_time_mark>()
.Where(it => it.NEW_DB_TABLE_NAME == "authoritydb.userinfo")
.ToList();
if (itList.Count > 0)
{
if (itList[0].LAST_LATESTREC_TIME == null)
{
lastRecTime = "2023-10-08";
}
else
{
var timeRec = Convert.ToDateTime(itList[0].LAST_LATESTREC_TIME);
if (timeRec.Year < 2023)
{
lastRecTime = "2023-10-08";
}
else
{
lastRecTime = timeRec.ToString("yyyy-MM-dd HH:mm:ss.fff");
}
}
}
//1. 取到巫工数据库最新记录
List<UserInfo> hoteldata = DataTableHelper.ToEntities<UserInfo>(
SQLSERVER_Helper.GetDatatable(SQLSERVER_Helper.StrConnSqlServer, $@"select
OldId = b.ID,
HotelID = b.[HotelID],
Uid = b.[Account],
Pwd = b.[Password],
Sex = case when b.[Sex]='男' then 0 when b.[Sex]='女' then 1 else 2 end,
[Desc] = b.[Remark],
IsValid = case when b.[ActiveIndicator]=1 then 0 else 1 end ,
CreateTime = b.[CreatedDate],
EndTime = DATEADD(month,2,b.CreatedDate),
HotelGroupID = b.[SysHotelGroupID],
IsImport = 1,
SyncTime = b.[Last_Modified_Time],
IsDel = b.IsDeleted
from tb_Sys_Users b where Last_Modified_Time > '{lastRecTime}' order by Last_Modified_Time asc;")
);
//2. 从巫工数据库更新到我们的数据库
if (hoteldata.Count > 0)
{
//从SQL server数据库取到的最新记录的记录时间
//冲掉
//从时间戳表里面取的上次记录的时间
DateTime dtLastRecTime = Convert.ToDateTime(hoteldata[0].SyncTime);
//记日志
string retStr = "";
for (int i = 0; i < hoteldata.Count; i++)
{
retStr += "编号:" + hoteldata[i].OldId + "名字:" + hoteldata[i].Uid;
}
DbLogServer.WriteDbLog($"同步[{GlobalSyncLockTest.gSyncSeq}], 用户表如下记录有更新:" + retStr);
List<UserInfo> updatelist = new List<UserInfo>();
List<UserInfo> insertlist = new List<UserInfo>();
//联系键:
//那边的主键 b.id == 这边的 OldId
//var listidstump
var listIds = SqlSugarBase.Db.Queryable<UserInfo>()
.Where(it => it.OldId != 0)
.Select(it => new
{
mainID = it.Id,
outerMainID = it.OldId
}).ToList().GroupBy(X => X.outerMainID).Select(X => X.First()).ToDictionary(p => p.outerMainID);
//.ToList();
//var listIds = listidstump.ToDictionary(p => p.outerMainID);
foreach (var p in hoteldata)
{
if (listIds.ContainsKey(p.OldId))
{
p.Id = listIds[p.OldId].mainID;//SQL sugar默认是按主键更新所以主键要正确赋值
p.EndTime = DateTime.Now.AddYears(200);
updatelist.Add(p);
}
else
{
p.Autho = 0;
p.EndTime = DateTime.Now.AddYears(200);
insertlist.Add(p);
}
}
//更新指定列。 只更新取到的那些列
var affectResult = SqlSugarBase.Db.Updateable(updatelist).UpdateColumns(it => new
{
//it.OldId, //不用更新,这个再老表里面已经有正确的值了,
it.HotelGroupID,
it.HotelID,
it.CreateTime,
it.Desc,
it.Sex,
it.Uid,
it.Pwd
})
.ExecuteCommand();
//插入所有列
var iAffectResult = SqlSugarBase.Db.Insertable(insertlist).ExecuteCommand();
//更新成功,记录这次更新时间。
itList[0].LAST_UPDATE_TIME = stTime;
itList[0].LAST_LATESTREC_TIME = dtLastRecTime;
db.Updateable(itList[0]).UpdateColumns(it => new { it.LAST_UPDATE_TIME, it.LAST_LATESTREC_TIME }).ExecuteCommand();
}
}
public static void SyncOrgUserInfoAll(SqlSugarScope db, DateTime stTime)
{
//把这些记录值插入到组用户表里面 insert into OrgUsers (OrgId,UserId,CreateTime,CreatedBy)
// 使用组1作为这些记录的组 select 1,Id,CURTIME(),'系统'
// 用户表中那些不属于任何一组的用户。 where id not in
// 用户属于某一组。select UserId from OrgUsers
//也就是将没有组的用户,都归拢到 组1 去。
string sqlorg = @"insert into OrgUsers (OrgId,UserId,CreateTime,CreatedBy)
select 1,Id,CURTIME(),'' from UserInfo where id not in (
select UserId from OrgUsers
)";
SqlSugarBase.Db.Ado.ExecuteCommand(sqlorg);
}
public static void ClearNotExistHotelAuto(SqlSugarScope db, DateTime stTime)
{
//如果酒店不存在了,
string sqlRemove = "DELETE FROM UserAuthoes b WHERE b.HotelId not in (SELECT id from hotels )";
SqlSugarBase.Db.Ado.ExecuteCommand(sqlRemove);
}
public static void RecreateUserCache()
{
//清除所有
//清除redis里面下列的key
/* authority_autho_sysAuthorityListKey,
authority_autho_sysHotelsListKey,
authority_autho_sysGsInfoListKey,
authority_autho_sysAuthoStatusTypeListKey,
authority_autho_sysOrganizationListKey,
authority_autho_sysOrgAuthorityListKey,
authority_autho_sysOrgUserListKey,
authority_autho_sysErrorInfoListKey,
authority_autho_sysUserAuthoListKey,
authority_autho_sysAppsListKey,
authority_autho_sysUserInfoListKey,
authority_autho_sysAppAuthoListKey,
authority_autho_sysHoteldGroupsListKey,
authority_autho_sysView_UOAListKey,
authority_autho_sysView_UAListKey,
authority_autho_sysDbLogListKey,
authority_autho_sysHostsListKey,
authority_autho_Appversions,
authority_autho_sysMACLogs,
authority_autho_sysALLqxListKey,
authority_autho_sysQxIfoListKey,
authority_autho_sysView_AppAuthoListKey
*/
// 清除缓存
CacheHelp.Removesys(null);
//自动授权
SyncHotelServer.SyncAuthoOptimized();
}
#endregion
#region
#endregion
}
}
public static class GlobalTest
{
public static bool isInProcessing = false;
public static object testLock = new object();
public static DateTime lastStartTime = new DateTime();
}
public class SyncHotelServer
{
//键值对存储酒店的最高就酒店组 如果存在就不需要查找
public static Dictionary<int, List<int>> keyValues = new Dictionary<int, List<int>>();
static object lockstr = "";
static DateTime? oldtime = null;
/// <summary>
/// 同步酒店组信息
/// </summary>
public static bool SyncHotelGroups(string CreatedBy = "系统")
{
try
{
if (oldtime != null && DateTime.Now - oldtime < TimeSpan.FromSeconds(20))
return false;
//排队测试并抢flag.
//只有第一个能通过测试,并抢到。
//后面的都不能通过测试。
lock (GlobalTest.testLock)
{
if (GlobalTest.isInProcessing)
return false;
GlobalTest.isInProcessing = true;
}
//20s只能刷新一次
if (oldtime != null && DateTime.Now - oldtime < TimeSpan.FromSeconds(20))
return false;
GlobalTest.lastStartTime = DateTime.Now;
oldtime = GlobalTest.lastStartTime;
DbLogServer.WriteDbLog($"同步数据。。。开始{oldtime}");
string sql = "CALL porc_user ('{{table}}','{{table}}New')";
#region
//获取酒店的信息
var HotelList = HttpRequestHelp.GetHotelList();
//创建 临时表
string sqlclear = "drop table if exists HotelsNew;Create table HotelsNew(Select * from Hotels); truncate table HotelsNew;";
//db.Database.ExecuteSqlCommand(sqlclear);
SqlSugarBase.Db.Ado.ExecuteCommand(sqlclear);
oldtime = DateTime.Now;
var datatable = GetTableSchema<Hotels>(HotelList.ToArray());//将传入的 Hotels 集合转换成 DataTable 返回
if (BulkToDB("HotelsNew", datatable)) //将 DataTable 写入数据库表 HotelsNew
{
var newsql = sql.Replace("{{table}}", "Hotels"); //调用存储过程porc_user使用 HotelsNew 数据重新生成 Hotels 表
//db.Database.ExecuteSqlCommand(newsql);
SqlSugarBase.Db.Ado.ExecuteCommand(newsql);
};
#endregion
DbLogServer.WriteDbLog($"同步数据。。。1/4酒店同步完成");
#region
var HotelGroups = HttpRequestHelp.GetHotelGroups();
//创建 临时表
// string sqlHotelGroups = "IF EXISTS(Select 1 From Sysobjects Where Name='HotelGroupsNew') begin DROP table HotelGroupsNew end ; select * into HotelGroupsNew from HotelGroups;";
// sqlHotelGroups += @"
//truncate table HotelGroupsNew";
//db.Database.ExecuteSqlCommand(sqlHotelGroups);
string sqlHotelGroups = "drop table if exists HotelGroupsNew;Create table HotelGroupsNew (Select * from HotelGroups);truncate table HotelGroupsNew;";
SqlSugarBase.Db.Ado.ExecuteCommand(sqlHotelGroups);
oldtime = DateTime.Now;
var datatableHotelGroups = GetTableSchema<HotelGroups>(HotelGroups.ToArray());
if (BulkToDB("HotelGroupsNew", datatableHotelGroups))
{
//db.Database.ExecuteSqlCommand(sql.Replace("{{table}}", "HotelGroups"));
SqlSugarBase.Db.Ado.ExecuteCommand(sql.Replace("{{table}}", "HotelGroups"));
};
#endregion
DbLogServer.WriteDbLog($"同步数据。。。2/4酒店组同步完成");
#region
var userinfodata = HttpRequestHelp.GetUserList();
//var OldId = db.UserInfos.Where(x => x.OldId != null || x.OldId > 0).Select(x => x.OldId).ToArray();
//更新数据
//var updata = userinfodata.Where(x => OldId.Contains(x.OldId)).ToList();
foreach (var userInfo in userinfodata)
{
UserInfo item = userInfo;
//UserInfo userinfo = db1.UserInfos.FirstOrDefault(x => x.OldId == item.OldId || x.Uid == item.Uid);
UserInfo userinfo = SqlSugarBase.Db.Queryable<UserInfo>().First(x => x.OldId == item.OldId || x.Uid == item.Uid);
try
{
if (userinfo != null)
{
userinfo.OldId = item.OldId;
//userinfo.IsValid = item.IsValid;
userinfo.HotelGroupID = item.HotelGroupID;
userinfo.HotelID = item.HotelID;
userinfo.CreateTime = item.CreateTime;
userinfo.Desc = item.Desc;
userinfo.Sex = item.Sex;
userinfo.Uid = item.Uid;
if (userinfo.Uid != item.Uid)
{
userinfo.Uid = item.Uid;
}
userinfo.Pwd = item.Pwd;
//db1.Entry(userinfo).State = EntityState.Modified;
SqlSugarBase.Db.Updateable(userinfo).ExecuteCommand();
}
else
{
userinfo = item;
//db.UserInfos.Add(userinfo);
//db1.Entry(userinfo).State = EntityState.Added;
SqlSugarBase.Db.Insertable(userinfo).ExecuteCommand();
}
//db1.SaveChanges();
}
catch (Exception ex)
{
Logs.WriteTimingUDPLog(ex.Message);
Logs.WriteTimingUDPLog("" + userinfo.Id + userinfo.Uid);
Logs.WriteTimingUDPLog("" + item.OldId + item.Uid);
}
//userinfo.EndTime = item.EndTime;
}
//添加数据
//var adddata = userinfodata.Where(x => !OldId.Contains(x.OldId)).ToList();
//db.UserInfos.AddRange(adddata);
//db.SaveChanges();
string sqlorg = "insert into OrgUsers (OrgId,UserId,CreateTime,CreatedBy) select 1,Id,CURTIME(),'系统' from UserInfo where id not in (select UserId from OrgUsers)";
//db.Database.ExecuteSqlCommand(sqlorg);
SqlSugarBase.Db.Ado.ExecuteCommand(sqlorg);
#endregion
DbLogServer.WriteDbLog($"同步数据。。。3/4人员同步完成");
//清除所有
CacheHelp.Removesys(null);
SyncHotelServer.SyncAutho();
DbLogServer.WriteDbLog($"同步数据。。。3.5/4清除缓存完成");
// 刷新权限信息数据
/*foreach (var item in cacheSysUserInfo)
{
UH_CENTER_Help.Sel_Hotel(item.Id, true);
}*/
UH_CENTER_Help.Sel_Hotel_All();
DbLogServer.WriteDbLog($"同步数据。。。4/4UH_CENTER_Help.Sel_Hotel完成");
SqlSugarBase.Db.Ado.ExecuteCommand("DELETE FROM UserAuthoes b WHERE b.HotelId not in (SELECT id from hotels )");
oldtime = DateTime.Now;
DbLogServer.WriteDbLog($"同步数据。。。完成{oldtime}");
//前面排队测试并抢flag.
//只有第一个能通过测试,并抢到。
//后面的都不能通过测试。
//所以只有一个能到这里。不用加锁。
if (GlobalTest.isInProcessing)
GlobalTest.isInProcessing = false;
}
catch (Exception ex)
{
//触发异常在排队测试之后的说明已经抢到flag那么reset
//前面排队测试并抢flag.
//只有第一个能通过测试,并抢到。
//后面的都不能通过测试。
//所以只有一个能到这里。不用加锁。
if (GlobalTest.isInProcessing)
GlobalTest.isInProcessing = false;
LogHelp.WriteExceptionLog(ex);
return false;
}
finally
{
CacheHelp.Removesys(null);
}
return true;
}
/// <summary>
/// 自动授权
/// </summary>
public static void SyncAutho()
{
try
{
//取到Autho是1的人员只有很少几个也不少有37个
var userinfo = CacheHelp.cacheSysUserInfo.Where(x => x.Autho == 1);
//取到所有定义的权限
var appautho = CacheHelp.cacheSysAutho;
List<UserAuthoes> RES = new List<UserAuthoes>();
List<QxIfo> RES_ = new List<QxIfo>();
foreach (var item in userinfo)
{
//得到这个用户的所有所属酒店。(递归所有酒店组)
//结构如下:
//用户在某个酒店上有几项权限
/*
* [
* {"uid":812,"id":706,"sum":8},
* {"uid":812,"id":720,"sum":8},
* {"uid":812,"id":727,"sum":8}
* ]
* 8127068
* 8127208
* 8127278
*/
RES_ = UH_CENTER_Help.Sel_Hotel(item.Id, true);
//用户权限表里面,当前用户的权限。可能有好几条权限
var ua = CacheHelp.cacheSysUserAutho.Where(X => X.UserId == item.Id).ToList();
foreach (var tupm in RES_)//当前用户有权限的每一个酒店
{
foreach (var tupm_ in appautho)//所有定义过的权限功能
{
//在权限表里面找这样的用户,权限的酒店,功能
if (ua.FirstOrDefault(X => X.HotelId == tupm.id && X.AuthorityId == tupm_.Id) == null)
{
var tp = 5;
int.TryParse(tupm_.AuthoStatusTypeId.Split(',').Where(x => x != "6" && x != "1").Last(), out tp);
RES.Add(new UserAuthoes() { AuthorityId = tupm_.Id, CreatedBy = "自动授权", UserId = item.Id, HotelId = tupm.id, AuthotypeId = tp });
}
}
}
}
BulkToDB("UserAuthoes", GetTableSchema(RES.ToArray()));
}
catch (Exception ex)
{
//db.Database.ExecuteSqlCommand("drop table #TEMP");
Logs.WriteTimingUDPLog($"授权失败~{ex.Message}");
}
}
public static void SyncAuthoOptimized()
{
try
{
//1. 取到备用数据
Dictionary<int, Authority> authDic = CacheHelp.cacheSysAutho.ToDictionary(p => p.Id); //Authority 取到权限的定义表
//View_UserInfo视图取到Autho是1的人员只有很少几个也不少有37个
List<View_UserInfo> usrViewList = CacheHelp.cacheSysUserInfo.Where(x => x.Autho == 1).ToList();
List<int> uidList = usrViewList.Select(x => x.Id).ToList();
//UserAuthoes 取到授权表
List<UserAuthoes> authList = SqlSugarBase.Db.Queryable<UserAuthoes>()
.Where(it => uidList.Contains(it.UserId)).ToList();
//酒店信息
List<Hotels> hotelList = SqlSugarBase.Db.Queryable<Hotels>().ToList();
//分成全权限,部分权限两种方式处理。
List<View_UserInfo> superUserViewList = usrViewList.Where(it => it.HotelGroupID == 1 && it.IsImport != 0).ToList();// 导入的酒店组用户
List<View_UserInfo> normalUserViewList = usrViewList.Where(it => it.HotelGroupID != 1 || it.IsImport == 0).ToList();// 非酒店组用户或者非导入用户
//2. 对每一个用户,每一个酒店,每一项权限,如果有漏的,收集。
//收集的权限插入到权限关系表里面去。
List<UserAuthoes> insertAuth = new List<UserAuthoes>();
//2.1. 全权限用户的处理
int curUsrID = -1;
int curHotelId = -1;
int curAuthId = -1;
List<int> fullHotelId = hotelList.Select(x => x.Id).ToList();
List<int> existHotelId = new List<int>();
List<int> shouldAddId = new List<int>();//shouldAddId = fullHotelId.Except(existHotelId).ToList();
//循环导入的酒店组用户
foreach (var dicUsritem in superUserViewList)//每一个用户
{
curUsrID = dicUsritem.Id;
//循环权限
foreach (var authDicItem in authDic)//每一项功能
{
curAuthId = authDicItem.Key;
List<UserAuthoes> matchedHtlList = authList
.Where(it => it.UserId == curUsrID && it.AuthorityId == curAuthId)
.ToList();
existHotelId = matchedHtlList.Select(x => x.HotelId).ToList();
shouldAddId = fullHotelId.Except(existHotelId).ToList();
foreach (int htlid in shouldAddId)
{
var tp = 5;
//权限取值 1禁止 2 只读 3读写 4管理 5允许 6拒绝 authostatustype 权限数值选项 表
//authority 权限表 AuthoStatusTypeId 权限数值选项 多个用逗号分隔 自动授权时排除 6 1 拒绝选项 给予 最大的权限
int.TryParse(authDicItem.Value.AuthoStatusTypeId.Split(',').Where(x => x != "6" && x != "1").Last(), out tp);
insertAuth.Add(new UserAuthoes()
{
AuthorityId = curAuthId,
CreatedBy = "自动授权",
UserId = curUsrID,
HotelId = htlid,
AuthotypeId = tp
});
}
}
}
//2.2. 部分权限用户的处理
// 1.取到权限信息
// 2. 对每一个用户,每一项功能,检查是否分配到每一个酒店上
curUsrID = -1;
curHotelId = -1;
curAuthId = -1;
fullHotelId = new List<int>();
existHotelId = new List<int>();
shouldAddId = new List<int>();
Dictionary<int, List<QxIfo>> normalUsrResult = UH_CENTER_Help.Sel_HotelOptimized(normalUserViewList);
//非酒店组用户或者非导入用户
foreach (var dicUsritem in normalUsrResult)//每一个用户
{
curUsrID = dicUsritem.Key;
List<QxIfo> curUsrHotelList = dicUsritem.Value;
foreach (var authDicItem in authDic)//每一项功能
{
curAuthId = authDicItem.Key;
List<UserAuthoes> matchedHtlList = authList
.Where(it => it.UserId == curUsrID && it.AuthorityId == curAuthId)
.ToList();
fullHotelId = curUsrHotelList.Select(x => x.id).ToList();
existHotelId = matchedHtlList.Select(x => x.HotelId).ToList();
shouldAddId = fullHotelId.Except(existHotelId).ToList();
foreach (int htlid in shouldAddId)
{
var tp = 5;
int.TryParse(authDicItem.Value.AuthoStatusTypeId.Split(',').Where(x => x != "6" && x != "1").Last(), out tp);
insertAuth.Add(new UserAuthoes()
{
AuthorityId = curAuthId,
CreatedBy = "自动授权",
UserId = curUsrID,
HotelId = htlid,
AuthotypeId = tp
});
}
}//每一项功能
}//每一个用户
// 3. 批量插入到用户权限表 UserAuthoes
int insertRowCount = SqlSugarBase.Db.Insertable(insertAuth).ExecuteCommand();
//BulkToDB("UserAuthoes", GetTableSchema(RES.ToArray()));
}
catch (Exception ex)
{
//db.Database.ExecuteSqlCommand("drop table #TEMP");
Logs.WriteTimingUDPLog($"授权失败~{ex.Message}");
}
finally
{
//清楚缓存
CacheHelp.Removesys(syskey.sysUserInfoListKey);
CacheHelp.Removesys(syskey.sysAuthorityListKey);
}
}
/// <summary>
/// 根据酒店组查找下面所有酒店
/// </summary>
/// <param name="Groups"></param>
/// <returns></returns>
public static List<int> FindHotel(int? Groups = 1)
{
var key = int.Parse(Groups.ToString());
if (keyValues.ContainsKey(key))
{
return keyValues[key];
}
List<int> res = new List<int>();
//查找下面的直属酒店
res.AddRange(CacheHelp.cacheHotels.Where(x => x.GroupId == Groups).Select(x => x.Id));
//查找下面的酒店组
var Groupslist = CacheHelp.cacheHoteldGroups.Where(x => x.ParentId == Groups);
foreach (var item in Groupslist)
{
res.AddRange(FindHotel(item.Id));
}
keyValues.Add(key, res);
return res;
}
/// <summary>
/// 组织酒店
/// </summary>
/// <param name="Groups"></param>
/// <returns></returns>
public static List<int> FindGroup(Organization org)
{
return CacheHelp.cacheSysOrgAuthority.Where(x => x.OrgId == org.Id).Select(x => x.HotelId).Distinct().ToList();
}
/// <summary>
/// 酒店权限信息 酒店 权限数
/// </summary>
/// <param name="u"></param>
/// <returns></returns>
public static List<QxIfo> FindUHotelInfo(View_UserInfo Id)
{
try
{
return UH_CENTER_Help.Sel_Hotel(Id);
}
catch (Exception ex)
{
return new List<QxIfo>();
}
finally
{
if (Id != null && string.IsNullOrEmpty(Id.Hotel_Data))
CacheHelp.Removesys(CacheHelp.syskey.sysUserInfoListKey);
}
}
/// <summary>
/// 复制数据到表
/// </summary>
/// <param name="Name">表名</param>
/// <param name="dt">数据</param>
private static bool BulkToDB(string Name, DataTable dt)
{
try
{
MySqlConnection sqlConn = new MySqlConnection(SqlSugarBase.sql);
MySqlBulkCopy bulkCopy = new MySqlBulkCopy(sqlConn);
bulkCopy.DestinationTableName = Name;
//bulkCopy.BatchSize = dt.Rows.Count;
try
{
sqlConn.Open();
if (dt != null && dt.Rows.Count != 0)
bulkCopy.WriteToServer(dt);
}
catch (Exception ex)
{
LogHelp.WriteExceptionLog(ex);
return false;
}
finally
{
sqlConn.Close();
//if (bulkCopy != null)
//bulkCopy.Close();
}
return true;
}
catch (Exception ex)
{
LogHelp.WriteExceptionLog(ex);
return false;
}
}
private static DataTable GetTableSchema<T>(params T[] data)
{
DataTable dt = new DataTable();
T t = System.Activator.CreateInstance<T>();
var Info = t.GetType().GetProperties();
foreach (var item in Info)
{
dt.Columns.AddRange(new DataColumn[]{
new DataColumn(item.Name,item.PropertyType)});
}
foreach (var item in data)
{
var newrow = dt.NewRow();
foreach (var cel in Info)
{
newrow[cel.Name] = cel.GetValue(item);
}
dt.Rows.Add(newrow);
}
return dt;
}
}
}