private async void Form1_OnLoad(object sender, EventArgs e)
{
while (true)
{
var ringReq = WebRequest.Create(frontendUri);
ringReq.Method = "DIAG";
RingNode[] ringNodeArray;
using (var ringResp = await ringReq.GetResponseAsync())
{
var ringNodeSerializer = new XmlSerializer(typeof(RingNode[]), new XmlRootAttribute { ElementName = "Ring" });
ringNodeArray = (RingNode[])ringNodeSerializer.Deserialize(ringResp.GetResponseStream());
}
var allData = new System.Collections.Concurrent.ConcurrentBag<Tuple<int, string, byte[]>>();
Parallel.ForEach(ringNodeArray, node =>
{
var req = WebRequest.Create(node.NodeUri);
req.Method = "DIAG";
using (var resp = req.GetResponse())
{
var kvpsSerializer = new XmlSerializer(typeof(SerializableKeyValuePair));
var tmpKvps = kvpsSerializer.Deserialize(resp.GetResponseStream()) as SerializableKeyValuePair[];
foreach (var kvp in tmpKvps)
{
allData.Add(new Tuple<int, string, byte[]>(node.RingId, kvp.Key, kvp.Value));
}
}
});
this.listView1.Items.Clear();
this.listView1.Items.AddRange(allData.Select(t =>
new ListViewItem(new string[] {t.Item1.ToString(), t.Item2, Encoding.Default.GetString(t.Item3)})).ToArray());
}
}
/// <summary>
/// 获取库存信息
/// </summary>
/// <param name="orderCodeList">订单编号数组</param>
/// <returns></returns>
public List <ErpOrderStatusList> GetXMOrderStatus(List <RequestOrderStatusList> orderStatusList, Header header)
{
var baseProductbag = new System.Collections.Concurrent.ConcurrentBag <RequestOrderStatusList>();
var baseProductDictionary = new System.Collections.Concurrent.ConcurrentDictionary <string, List <string> >();//存储每个订单号和五道编码对应的拆分后的erp商品编码
#region 如果传回的商品编号中有组合商品的商品编号，则将组合商品拆分为基础商品数组
orderStatusList.AsParallel().ForAll(m =>
{
setProductNum(m, baseProductbag, baseProductDictionary);
});
#endregion
var MerchantCodeList = baseProductbag.Select(m => m.PlatformMerchantCode).ToList();
var OrderCodeList = baseProductbag.Select(m => m.OrderCode).ToList();
var sqlMerchantCodeList = string.Join("','", MerchantCodeList);
var sqlOrderNoList = string.Join("','", OrderCodeList);
var sql = string.Format(@"select a.PlatformMerchantCode,a.OrderNo as OrderCode,b.IsDelivery,c.LogisticsName,b.LogisticsNumber
from XM_Delivery_Details a join XM_Delivery b on b.Id = a.DeliveryId left join XM_CompanyCustom c on b.LogisticsId = c.LogisticsId where a.PlatformMerchantCode in ('{0}') and a.OrderNo in ('{1}') and b.IsEnabled = 0", sqlMerchantCodeList, sqlOrderNoList);//插入主表的sql语句
var dt = SqlDataHelper.GetDatatableBySql(sql);
var ErpOrderStatusList = CurUtilManager.ToEntity <ErpOrderStatusList>(dt);
var returnEntity = returnOrderStatus(orderStatusList, baseProductDictionary, ErpOrderStatusList.ToList());
#region 判断传入的订单号和商品编号是否都找到对应的订单信息
var returnOrderList = returnEntity.Select(m => new
{
Code = m.OrderCode + "_" + m.PlatformMerchantCode
}).Select(m => m.Code).ToList();
var returnorderList = orderStatusList.Select(m => new
{
Code = m.OrderCode + "_" + m.PlatformMerchantCode
}).Select(m => m.Code).ToList();
var ExceptList = returnorderList.Except(returnOrderList).ToList();
if (ExceptList.Count > 0)
{
header.IsSuccess = false;
header.Message = string.Format("这些订单号和商品编号组合{0}在ERP中无法找到对应的订单状态信息", string.Join(",", ExceptList));
}
#endregion
return(returnEntity);
}
public ActionResult ImportDataProcess(string id, CreateSimpleModel model, FormCollection form)
{
var email = Request?.RequestContext?.HttpContext?.User?.Identity?.Name;
if (Request.IsAuthenticated == false)
{
//https://www.hlidacstatu.cz/account/Login?returnUrl=%2F%3Frnd%3D0036bd9be9bc42d4bdf449492968846e
return(RedirectToAction("Login", "Account", new { returnUrl = this.Request.Url.PathAndQuery }));
}
ViewBag.NumOfRows = 0;
model.DatasetId = id;
string[] csvHeaders = null;
if (string.IsNullOrEmpty(id))
{
return(Redirect("/data"));
}
var ds = DataSet.CachedDatasets.Get(id);
if (ds == null)
{
return(Redirect("/data"));
}
if (ds.HasAdminAccess(email) == false)
{
return(View("NoAccess"));
}
datasetIndexStatCache.Invalidate();
if (ds.IsFlatStructure() == false)
{
return(RedirectToAction("ImportData", new { id = ds.DatasetId, fileId = model.FileId, delimiter = model.GetValidDelimiter() }));
}
var uTmp = new Lib.IO.UploadedTmpFile();
var path = uTmp.GetFullPath(model.FileId.ToString(), model.FileId.ToString() + ".csv");
if (!System.IO.File.Exists(path))
{
return(RedirectToAction("ImportData", new { id = ds.DatasetId }));
}
RuntimeClassBuilder rcb = new RuntimeClassBuilder(ds.GetPropertyNamesTypesFromSchema().ToDictionary(m => m.Key, v => v.Value.Type));
string[] formsHeaders = form["sheaders"].Split('|');
List <MappingCSV> mappingProps = new List <MappingCSV>();
for (int i = 0; i < formsHeaders.Length + 3; i++) //+3 a little bit more, at least +1 for id column
{
if (!string.IsNullOrEmpty(form["source_" + i]) &&
!string.IsNullOrEmpty(form["target_" + i]) &&
!string.IsNullOrEmpty(form["transform_" + i])
)
{
mappingProps.Add(new MappingCSV()
{
sourceCSV = form["source_" + i],
TargetJSON = form["target_" + i],
Transform = form["transform_" + i]
}
);
}
}
System.Collections.Concurrent.ConcurrentBag <Exception> errors = new System.Collections.Concurrent.ConcurrentBag <Exception>();
List <Tuple <object, string> > items = new List <Tuple <object, string> >();
try
{
using (System.IO.StreamReader r = new System.IO.StreamReader(path))
{
if (model.Delimiter == "auto")
{
model.Delimiter = Devmasters.IO.IOTools.DetectCSVDelimiter(r);
}
var csv = new CsvHelper.CsvReader(r, new CsvHelper.Configuration.CsvConfiguration(Util.Consts.csCulture)
{
HasHeaderRecord = true
,
Delimiter = model.GetValidDelimiter()
//,MissingFieldFound = null
}
);
csv.Read(); csv.ReadHeader();
csvHeaders = csv.HeaderRecord.Where(m => !string.IsNullOrEmpty(m?.Trim())).ToArray(); //for future control
while (csv.Read())
{
var newObj = rcb.CreateObject();
for (int m = 0; m < mappingProps.Count; m++)
{
Type destType = ds.GetPropertyNameTypeFromSchema(mappingProps[m].TargetJSON).FirstOrDefault().Value.Type;
object value = null;
string[] specialValues = new string[] { "-skip-", "-gen-", "--" };
if (specialValues.Contains(mappingProps[m].sourceCSV))
{
if (mappingProps[m].sourceCSV == "-gen-")
{
value = Guid.NewGuid().ToString("N");
rcb.SetPropertyValue(newObj, mappingProps[m].TargetJSON, value);
}
else
{
continue; // -skip- skip
}
}
else
{
string svalue = null;
try
{
svalue = csv.GetField(mappingProps[m].sourceCSV);
if (destType == typeof(string))
{
value = svalue;
}
else if (destType == typeof(DateTime) || destType == typeof(DateTime?))
{
value = Devmasters.DT.Util.ToDateTime(svalue);
}
else if (destType == typeof(decimal) || destType == typeof(decimal?))
{
value = Util.ParseTools.ToDecimal(svalue);
if (value == null)
{
value = Util.ParseTools.FromTextToDecimal(svalue);
}
}
else if (destType == typeof(long) || destType == typeof(long?) ||
destType == typeof(int) || destType == typeof(int?))
{
value = Devmasters.DT.Util.ToDate(svalue);
}
else if (destType == typeof(bool) || destType == typeof(bool?))
{
if (bool.TryParse(svalue, out bool tryp))
{
value = tryp;
}
}
else
{
value = svalue;
}
if (mappingProps[m].Transform == "normalize" &&
destType == typeof(string)
)
{
value = DataSet.NormalizeValueForId((string)value);
}
else if (mappingProps[m].Transform == "findico" &&
destType == typeof(string)
)
{
value = Lib.Validators.IcosInText((string)value).FirstOrDefault();
}
else //copy
{
}
rcb.SetPropertyValue(newObj, mappingProps[m].TargetJSON, value);
}
catch (Exception mex)
{
errors.Add(mex);
}
}
} //for
string idPropName = "id";
string idVal = rcb.GetPropertyValue(newObj, "id")?.ToString();
if (string.IsNullOrEmpty(idVal))
{
idVal = rcb.GetPropertyValue(newObj, "Id")?.ToString();
idPropName = "Id";
}
if (string.IsNullOrEmpty(idVal))
{
idVal = rcb.GetPropertyValue(newObj, "iD")?.ToString();
idPropName = "iD";
}
if (string.IsNullOrEmpty(idVal))
{
idVal = rcb.GetPropertyValue(newObj, "ID")?.ToString();
idPropName = "ID";
}
try
{
//var debugJson = Newtonsoft.Json.JsonConvert.SerializeObject(newObj);
//normalize ID
idVal = DataSet.NormalizeValueForId(idVal);
rcb.SetPropertyValue(newObj, idPropName, idVal);
items.Add(new Tuple <object, string>(newObj, idVal));
model.NumOfRows++;
}
catch (DataSetException dex)
{
errors.Add(dex);
}
catch (Exception ex)
{
errors.Add(ex);
}
}
}
}
catch (Exception ex)
{
errors.Add(ex);
}
try
{
Devmasters.Batch.Manager.DoActionForAll <Tuple <object, string> >(items,
(item) =>
{
try
{
ds.AddData(item.Item1, item.Item2, email, true);
}
catch (Exception ex)
{
errors.Add(ex);
}
return(new Devmasters.Batch.ActionOutputData());
}, true
);
}
catch (Exception ex)
{
errors.Add(ex);
}
if (errors?.Count > 0)
{
HlidacStatu.Util.Consts.Logger.Error("ImportDataProcess exceptions \n"
+ errors.Select(m => m.Message).Aggregate((f, s) => f + "\n" + s));
}
ViewBag.ApiResponseError = ApiResponseStatus.Error(-99, "Chyba při importu dat");
ViewBag.Errors = errors.ToList();
return(View(model));
}
/// <summary>
/// Run the health check.
/// </summary>
/// <param name="ctx">Test context</param>
public void Test(ITestContext ctx)
{
var settings = ConfigurationManager.ConnectionStrings.OfType <ConnectionStringSettings>().ToList();
if (this.connectionStringNamesToBeExcluded != null && this.connectionStringNamesToBeExcluded.Any())
{
settings =
settings.Where(
s =>
!this.connectionStringNamesToBeExcluded.Any(
cs => s.Name.Equals(cs, StringComparison.OrdinalIgnoreCase))).ToList();
}
var failedSettings = new System.Collections.Concurrent.ConcurrentBag <ConnectionStringSettings>();
var settingsCount = settings.Count();
var processedCount = 0;
ctx.UpdateProgress(0, processedCount, settingsCount);
Parallel.ForEach(
settings.ToList(),
setting =>
{
try
{
var isEntityClient = setting.ProviderName == "System.Data.EntityClient";
if (!isEntityClient)
{
var factory = DbProviderFactories.GetFactory(setting.ProviderName);
var csBuilder = new DbConnectionStringBuilder();
csBuilder.ConnectionString = setting.ConnectionString;
csBuilder["Connection Timeout"] = 5;
var connectionString = csBuilder.ConnectionString;
using (var cnn = factory.CreateConnection())
{
if (cnn == null)
{
ctx.WriteLine(
EventType.Error,
Errors.TestFailed,
setting.Name,
Errors.CannotCreateConnection);
failedSettings.Add(setting);
}
else
{
cnn.ConnectionString = connectionString;
cnn.Open();
}
}
}
else
{
var csBuilder = new EntityConnectionStringBuilder(setting.ConnectionString);
csBuilder.Provider = "System.Data.SqlClient";
csBuilder.ProviderConnectionString = csBuilder.ProviderConnectionString + ";Connection Timeout = 5";
using (var entityConnection = new EntityConnection(csBuilder.ConnectionString))
{
entityConnection.Open();
}
}
ctx.WriteLine(EventType.Success, Labels.ConnectionSuccessful, setting.Name);
}
catch (Exception ex)
{
ctx.WriteLine(EventType.Error, Errors.TestFailed, setting.Name, ex.Message);
failedSettings.Add(setting);
}
processedCount++;
ctx.UpdateProgress(0, processedCount, settingsCount);
});
if (failedSettings.Count > 0)
{
var msg = string.Format(Errors.CannotOpenConnection, string.Join(", ", failedSettings.Select(x => x.Name).ToArray()));
Assert.Fails(msg);
}
}
public void Test(ITestContext context)
{
var failedChecks = new System.Collections.Concurrent.ConcurrentBag<SqlDeployResult>();
var databasesCount = this.sqlDeploy.Settings.Databases.Count();
var processedCount = 0;
var databases = this.sqlDeploy.Settings.Databases.ToList();
context.UpdateProgress(0, processedCount, databasesCount);
Parallel.ForEach(
databases,
database =>
{
var csBuilder = new SqlConnectionStringBuilder(database.ConnectionString);
var dbName = csBuilder.InitialCatalog;
var upToDate = database.Status.IsUpToDate;
try
{
var reconcileResult = this.sqlDeploy.ReconcileDatabase(database.DatabaseName);
if (upToDate && reconcileResult.IsSuccessful)
{
context.WriteLine(EventType.Success, Titles.DbIsUpToDate, dbName);
}
else
{
if (!upToDate)
{
context.WriteLine(
EventType.Error,
Titles.DbCheckFailed,
dbName,
Titles.SchemaNotUpToDate);
var result = new SqlDeployResult
{
IsSuccessful = false,
DatabaseName = dbName,
Exceptions =
new List<Exception>
{
new Exception(
Titles
.SchemaNotUpToDate)
}
};
failedChecks.Add(result);
}
else
{
context.WriteLine(EventType.Error, Titles.DbCheckFailed, dbName, Titles.SchemaChanged);
failedChecks.Add(reconcileResult);
}
}
}
catch (SqlException ex)
{
context.WriteLine(
EventType.Error,
Titles.DbCheckFailed,
dbName,
ex.Message);
var result = new SqlDeployResult
{
IsSuccessful = false,
DatabaseName = dbName,
Exceptions =
new List<Exception>
{
new Exception(ex.Message)
}
};
failedChecks.Add(result);
}
processedCount++;
context.UpdateProgress(0, processedCount, databasesCount);
});
if (failedChecks.Any())
{
var msg = string.Format(Titles.DbsNotUpToDate, string.Join(", ", failedChecks.Select(x => x.DatabaseName).ToArray()));
Assert.Fails(msg);
}
}
public void Test(ITestContext context)
{
var failedChecks = new System.Collections.Concurrent.ConcurrentBag <SqlDeployResult>();
var databasesCount = this.sqlDeploy.Settings.Databases.Count();
var processedCount = 0;
var databases = this.sqlDeploy.Settings.Databases.ToList();
context.UpdateProgress(0, processedCount, databasesCount);
Parallel.ForEach(
databases,
database =>
{
var csBuilder = new SqlConnectionStringBuilder(database.ConnectionString);
var dbName = csBuilder.InitialCatalog;
var upToDate = database.Status.IsUpToDate;
try
{
var reconcileResult = this.sqlDeploy.ReconcileDatabase(database.DatabaseName);
if (upToDate && reconcileResult.IsSuccessful)
{
context.WriteLine(EventType.Success, Titles.DbIsUpToDate, dbName);
}
else
{
if (!upToDate)
{
context.WriteLine(
EventType.Error,
Titles.DbCheckFailed,
dbName,
Titles.SchemaNotUpToDate);
var result = new SqlDeployResult
{
IsSuccessful = false,
DatabaseName = dbName,
Exceptions =
new List <Exception>
{
new Exception(
Titles
.SchemaNotUpToDate)
}
};
failedChecks.Add(result);
}
else
{
context.WriteLine(EventType.Error, Titles.DbCheckFailed, dbName, Titles.SchemaChanged);
failedChecks.Add(reconcileResult);
}
}
}
catch (SqlException ex)
{
context.WriteLine(
EventType.Error,
Titles.DbCheckFailed,
dbName,
ex.Message);
var result = new SqlDeployResult
{
IsSuccessful = false,
DatabaseName = dbName,
Exceptions =
new List <Exception>
{
new Exception(ex.Message)
}
};
failedChecks.Add(result);
}
processedCount++;
context.UpdateProgress(0, processedCount, databasesCount);
});
if (failedChecks.Any())
{
var msg = string.Format(Titles.DbsNotUpToDate, string.Join(", ", failedChecks.Select(x => x.DatabaseName).ToArray()));
Assert.Fails(msg);
}
}