1051 lines
36 KiB
C#
1051 lines
36 KiB
C#
using System;
|
|
using System.Configuration;
|
|
using System.Collections.Generic;
|
|
using System.Collections.Concurrent;
|
|
using System.Reflection;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Xml;
|
|
using System.Net;
|
|
using System.Data;
|
|
using System.IO;
|
|
using System.Diagnostics;
|
|
using System.Threading;
|
|
using System.Data.SqlClient;
|
|
using Foresight.Security;
|
|
using Foresight.Data;
|
|
using Foresight.ServiceModel;
|
|
using Foresight.Fleet.Services;
|
|
using Foresight.Fleet.Services.Customer;
|
|
using Foresight.Fleet.Services.Asset;
|
|
using Foresight.Fleet.Services.Styles;
|
|
using Foresight.Fleet.Services.Style;
|
|
using IronIntel.Contractor.Users;
|
|
using Foresight.Fleet.Services.User;
|
|
using Foresight.Fleet.Services.SystemOption;
|
|
using Foresight;
|
|
using DocumentFormat.OpenXml.Presentation;
|
|
using DocumentFormat.OpenXml.Spreadsheet;
|
|
|
|
namespace IronIntel.Contractor
|
|
{
|
|
public static class SystemParams
|
|
{
|
|
private static Dictionary<string, string> _CompanyDbString = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
|
|
|
|
private static ConcurrentDictionary<string, string> _Params = new ConcurrentDictionary<string, string>(StringComparer.OrdinalIgnoreCase);
|
|
|
|
private static readonly byte[] KEY = new byte[] { 134, 109, 104, 92, 86, 241, 196, 160, 203, 10, 175, 253, 14, 48, 138, 42, 131, 123, 238, 226, 146, 45, 125, 185, 217, 119, 183, 64, 16, 113, 37, 62 };
|
|
private static readonly byte[] IV = new byte[] { 178, 198, 121, 147, 158, 41, 192, 222, 198, 61, 142, 50, 24, 111, 158, 169 };
|
|
|
|
private static string _ContractorVersion = "";
|
|
private static string _FICVersion = "";
|
|
public const string ICONCOLOR = "?typeid={0}&bkcolor=FF000000&dotcolor=FF69D850&sn={1}";
|
|
|
|
public const string WOSMSFootnotes = "WOSMSFootnotes";
|
|
public const string EstimateMessage = "EstimateMessage";
|
|
public const string DefaultPORequired = "DefaultPORequired";
|
|
public const string InvoiceMessage = "InvoiceMessage";
|
|
|
|
public const string AlertMappingDefaultCategory = "AlertMappingDefaultCategory";
|
|
|
|
private static string EncryptString(string s)
|
|
{
|
|
byte[] buf = Encoding.UTF8.GetBytes(s);
|
|
byte[] tmp = SecurityHelper.AesEncrypt(buf, KEY, IV);
|
|
return Convert.ToBase64String(tmp);
|
|
}
|
|
|
|
private static string GetAssemblyFileVersion()
|
|
{
|
|
try
|
|
{
|
|
string filename = Assembly.GetExecutingAssembly().GetName().Name + ".dll";
|
|
string fn = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "bin\\" + filename);
|
|
FileVersionInfo fv = FileVersionInfo.GetVersionInfo(fn);
|
|
return fv.FileVersion.ToString();
|
|
}
|
|
catch
|
|
{
|
|
return string.Empty;
|
|
}
|
|
}
|
|
|
|
public static void CreateDbObjects()
|
|
{
|
|
try
|
|
{
|
|
FI.FIC.Database.FIC.FICDbInitializer ficdb = new FI.FIC.Database.FIC.FICDbInitializer(FICDbConnectionString);
|
|
ficdb.RunIronIntel();
|
|
}
|
|
catch
|
|
{ }
|
|
}
|
|
|
|
public static string AppVersion
|
|
{
|
|
get
|
|
{
|
|
return GetVersion();
|
|
}
|
|
}
|
|
|
|
internal static string GetCompanyDbString(string companyid)
|
|
{
|
|
string rst = null;
|
|
if (_CompanyDbString.TryGetValue(companyid, out rst))
|
|
{
|
|
return rst;
|
|
}
|
|
try
|
|
{
|
|
CustomerDetail cust = FleetServiceClientHelper.CreateClient<CustomerProvider>(companyid, string.Empty).GetCustomerDetail(companyid);
|
|
string dbstr = cust.MasterDataDbString;
|
|
if (!string.IsNullOrWhiteSpace(dbstr))
|
|
{
|
|
_CompanyDbString[companyid] = dbstr;
|
|
return dbstr;
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
return string.Empty;
|
|
}
|
|
return string.Empty;
|
|
}
|
|
|
|
internal static FISqlConnection GetCompanyDbConnection(string companyid)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(companyid) || string.Compare(companyid, CompanyID, true) == 0)
|
|
{
|
|
return GetDbInstance();
|
|
}
|
|
string s = GetCompanyDbString(companyid);
|
|
if (string.IsNullOrWhiteSpace(s))
|
|
{
|
|
return null;
|
|
}
|
|
else
|
|
{
|
|
return new FISqlConnection(s);
|
|
}
|
|
}
|
|
|
|
private static string DecryptString(string s)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(s))
|
|
{
|
|
return string.Empty;
|
|
}
|
|
byte[] tmp = Convert.FromBase64String(s);
|
|
byte[] buf = SecurityHelper.AesDecrypt(tmp, KEY, IV);
|
|
return Encoding.UTF8.GetString(buf);
|
|
}
|
|
|
|
private static string _HostName = null;
|
|
|
|
public static string HostName
|
|
{
|
|
get
|
|
{
|
|
if (_HostName == null)
|
|
{
|
|
try
|
|
{
|
|
_HostName = Dns.GetHostName();
|
|
}
|
|
catch
|
|
{
|
|
_HostName = string.Empty;
|
|
}
|
|
}
|
|
return _HostName;
|
|
}
|
|
}
|
|
|
|
private static string _DataDbConnectionString = null;
|
|
|
|
/// <summary>
|
|
/// 获取主数据库连接字符串
|
|
/// </summary>
|
|
/// <returns>获取主数据库连接字符串</returns>
|
|
public static string DataDbConnectionString
|
|
{
|
|
get
|
|
{
|
|
if (_DataDbConnectionString == null)
|
|
{
|
|
SqlConnectionStringBuilder sb = new SqlConnectionStringBuilder(ConfigurationManager.AppSettings["DbConntionString"]);
|
|
try
|
|
{
|
|
sb.Password = DecryptString(sb.Password);
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
_DataDbConnectionString = sb.ToString();
|
|
}
|
|
return _DataDbConnectionString;
|
|
}
|
|
}
|
|
|
|
private static string _ficdbstr = null;
|
|
|
|
public static string FICDbConnectionString
|
|
{
|
|
get
|
|
{
|
|
if (_ficdbstr == null)
|
|
{
|
|
string db = GetStringParam("FICSysDBName");
|
|
if (string.IsNullOrWhiteSpace(db))
|
|
{
|
|
_ficdbstr = string.Empty;
|
|
}
|
|
else
|
|
{
|
|
SqlConnectionStringBuilder sc = new SqlConnectionStringBuilder(DataDbConnectionString);
|
|
sc.InitialCatalog = db;
|
|
_ficdbstr = sc.ToString();
|
|
}
|
|
}
|
|
return _ficdbstr;
|
|
}
|
|
}
|
|
|
|
public static FISqlConnection GetDbInstance()
|
|
{
|
|
return new FISqlConnection(DataDbConnectionString);
|
|
}
|
|
|
|
public static FISqlConnection FICDBInstance
|
|
{
|
|
get
|
|
{
|
|
return new FISqlConnection(FICDbConnectionString);
|
|
}
|
|
}
|
|
|
|
public static void SetStringParam(string paramname, string value)
|
|
{
|
|
FleetServiceClientHelper.CreateClient<CustomerProvider>().SetSystemParams(CompanyID, paramname, value);
|
|
_Params[paramname] = value;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 根据参数名称获取参数值
|
|
/// </summary>
|
|
/// <param name="paramname">参数名称</param>
|
|
/// <returns>参数值</returns>
|
|
public static string GetStringParam(string paramname, bool useCache = true, FISqlConnection db = null)
|
|
{
|
|
const string SQL = "select PARAMVALUE from SYSPARAMS with(nolock) where PARAMNAME={0}";
|
|
|
|
string v = null;
|
|
if (useCache && _Params.TryGetValue(paramname, out v))
|
|
{
|
|
return v;
|
|
}
|
|
if (db == null)
|
|
db = GetDbInstance();
|
|
object obj = db.GetRC1BySQL(SQL, paramname);
|
|
v = FIDbAccess.GetFieldString(obj, string.Empty);
|
|
_Params[paramname] = v;
|
|
return v;
|
|
}
|
|
|
|
public static string GetFICStringParam(string paramcode)
|
|
{
|
|
const string SQL = "select PARAMVALUE from SystemParams where PARAMCODE={0}";
|
|
if (string.IsNullOrWhiteSpace(FICDbConnectionString))
|
|
{
|
|
return string.Empty;
|
|
}
|
|
|
|
object obj = FICDBInstance.GetRC1BySQL(SQL, paramcode);
|
|
return FIDbAccess.GetFieldString(obj, string.Empty);
|
|
}
|
|
|
|
public static void SetFICStringParameter(string paramname, string value)
|
|
{
|
|
const string SQL = "if exists(select 1 from SYSTEMPARAMS where PARAMCODE={0}) "
|
|
+ " update SYSTEMPARAMS set PARAMVALUE={1} where PARAMCODE={0} "
|
|
+ " else insert into SYSTEMPARAMS(IID,PARAMTYPE,PARAMCODE,PARAMNAME,PARAMVALUE,PARAMMEMO) values(newid(),1,{0},{0},{1},{0}) ";
|
|
|
|
FICDBInstance.ExecSQL(SQL, paramname, value);
|
|
}
|
|
|
|
private static CustomerInfo _Company = null;
|
|
|
|
public static string CompanyID
|
|
{
|
|
get
|
|
{
|
|
return GetStringParam("CompanyID");
|
|
}
|
|
}
|
|
|
|
private static CustomerDetail _Customer = null;
|
|
private static object _syccust = new object();
|
|
|
|
public static CustomerDetail CustomerDetail
|
|
{
|
|
get
|
|
{
|
|
if (_Customer == null)
|
|
{
|
|
lock (_syccust)
|
|
{
|
|
if (_Customer == null)
|
|
{
|
|
_Customer = FleetServiceClientHelper.CreateClient<CustomerProvider>().GetCustomerDetail(CompanyID);
|
|
}
|
|
}
|
|
}
|
|
return _Customer;
|
|
}
|
|
}
|
|
|
|
private static CustomerDetail _ForesightCustomer = null;
|
|
private static object _sycfcust = new object();
|
|
|
|
public static CustomerDetail ForesightCustomerDetail
|
|
{
|
|
get
|
|
{
|
|
if (_ForesightCustomer == null)
|
|
{
|
|
lock (_sycfcust)
|
|
{
|
|
if (_ForesightCustomer == null)
|
|
{
|
|
_ForesightCustomer = FleetServiceClientHelper.CreateClient<CustomerProvider>().GetCustomerDetail("Foresight");
|
|
}
|
|
}
|
|
}
|
|
return _ForesightCustomer;
|
|
}
|
|
}
|
|
|
|
public static CustomerDetail GetCustomerDetail(string cid)
|
|
{
|
|
return FleetServiceClientHelper.CreateClient<CustomerProvider>().GetCustomerDetail(cid);
|
|
}
|
|
|
|
private static CustomerParams _CurrentCustomerParams = null;
|
|
|
|
public static CustomerParams CurrentCustomerParams
|
|
{
|
|
get
|
|
{
|
|
if (_CurrentCustomerParams == null)
|
|
_CurrentCustomerParams = GetCustomerParams(CompanyID);
|
|
return _CurrentCustomerParams;
|
|
}
|
|
}
|
|
|
|
public static CustomerParams GetCustomerParams(string cid)
|
|
{
|
|
return FleetServiceClientHelper.CreateClient<CustomerProvider>().GetConfiguredParams(cid);
|
|
}
|
|
|
|
public static LicenseInfo GetLicense()
|
|
{
|
|
CustomerProvider ic = FleetServiceClientHelper.CreateClient<CustomerProvider>();
|
|
return ic.GetLicenseInfo(CompanyID);
|
|
}
|
|
|
|
public static bool HasLicense(string itemName)
|
|
{
|
|
bool result = false;
|
|
var license = GetLicense();
|
|
if (license != null && license.Items.Count > 0)
|
|
{
|
|
var item = license.Items.FirstOrDefault(m => m.Key.Equals(itemName, StringComparison.OrdinalIgnoreCase));
|
|
if (item != null && Helper.IsTrue(item.Value))
|
|
result = true;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public static string GetVersion()
|
|
{
|
|
if (string.IsNullOrEmpty(_ContractorVersion))
|
|
{
|
|
_ContractorVersion = GetAssemblyFileVersion();
|
|
}
|
|
return _ContractorVersion;
|
|
}
|
|
|
|
public static string GetFICVersion()
|
|
{
|
|
if (string.IsNullOrEmpty(_FICVersion))
|
|
{
|
|
string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "bin\\FICBLC.dll");
|
|
if (File.Exists(path))
|
|
{
|
|
FileVersionInfo fv = FileVersionInfo.GetVersionInfo(path);
|
|
_FICVersion = fv.FileVersion.ToString();
|
|
}
|
|
}
|
|
return _FICVersion;
|
|
}
|
|
|
|
private static string _ReportDbString = string.Empty;
|
|
|
|
public static string GetIronIntelReportDataDbString(string companyid = null)
|
|
{
|
|
if (string.IsNullOrEmpty(companyid))
|
|
companyid = CompanyID;
|
|
if (!string.IsNullOrWhiteSpace(_ReportDbString))
|
|
{
|
|
return _ReportDbString;
|
|
}
|
|
CustomerDetail cust = FleetServiceClientHelper.CreateClient<CustomerProvider>(companyid, string.Empty).GetCustomerDetail(companyid);
|
|
string dbstring = cust.ReportDataDbString;
|
|
if (!string.IsNullOrEmpty(dbstring))
|
|
{
|
|
_ReportDbString = dbstring;
|
|
return _ReportDbString;
|
|
}
|
|
return string.Empty;
|
|
}
|
|
|
|
static Dictionary<string, string> _CompanyDBStrings = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
|
|
public static string GetDbStringByCompany(string companyid)
|
|
{
|
|
return GetCustomerDbString(companyid, "MASTER_DATA_DB");
|
|
}
|
|
|
|
public static string[] GetMonitorServiceAddresses()
|
|
{
|
|
SystemOptionProvider sp = FleetServiceClientHelper.CreateClient<SystemOptionProvider>();
|
|
string xml = sp.GetMasterSysParam("ForesightPublicService");
|
|
if (string.IsNullOrWhiteSpace(xml))
|
|
{
|
|
return null;
|
|
}
|
|
XmlDocument doc = new XmlDocument();
|
|
doc.LoadXml(xml);
|
|
foreach (XmlNode node in doc.DocumentElement.ChildNodes)
|
|
{
|
|
if (string.Compare(node.Name, "MonitorServiceAddress", true) == 0)
|
|
{
|
|
if (!string.IsNullOrWhiteSpace(node.InnerText))
|
|
{
|
|
return node.InnerText.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public static string GetCustomerDbString(string companyid, string dbtype)
|
|
{
|
|
string key = companyid + dbtype;
|
|
if (_CompanyDBStrings.ContainsKey(key))
|
|
return _CompanyDBStrings[key];
|
|
|
|
CustomerDetail cust = FleetServiceClientHelper.CreateClient<CustomerProvider>(companyid, string.Empty).GetCustomerDetail(companyid);
|
|
string dbstring = cust.MasterDataDbString;
|
|
_CompanyDBStrings[key] = dbstring;
|
|
return dbstring;
|
|
}
|
|
|
|
public static CustomerInfo GetCompanyInfo()
|
|
{
|
|
if (_Company == null)
|
|
{
|
|
var ic = FleetServiceClientHelper.CreateClient<CustomerProvider>(CompanyID);
|
|
_Company = ic.GetCustomerByID(CompanyID);
|
|
}
|
|
return _Company;
|
|
}
|
|
public static MainStyle GetMainStyle()
|
|
{
|
|
var sp = FleetServiceClientHelper.CreateClient<StyleProvider>();
|
|
return sp.GetMainStyle(CompanyID);
|
|
}
|
|
|
|
public static bool IsDealer
|
|
{
|
|
get
|
|
{
|
|
return CustomerDetail.IsDealer;
|
|
}
|
|
}
|
|
|
|
public static CustomerInfo[] GetContractors()
|
|
{
|
|
if (IsDealer)
|
|
{
|
|
var ic = FleetServiceClientHelper.CreateClient<CustomerProvider>(CompanyID);
|
|
return ic.GetContractors(CompanyID);
|
|
}
|
|
else
|
|
{
|
|
return new CustomerInfo[0];
|
|
}
|
|
}
|
|
|
|
public static byte[] GetCompanyLOGO(string companyid)
|
|
{
|
|
return FleetServiceClientHelper.CreateClient<CustomerProvider>(companyid, string.Empty).GetCustomerLOGO(companyid);
|
|
}
|
|
|
|
public static byte[] GetForesightLOGOInMainStyle()
|
|
{
|
|
var sp = FleetServiceClientHelper.CreateClient<StyleProvider>();
|
|
return sp.GetLogoInMainStyle(CompanyID, 1);
|
|
}
|
|
|
|
public static byte[] GetCompanyLocationLOGO(string companyid)
|
|
{
|
|
byte[] buffer = FleetServiceClientHelper.CreateClient<CustomerProvider>(companyid, string.Empty).GetDefaultLocationLOGO(companyid);
|
|
if ((buffer == null) || (buffer.Length == 0))
|
|
{
|
|
return GetCompanyLOGO(companyid);
|
|
}
|
|
else
|
|
{
|
|
return buffer;
|
|
}
|
|
}
|
|
|
|
public static CustomerInfo GetFirstDealerInfo()
|
|
{
|
|
if (IsDealer)
|
|
{
|
|
return GetCompanyInfo();
|
|
}
|
|
else
|
|
{
|
|
var cust = FleetServiceClientHelper.CreateClient<CustomerProvider>(CompanyID);
|
|
var cmps = cust.GetDealers(CompanyID);
|
|
if ((cmps != null) && (cmps.Length > 0))
|
|
{
|
|
return cmps[0];
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private static Dictionary<string, CustomerInfo> _DealerConttactors = new Dictionary<string, CustomerInfo>();
|
|
public static CustomerInfo GetCustomerInfo(string id)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(id)) return null;
|
|
if (!_DealerConttactors.ContainsKey(id))
|
|
{
|
|
var ic = FleetServiceClientHelper.CreateClient<CustomerProvider>(id);
|
|
var c = ic.GetCustomerByID(id);
|
|
_DealerConttactors[id] = c;
|
|
}
|
|
return _DealerConttactors[id];
|
|
}
|
|
|
|
public static bool HasLOGO(string companyid)
|
|
{
|
|
CustomerProvider ic = FleetServiceClientHelper.CreateClient<CustomerProvider>();
|
|
return ic.HasLOGO(companyid);
|
|
}
|
|
public static void ExecSQL(FIDbAccess db, int retrytimes, string sql, params object[] values)
|
|
{
|
|
int n = 0;
|
|
while (true)
|
|
{
|
|
n++;
|
|
try
|
|
{
|
|
db.ExecSQL(sql, values);
|
|
return;
|
|
}
|
|
catch
|
|
{
|
|
if (n >= retrytimes)
|
|
{
|
|
throw;
|
|
}
|
|
}
|
|
System.Threading.Thread.Sleep(100);
|
|
}
|
|
}
|
|
|
|
/**Fleet Service***/
|
|
public static string[] FleetAssetServiceAddresses
|
|
{
|
|
get
|
|
{
|
|
string addresses = ConfigurationManager.AppSettings["FleetAssetServiceAddress"];
|
|
if (!string.IsNullOrWhiteSpace(addresses))
|
|
return addresses.Split(';');
|
|
return new string[0];
|
|
}
|
|
}
|
|
|
|
//public static T GetFleetServiceClient<T>() where T : Foresight.Fleet.Services.RemoteClientBase, new()
|
|
//{
|
|
// T rst = (T)System.Activator.CreateInstance(typeof(T), new object[] { FleetAssetServiceAddresses });
|
|
// return rst;
|
|
//}
|
|
|
|
//public static T GetFleetServiceClient<T>(string sessionid, string workingCompanyID) where T : Foresight.Fleet.Services.RemoteClientBase, new()
|
|
//{
|
|
// T rst = (T)System.Activator.CreateInstance(typeof(T), new object[] { FleetAssetServiceAddresses });
|
|
// rst.SessionID = sessionid;
|
|
// rst.WorkingCompanyID = sessionid;
|
|
// return rst;
|
|
//}
|
|
|
|
|
|
private static string _MachineTypeMapViewIconUrl = string.Empty;
|
|
public static string MachineTypeMapViewIconUrl
|
|
{
|
|
get
|
|
{
|
|
if (string.IsNullOrWhiteSpace(_MachineTypeMapViewIconUrl))
|
|
{
|
|
var client = FleetServiceClientHelper.CreateClient<AssetClassProvider>();
|
|
_MachineTypeMapViewIconUrl = client.GetMachineTypeIconUrl();
|
|
}
|
|
return _MachineTypeMapViewIconUrl;
|
|
}
|
|
}
|
|
private static string _MachineMovingIconUrl = string.Empty;
|
|
public static string MachineMovingIconUrl
|
|
{
|
|
get
|
|
{
|
|
if (string.IsNullOrWhiteSpace(_MachineMovingIconUrl))
|
|
{
|
|
var client = FleetServiceClientHelper.CreateClient<AssetClassProvider>();
|
|
_MachineMovingIconUrl = client.GetMachineMovingIconUrl();
|
|
}
|
|
return _MachineMovingIconUrl;
|
|
}
|
|
}
|
|
|
|
public static CustUIStyle GetUIStyle(string useriid)
|
|
{
|
|
//var up = UserParams.GetUserParams(useriid);
|
|
string sid = UserParams.GetStringParameter(useriid, UserParams._SystemStyleID);
|
|
int styleID = -1;
|
|
if (string.IsNullOrEmpty(sid) || !int.TryParse(sid, out styleID))
|
|
styleID = -1;
|
|
var sp = FleetServiceClientHelper.CreateClient<StyleProvider>();
|
|
CustUIStyle style = sp.GetDefaultUIStyle(CompanyID, styleID);
|
|
return style;
|
|
}
|
|
|
|
public static TimeZoneInfo GetTimeZoneInfo(string custid)
|
|
{
|
|
string tzName = FleetServiceClientHelper.CreateClient<CustomerProvider>(custid, string.Empty).GetCustomerTimeZoneName(custid);
|
|
var tz = TimeZoneInfo.FindSystemTimeZoneById(tzName.Trim());
|
|
return tz;
|
|
}
|
|
|
|
public static StringKeyValue[] GetTimeZones()
|
|
{
|
|
var tzs = TimeZoneInfo.GetSystemTimeZones();
|
|
List<StringKeyValue> result = new List<StringKeyValue>();
|
|
DateTime now = DateTime.UtcNow;
|
|
foreach (TimeZoneInfo tz in tzs.OrderBy(tz => tz.GetUtcOffset(now)).ThenBy(tz => tz.Id))
|
|
{
|
|
StringKeyValue skv = new StringKeyValue();
|
|
skv.Key = tz.Id;
|
|
TimeSpan offset = tz.GetUtcOffset(now);//tz.BaseUtcOffset; BaseUtcOffset有问题
|
|
skv.Value = string.Format("{0}{1}:{2}", offset.Hours >= 0 ? "+" : "", offset.Hours.ToString("00"), Math.Abs(offset.Minutes).ToString("00"));
|
|
|
|
skv.Tag1 = offset.TotalMinutes.ToString();
|
|
result.Add(skv);
|
|
}
|
|
return result.ToArray();
|
|
}
|
|
|
|
public static DateTime ConvertToUserTimeFromUtc(Foresight.Fleet.Services.User.UserInfo ui, DateTime utctime)
|
|
{
|
|
TimeZoneInfo timeZone = null;
|
|
if (!string.IsNullOrWhiteSpace(ui.TimeZone))
|
|
{
|
|
timeZone = TimeZoneInfo.FindSystemTimeZoneById(ui.TimeZone);
|
|
}
|
|
|
|
if (timeZone == null)
|
|
{
|
|
if (ui.IsForesightUser)
|
|
timeZone = ForesightCustomerDetail.TimeZone;
|
|
else
|
|
timeZone = CustomerDetail.TimeZone;
|
|
}
|
|
|
|
return TimeZoneInfo.ConvertTimeFromUtc(new DateTime(utctime.Ticks), timeZone);
|
|
}
|
|
|
|
public static string GetUserTimeZoneId(Foresight.Fleet.Services.User.UserInfo ui)
|
|
{
|
|
string tzid = ui.TimeZone;
|
|
if (!string.IsNullOrWhiteSpace(tzid))
|
|
return tzid;
|
|
|
|
if (ui.IsForesightUser)
|
|
tzid = ForesightCustomerDetail.TimeZoneId;
|
|
else
|
|
tzid = CustomerDetail.TimeZoneId;
|
|
|
|
return tzid;
|
|
}
|
|
|
|
public const string APPNAME = "IronIntelCustomerSite";
|
|
private const string WORKING_COMPANY_HEADER = "WorkingCompanyID";
|
|
|
|
public static long SendMail(System.Net.Mail.MailMessage msg)
|
|
{
|
|
return SendMail(APPNAME, msg);
|
|
}
|
|
|
|
public static long SendMail(string appname, System.Net.Mail.MailMessage msg)
|
|
{
|
|
return FleetServiceClientHelper.CreateClient<SystemUtil>().SendMail(CompanyID, appname, msg);
|
|
}
|
|
|
|
public static void WriteLog(string logType, string source, string message, string detail)
|
|
{
|
|
try
|
|
{
|
|
FleetServiceClientHelper.CreateClient<SystemUtil>().WriteLog(CompanyID, APPNAME, logType, source, message, detail, string.Empty);
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
}
|
|
|
|
public static void WriteLog(string logType, string category, string source, string message, string detail)
|
|
{
|
|
try
|
|
{
|
|
FleetServiceClientHelper.CreateClient<SystemUtil>().WriteLog(CompanyID, category, logType, source, message, detail, string.Empty);
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
}
|
|
|
|
public static void WriteLog_Ext(string logType, string source, string message, string detail, string extmsg)
|
|
{
|
|
try
|
|
{
|
|
FleetServiceClientHelper.CreateClient<SystemUtil>().WriteLog(CompanyID, APPNAME, logType, source, message, detail, extmsg);
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
}
|
|
|
|
public static void WriteRefreshLog(string useriid, string userhost, string objname, string refreshtype)
|
|
{
|
|
ThreadPool.QueueUserWorkItem(new WaitCallback((e) => { _WriteRefreshLog(useriid, userhost, objname, refreshtype); }), null);
|
|
}
|
|
|
|
|
|
private static void _WriteRefreshLog(string useriid, string userhost, string objname, string refreshtype)
|
|
{
|
|
const string SQL = "insert into REFRESHLOG(USERIID,HOSTADDRESS,OBJNAME,REFRESHTYPE,REFRESHTIME_UTC) values({0},{1},{2},{3},GETUTCDATE())";
|
|
|
|
try
|
|
{
|
|
FIDbAccess db = GetDbInstance();
|
|
db.ExecSQL(SQL, useriid, userhost, objname, refreshtype);
|
|
}
|
|
catch
|
|
{ }
|
|
}
|
|
|
|
public static string GetResourceLock(string resourceid, int locksecond)
|
|
{
|
|
try
|
|
{
|
|
return FleetServiceClientHelper.CreateClient<SystemUtil>().GetResourceLock(CompanyID, resourceid, locksecond);
|
|
}
|
|
catch
|
|
{
|
|
return "";
|
|
}
|
|
}
|
|
|
|
public static void ReleaseResourceLock(string lockid)
|
|
{
|
|
try
|
|
{
|
|
FleetServiceClientHelper.CreateClient<SystemUtil>().ReleaseResourceLock(lockid);
|
|
}
|
|
catch
|
|
{ }
|
|
}
|
|
|
|
public static string ConnectorToken
|
|
{
|
|
get
|
|
{
|
|
return GetFICStringParam("ConnectorToken");
|
|
}
|
|
}
|
|
|
|
public static string ConnectorServer
|
|
{
|
|
get
|
|
{
|
|
return GetFICStringParam("ConnectorServer");
|
|
}
|
|
}
|
|
|
|
public static string LdapAgentID
|
|
{
|
|
get
|
|
{
|
|
return GetFICStringParam("LdapAgentID");
|
|
}
|
|
}
|
|
|
|
public static string LdapAgentToken
|
|
{
|
|
get
|
|
{
|
|
return GetFICStringParam("LdapAgentToken");
|
|
}
|
|
}
|
|
public static bool CanUseConnectorLDAP
|
|
{
|
|
get
|
|
{
|
|
return GetFICStringParam("CanUseConnectorLDAP") == "1";
|
|
}
|
|
}
|
|
public static bool RedisEnabled
|
|
{
|
|
get
|
|
{
|
|
return string.Equals(GetFICStringParam("RedisEnabled"), "Yes", StringComparison.OrdinalIgnoreCase);
|
|
}
|
|
}
|
|
|
|
public static string RedisToken
|
|
{
|
|
get
|
|
{
|
|
return GetFICStringParam("RedisToken");
|
|
}
|
|
}
|
|
|
|
public static Dictionary<string, string> GetAdditionalParameter()
|
|
{
|
|
StringKeyValue connector = new StringKeyValue();
|
|
|
|
string connectorxml = GetStringParam("Connector");
|
|
StringKeyValue[] connectors = ConnectorHelper.FromXML(connectorxml);
|
|
if (connectors != null && connectors.Length > 0)
|
|
connector = connectors[0];
|
|
|
|
var dict = new Dictionary<string, string>
|
|
{
|
|
{ "ConnectorServer", connector.Key },
|
|
{ "ConnectorToken", connector.Value },
|
|
{ "LdapAgentID", LdapAgentID },
|
|
{ "LdapAgentToken", LdapAgentToken },
|
|
{ "CanUseConnectorLDAP", CanUseConnectorLDAP ? "1" : "0" }
|
|
};
|
|
|
|
return dict;
|
|
}
|
|
|
|
private static ConcurrentDictionary<string, Dictionary<string, object>> _Languages = new ConcurrentDictionary<string, Dictionary<string, object>>(StringComparer.OrdinalIgnoreCase);
|
|
private static Dictionary<string, object> GetLanguage(string lang)
|
|
{
|
|
if (!_Languages.ContainsKey(lang))
|
|
{
|
|
var ldata = LoadLanguage(lang);
|
|
if (ldata != null)
|
|
{
|
|
_Languages[lang] = ldata;
|
|
return ldata;
|
|
}
|
|
}
|
|
else
|
|
return _Languages[lang];
|
|
|
|
return null;
|
|
}
|
|
|
|
public static Dictionary<string, object> LoadLanguage(string lang)
|
|
{
|
|
try
|
|
{
|
|
if (string.IsNullOrEmpty(lang))
|
|
lang = "en-us";
|
|
|
|
string filename = lang + ".json";
|
|
string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Languages\\" + filename);
|
|
TextReader tr = File.OpenText(path);
|
|
Newtonsoft.Json.JsonTextReader jtr = new Newtonsoft.Json.JsonTextReader(tr);
|
|
Newtonsoft.Json.Linq.JObject obj = Newtonsoft.Json.Linq.JObject.Load(jtr);
|
|
|
|
System.Web.Script.Serialization.JavaScriptSerializer js = new System.Web.Script.Serialization.JavaScriptSerializer();
|
|
Dictionary<string, object> dic = (Dictionary<string, object>)js.DeserializeObject(obj["Values"].ToString());
|
|
|
|
return dic;
|
|
}
|
|
catch
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public static string GetTextByKey(string lang, string key, string defaultValue)
|
|
{
|
|
try
|
|
{
|
|
Dictionary<string, object> dic = GetLanguage(lang);
|
|
if (dic == null || !dic.ContainsKey(key))
|
|
return defaultValue;
|
|
return dic[key].ToString();
|
|
}
|
|
catch
|
|
{
|
|
return defaultValue;
|
|
}
|
|
}
|
|
|
|
public static string _TimeZoneAbbreviation = "";
|
|
public static string TimeZoneAbbreviation
|
|
{
|
|
get
|
|
{
|
|
if (string.IsNullOrEmpty(_TimeZoneAbbreviation))
|
|
{
|
|
_TimeZoneAbbreviation = GetUpperTimeZone(CustomerDetail.TimeZone.Id);
|
|
//Dictionary<string, string> dic = GetTimeZoneAbbreviations();
|
|
//if (dic.ContainsKey(CustomerDetail.TimeZone.Id))
|
|
// _TimeZoneAbbreviation = dic[CustomerDetail.TimeZone.Id];
|
|
//else
|
|
// _TimeZoneAbbreviation = CustomerDetail.TimeZone.Id;
|
|
}
|
|
return _TimeZoneAbbreviation;
|
|
}
|
|
}
|
|
|
|
private static string GetUpperTimeZone(string tzid)
|
|
{
|
|
tzid = System.Text.RegularExpressions.Regex.Replace(tzid, @"\(.*\)", "");
|
|
return System.Text.RegularExpressions.Regex.Replace(tzid, @"[a-z ]*", "");
|
|
}
|
|
|
|
public static bool ShowForesightLogo()
|
|
{
|
|
string temp = GetStringParam("ShowForesightLogo");
|
|
if (string.IsNullOrEmpty(temp))
|
|
return true;
|
|
return Helper.IsTrue(temp);
|
|
}
|
|
|
|
public static string GetUserLanguage(string useriid)
|
|
{
|
|
var uc = FleetServiceClientHelper.CreateClient<UserQueryClient>();
|
|
string language = uc.GetUserPreferredLanguageByIID(useriid);
|
|
if (string.IsNullOrEmpty(language))
|
|
{
|
|
var ic = FleetServiceClientHelper.CreateClient<CustomerProvider>(CompanyID);
|
|
var cust = ic.GetCustomerByID(CompanyID);
|
|
language = cust.LanguageId;
|
|
}
|
|
|
|
return string.IsNullOrEmpty(language) ? "en-us" : language;
|
|
}
|
|
|
|
|
|
public static bool CheckRight(string custid, Foresight.Fleet.Services.User.UserInfo user, int featureid, Permissions per = Permissions.ReadOnly)
|
|
{
|
|
if (user == null)
|
|
return false;
|
|
|
|
if (user.UserType == Foresight.Fleet.Services.User.UserTypes.SupperAdmin)
|
|
return true;
|
|
|
|
if (user.UserType == Foresight.Fleet.Services.User.UserTypes.Common || user.UserType == Foresight.Fleet.Services.User.UserTypes.Admin)
|
|
{
|
|
var client = FleetServiceClientHelper.CreateClient<PermissionProvider>();
|
|
Tuple<Feature, Permissions>[] pmss = client.GetUserPermissions(custid, user.UID);
|
|
if (pmss.Length > 0)
|
|
{
|
|
Tuple<Feature, Permissions> permission = pmss.FirstOrDefault(m => m.Item1.Id == featureid);
|
|
if (permission != null && permission.Item2 >= per)
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public class ConnectorHelper
|
|
{
|
|
public static StringKeyValue[] FromXML(string xmlstr)
|
|
{
|
|
List<StringKeyValue> ls = new List<StringKeyValue>();
|
|
if (!string.IsNullOrEmpty(xmlstr))
|
|
{
|
|
XmlDocument doc = new XmlDocument();
|
|
doc.LoadXml(xmlstr);
|
|
XmlNode ch = doc.DocumentElement.FirstChild;
|
|
if (string.Compare(ch.Name, "Connectors", true) == 0)
|
|
{
|
|
foreach (XmlNode node in ch.ChildNodes)
|
|
{
|
|
ls.Add(FromXml(node));
|
|
}
|
|
}
|
|
}
|
|
return ls.ToArray();
|
|
}
|
|
|
|
private static StringKeyValue FromXml(XmlNode node)
|
|
{
|
|
StringKeyValue kv = new StringKeyValue();
|
|
foreach (XmlNode ch in node.ChildNodes)
|
|
{
|
|
if (string.Compare(ch.Name, "Server", true) == 0)
|
|
kv.Key = ch.InnerText;
|
|
else if (string.Compare(ch.Name, "Token", true) == 0)
|
|
kv.Value = ch.InnerText;
|
|
|
|
}
|
|
return kv;
|
|
}
|
|
|
|
public static XmlDocument ToXml(StringKeyValue[] kvs)
|
|
{
|
|
XmlDocument doc = XmlHelper.CreateXmlDocument();
|
|
XmlNode node = XmlHelper.AppendChildNode(doc.DocumentElement, "Connectors", "");
|
|
if (kvs != null && kvs.Length > 0)
|
|
{
|
|
foreach (var kv in kvs)
|
|
{
|
|
var sn = AddSubNode(node, "Connector", "");
|
|
|
|
AddSubNode(sn, "Server", kv.Key);
|
|
AddSubNode(sn, "Token", kv.Value);
|
|
}
|
|
}
|
|
return doc;
|
|
}
|
|
|
|
private static XmlNode AddSubNode(XmlNode parent, string nodename, string innertext)
|
|
{
|
|
XmlNode node = parent.OwnerDocument.CreateNode(XmlNodeType.Element, nodename, string.Empty);
|
|
if (!string.IsNullOrEmpty(innertext))
|
|
{
|
|
node.InnerText = innertext;
|
|
}
|
|
parent.AppendChild(node);
|
|
return node;
|
|
}
|
|
|
|
}
|
|
}
|