/// <summary>
/// Read start csv file
/// </summary>
/// <param name="path">path to file</param>
/// <returns></returns>
public IEnumerable <Student> ReadFile(string path)
{
const int SkipThreeItems = 3;
using var reader = new StreamReader(path);
using var csv = new CsvHelper.CsvReader(reader, CultureInfo.InvariantCulture);
var records = new List <Student>();
csv.Read();
csv.ReadHeader();
while (csv.Read())
{
if (csv.Context.Record.Length != csv.Context.HeaderRecord.Length)
{
throw new InvalidDataException("Wrong number of parameters");
}
var listOfSubjects = new List <Subject>();
for (int index = SkipThreeItems; index < csv.Context.Record.Length; index++)
{
var subject = new Subject(csv.Context.HeaderRecord[index], csv.GetField <int>(index));
listOfSubjects.Add(subject);
}
records.Add(new Student(csv.GetField(0), csv.GetField(1), csv.GetField(2), listOfSubjects));
}
return(records);
}
private void Form1_Load(object sender, EventArgs e)
{
//read remember csv
using (var reader = new StreamReader(Functions.bingPathToAppDir("\\data\\RememberMe.csv")))
using (var csv = new CsvHelper.CsvReader(reader, CultureInfo.InvariantCulture))
{
csv.Read();
csv.ReadHeader();
while (csv.Read())
{
var record = new user
{
Username = csv.GetField("Username"),
Password = csv.GetField("Password"),
UserType = csv.GetField("UserType")
};
UserR = record;
}
}
//re login if remember file includes info
if (UserR.Password != " " && UserR.Username != " ")
{
tBname.Text = UserR.Username;
tBpassword.Text = UserR.Password;
for (int i = 0; i < Program.records.Count; i++)
{
if (Program.records[i].Username == tBname.Text)
{
if (Program.records[i].Password == tBpassword.Text)
{
Flag = true;
CurrentUser.Username = Program.records[i].Username;
CurrentUser.Password = Program.records[i].Password;
CurrentUser.UserType = Program.records[i].UserType;
break;
}
}
}
if (Flag == true)
{
lbFlag.ForeColor = System.Drawing.Color.Green;
cB1.Checked = true;
cB1.Enabled = false;
lbFlag.Text = "Sucsesfull Login";
testc();
btnLgn.Enabled = false;
btnSignup.Enabled = false;
}
}
}
private void Personalinformation_Load(object sender, EventArgs e)
{
using (var reader = new StreamReader(Functions.bingPathToAppDir("\\data\\users.csv")))
using (var csv = new CsvHelper.CsvReader(reader, CultureInfo.InvariantCulture))
{
csv.Read();
csv.ReadHeader();
while (csv.Read())
{
var record = new user
{
Username = csv.GetField("Username"),
Password = csv.GetField("Password"),
UserType = csv.GetField("UserType"),
Name = csv.GetField("Name"),
Surname = csv.GetField("Surname"),
Phonenumber = csv.GetField("Phonenumber"),
Address = csv.GetField("Address"),
Email = csv.GetField("Email"),
Photo = csv.GetField("Photo")
};
records.Add(record);
}
}
for (int i = 0; i < records.Count; i++)
{
if (records[i].Username == Login.CurrentUser.Username)
{
textBoxName.Text = records[i].Name;
textBoxSurname.Text = records[i].Surname;
maskedTextBoxNumber.Text = records[i].Phonenumber;
tBadress.Text = records[i].Address;
textBoxEmail.Text = records[i].Email;
base64Text = records[i].Photo;
byte[] imageBytes = Convert.FromBase64String(records[i].Photo);
// Convert byte[] to Image
using (var ms = new MemoryStream(imageBytes, 0, imageBytes.Length))
{
pictureBox1.Image = Image.FromStream(ms, true);
}
}
Program.records[i] = records[i];
}
Clear();
ClearUndo();
}
//***********************************ReadFile***********************************
// This would only be used if we wanted to edit the by talking to alexa
// This method is not implemented.
private void ReadFile()
{
if (System.IO.File.Exists(FilePath))
{
// Stream file and read
using (var fs = new System.IO.FileStream(FilePath, System.IO.FileMode.Open, System.IO.FileAccess.Read, System.IO.FileShare.ReadWrite))
{
//Read file stream
using (var tr = new System.IO.StreamReader(fs))
{
// Read csv file.
CsvHelper.CsvReader csvR = new CsvHelper.CsvReader(tr);
try
{
while (csvR.Read())
{
string item = csvR.GetField <string>(0);
string property = csvR.GetField <string>(1);
}
}
catch { }
// close
tr.Dispose();
fs.Dispose();
fs.Close();
}
}
}
}
public Dictionary <long, Facility> LoadFacility(string fileName)
{
var returnVal = new Dictionary <long, Facility>();
using (var reader = new StreamReader(fileName))
{
var csvReader = new CsvHelper.CsvReader(reader);
while (csvReader.Read())
{
///todo: this is very brittle
///amount,interest_rate,id,bank_id
var record = csvReader.CurrentRecord;
int amount = int.Parse(record[0], System.Globalization.NumberStyles.AllowDecimalPoint);
float interest = float.Parse(record[1]);
long id = int.Parse(record[2]);
long bankId = long.Parse(record[2]);
returnVal.Add(id, new Facility()
{
Id = id, Amount = amount, InterestRate = interest, BankId = bankId
});
}
}
return(returnVal);
}
public List <Covenant> LoadCovenents(string fileName)
{
var returnVal = new List <Covenant>();
using (var reader = new StreamReader(fileName))
{
var csvReader = new CsvHelper.CsvReader(reader);
while (csvReader.Read())
{
///todo: this is very brittle
var record = csvReader.CurrentRecord;
long bankId = 0;
float maxDefualt = 1.0f;
long facilityId = 0;
if (long.TryParse(record[0], out facilityId))
{
float.TryParse(record[1], out maxDefualt);
long.TryParse(record[2], out bankId);
returnVal.Add(new Covenant()
{
BankId = bankId, FacilityId = facilityId, MaxDefaultLikelihood = maxDefualt, BannedState = record[3].Trim()
});
}
}
}
return(returnVal);
}
public override ContentItem GetById(ValidUrl url_, ContentViewType viewType_)
{
//ContentItem item = _db.GetCollection<ContentItem>(COLLNAME).AsQueryable<ContentItem>().Where(x => x.Url.Id == url_.Id && x.ContentView.ViewType == viewType_).FirstOrDefault<ContentItem>();
ContentItem item = _db.GetCollection <ContentItem>(COLLNAME).Find(Query.And(Query.EQ("Url.Id", url_.Id), Query.EQ("ViewType", Convert.ToInt32(viewType_)))).FirstOrDefault <ContentItem>();
if (item == null)
{
DependencyManager.Logger.Log(new LogEventInfo(LogLevel.Debug, ECMSSettings.DEFAULT_LOGGER, "Specific content not found now going to search for default content."));
item = _db.GetCollection <ContentItem>(COLLNAME).Find(Query.And(Query.EQ("ContentView.SiteId", url_.SiteId), Query.EQ("ContentView.ViewName", url_.View), Query.EQ("ContentView.ViewType", Convert.ToInt32(viewType_)))).FirstOrDefault <ContentItem>();
}
//TODO : Optimize this
if (item != null)
{
using (StringReader streamReader = new StringReader(item.Body[0].ToString()))
{
using (var csv = new CsvHelper.CsvReader(streamReader))
{
//csv.Configuration.IgnoreQuotes = true;
csv.Read();
item.Body = JObject.FromObject(csv.GetRecord(typeof(object)));
}
}
}
return(item);
}
public List <String> GetStockSymbols()
{
List <string> myStringColumn = new List <string>();
using (var fileReader = File.OpenText(csvPath))
using (var csvResult = new CsvHelper.CsvReader(fileReader, CultureInfo.InvariantCulture))
{
csvResult.Read();
csvResult.ReadHeader();
while (csvResult.Read())
{
string stringField = csvResult.GetField <string>("Symbol");
myStringColumn.Add(stringField);
}
}
return(myStringColumn);
}
static void Main(string[] args)
{
//Create our service
PushService push = new PushService();
//Wire up the events
push.Events.OnDeviceSubscriptionExpired += new PushSharp.Common.ChannelEvents.DeviceSubscriptionExpired(Events_OnDeviceSubscriptionExpired);
push.Events.OnDeviceSubscriptionIdChanged += new PushSharp.Common.ChannelEvents.DeviceSubscriptionIdChanged(Events_OnDeviceSubscriptionIdChanged);
push.Events.OnChannelException += new PushSharp.Common.ChannelEvents.ChannelExceptionDelegate(Events_OnChannelException);
push.Events.OnNotificationSendFailure += new PushSharp.Common.ChannelEvents.NotificationSendFailureDelegate(Events_OnNotificationSendFailure);
push.Events.OnNotificationSent += new PushSharp.Common.ChannelEvents.NotificationSentDelegate(Events_OnNotificationSent);
push.Events.OnChannelCreated += new PushSharp.Common.ChannelEvents.ChannelCreatedDelegate(Events_OnChannelCreated);
push.Events.OnChannelDestroyed += new PushSharp.Common.ChannelEvents.ChannelDestroyedDelegate(Events_OnChannelDestroyed);
//Configure and start Apple APNS
// IMPORTANT: Make sure you use the right Push certificate. Apple allows you to generate one for connecting to Sandbox,
// and one for connecting to Production. You must use the right one, to match the provisioning profile you build your
// app with!
var appleCert = File.ReadAllBytes(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "../../../Resources/myMood-prod-push-cert.p12"));
//IMPORTANT: If you are using a Development provisioning Profile, you must use the Sandbox push notification server
// (so you would leave the first arg in the ctor of ApplePushChannelSettings as 'false')
// If you are using an AdHoc or AppStore provisioning profile, you must use the Production push notification server
// (so you would change the first arg in the ctor of ApplePushChannelSettings to 'true')
push.StartApplePushService(new ApplePushChannelSettings(appleCert, "d1scov3r!"));
//push.QueueNotification(NotificationFactory.Apple()
// .ForDeviceToken("14e9c79db41cf4aa205cb72e7d60cede573cfa1867f1427ddd7372ef19c29b3a")
// .WithAlert("Remember to send yourself a myMood report before handing back the iPad")
// .WithSound("default")
// );
using (var csv = new CsvHelper.CsvReader(new StreamReader(typeof(Device).Assembly.GetManifestResourceStream(typeof(Device).Assembly.GetName().Name + ".devices.csv"))))
{
while (csv.Read())
{
var device = csv.GetRecord <Device>();
//Fluent construction of an iOS notification
//IMPORTANT: For iOS you MUST MUST MUST use your own DeviceToken here that gets generated within your iOS app itself when the Application Delegate
// for registered for remote notifications is called, and the device token is passed back to you
push.QueueNotification(NotificationFactory.Apple()
.ForDeviceToken(device.DeviceId)
.WithAlert("Remember to send yourself a myMood report before handing back the iPad!")
//.WithSound("default")
);
}
}
//Stop and wait for the queues to drains
push.StopAllServices(true);
Console.WriteLine("Queue Finished, press return to exit...");
Console.ReadLine();
}
private void Form1_Load(object sender, EventArgs e)
{
listView1.Visible = false;
btnUpdate.Enabled = false;
btnDelete.Enabled = false;
if (!System.IO.File.Exists(Functions.bingPathToAppDir("\\data\\reminder.csv")))
{
System.IO.FileStream f = System.IO.File.Create(Functions.bingPathToAppDir("\\data\\reminder.csv"));
f.Close();
}
using (var reader = new StreamReader(Functions.bingPathToAppDir("\\data\\reminder.csv")))
using (var csv = new CsvHelper.CsvReader(reader, CultureInfo.InvariantCulture))
{
csv.Read();
csv.ReadHeader();
while (csv.Read())
{
var record = new calender
{
username = csv.GetField("username"),
type = csv.GetField("type"),
note = csv.GetField("note"),
date = csv.GetField("date"),
clock = csv.GetField("clock")
};
records.Add(record);
}
}
listView1.Items.Clear();
foreach (var person in records)
{
if (Login.CurrentUser.Username == person.username)
{
var row = new string[] { person.type, person.note, person.date, person.clock };
var lvi = new ListViewItem(row);
lvi.Tag = person;
listView1.Items.Add(lvi);
}
}
}
private void FormPhoneBook_Load(object sender, EventArgs e)
{
if (!System.IO.File.Exists(Functions.bingPathToAppDir("\\data\\phonebook.csv")))
{
System.IO.FileStream f = System.IO.File.Create(Functions.bingPathToAppDir("\\data\\phonebook.csv"));
f.Close();
}
// load recods from users csv file
using (var reader = new StreamReader(Functions.bingPathToAppDir("\\data\\phonebook.csv")))
using (var csv = new CsvHelper.CsvReader(reader, CultureInfo.InvariantCulture))
{
csv.Read();
csv.ReadHeader();
while (csv.Read())
{
var record = new phonebook
{
name = csv.GetField("name"),
surname = csv.GetField("surname"),
phonenumber = csv.GetField("phonenumber"),
address = csv.GetField("address"),
description = csv.GetField("description"),
email = csv.GetField("email"),
user = csv.GetField("user")
};
records.Add(record);
}
}
listView1.Items.Clear();
foreach (var person in records)
{
if (Login.CurrentUser.Username == person.user)
{
var row = new string[] { person.name, person.surname, person.phonenumber, person.address, person.description, person.email };
var lvi = new ListViewItem(row);
lvi.Tag = person;
listView1.Items.Add(lvi);
}
}
}
private void Form2_Load(object sender, EventArgs e)
{
Flag = true;
testc();
if (!System.IO.File.Exists(Functions.bingPathToAppDir("\\data\\reminder.csv")))
{
System.IO.FileStream f = System.IO.File.Create(Functions.bingPathToAppDir("\\data\\reminder.csv"));
f.Close();
}
// load recods from users csv file
using (var reader = new StreamReader(Functions.bingPathToAppDir("\\data\\reminder.csv")))
using (var csv = new CsvHelper.CsvReader(reader, CultureInfo.InvariantCulture))
{
csv.Read();
csv.ReadHeader();
while (csv.Read())
{
var record = new calender
{
username = csv.GetField("username"),
type = csv.GetField("type"),
note = csv.GetField("note"),
date = csv.GetField("date"),
clock = csv.GetField("clock")
};
data.Add(record);
}
}
foreach (var person in data)
{
if (Login.CurrentUser.Username == person.username)
{
pictureBox1.Visible = true;
label2.Visible = true;
label3.Visible = true;
label2.Text = person.note;
label3.Text = person.date + " " + person.clock;
}
}
}
public static void ReadAll_CsvHelper(DelimitedRecordReaderBenchmarkArguments args)
{
var config = new CH.Configuration.CsvConfiguration
{
BufferSize = args.BufferSize,
AllowComments = true,
IgnoreBlankLines = args.SkipEmptyLines,
HasHeaderRecord = false,
DetectColumnCountChanges = true,
TrimFields = args.TrimWhiteSpaces,
TrimHeaders = args.TrimWhiteSpaces
};
using (var reader = new CH.CsvReader(new StreamReader(args.Path, args.Encoding, true, args.BufferSize), config))
{
string s;
if (args.FieldIndex < 0)
{
while (reader.Read())
{
var record = reader.CurrentRecord;
for (int i = 0; i < record.Length; i++)
{
s = record[i];
}
}
}
else
{
while (reader.Read())
{
for (int i = 0; i < args.FieldIndex + 1; i++)
{
s = reader[i];
}
}
}
}
}
private void Notes_Load(object sender, EventArgs e)
{
if (!System.IO.File.Exists(Functions.bingPathToAppDir("\\data\\notes.csv")))
{
System.IO.FileStream f = System.IO.File.Create(Functions.bingPathToAppDir("\\data\\notes.csv"));
f.Close();
}
using (var reader = new StreamReader(Functions.bingPathToAppDir("\\data\\notes.csv")))
using (var csv = new CsvHelper.CsvReader(reader, CultureInfo.InvariantCulture))
{
csv.Read();
csv.ReadHeader();
while (csv.Read())
{
var record = new notes // we have one field for note, one field for note name,one field for current user
{
notename = csv.GetField("notename"),
note = csv.GetField("note"),
user = csv.GetField("user")
};
records.Add(record);
}
}
listView1.Items.Clear();
foreach (var person in records)
{
if (Login.CurrentUser.Username == person.user)
{
var row = new string[] { person.notename, person.note, person.user };
var lvi = new ListViewItem(row);
lvi.Tag = person;
listView1.Items.Add(lvi);
}
}
}
public List <MenuItem> CallAPI()
{
List <MenuItem> menuList;
List <string> myStringColumn = new List <string>();
using (var fileReader = File.OpenText(inFile))
using (var csvResult = new CsvHelper.CsvReader(fileReader))
{
while (csvResult.Read())
{
string stringField = csvResult.GetField <string>("Header Name");
myStringColumn.Add(stringField);
}
}
return(menuList);
}
public static CSVFile LoadFromFileData(StreamReader ReadFile, string ColDelimiter = ",")
{
CSVFile CSVF = new CSVFile();
CSVF.ColumnDelimiter = ColDelimiter;
var parser = new CsvHelper.CsvReader(ReadFile, new CsvConfiguration(CultureInfo.CurrentCulture)
{
Delimiter = ColDelimiter
});
while (parser.Read())
{
var cols = new List <string>();
for (int a = 0; a < parser.ColumnCount; a++)
{
cols.Add(parser.GetField(a));
}
CSVF.Lines.Add(new CSVLine(cols));
}
return(CSVF);
}
public static System.Data.DataTable Read(string FilePath)
{
List<string> headers = GetHeaderNames(FilePath);
System.Data.DataTable table = GetEmptyDataTable(headers);
System.Data.DataRow row;
using (var fileReader = File.OpenText(FilePath))
using (var csvResult = new CsvHelper.CsvReader(fileReader))
{
while (csvResult.Read())
{
row = table.NewRow();
foreach (string s in headers)
{
row[s] = csvResult.GetField<string>(s);
}
table.Rows.Add(row);
}
}
return table;
}
private void loadCompleteDatabase()
{
using (var fs = File.OpenRead(@"movies.csv"))
using (var reader = new StreamReader(fs))
{
using (var csvReader = new CsvHelper.CsvReader(reader))
{
while (csvReader.Read())
{
//the first line is the headers line (movieID,Title,genres)
Movie movie = new Movie(csvReader[0]);
movie.MovieTitle = csvReader[1];
movie.Year = csvReader.GetField <int>(2);
movie.Poster = csvReader.GetField <string>(3);
movie.Rating = csvReader.GetField <double>(4);
movie.Plot = csvReader.GetField <string>(5);
moviesDictionary[csvReader[0]] = movie;
}
}
}
using (var fs = File.OpenRead(@"db/movies.csv"))
using (var reader = new StreamReader(fs))
{
using (var csvReader = new CsvHelper.CsvReader(reader))
{
while (csvReader.Read())
{
if (moviesDictionary.ContainsKey(csvReader[0]))
{
moviesDictionary[csvReader[0]].Genres = Movie.splitToGenres(csvReader[2]);
moviesList.Add(moviesDictionary[csvReader[0]]);
}
}
}
}
}
private DataTable GetData(CsvContext context)
{
DataTable dt = new DataTable();
try
{
System.Text.Encoding encode = System.Text.Encoding.GetEncoding("UTF-8");
using (var csv = new CsvHelper.CsvReader(new StreamReader(context.CSVFile, encode)))
{
CsvHelper.Configuration.CsvConfiguration config = csv.Configuration;
config.Encoding = encode;
config.Delimiter = context.SpliterChar.ToString();
//csvhelper bug fix
config.HasHeaderRecord = !context.IncludeHeader;
int rowIndex = 0;
int columnIndex = 0;
while (csv.Read())
{
dt.ExpandRow(rowIndex);
for (int i = 0; i < csv.CurrentRecord.Length; i++)
{
dt.ExpandColumn(columnIndex);
dt.Rows[rowIndex][columnIndex] = csv.GetField(i);
columnIndex++;
}
columnIndex = 0;
rowIndex++;
}
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
return(dt);
}
public CountryHelper(string fileLocation)
{
// Using CsvHelper instead of my own implementation
using (var reader = new StreamReader(fileLocation))
using (var csv = new CsvHelper.CsvReader(reader, CultureInfo.InvariantCulture))
{
Console.WriteLine($"Reading countries from {fileLocation}...");
try
{
csv.Configuration.HasHeaderRecord = false;
csv.Read();
Records = csv.GetRecords <Country>().ToList();
}
catch (FileNotFoundException e)
{
Console.WriteLine(e.Message);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
Console.WriteLine($"Success! Found {Records.Count} countries in the file.");
}
}
private void PopulateCommandItems()
{
var fileName = @"C:\Users\Johandry.Amador\Documents\GitHub\ATK\Client\Visual Studio - C#\ATK\Properties\DataSources\Commands.csv";
var fileReader = File.OpenText(fileName);
var csvReader = new CsvHelper.CsvReader(fileReader);
while (csvReader.Read())
{
CommandsList.Add(new Command() { ItemName = csvReader.CurrentRecord[3],
ItemCommand = csvReader.CurrentRecord[0],
ItemDescription = csvReader.CurrentRecord[4]
});
}
}
/// <inheritdoc />
public override async Task <bool> ExecuteAsync()
{
if (!Directory.Exists(Context.Options.Source))
{
Context.LogLine($"Source folder \"{Context.Options.Source}\" does not exist.");
return(false);
}
if (!Directory.Exists(Context.Options.Destination))
{
IoHelper.CreateDirectoryRecursive(Context.Options.Destination);
}
var searchOption = Context.Options.Recursive ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly;
var sourceFiles = Directory.GetFiles(Context.Options.Source, "*.svg", searchOption);
Context.LogLine($"Generating files based on {sourceFiles.Length} source files.");
if (Context.Options.ImageFormats.Length <= 0)
{
Context.LogLine($"Missing ImageFormats in configuration. E.g. 24x24;48x48.");
return(false);
}
if (Context.Options.FileExtensions.Length == 0)
{
Context.LogLine($"Invalid extensions specified: {Context.Options.FileExtensions}.");
return(false);
}
Context.Options.AliasMappings = new Dictionary <string, string>();
if (File.Exists(Context.Options.AliasMappingPath))
{
Context.LogLine($"Alias mapping file '{Context.Options.AliasMappingPath}' is being used.");
var reader = new CsvHelper.CsvReader(new StreamReader(Context.Options.AliasMappingPath), new Configuration(), false);
while (reader.Read())
{
var fileName = reader.GetField(0);
var alias = reader.GetField(1);
if (Context.Options.AliasMappings.TryGetValue(fileName, out var presentAlias))
{
Context.LogLine($"Alias for '{fileName}' is already mapped to '{presentAlias}'. Discarding alias '{alias}'.");
}
else
{
Context.Options.AliasMappings.Add(fileName, alias);
}
}
}
HashSet <string> filteredExtensions = new HashSet <string>();
foreach (var extension in Context.Options.FileExtensions)
{
if (GeneratorModule.SupportedFormats.ContainsKey(extension.ToLowerInvariant()))
{
filteredExtensions.Add(extension);
}
else
{
Context.LogLine($"Extension {extension} is not supported and will not be rendered.");
}
}
var extensions = filteredExtensions.ToArray();
if (extensions.Length == 0)
{
Context.LogLine("There are no valid extensions left to render.");
return(false);
}
var current = 0;
var max = Context.Options.ImageFormats.Length * Math.Max(1, Context.Options.ColorCodes.Length);
if (Context.Options.ColorCodes.Length <= 0)
{
foreach (var format in Context.Options.ImageFormats)
{
current++;
await RunModuleAsync(current, max, sourceFiles, format, null, extensions).ConfigureAwait(false);
}
}
else
{
foreach (var colorCode in Context.Options.ColorCodes)
{
foreach (var format in Context.Options.ImageFormats)
{
current++;
await RunModuleAsync(current, max, sourceFiles, format, colorCode, extensions).ConfigureAwait(false);
}
}
}
return(true);
}
protected void Page_Init(object sender, EventArgs e)
{
MsgErr(true);
divStart.Visible = !ImportStatistic.IsRun && (string.IsNullOrEmpty(Request["action"]));
divAction.Visible = !ImportStatistic.IsRun && (Request["action"] == "start");
choseDiv.Visible = !ImportStatistic.IsRun;
OutDiv.Visible = ImportStatistic.IsRun;
linkCancel.Visible = ImportStatistic.IsRun;
if (ImportStatistic.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")
};
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 = Resources.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 = Resources.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 = Resources.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 = chbHasHeadrs.Checked;
using (var csv = new CsvHelper.CsvReader(new StreamReader(_fullPath, Encodings.GetEncoding())))
{
csv.Configuration.Delimiter = Separators.GetCharSeparator();
csv.Configuration.BufferSize = 0x1000;
csv.Configuration.HasHeaderRecord = false;
csv.Read();
if (_hasHeadrs && csv.CurrentRecord.HasDuplicates())
{
var strFileds = string.Empty;
foreach (var item in csv.CurrentRecord.Duplicates())
{
strFileds += "\"" + item + "\",";
}
MsgErr(Resource.Admin_ImportCsv_DuplicateHeader + strFileds.Trim(','));
btnAction.Visible = false;
}
for (int i = 0; i < csv.CurrentRecord.Length; i++)
{
//Added by Evgeni to Import csv with dotes
// csv.CurrentRecord[0] = csv.CurrentRecord[0].Replace(".", "").Replace(" ", "");
var cell = new TableCell {
ID = "cell" + i.ToString()
};
var lb = new Label();
bool flagMustReqField = false;
if (Request["hasheadrs"].ToLower() == "true")
{
var tempCsv = (csv[i].Length > 50 ? csv[i].Substring(0, 49) : csv[i]).Replace("*", "");
if (_mustRequiredFfield.Any(item => ProductFields.GetStringNameByEnum(item).Replace("*", "") == 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.ToString(), Width = 150
};
ddl.Items.Add(new ListItem(ProductFields.GetDisplayNameByEnum(ProductFields.Fields.None), ProductFields.GetStringNameByEnum(ProductFields.Fields.None)));
ddl.Items.Add(new ListItem(ProductFields.GetDisplayNameByEnum(ProductFields.Fields.Sku), ProductFields.GetStringNameByEnum(ProductFields.Fields.Sku)));
ddl.Items.Add(new ListItem(ProductFields.GetDisplayNameByEnum(ProductFields.Fields.Name), ProductFields.GetStringNameByEnum(ProductFields.Fields.Name).Trim('*')));
ddl.Items.Add(new ListItem(ProductFields.GetDisplayNameByEnum(ProductFields.Fields.ParamSynonym), ProductFields.GetStringNameByEnum(ProductFields.Fields.ParamSynonym)));
ddl.Items.Add(new ListItem(ProductFields.GetDisplayNameByEnum(ProductFields.Fields.Category), ProductFields.GetStringNameByEnum(ProductFields.Fields.Category).Trim('*')));
ddl.Items.Add(new ListItem(ProductFields.GetDisplayNameByEnum(ProductFields.Fields.Enabled), ProductFields.GetStringNameByEnum(ProductFields.Fields.Enabled).Trim('*')));
ddl.Items.Add(new ListItem(ProductFields.GetDisplayNameByEnum(ProductFields.Fields.Price), ProductFields.GetStringNameByEnum(ProductFields.Fields.Price).Trim('*')));
ddl.Items.Add(new ListItem(ProductFields.GetDisplayNameByEnum(ProductFields.Fields.PurchasePrice), ProductFields.GetStringNameByEnum(ProductFields.Fields.PurchasePrice)));
ddl.Items.Add(new ListItem(ProductFields.GetDisplayNameByEnum(ProductFields.Fields.Amount), ProductFields.GetStringNameByEnum(ProductFields.Fields.Amount)));
ddl.Items.Add(new ListItem(ProductFields.GetDisplayNameByEnum(ProductFields.Fields.Unit), ProductFields.GetStringNameByEnum(ProductFields.Fields.Unit)));
ddl.Items.Add(new ListItem(ProductFields.GetDisplayNameByEnum(ProductFields.Fields.Discount), ProductFields.GetStringNameByEnum(ProductFields.Fields.Discount)));
ddl.Items.Add(new ListItem(ProductFields.GetDisplayNameByEnum(ProductFields.Fields.ShippingPrice), ProductFields.GetStringNameByEnum(ProductFields.Fields.ShippingPrice)));
ddl.Items.Add(new ListItem(ProductFields.GetDisplayNameByEnum(ProductFields.Fields.Weight), ProductFields.GetStringNameByEnum(ProductFields.Fields.Weight)));
ddl.Items.Add(new ListItem(ProductFields.GetDisplayNameByEnum(ProductFields.Fields.Size), ProductFields.GetStringNameByEnum(ProductFields.Fields.Size)));
ddl.Items.Add(new ListItem(ProductFields.GetDisplayNameByEnum(ProductFields.Fields.BriefDescription), ProductFields.GetStringNameByEnum(ProductFields.Fields.BriefDescription)));
ddl.Items.Add(new ListItem(ProductFields.GetDisplayNameByEnum(ProductFields.Fields.Description), ProductFields.GetStringNameByEnum(ProductFields.Fields.Description)));
ddl.Items.Add(new ListItem(ProductFields.GetDisplayNameByEnum(ProductFields.Fields.Title), ProductFields.GetStringNameByEnum(ProductFields.Fields.Title)));
ddl.Items.Add(new ListItem(ProductFields.GetDisplayNameByEnum(ProductFields.Fields.MetaKeywords), ProductFields.GetStringNameByEnum(ProductFields.Fields.MetaKeywords)));
ddl.Items.Add(new ListItem(ProductFields.GetDisplayNameByEnum(ProductFields.Fields.MetaDescription), ProductFields.GetStringNameByEnum(ProductFields.Fields.MetaDescription)));
ddl.Items.Add(new ListItem(ProductFields.GetDisplayNameByEnum(ProductFields.Fields.Photos), ProductFields.GetStringNameByEnum(ProductFields.Fields.Photos)));
ddl.Items.Add(new ListItem(ProductFields.GetDisplayNameByEnum(ProductFields.Fields.Markers), ProductFields.GetStringNameByEnum(ProductFields.Fields.Markers)));
ddl.Items.Add(new ListItem(ProductFields.GetDisplayNameByEnum(ProductFields.Fields.Properties), ProductFields.GetStringNameByEnum(ProductFields.Fields.Properties)));
ddl.Items.Add(new ListItem(ProductFields.GetDisplayNameByEnum(ProductFields.Fields.Producer), ProductFields.GetStringNameByEnum(ProductFields.Fields.Producer)));
ddl.Items.Add(new ListItem(ProductFields.GetDisplayNameByEnum(ProductFields.Fields.OrderByRequest), ProductFields.GetStringNameByEnum(ProductFields.Fields.OrderByRequest)));
ddl.SelectedValue = lb.Text.Replace("*", "").Trim().ToLower();
cell.Controls.Add(ddl);
ddlRow.Cells.Add(cell);
}
csv.Read();
if (csv.CurrentRecord != null)
{
for (int i = 0; i < csv.CurrentRecord.Length; i++)
{
//Added by Evgeni to remove dots
//csv.CurrentRecord[0] = csv.CurrentRecord[0].Replace(".", "").Replace(" ", "");
var cell = new TableCell();
if (csv[i] == null)
{
cell.Controls.Add(new Label {
Text = string.Empty
});
}
else
{
cell.Controls.Add(new Label {
Text = csv[i].Length > 50 ? csv[i].Substring(0, 49).HtmlEncode() : csv[i].HtmlEncode()
});
}
firstValRow.Cells.Add(cell);
}
}
}
tbl.Rows.Add(namesRow);
tbl.Rows.Add(firstValRow);
tbl.Rows.Add(ddlRow);
choseDiv.Controls.Add(tbl);
}
/// <summary>
/// List of invoice items.
/// This is used for free-form invoices.
/// </summary>
/// <returns>The list of invoices.</returns>
public IList <InvoiceItem> ListLineItems()
{
if (_listLineItems == null)
{
_listLineItems = new List <InvoiceItem>();
// Null check
if (string.IsNullOrEmpty(CsvLineItems))
{
return(_listLineItems);
}
// Get memory stream of data
using (System.IO.MemoryStream stream = new System.IO.MemoryStream(System.Text.Encoding.UTF8.GetBytes(CsvLineItems)))
using (var streamReader = new StreamReader(stream))
using (var parser = new CsvHelper.CsvReader(streamReader)) {
List <string> headers = new List <string>();
int lineindex = 0;
while (parser.Read())
{
string[] fields = GetFields(parser);
int fieldindex = 0;
InvoiceItem invocieitem = null;
foreach (string field in fields)
{
// Header, or content?
if (lineindex == 0)
{
headers.Add(field);
}
else
{
if (invocieitem == null)
{
invocieitem = new InvoiceItem();
}
// Parse by header name
switch (headers[fieldindex])
{
case "kind": invocieitem.Kind = field; break;
case "description": invocieitem.Description = field; break;
case "quantity": invocieitem.Quantity = decimal.Parse(field, System.Globalization.CultureInfo.InvariantCulture); break;
case "unit_price": invocieitem.UnitPrice = decimal.Parse(field, System.Globalization.CultureInfo.InvariantCulture); break;
case "amount": invocieitem.Amount = decimal.Parse(field, System.Globalization.CultureInfo.InvariantCulture); break;
case "taxed": invocieitem.Taxed = bool.Parse(field); break;
case "taxed2": invocieitem.Taxed2 = bool.Parse(field); break;
case "project_id": invocieitem.ProjectId = string.IsNullOrEmpty(field) ? 0 : long.Parse(field); break;
}
}
fieldindex++;
}
lineindex++;
if (invocieitem != null)
{
_listLineItems.Add(invocieitem);
}
}
}
}
return(_listLineItems);
}
private void ProcessCsv(string fullPath)
{
ImportStatistic.Init();
ImportStatistic.IsRun = true;
var fieldMapping = new Dictionary <string, int>();
using (var csv = new CsvHelper.CsvReader(new StreamReader(fullPath, Encoding.UTF8)))
{
csv.Configuration.Delimiter = ';';
csv.Configuration.HasHeaderRecord = false;
csv.Read();
for (int i = 0; i < csv.CurrentRecord.Length; i++)
{
if (csv.CurrentRecord[i] == ProductFields.GetStringNameByEnum(ProductFields.Fields.None))
{
continue;
}
if (!fieldMapping.ContainsKey(csv.CurrentRecord[i]))
{
fieldMapping.Add(csv.CurrentRecord[i], i);
}
}
}
using (var csv = new CsvHelper.CsvReader(new StreamReader(fullPath, Encoding.UTF8)))
{
csv.Configuration.Delimiter = ';';
csv.Configuration.HasHeaderRecord = true;
while (csv.Read())
{
if (!ImportStatistic.IsRun)
{
csv.Dispose();
FileHelpers.DeleteFile(fullPath);
return;
}
ImportStatistic.RowPosition++;
try
{
// Step by rows
var productInStrings = new Dictionary <ProductFields.Fields, string>();
string nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.Sku);
if (fieldMapping.ContainsKey(nameField))
{
productInStrings.Add(ProductFields.Fields.Sku, Convert.ToString(csv[fieldMapping[nameField]]));
}
nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.Name).Trim('*');
if (fieldMapping.ContainsKey(nameField))
{
var name = Convert.ToString(csv[fieldMapping[nameField]]);
if (!string.IsNullOrEmpty(name))
{
productInStrings.Add(ProductFields.Fields.Name, name);
}
else
{
Log(string.Format(Resource.Admin_ImportCsv_CanNotEmpty, ProductFields.GetDisplayNameByEnum(ProductFields.Fields.Name), ImportStatistic.RowPosition + 2), "InvalidData");
continue;
}
}
nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.Enabled).Trim('*');
if (fieldMapping.ContainsKey(nameField))
{
string enabled = Convert.ToString(csv[fieldMapping[nameField]]);
productInStrings.Add(ProductFields.Fields.Enabled, enabled);
}
nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.Discount);
if (fieldMapping.ContainsKey(nameField))
{
string discount = Convert.ToString(csv[fieldMapping[nameField]]);
if (string.IsNullOrEmpty(discount))
{
discount = "0";
}
decimal tmp;
if (decimal.TryParse(discount, out tmp))
{
productInStrings.Add(ProductFields.Fields.Discount, tmp.ToString());
}
else if (decimal.TryParse(discount, NumberStyles.Any, CultureInfo.InvariantCulture, out tmp))
{
productInStrings.Add(ProductFields.Fields.Discount, tmp.ToString());
}
else
{
Log(string.Format(Resource.Admin_ImportCsv_MustBeNumber, ProductFields.GetDisplayNameByEnum(ProductFields.Fields.Discount), ImportStatistic.RowPosition + 2), "InvalidData");
continue;
}
}
nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.Weight);
if (fieldMapping.ContainsKey(nameField))
{
string weight = Convert.ToString(csv[fieldMapping[nameField]]);
if (string.IsNullOrEmpty(weight))
{
weight = "0";
}
decimal tmp;
if (decimal.TryParse(weight, out tmp))
{
productInStrings.Add(ProductFields.Fields.Weight, tmp.ToString());
}
else if (decimal.TryParse(weight, NumberStyles.Any, CultureInfo.InvariantCulture, out tmp))
{
productInStrings.Add(ProductFields.Fields.Weight, tmp.ToString());
}
else
{
Log(string.Format(Resource.Admin_ImportCsv_MustBeNumber, ProductFields.GetDisplayNameByEnum(ProductFields.Fields.Weight), ImportStatistic.RowPosition + 2), "InvalidData");
continue;
}
}
nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.Size);
if (fieldMapping.ContainsKey(nameField))
{
productInStrings.Add(ProductFields.Fields.Size, Convert.ToString(csv[fieldMapping[nameField]]));
}
nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.BriefDescription);
if (fieldMapping.ContainsKey(nameField))
{
productInStrings.Add(ProductFields.Fields.BriefDescription, Convert.ToString(csv[fieldMapping[nameField]]));
}
nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.Description);
if (fieldMapping.ContainsKey(nameField))
{
productInStrings.Add(ProductFields.Fields.Description, Convert.ToString(csv[fieldMapping[nameField]]));
}
nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.Price).Trim('*');
if (fieldMapping.ContainsKey(nameField))
{
string price = Convert.ToString(csv[fieldMapping[nameField]]);
if (string.IsNullOrEmpty(price))
{
price = "0";
}
decimal tmp;
if (decimal.TryParse(price, out tmp))
{
productInStrings.Add(ProductFields.Fields.Price, tmp.ToString());
}
else if (decimal.TryParse(price, NumberStyles.Any, CultureInfo.InvariantCulture, out tmp))
{
productInStrings.Add(ProductFields.Fields.Price, tmp.ToString());
}
else
{
Log(string.Format(Resource.Admin_ImportCsv_MustBeNumber, ProductFields.GetDisplayNameByEnum(ProductFields.Fields.Price), ImportStatistic.RowPosition + 2), "InvalidData");
continue;
}
}
nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.PurchasePrice);
if (fieldMapping.ContainsKey(nameField))
{
string sypplyprice = Convert.ToString(csv[fieldMapping[nameField]]);
if (string.IsNullOrEmpty(sypplyprice))
{
sypplyprice = "0";
}
decimal tmp;
if (decimal.TryParse(sypplyprice, out tmp))
{
productInStrings.Add(ProductFields.Fields.PurchasePrice, tmp.ToString());
}
else if (decimal.TryParse(sypplyprice, NumberStyles.Any, CultureInfo.InvariantCulture, out tmp))
{
productInStrings.Add(ProductFields.Fields.PurchasePrice, tmp.ToString());
}
else
{
Log(string.Format(Resource.Admin_ImportCsv_MustBeNumber, ProductFields.GetDisplayNameByEnum(ProductFields.Fields.PurchasePrice), ImportStatistic.RowPosition + 2), "InvalidData");
continue;
}
}
nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.ShippingPrice);
if (fieldMapping.ContainsKey(nameField))
{
string shippingPrice = Convert.ToString(csv[fieldMapping[nameField]]);
if (string.IsNullOrEmpty(shippingPrice))
{
shippingPrice = "0";
}
decimal tmp;
if (decimal.TryParse(shippingPrice, out tmp))
{
productInStrings.Add(ProductFields.Fields.ShippingPrice, tmp.ToString());
}
else if (decimal.TryParse(shippingPrice, NumberStyles.Any, CultureInfo.InvariantCulture, out tmp))
{
productInStrings.Add(ProductFields.Fields.ShippingPrice, tmp.ToString());
}
else
{
Log(string.Format(Resource.Admin_ImportCsv_MustBeNumber, ProductFields.GetDisplayNameByEnum(ProductFields.Fields.ShippingPrice), ImportStatistic.RowPosition + 2), "InvalidData");
continue;
}
}
nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.Amount);
if (fieldMapping.ContainsKey(nameField))
{
string amount = Convert.ToString(csv[fieldMapping[nameField]]);
if (string.IsNullOrEmpty(amount))
{
amount = "0";
}
int tmp;
if (int.TryParse(amount, out tmp))
{
productInStrings.Add(ProductFields.Fields.Amount, amount);
}
else
{
Log(string.Format(Resource.Admin_ImportCsv_MustBeNumber, ProductFields.GetDisplayNameByEnum(ProductFields.Fields.Amount), ImportStatistic.RowPosition + 2), "InvalidData");
continue;
}
}
nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.Unit);
if (fieldMapping.ContainsKey(nameField))
{
productInStrings.Add(ProductFields.Fields.Unit, Convert.ToString(csv[fieldMapping[nameField]]));
}
nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.ParamSynonym);
if (fieldMapping.ContainsKey(nameField))
{
string rewurl = Convert.ToString(csv[fieldMapping[nameField]]);
productInStrings.Add(ProductFields.Fields.ParamSynonym, rewurl);
}
nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.Title);
if (fieldMapping.ContainsKey(nameField))
{
productInStrings.Add(ProductFields.Fields.Title, Convert.ToString(csv[fieldMapping[nameField]]));
}
nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.MetaKeywords);
if (fieldMapping.ContainsKey(nameField))
{
productInStrings.Add(ProductFields.Fields.MetaKeywords, Convert.ToString(csv[fieldMapping[nameField]]));
}
nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.MetaDescription);
if (fieldMapping.ContainsKey(nameField))
{
productInStrings.Add(ProductFields.Fields.MetaDescription, Convert.ToString(csv[fieldMapping[nameField]]));
}
nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.Photos);
if (fieldMapping.ContainsKey(nameField))
{
productInStrings.Add(ProductFields.Fields.Photos, Convert.ToString(csv[fieldMapping[nameField]]));
}
nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.Markers);
if (fieldMapping.ContainsKey(nameField))
{
productInStrings.Add(ProductFields.Fields.Markers, Convert.ToString(csv[fieldMapping[nameField]]));
}
nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.Properties);
if (fieldMapping.ContainsKey(nameField))
{
productInStrings.Add(ProductFields.Fields.Properties, Convert.ToString(csv[fieldMapping[nameField]]));
}
nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.Producer);
if (fieldMapping.ContainsKey(nameField))
{
productInStrings.Add(ProductFields.Fields.Producer, Convert.ToString(csv[fieldMapping[nameField]]));
}
nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.Category).Trim('*');
if (fieldMapping.ContainsKey(nameField))
{
var parentCategory = Convert.ToString(csv[fieldMapping[nameField]]);
if (!string.IsNullOrEmpty(parentCategory))
{
productInStrings.Add(ProductFields.Fields.Category, parentCategory);
}
}
ImportProduct.UpdateInsertProduct(productInStrings);
}
catch (Exception ex)
{
Log(ex.Message, "InvalidData");
}
}
CategoryService.RecalculateProductsCountManual();
}
ImportStatistic.IsRun = false;
FileHelpers.DeleteFile(fullPath);
}
private static void OpenDataDIP()
{
List <NemocniceData.Region> raw = new List <NemocniceData.Region>();
//process https://dip.mzcr.cz/api/v1/kapacity-intenzivni-pece-vlna-2.csv
DateTime mindate = DateTime.Now.Date.AddDays(-120);
using (var net = new System.Net.Http.HttpClient().GetStreamAsync("https://dip.mzcr.cz/api/v1/kapacity-intenzivni-pece-zdravotnicke-zarizeni-04-2021.csv"))
{
using (System.IO.StreamReader rr = new StreamReader(net.Result))
{
var csv = new CsvHelper.CsvReader(rr, new CsvHelper.Configuration.CsvConfiguration(System.Globalization.CultureInfo.GetCultureInfo("cs"))
{
HasHeaderRecord = true, Delimiter = ","
});
csv.Read(); csv.ReadHeader();
//csv.Read();//skip second line
while (csv.Read())
{
DateTime?date = Devmasters.DT.Util.ParseDateTime(csv.GetField <string>("datum")?.Trim(), null);
if (date == null)
{
continue;
}
DateTime dt = date.Value;
if (dt < mindate)
{
continue;
}
Console.WriteLine(".");
string kraj_nuts_kod = csv.GetField <string>("kraj_nuts_kod");
string region = Kraje[kraj_nuts_kod];
var r = new NemocniceData.Region();
r.lastModified = date.Value;
r.region = region;
r.name = csv.GetField <string>("zz_nazev");
r.UPV_celkem = 0;
r.UPV_volna = 0;
r.ECMO_celkem = Devmasters.TextUtil.ConvertToInt(csv.GetField <string>("ecmo_kapacita_celkem"), 0).Value;
r.ECMO_volna = Devmasters.TextUtil.ConvertToInt(csv.GetField <string>("ecmo_kapacita_volna"), 0).Value;
r.CRRT_celkem = Devmasters.TextUtil.ConvertToInt(csv.GetField <string>("cvvhd_kapacita_celkem"), 0).Value;
r.CRRT_volna = Devmasters.TextUtil.ConvertToInt(csv.GetField <string>("cvvhd_kapacita_volna"), 0).Value;
r.IHD_celkem = 0;
r.IHD_volna = 0;
r.AROJIP_luzka_celkem = Devmasters.TextUtil.ConvertToInt(csv.GetField <string>("luzka_upv_niv_kapacita_celkem"), 0).Value;
r.AROJIP_luzka_covid = Devmasters.TextUtil.ConvertToInt(csv.GetField <string>("luzka_upv_niv_kapacita_volna_covid_pozitivni"), 0).Value;
r.AROJIP_luzka_necovid = Devmasters.TextUtil.ConvertToInt(csv.GetField <string>("luzka_upv_niv_kapacita_volna_covid_negativni"), 0).Value;
r.Standard_luzka_s_kyslikem_celkem = Devmasters.TextUtil.ConvertToInt(csv.GetField <string>("luzka_standard_kyslik_kapacita_celkem"), 0).Value;
r.Standard_luzka_s_kyslikem_covid = Devmasters.TextUtil.ConvertToInt(csv.GetField <string>("luzka_standard_kyslik_kapacita_volna_covid_pozitivni"), 0).Value;
r.Standard_luzka_s_kyslikem_necovid = Devmasters.TextUtil.ConvertToInt(csv.GetField <string>("luzka_standard_kyslik_kapacita_volna_covid_negativni"), 0).Value;
//r.Lekari_AROJIP_celkem = 0;
//r.Lekari_AROJIP_dostupni = 0;
//r.Sestry_AROJIP_celkem = 0;
//r.Sestry_AROJIP_dostupni = 0;
//r.Standard_luzka_celkem = 0;
//r.Standard_luzka_s_monitor_celkem = 0;
r.Ventilatory_prenosne_celkem = Devmasters.TextUtil.ConvertToInt(csv.GetField <string>("ventilatory_prenosne_kapacita_celkem"), 0).Value;
r.Ventilatory_operacnisal_celkem = Devmasters.TextUtil.ConvertToInt(csv.GetField <string>("ventilatory_operacni_sal_kapacita_celkem"), 0).Value;
raw.Add(r);
}
}
}
Devmasters.Logging.Logger.Root.Info("Saving");
var dates = raw.Select(m => m.lastModified).Distinct();
var kraje = raw.Select(m => m.region).Distinct();
foreach (var dt in dates.Where(m => m > mindate))
{
Console.WriteLine(dt);
NemocniceData nem = null; //new NemocniceData();
var id = "id_" + dt.ToString("yyyy-MM-dd");
List <NemocniceData.Region> nr = new List <NemocniceData.Region>();
foreach (var kr in kraje)
{
var lines = raw.Where(m => m.lastModified == dt && m.region == kr).ToArray();
var r = NemocniceData.Aggregate(lines);
r.region = kr;
nr.Add(r);
}
try
{
nem = ds.GetItem(id); // new NemocniceData();
}
catch (Exception)
{
}
if (nem == null)
{
nem = new NemocniceData();
}
nem.id = id;
nem.regions = nr;
nem.lastUpdated = dt;
ds.AddOrUpdateItem(nem, HlidacStatu.Api.V2.Dataset.Typed.ItemInsertMode.rewrite);
}
//ds.AddOrUpdateItem(nd, HlidacStatu.Api.V2.Dataset.Typed.ItemInsertMode.rewrite);
}
/// <summary>
/// Advances the <see cref="T:System.Data.IDataReader"></see> to the next record.
/// </summary>
/// <returns>
/// true if there are more rows; otherwise, false.
/// </returns>
public bool Read()
{
return(csv.Read());
}
public static void ReadAll_CsvHelper(DelimitedRecordReaderBenchmarkArguments args)
{
var config = new CH.Configuration.CsvConfiguration
{
BufferSize = args.BufferSize,
AllowComments = true,
IgnoreBlankLines = args.SkipEmptyLines,
HasHeaderRecord = false,
DetectColumnCountChanges = true,
TrimFields = args.TrimWhiteSpaces,
TrimHeaders = args.TrimWhiteSpaces
};
using (var reader = new CH.CsvReader(new StreamReader(args.Path, args.Encoding, true, args.BufferSize), config))
{
string s;
if (args.FieldIndex < 0)
{
while (reader.Read())
{
var record = reader.CurrentRecord;
for (int i = 0; i < record.Length; i++)
s = record[i];
}
}
else
{
while (reader.Read())
{
for (int i = 0; i < args.FieldIndex + 1; i++)
s = reader[i];
}
}
}
}
public override ContentItem GetById(ValidUrl url_, ContentViewType viewType_)
{
//ContentItem item = _db.GetCollection<ContentItem>(COLLNAME).AsQueryable<ContentItem>().Where(x => x.Url.Id == url_.Id && x.ContentView.ViewType == viewType_).FirstOrDefault<ContentItem>();
ContentItem item = _db.GetCollection<ContentItem>(COLLNAME).Find(Query.And(Query.EQ("Url.Id", url_.Id), Query.EQ("ViewType", Convert.ToInt32(viewType_)))).FirstOrDefault<ContentItem>();
if (item == null)
{
DependencyManager.Logger.Log(new LogEventInfo(LogLevel.Debug, ECMSSettings.DEFAULT_LOGGER, "Specific content not found now going to search for default content."));
item = _db.GetCollection<ContentItem>(COLLNAME).Find(Query.And(Query.EQ("ContentView.SiteId", url_.SiteId), Query.EQ("ContentView.ViewName", url_.View), Query.EQ("ContentView.ViewType", Convert.ToInt32(viewType_)))).FirstOrDefault<ContentItem>();
}
//TODO : Optimize this
if (item != null)
{
using (StringReader streamReader = new StringReader(item.Body[0].ToString()))
{
using (var csv = new CsvHelper.CsvReader(streamReader))
{
//csv.Configuration.IgnoreQuotes = true;
csv.Read();
item.Body = JObject.FromObject(csv.GetRecord(typeof(object)));
}
}
}
return item;
}
private void ProcessCsv()
{
if (chboxDisableProducts.Checked)
{
ProductService.DisableAllProducts();
}
long count = 0;
using (var csv = new CsvHelper.CsvReader(new StreamReader(_fullPath, Encodings.GetEncoding())))
{
csv.Configuration.Delimiter = Separators.GetCharSeparator();
csv.Configuration.HasHeaderRecord = _hasHeadrs;
while (csv.Read())
{
count++;
}
}
ImportStatistic.TotalRow = count;
using (var csv = new CsvHelper.CsvReader(new StreamReader(_fullPath, Encodings.GetEncoding())))
{
csv.Configuration.Delimiter = Separators.GetCharSeparator();
csv.Configuration.HasHeaderRecord = _hasHeadrs;
while (csv.Read())
{
if (!ImportStatistic.IsRun)
{
csv.Dispose();
FileHelpers.DeleteFile(_fullPath);
return;
}
try
{
//Added by Evgeni to Remove dots
// csv.CurrentRecord[0] = csv.CurrentRecord[0].Replace(".", "").Replace(" ", "");
// Step by rows
var productInStrings = new Dictionary <ProductFields.Fields, string>();
string nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.Sku);
if (FieldMapping.ContainsKey(nameField))
{
productInStrings.Add(ProductFields.Fields.Sku, Convert.ToString(csv[FieldMapping[nameField]]));
}
nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.Name).Trim('*');
if (FieldMapping.ContainsKey(nameField))
{
var name = Convert.ToString(csv[FieldMapping[nameField]]);
if (!string.IsNullOrEmpty(name))
{
productInStrings.Add(ProductFields.Fields.Name, name);
}
else
{
LogInvalidData(string.Format(Resource.Admin_ImportCsv_CanNotEmpty, ProductFields.GetDisplayNameByEnum(ProductFields.Fields.Name), ImportStatistic.RowPosition + 2));
continue;
}
}
nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.Enabled).Trim('*');
if (FieldMapping.ContainsKey(nameField))
{
string enabled = Convert.ToString(csv[FieldMapping[nameField]]);
productInStrings.Add(ProductFields.Fields.Enabled, enabled);
//product.Enabled = !string.IsNullOrEmpty(enabled) && enabled.Trim().Equals("+");
}
nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.Discount);
if (FieldMapping.ContainsKey(nameField))
{
var discount = Convert.ToString(csv[FieldMapping[nameField]]);
if (string.IsNullOrEmpty(discount))
{
discount = "0";
}
decimal tmp;
if (decimal.TryParse(discount, out tmp))
{
productInStrings.Add(ProductFields.Fields.Discount, tmp.ToString());
}
else if (decimal.TryParse(discount, NumberStyles.Any, CultureInfo.InvariantCulture, out tmp))
{
productInStrings.Add(ProductFields.Fields.Discount, tmp.ToString());
}
else
{
LogInvalidData(string.Format(Resource.Admin_ImportCsv_MustBeNumber, ProductFields.GetDisplayNameByEnum(ProductFields.Fields.Discount), ImportStatistic.RowPosition + 2));
continue;
}
}
nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.Weight);
if (FieldMapping.ContainsKey(nameField))
{
var weight = Convert.ToString(csv[FieldMapping[nameField]]);
if (string.IsNullOrEmpty(weight))
{
weight = "0";
}
decimal tmp;
if (decimal.TryParse(weight, out tmp))
{
productInStrings.Add(ProductFields.Fields.Weight, tmp.ToString());
}
else if (decimal.TryParse(weight, NumberStyles.Any, CultureInfo.InvariantCulture, out tmp))
{
productInStrings.Add(ProductFields.Fields.Weight, tmp.ToString());
}
else
{
LogInvalidData(string.Format(Resource.Admin_ImportCsv_MustBeNumber, ProductFields.GetDisplayNameByEnum(ProductFields.Fields.Weight), ImportStatistic.RowPosition + 2));
continue;
}
}
nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.Size);
if (FieldMapping.ContainsKey(nameField))
{
productInStrings.Add(ProductFields.Fields.Size, Convert.ToString(csv[FieldMapping[nameField]]));
}
nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.BriefDescription);
if (FieldMapping.ContainsKey(nameField))
{
productInStrings.Add(ProductFields.Fields.BriefDescription, Convert.ToString(csv[FieldMapping[nameField]]));
}
nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.Description);
if (FieldMapping.ContainsKey(nameField))
{
productInStrings.Add(ProductFields.Fields.Description, Convert.ToString(csv[FieldMapping[nameField]]));
}
nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.Price).Trim('*');
if (FieldMapping.ContainsKey(nameField))
{
var price = Convert.ToString(csv[FieldMapping[nameField]]);
if (string.IsNullOrEmpty(price))
{
price = "0";
}
decimal tmp;
if (decimal.TryParse(price, out tmp))
{
productInStrings.Add(ProductFields.Fields.Price, tmp.ToString());
}
else if (decimal.TryParse(price, NumberStyles.Any, CultureInfo.InvariantCulture, out tmp))
{
productInStrings.Add(ProductFields.Fields.Price, tmp.ToString());
}
else
{
LogInvalidData(string.Format(Resource.Admin_ImportCsv_MustBeNumber, ProductFields.GetDisplayNameByEnum(ProductFields.Fields.Price), ImportStatistic.RowPosition + 2));
continue;
}
}
nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.PurchasePrice);
if (FieldMapping.ContainsKey(nameField))
{
var sypplyprice = Convert.ToString(csv[FieldMapping[nameField]]);
if (string.IsNullOrEmpty(sypplyprice))
{
sypplyprice = "0";
}
decimal tmp;
if (decimal.TryParse(sypplyprice, out tmp))
{
productInStrings.Add(ProductFields.Fields.PurchasePrice, tmp.ToString());
}
else if (decimal.TryParse(sypplyprice, NumberStyles.Any, CultureInfo.InvariantCulture, out tmp))
{
productInStrings.Add(ProductFields.Fields.PurchasePrice, tmp.ToString());
}
else
{
LogInvalidData(string.Format(Resource.Admin_ImportCsv_MustBeNumber, ProductFields.GetDisplayNameByEnum(ProductFields.Fields.PurchasePrice), ImportStatistic.RowPosition + 2));
continue;
}
}
nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.ShippingPrice);
if (FieldMapping.ContainsKey(nameField))
{
var shippingPrice = Convert.ToString(csv[FieldMapping[nameField]]);
if (string.IsNullOrEmpty(shippingPrice))
{
shippingPrice = "0";
}
decimal tmp;
if (decimal.TryParse(shippingPrice, out tmp))
{
productInStrings.Add(ProductFields.Fields.ShippingPrice, tmp.ToString());
}
else if (decimal.TryParse(shippingPrice, NumberStyles.Any, CultureInfo.InvariantCulture, out tmp))
{
productInStrings.Add(ProductFields.Fields.ShippingPrice, tmp.ToString());
}
else
{
LogInvalidData(string.Format(Resource.Admin_ImportCsv_MustBeNumber, ProductFields.GetDisplayNameByEnum(ProductFields.Fields.ShippingPrice), ImportStatistic.RowPosition + 2));
continue;
}
}
nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.Amount);
if (FieldMapping.ContainsKey(nameField))
{
var amount = Convert.ToString(csv[FieldMapping[nameField]]);
if (string.IsNullOrEmpty(amount))
{
amount = "0";
}
int tmp;
if (int.TryParse(amount, out tmp))
{
productInStrings.Add(ProductFields.Fields.Amount, amount);
}
else
{
LogInvalidData(string.Format(Resource.Admin_ImportCsv_MustBeNumber, ProductFields.GetDisplayNameByEnum(ProductFields.Fields.Amount), ImportStatistic.RowPosition + 2));
continue;
}
}
nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.Unit);
if (FieldMapping.ContainsKey(nameField))
{
productInStrings.Add(ProductFields.Fields.Unit, Convert.ToString(csv[FieldMapping[nameField]]));
}
nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.ParamSynonym);
if (FieldMapping.ContainsKey(nameField))
{
string rewurl = Convert.ToString(csv[FieldMapping[nameField]]);
productInStrings.Add(ProductFields.Fields.ParamSynonym, rewurl);
}
nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.Title);
if (FieldMapping.ContainsKey(nameField))
{
productInStrings.Add(ProductFields.Fields.Title, Convert.ToString(csv[FieldMapping[nameField]]));
}
nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.MetaKeywords);
if (FieldMapping.ContainsKey(nameField))
{
productInStrings.Add(ProductFields.Fields.MetaKeywords, Convert.ToString(csv[FieldMapping[nameField]]));
}
nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.MetaDescription);
if (FieldMapping.ContainsKey(nameField))
{
productInStrings.Add(ProductFields.Fields.MetaDescription, Convert.ToString(csv[FieldMapping[nameField]]));
}
nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.Photos);
if (FieldMapping.ContainsKey(nameField))
{
productInStrings.Add(ProductFields.Fields.Photos, Convert.ToString(csv[FieldMapping[nameField]]));
}
nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.Markers);
if (FieldMapping.ContainsKey(nameField))
{
productInStrings.Add(ProductFields.Fields.Markers, Convert.ToString(csv[FieldMapping[nameField]]));
}
nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.Properties);
if (FieldMapping.ContainsKey(nameField))
{
productInStrings.Add(ProductFields.Fields.Properties, Convert.ToString(csv[FieldMapping[nameField]]));
}
nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.Producer);
if (FieldMapping.ContainsKey(nameField))
{
productInStrings.Add(ProductFields.Fields.Producer, Convert.ToString(csv[FieldMapping[nameField]]));
}
nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.OrderByRequest);
if (FieldMapping.ContainsKey(nameField))
{
string orderbyrequest = Convert.ToString(csv[FieldMapping[nameField]]);
productInStrings.Add(ProductFields.Fields.OrderByRequest, orderbyrequest);
}
nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.Category).Trim('*');
if (FieldMapping.ContainsKey(nameField))
{
var parentCategory = Convert.ToString(csv[FieldMapping[nameField]]);
if (!string.IsNullOrEmpty(parentCategory))
{
productInStrings.Add(ProductFields.Fields.Category, parentCategory);
}
}
ImportProduct.UpdateInsertProduct(productInStrings);
}
catch (Exception ex)
{
MsgErr(ex.Message + " at csv");
Debug.LogError(ex);
}
}
CategoryService.RecalculateProductsCountManual();
}
ImportStatistic.IsRun = false;
LuceneSearch.CreateAllIndexInBackground();
CacheManager.Clean();
FileHelpers.DeleteFilesFromImageTempInBackground();
FileHelpers.DeleteFile(_fullPath);
}
