private static IList <T> ReadFromCsv <T>(string path) where T : new()
{
var csvImport = new CsvImport <T>();
var items = csvImport.Read(path).ToList();
return(items);
}
private User[] UserSeed(CNCLibContext context)
{
var userImport = new CsvImport <User>();
var users = userImport.Read(DefaultDataDir + @"\DefaultData\User.csv").ToArray();
return(users);
}
public void InvalidMultipleOrder()
{
string input = "TestFiles\\invalid_multiple_order.csv";
string output = "invalid_multiple_order.json";
char separator = ',';
var cx = new CsvImport(input, output, separator);
Assert.ThrowsException <NotImplementedException>(() => cx.Parse());
}
/// <summary>
/// Send exam list to client.
/// </summary>
/// <param name="client"></param>
/// <param name="filename"></param>
private static void SendExamListToClient(TcpClient client, object data)
{
_log.AppendToLog("Sending exam list to client: " +
((IPEndPoint)client.Client.RemoteEndPoint).Address.ToString(), LogType.Info);
_csv = new CsvImport(_exampath);
var list = _csv.GetExamNames();
_server.SendPacket(client, new AvailibleExams(list));
}
public void InvalidMissingField()
{
string input = "TestFiles\\invalid_missingfield.csv";
string output = "invalid_missingfield.json";
char separator = ',';
var cx = new CsvImport(input, output, separator);
Assert.ThrowsException <Exception>(() => cx.Parse());
}
private void ConfigurationSeed(CNCLibContext context, bool isTest)
{
if (isTest)
{
var configurationImport = new CsvImport <Configuration>();
var configurations = configurationImport.Read(DefaultDataDir + @"\DefaultData\Configuration.csv").ToArray();
context.Set <Configuration>().AddRange(configurations);
}
}
/// <summary>
/// Send exercises to client, depending on selected exam.
/// </summary>
/// <param name="client"></param>
/// <param name="filename"></param>
private static void SendExercisesToClient(TcpClient client, object data)
{
_server.SetExamFileName(client, (string)data);
_log.AppendToLog("Sending exercises to client: " +
((IPEndPoint)client.Client.RemoteEndPoint).Address.ToString(), LogType.Info);
_csv = new CsvImport(_exampath);
var ex = _csv.GetExercises((string)data);
_server.SendPacket(client, ex);
}
public XmlDocument ImportCatalogInCsvFromZip(string username, string password)
{
if (!IsUserValid(username, password))
{
return(new XmlDocument());
}
try
{
var result = new XmlDocument();
if (!Directory.Exists(Server.MapPath("~/1c_temp")))
{
Directory.CreateDirectory(Server.MapPath("~/1c_temp"));
}
result.AppendChild(result.CreateElement("ImportLog"));
var zipfile = Server.MapPath("~/1c_temp/import.zip");
var impDir = Server.MapPath("~/1c_temp/import/");
if (!Directory.Exists(impDir))
{
Directory.CreateDirectory(impDir);
}
ExtractZip(zipfile, impDir);
foreach (string file in Directory.GetFiles(impDir))
{
if (file.EndsWith(".csv") || file.EndsWith(".xml"))
{
continue;
}
File.Delete(file.Replace("1c_temp\\import", "upload_images"));
File.Move(file, file.Replace("1c_temp\\import", "upload_images"));
}
foreach (string file in Directory.GetFiles(impDir))
{
if (!file.EndsWith(".csv"))
{
continue;
}
CsvImport.Factory(file, false).Process();
if (result.DocumentElement == null)
{
continue;
}
if (_sdsLog.DocumentElement == null)
{
continue;
}
result.DocumentElement.InnerXml = result.DocumentElement.InnerXml + _sdsLog.DocumentElement.InnerXml;
_sdsLog.DocumentElement.RemoveAll();
}
return(result);
}
catch (Exception ex)
{
return(MsgErr(ex.Message));
}
}
public void CountProduct()
{
string str = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "CsvFolder\\");
DirectoryInfo import = Directory.CreateDirectory(str);
try
{
CsvImport csv = new CsvImport(import);
csv.Import<ProductMap, ProductModel, MyContext>("products-*.csv");
}
catch { }
MyContext db = new MyContext();
Assert.AreEqual(2, db.Products.Count());
}
public void BaguetteRightQuantity()
{
string str = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "CsvFolder\\");
DirectoryInfo import = Directory.CreateDirectory(str);
try
{
CsvImport csv = new CsvImport(import);
csv.Import<ProductMap, ProductModel, MyContext>("products-*.csv");
}
catch { }
MyContext db = new MyContext();
Assert.AreEqual(20, db.Products.Where(x => x.Reference == "BAGUETTE").First().Quantity);
}
public void ImportBrugere()
{
string filsti;
Console.WriteLine("Angiv sti til .CSV fil:");
Console.WriteLine("Første linje i .CSV filen skal være formateret således: fornavn,efternavn,adress,postnummer,telefon,foedselsdag,mail");
filsti = Console.ReadLine();
CsvImport csvimport = new CsvImport();
mmdb.ImportMedlemmer(csvimport.GetDataFromFile(filsti));
Console.WriteLine("Medlemmer importeret");
}
public void ValidSingleOrder()
{
string input = "TestFiles\\valid_single_order.csv";
string output = "valid_single_order.json";
char separator = ',';
var cx = new CsvImport(input, output, separator);
cx.Parse();
string errors = cx.ValidateImport();
var fn = cx.SaveOutputToFile();
TestFileCleanup(fn);
Assert.IsTrue(string.IsNullOrWhiteSpace(errors));
}
/// <summary>
/// Process received answers from client and sending the result back
/// </summary>
/// <param name="client"></param>
/// <param name="data"></param>
private static void ProcessAnswers(TcpClient client, object data)
{
_csv = new CsvImport(_exampath);
var filename = _server.GetExamFileName(client);
var list = _csv.GetExercises(filename);
var erh = new ExerciseResultHelper();
var result = erh.ProcessResult((List <DefaultAnswer>)data, list);
var examlog = new ExamLog
{
ConsoleOutput = true
};
examlog.AppendToLog(_server.GetIpFromClient(client), erh.ExistingAnswers, erh.CorrectAnswers);
_server.SendPacket(client, result);
}
public void BasicTest()
{
string str = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "CsvFolder\\");
DirectoryInfo import = Directory.CreateDirectory(str);
try
{
CsvImport csv = new CsvImport(import);
csv.Import<ProductMap, ProductModel, MyContext>("products-*.csv");
}
catch { }
MyContext db = new MyContext();
Product p = db.Products.Where(x => x.Reference == "FROMAGE").FirstOrDefault();
Assert.AreNotEqual(null, p);
}
public void BaguetteRightQuantity()
{
string str = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "CsvFolder\\");
DirectoryInfo import = Directory.CreateDirectory(str);
try
{
CsvImport csv = new CsvImport(import);
csv.Import <ProductMap, ProductModel, MyContext>("products-*.csv");
}
catch { }
MyContext db = new MyContext();
Assert.AreEqual(20, db.Products.Where(x => x.Reference == "BAGUETTE").First().Quantity);
}
public void CountProduct()
{
string str = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "CsvFolder\\");
DirectoryInfo import = Directory.CreateDirectory(str);
try
{
CsvImport csv = new CsvImport(import);
csv.Import <ProductMap, ProductModel, MyContext>("products-*.csv");
}
catch { }
MyContext db = new MyContext();
Assert.AreEqual(2, db.Products.Count());
}
public void BasicTest()
{
string str = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "CsvFolder\\");
DirectoryInfo import = Directory.CreateDirectory(str);
try
{
CsvImport csv = new CsvImport(import);
csv.Import <ProductMap, ProductModel, MyContext>("products-*.csv");
}
catch { }
MyContext db = new MyContext();
Product p = db.Products.Where(x => x.Reference == "FROMAGE").FirstOrDefault();
Assert.AreNotEqual(null, p);
}
public void CsvImportQuotedStringTest()
{
var lines = new[]
{
"ColString1;ColString2",
"No quote1;No quote2",
"\"Single Quote1\";\"Single Quote2\"",
"\"Semicolon in string ; Quoted1\";\"Semicolon in string ; Quoted2\"",
"\"newline in string ", "Quoted1\";\"newline in string ", "Quoted2\"",
"\"Quote \"\"in\"\" string1\";\"Quote \"\"in\"\" string2\"",
"\"\"\"\"\"\"\"\";\"\"\"\""
};
var csvList = new CsvImport <CsvImportStringClass>().Read(lines);
csvList.Should().HaveCount(lines.Length - 3);
csvList[0].Should().BeEquivalentTo(new CsvImportStringClass()
{
ColString1 = "No quote1", ColString2 = "No quote2"
});
csvList[1].Should().BeEquivalentTo(new CsvImportStringClass()
{
ColString1 = "Single Quote1", ColString2 = "Single Quote2"
});
csvList[2].Should().BeEquivalentTo(new CsvImportStringClass()
{
ColString1 = "Semicolon in string ; Quoted1", ColString2 = "Semicolon in string ; Quoted2"
});
csvList[3].Should().BeEquivalentTo(new CsvImportStringClass()
{
ColString1 = "newline in string \nQuoted1", ColString2 = "newline in string \nQuoted2"
});
csvList[4].Should().BeEquivalentTo(new CsvImportStringClass()
{
ColString1 = "Quote \"in\" string1", ColString2 = "Quote \"in\" string2"
});
csvList[5].Should().BeEquivalentTo(new CsvImportStringClass()
{
ColString1 = "\"\"\"", ColString2 = "\""
});
}
private void MachineSeed(CNCLibContext context, User[] users)
{
var machineImport = new CsvImport <Machine>();
var machines = machineImport.Read(DefaultDataDir + @"\DefaultData\Machine.csv").ToArray();
var machineCommandImport = new CsvImport <MachineCommand>();
var machineCommands = machineCommandImport.Read(DefaultDataDir + @"\DefaultData\MachineCommand.csv").ToArray();
var machineInitCommandImport = new CsvImport <MachineInitCommand>();
var machineInitCommands = machineInitCommandImport.Read(DefaultDataDir + @"\DefaultData\MachineInitCommand.csv").ToArray();
foreach (var machineInitCommand in machineInitCommands)
{
machineInitCommand.Machine = machines.First(m => m.MachineId == machineInitCommand.MachineId);
machineInitCommand.MachineId = 0;
machineInitCommand.MachineInitCommandId = 0;
}
foreach (var machineCommand in machineCommands)
{
machineCommand.Machine = machines.First(m => m.MachineId == machineCommand.MachineId);
machineCommand.MachineId = 0;
machineCommand.MachineCommandId = 0;
}
foreach (var machine in machines)
{
machine.User = users.FirstOrDefault(u => u.UserId == machine.UserId);
machine.UserId = null;
machine.MachineId = 0;
}
foreach (var user in users)
{
user.UserId = 0;
}
context.Set <Machine>().AddRange(machines);
context.Set <MachineCommand>().AddRange(machineCommands);
context.Set <MachineInitCommand>().AddRange(machineInitCommands);
}
public ActionResult Import(HttpPostedFileBase postedFile)
{
List <SalesRecord> sales = new List <SalesRecord>();
CsvImport csvImport = new CsvImport();
string filePath = string.Empty;
if (postedFile == null || postedFile.ContentLength == 0)
{
ViewBag.Error = "Please select a CSV file";
return(View("Index"));
}
else
{
if (postedFile.FileName.EndsWith("csv"))
{
string path = Server.MapPath("~/Uploads/");
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
}
filePath = path + Path.GetFileName(postedFile.FileName);
postedFile.SaveAs(filePath);
// Read the contents of CSV file:
sales = csvImport.ParseCSV(filePath);
// Bulk Insert the sales record
csvImport.BulkInsertSalesRecords(sales);
return(View("Index", sales.Take(100)));
}
else
{
ViewBag.Error = "File type is incorrect <br>";
return(View("Index"));
}
}
}
private async void Sync_Button_Click(object sender, RoutedEventArgs e)
{
SyncButton.IsEnabled = false;
using (var sync = new NightSync(App.Configuration))
{
await Task.WhenAll(
sync.ImportBg(),
sync.ImportBasalProfiles(),
sync.ImportTempBasals(),
sync.ImportBoluses(),
sync.ImportExtendedBoluses(),
sync.ImportCarbs()
);
}
var csvsync = new CsvImport(App.Configuration);
await csvsync.ImportFile(@"C:\Users\kurtl\Desktop\boluses.tsv").ConfigureAwait(true);
await viewModel.Update();
SyncButton.IsEnabled = true;
}
private void ItemSeed(CNCLibContext context)
{
var itemImport = new CsvImport <Item>();
var items = itemImport.Read(DefaultDataDir + @"\DefaultData\Item.csv").ToArray();
var itemPropertyImport = new CsvImport <ItemProperty>();
var itemProperties = itemPropertyImport.Read(DefaultDataDir + @"\DefaultData\ItemProperty.csv").ToArray();
foreach (var itemProperty in itemProperties)
{
itemProperty.Item = items.First(i => i.ItemId == itemProperty.ItemId);
itemProperty.ItemId = 0;
}
foreach (var item in items)
{
item.ItemId = 0;
}
context.Set <Item>().AddRange(items);
context.Set <ItemProperty>().AddRange(itemProperties);
}
private void btnLoad_Click(object sender, EventArgs e)
{
OpenFileDialog openFileDialog1 = new OpenFileDialog
{
Title = "Browse csv Files",
CheckFileExists = true,
CheckPathExists = true,
DefaultExt = "csv",
Filter = "CSV files (*.csv)|*.csv",
RestoreDirectory = true,
};
if (openFileDialog1.ShowDialog() == DialogResult.OK)
{
txtFileName.Text = openFileDialog1.FileName;
dgvBooks.Columns.Clear();
List <Book> books = CsvImport.GetBooks(txtFileName.Text, ";");
List <string> bindingList = books.Select(b => b.Binding).Distinct().ToList();
BindGrid(bindingList);
dgvBooks.DataSource = books;
}
}
protected void btnAction_Click(object sender, EventArgs e)
{
if (!String.IsNullOrEmpty(lblError.Text))
{
return;
}
if (!_fieldMapping.ContainsKey(ProductFields.Sku.StrName()) && !_fieldMapping.ContainsKey(ProductFields.Name.StrName()))
{
MsgErr(Resource.Admin_ImportCsv_SelectNameOrSKU);
return;
}
divAction.Visible = false;
choseDiv.Visible = false;
if (!File.Exists(_fullPath))
{
return;
}
if (CommonStatistic.IsRun)
{
return;
}
_hasHeadrs = Request["hasheadrs"] == "true";
CommonStatistic.Init();
CommonStatistic.CurrentProcess = Request.Url.PathAndQuery;
CommonStatistic.CurrentProcessName = Resource.Admin_ImportXLS_CatalogUpload;
linkCancel.Visible = true;
MsgErr(true);
lblRes.Text = string.Empty;
CsvImport.Factory(_fullPath, _hasHeadrs, chboxDisableProducts.Checked, CsvSettings.CsvSeparator, CsvSettings.CsvEnconing, _fieldMapping, CsvSettings.CsvColumSeparator, CsvSettings.CsvPropertySeparator).Process();
OutDiv.Visible = true;
TrialService.TrackEvent(TrialEvents.MakeCSVImport, "");
}
public async Task Process(string filePath, string type)
{
// read file
CsvImport import = null;
try
{
import = await CsvImport.ImportFactory(type, filePath);
}
catch (Exception e)
{
MessageBox.Show(e.Message, "Error importing file", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
this.startButton.Enabled = true;
this.label1.Text = "Importing...";
this.label2.Text = filePath;
int warnCount = 0;
int errorCount = 0;
int successCount = 0;
foreach (var row in import)
{
// process row
int currRow = row.Row;
if (row.RowStatus == CsvRowResult.Status.SUCCESS)
{
try
{
if (await import.AddIfNotExists(row))
{
successCount++;
}
else
{
RegisterWarning(currRow, row.EntityName, import.GetTypeName);
warnCount++;
}
}
catch
{
// something bad happened while accessing the database
// register it as an error
// TODO: provide error message?
RegisterError(currRow);
errorCount++;
}
}
else if (row.RowStatus == CsvRowResult.Status.ERROR)
{
// failed to parse row as the proper entity
// register it in the list
RegisterError(currRow);
errorCount++;
}
}
// finished
this.startButton.Enabled = true;
// display summary
this.label1.Text = "Task Complete.";
this.label2.Text = errorCount + " errors, " + warnCount + " warnings. " + successCount + " " + type + "s added.";
}
public async Task <IActionResult> OnPostAsync()
{
if (!ModelState.IsValid)
{
return(Page());
}
await _context.Database.ExecuteSqlCommandAsync(@"DELETE FROM Bookings");
await _context.Database.ExecuteSqlCommandAsync(@"DELETE FROM Tools");
int lineCount = 0;
try
{
using (var streamReader = new StreamReader(files.OpenReadStream()))
using (var csv = new CsvReader(streamReader))
{
//csv.Configuration.PrepareHeaderForMatch = (string header, int index) => header.Trim(new Char[] { ' ', '*', '.' });
csv.Configuration.PrepareHeaderForMatch = (string header, int index) => header.Replace(" ", string.Empty).Replace(".", string.Empty);
csv.Configuration.HeaderValidated = null;
var record = new CsvImport();
var records = csv.EnumerateRecords(record);
foreach (var r in records)
{
char[] charsToTrim = { '"', '\'' };
string startData = r.Fra;
string endDate = r.Til;
foreach (var month in months)
{
if (startData.ToLower().Contains(month.Key))
{
startData = startData.ToLower().Replace(month.Key, month.Value);
startData = startData.Replace(" ", "-").Trim(charsToTrim);
}
if (endDate.ToLower().Contains(month.Key))
{
endDate = endDate.ToLower().Replace(month.Key, month.Value);
endDate = endDate.Replace(" ", "-").Trim(charsToTrim);
}
}
var tool = new Tool()
{
isComplete = false,
Title = r.Produkt,
};
_context.Tools.Add(tool);
await _context.SaveChangesAsync();
var booking = new Booking()
{
ToolId = tool.Id,
Title = r.Hold,
StartDate = DateTime.ParseExact(startData, "dd-MM-yyyy", CultureInfo.InvariantCulture),
EndDate = DateTime.ParseExact(endDate, "dd-MM-yyyy", CultureInfo.InvariantCulture),
};
_context.Bookings.Add(booking);
await _context.SaveChangesAsync();
}
}
/*
* using (var streamReader = new StreamReader(files.OpenReadStream()))
* {
* while (streamReader.Peek() >= 0)
* {
* lineCount++;
#if DEBUG
* if (lineCount == 30) Console.Write("Break");
#endif
* var line = streamReader.ReadLine();
* if (lineCount == 1) continue;
* var data = line.Split(new[] { ';' });
* //DateTime myDate = new DateTime();
* //DateTime.TryParseExact(data[3], "d-M-yyyy", System.Globalization.CultureInfo.InvariantCulture, System.Globalization.DateTimeStyles.None, out myDate);
*
* char[] charsToTrim = { '"', '\'' };
* string startData = data[(int)MembaExport.Fra];
* string endDate = data[(int)MembaExport.Til];
*
* foreach (var month in months)
* {
* if (startData.ToLower().Contains(month.Key))
* {
* startData = startData.ToLower().Replace(month.Key, month.Value);
* startData = startData.Replace(" ", "-").Trim(charsToTrim);
* }
* if (endDate.ToLower().Contains(month.Key))
* {
* endDate = endDate.ToLower().Replace(month.Key, month.Value);
* endDate = endDate.Replace(" ", "-").Trim(charsToTrim);
* }
* }
*
* var tool = new Tool()
* {
* isComplete = false,
* Title = data[(int)MembaExport.Produkt],
* };
* _context.Tools.Add(tool);
*
* await _context.SaveChangesAsync();
* var booking = new Booking()
* {
* ToolId = tool.Id,
* Title = data[(int)MembaExport.Hold],
* StartDate = DateTime.ParseExact(startData, "dd-MM-yyyy", CultureInfo.InvariantCulture),
* EndDate = DateTime.ParseExact(endDate, "dd-MM-yyyy", CultureInfo.InvariantCulture),
* };
* _context.Bookings.Add(booking);
* await _context.SaveChangesAsync();
*
* }
* }*/
}
catch (Exception exp)
{
TempData["Message-Type"] = "danger";
TempData["Message-Content"] = "Could not import file. Error in line " + lineCount.ToString() + ". " + exp.Message;
return(Page());
}
await _context.SaveChangesAsync();
//return RedirectToAction(nameof(Details), new { id = areaFile.AreaID });
// _context.Projects.Add(Project);
//await _context.SaveChangesAsync();
return(RedirectToPage("./Index"));
}
public void CsvImportFileTest()
{
var lines = new[]
{
"ColString;ColInt;ColShort;ColDecimal;ColByte;ColBool;ColLong;ColEnum;ColDate;ColDateAndTime;ColDateAndTimeFraction;ColTimeSpan;ColDouble;ColIntNull;ColShortNull;ColDecimalNull;ColByteNull;ColBoolNull;ColLongNull;ColEnumNull;ColDateNull;ColDateAndTimeNull;ColDateAndTimeFractionNull;ColDoubleNull;ColTimeSpanNull",
"Str;1;2;2.5;127;true;1234567890;EnumValue1;2018/12/31;2018/12/31 15:56:45;2018/12/31 15:56:45.123;15:56:45;34.12;1;2;2.5;127;false;9876543210;EnumValue1;2018/12/31;2018/12/31 15:56:45;2018/12/31 15:56:45.123;34.12;15:56:45",
";1;2;2.5;127;true;1234567890;EnumValue2;2018/12/31;2018/12/31 15:56:45;2018/12/31 15:56:45.123;15:56:45.123;34.12;;;;;;;;;;;"
};
var csvList = new CsvImport <CsvImportClass>().Read(lines);
csvList.Should().HaveCount(lines.Length - 1);
var csvObjectShouldBe = new CsvImportClass
{
ColString = "Str",
ColInt = 1,
ColShort = 2,
ColDecimal = 2.5m,
ColByte = 127,
ColBool = true,
ColLong = 1234567890,
ColEnum = CsvImportClass.TestEnum.EnumValue1,
ColDate = 31.December(2018),
ColDateAndTime = new DateTime(2018, 12, 31, 15, 56, 45),
ColDateAndTimeFraction = new DateTime(2018, 12, 31, 15, 56, 45, 123),
ColTimeSpan = new TimeSpan(15, 56, 45),
ColDouble = 34.12,
ColIntNull = 1,
ColShortNull = 2,
ColDecimalNull = 2.5m,
ColByteNull = 127,
ColBoolNull = false,
ColLongNull = 9876543210,
ColEnumNull = CsvImportClass.TestEnum.EnumValue1,
ColDateNull = 31.December(2018),
ColDateAndTimeNull = new DateTime(2018, 12, 31, 15, 56, 45),
ColDateAndTimeFractionNull = new DateTime(2018, 12, 31, 15, 56, 45, 123),
ColTimeSpanNull = new TimeSpan(15, 56, 45),
ColDoubleNull = 34.12
};
var csvObjectShouldBeNull = new CsvImportClass
{
ColString = string.Empty,
ColInt = 1,
ColShort = 2,
ColDecimal = 2.5m,
ColByte = 127,
ColBool = true,
ColLong = 1234567890,
ColEnum = CsvImportClass.TestEnum.EnumValue2,
ColDate = 31.December(2018),
ColDateAndTime = new DateTime(2018, 12, 31, 15, 56, 45),
ColDateAndTimeFraction = new DateTime(2018, 12, 31, 15, 56, 45, 123),
ColTimeSpan = new TimeSpan(0, 15, 56, 45, 123),
ColDouble = 34.12,
};
var csvObject = csvList[0];
var csvObjectNull = csvList[1];
csvObject.Should().BeEquivalentTo(csvObjectShouldBe);
csvObjectNull.Should().BeEquivalentTo(csvObjectShouldBeNull);
}
private void LoadIterationsData()
{
IterationData = passes.Select(passFolder =>
{
var csv = new CsvImport<IterationData>();
csv.Import(Path.Combine(passFolder, "iterations.csv"));
return csv.Objects;
}).ToList();
}
protected void Page_Init(object sender, EventArgs e)
{
MsgErr(true);
divStart.Visible = !CommonStatistic.IsRun && (string.IsNullOrEmpty(Request["action"]));
divAction.Visible = !CommonStatistic.IsRun && (Request["action"] == "start");
choseDiv.Visible = !CommonStatistic.IsRun;
OutDiv.Visible = CommonStatistic.IsRun;
linkCancel.Visible = CommonStatistic.IsRun;
if (CommonStatistic.IsRun || (Request["action"] != "start"))
{
return;
}
if (!File.Exists(_fullPath))
{
return;
}
var tbl = new Table {
ID = "tblValues"
};
var namesRow = new TableRow {
ID = "namesRow", BackColor = System.Drawing.ColorTranslator.FromHtml("#0D76B8"), Height = 28
};
var firstValRow = new TableRow {
ID = "firstValsRow"
};
var ddlRow = new TableRow {
ID = "ddlRow"
};
var firstCell = new TableCell {
Width = 200, BackColor = System.Drawing.Color.White,
};
firstCell.Controls.Add(new Label {
Text = Resource.Admin_ImportCsv_Column, CssClass = "firstColumn"
});
var div1 = new Panel {
CssClass = "arrow_left_bg"
};
div1.Controls.Add(new Panel {
CssClass = "arrow_right_bg"
});
firstCell.Controls.Add(div1);
var secondCell = new TableCell {
Width = 200
};
secondCell.Controls.Add(new Label {
Text = Resource.Admin_ImportCsv_FistLineInTheFile, CssClass = "firstColumn"
});
var div2 = new Panel {
CssClass = "arrow_left_bg_two"
};
div2.Controls.Add(new Panel {
CssClass = "arrow_right_bg"
});
secondCell.Controls.Add(div2);
var firdCell = new TableCell {
Width = 200
};
firdCell.Controls.Add(new Label {
Text = Resource.Admin_ImportCsv_DataType, CssClass = "firstColumn"
});
var div3 = new Panel {
CssClass = "arrow_left_bg_free"
};
div3.Controls.Add(new Panel {
CssClass = "arrow_right_bg"
});
firdCell.Controls.Add(div3);
var div4 = new Panel {
Width = 200
};
firdCell.Controls.Add(div4);
namesRow.Cells.Add(firstCell);
firstValRow.Cells.Add(secondCell);
ddlRow.Cells.Add(firdCell);
_hasHeadrs = Request["hasheadrs"].TryParseBool();
var csvrows = CsvImport.Factory(_fullPath, false, false, CsvSettings.CsvSeparator, CsvSettings.CsvEnconing, null, CsvSettings.CsvColumSeparator, CsvSettings.CsvPropertySeparator).ReadFirst2();
if (csvrows.Count == 0)
{
MsgErr(Resource.Admin_ImportCsv_ErrorReadFille);
return;
}
if (_hasHeadrs && csvrows[0].HasDuplicates())
{
var strFileds = string.Empty;
foreach (var item in csvrows[0].Duplicates())
{
strFileds += "\"" + item + "\",";
}
MsgErr(Resource.Admin_ImportCsv_DuplicateHeader + strFileds.Trim(','));
btnAction.Visible = false;
}
for (int i = 0; i < csvrows[0].Length; i++)
{
var cell = new TableCell {
ID = "cell" + i
};
var lb = new Label();
bool flagMustReqField = false;
if (Request["hasheadrs"].ToLower() == "true")
{
var tempCsv = (csvrows[0][i].Length > 50 ? csvrows[0][i].Substring(0, 49) : csvrows[0][i]);
if (_mustRequiredFfield.Any(item => item.StrName() == tempCsv.ToLower()))
{
flagMustReqField = true;
}
lb.Text = tempCsv;
}
else
{
lb.Text = Resource.Admin_ImportCsv_Empty;
}
lb.ForeColor = System.Drawing.Color.White;
cell.Controls.Add(lb);
if (flagMustReqField)
{
var lbl = new Label
{
Text = @"*",
ForeColor = System.Drawing.Color.Red
};
cell.Controls.Add(lbl);
}
namesRow.Cells.Add(cell);
cell = new TableCell {
Width = 150
};
var ddl = new DropDownList {
ID = "ddlType" + i, Width = 150
};
ddl.Items.Add(new ListItem(ProductFields.None.ResourceKey(), ProductFields.None.StrName()));
ddl.Items.Add(new ListItem(ProductFields.Sku.ResourceKey(), ProductFields.Sku.StrName()));
ddl.Items.Add(new ListItem(ProductFields.Name.ResourceKey(), ProductFields.Name.StrName()));
ddl.Items.Add(new ListItem(ProductFields.ParamSynonym.ResourceKey(), ProductFields.ParamSynonym.StrName()));
ddl.Items.Add(new ListItem(ProductFields.Category.ResourceKey(), ProductFields.Category.StrName()));
ddl.Items.Add(new ListItem(ProductFields.Enabled.ResourceKey(), ProductFields.Enabled.StrName()));
ddl.Items.Add(new ListItem(ProductFields.Price.ResourceKey(), ProductFields.Price.StrName()));
ddl.Items.Add(new ListItem(ProductFields.PurchasePrice.ResourceKey(), ProductFields.PurchasePrice.StrName()));
ddl.Items.Add(new ListItem(ProductFields.Amount.ResourceKey(), ProductFields.Amount.StrName()));
ddl.Items.Add(new ListItem(ProductFields.MultiOffer.ResourceKey(), ProductFields.MultiOffer.StrName()));
ddl.Items.Add(new ListItem(ProductFields.Unit.ResourceKey(), ProductFields.Unit.StrName()));
ddl.Items.Add(new ListItem(ProductFields.Discount.ResourceKey(), ProductFields.Discount.StrName()));
ddl.Items.Add(new ListItem(ProductFields.ShippingPrice.ResourceKey(), ProductFields.ShippingPrice.StrName()));
ddl.Items.Add(new ListItem(ProductFields.Weight.ResourceKey(), ProductFields.Weight.StrName()));
ddl.Items.Add(new ListItem(ProductFields.Size.ResourceKey(), ProductFields.Size.StrName()));
ddl.Items.Add(new ListItem(ProductFields.BriefDescription.ResourceKey(), ProductFields.BriefDescription.StrName()));
ddl.Items.Add(new ListItem(ProductFields.Description.ResourceKey(), ProductFields.Description.StrName()));
ddl.Items.Add(new ListItem(ProductFields.Title.ResourceKey(), ProductFields.Title.StrName()));
ddl.Items.Add(new ListItem(ProductFields.MetaKeywords.ResourceKey(), ProductFields.MetaKeywords.StrName()));
ddl.Items.Add(new ListItem(ProductFields.MetaDescription.ResourceKey(), ProductFields.MetaDescription.StrName()));
ddl.Items.Add(new ListItem(ProductFields.H1.ResourceKey(), ProductFields.H1.StrName()));
ddl.Items.Add(new ListItem(ProductFields.Photos.ResourceKey(), ProductFields.Photos.StrName()));
ddl.Items.Add(new ListItem(ProductFields.Videos.ResourceKey(), ProductFields.Videos.StrName()));
ddl.Items.Add(new ListItem(ProductFields.Markers.ResourceKey(), ProductFields.Markers.StrName()));
ddl.Items.Add(new ListItem(ProductFields.Properties.ResourceKey(), ProductFields.Properties.StrName()));
ddl.Items.Add(new ListItem(ProductFields.Producer.ResourceKey(), ProductFields.Producer.StrName()));
ddl.Items.Add(new ListItem(ProductFields.OrderByRequest.ResourceKey(), ProductFields.OrderByRequest.StrName()));
ddl.Items.Add(new ListItem(ProductFields.SalesNotes.ResourceKey(), ProductFields.SalesNotes.StrName()));
ddl.Items.Add(new ListItem(ProductFields.Sorting.ResourceKey(), ProductFields.Sorting.StrName()));
ddl.Items.Add(new ListItem(ProductFields.Related.ResourceKey(), ProductFields.Related.StrName()));
ddl.Items.Add(new ListItem(ProductFields.Alternative.ResourceKey(), ProductFields.Alternative.StrName()));
ddl.Items.Add(new ListItem(ProductFields.CustomOption.ResourceKey(), ProductFields.CustomOption.StrName()));
ddl.Items.Add(new ListItem(ProductFields.Gtin.ResourceKey(), ProductFields.Gtin.StrName()));
ddl.Items.Add(new ListItem(ProductFields.GoogleProductCategory.ResourceKey(), ProductFields.GoogleProductCategory.StrName()));
ddl.Items.Add(new ListItem(ProductFields.Adult.ResourceKey(), ProductFields.Adult.StrName()));
ddl.Items.Add(new ListItem(ProductFields.ManufacturerWarranty.ResourceKey(), ProductFields.ManufacturerWarranty.StrName()));
ddl.SelectedValue = lb.Text.Trim().ToLower();
cell.Controls.Add(ddl);
ddlRow.Cells.Add(cell);
}
var dataRow = csvrows.Count > 1 ? csvrows[1] : csvrows[0];
if (dataRow != null)
{
for (int i = 0; i < dataRow.Length; i++)
{
var cell = new TableCell();
if (dataRow[i] == null)
{
cell.Controls.Add(new Label {
Text = string.Empty
});
}
else
{
cell.Controls.Add(new Label {
Text = dataRow[i].Length > 50 ? dataRow[i].Substring(0, 49).HtmlEncode() : dataRow[i].HtmlEncode()
});
}
firstValRow.Cells.Add(cell);
}
}
tbl.Rows.Add(namesRow);
tbl.Rows.Add(firstValRow);
tbl.Rows.Add(ddlRow);
choseDiv.Controls.Add(tbl);
}
