private void _resumeArchiveSprinter(object obj)
{
if (File.Exists(ProjectControlVM.SelectedProject.SelectedRun.PauseFilePath))
{
Pause config;
using (StreamReader reader = File.OpenText(ProjectControlVM.SelectedProject.SelectedRun.PauseFilePath))
{
JsonSerializer serializer = new JsonSerializer();
config = (Pause)serializer.Deserialize(reader, typeof(Pause));
}
File.Delete(ProjectControlVM.SelectedProject.SelectedRun.PauseFilePath);
var sigcsv = new CSVFileReader();
var data = sigcsv.ReadSignatureCSV(config.LastWrittenFileName);
var lasttime = data.LastOrDefault();
ProjectControlVM.SelectedProject.SelectedRun.PauseFilePath = null;
ProjectControlVM.SelectedProject.SelectedRun.CheckTaskDirIntegrity();
_numberOfFilesRead = 0;
_setupFileManager();
_reader.DateTimeStart = config.LastReadFileTime;
var numberOfDataWriters = SettingsVM.DataWriters.Count();
_setupDataManager(numberOfDataWriters);
DataMngr.FirstFile = false;
DataMngr.ResumedTask = true;
DataMngr.CurrentTimeStamp = config.CurrentTimeStamp;
DataMngr.TimeZero = lasttime.AddSeconds(Convert.ToInt32(SettingsVM.WindowSizeStr) - Convert.ToInt32(SettingsVM.WindowOverlapStr));
ProjectControlVM.SelectedProject.SelectedRun.IsTaskRunning = true;
ProjectControlVM.CanRun = false;
_startAS(numberOfDataWriters);
}
}
public IEnumerable <FileValidationError> Validate <T>(string filePath) where T : BaseEntity, new()
{
List <FileValidationError> fileValidationErrors = new List <FileValidationError>();
FileInfo fileInfo = new FileInfo(filePath);
if (!fileInfo.Exists)
{
fileValidationErrors.Add(new FileValidationError {
ErrorType = "Error", Description = "File does not exist"
});
}
if (fileInfo.Exists)
{
if (fileInfo.Length == 0)
{
fileValidationErrors.Add(new FileValidationError {
ErrorType = "Error", Description = "File is empty"
});
}
if (fileInfo.Extension.ToLower() != ".csv")
{
fileValidationErrors.Add(new FileValidationError {
ErrorType = "Extenion Not Supported", Description = fileInfo.Extension
});
}
var csvFileReader = new CSVFileReader <T>(filePath);
string[] columns = csvFileReader.NormalizedColumns;
if (!csvFileReader.HasRecords())
{
fileValidationErrors.Add(new FileValidationError {
ErrorType = "Only Header", Description = "File does not have data!"
});
}
var flags = BindingFlags.Public | BindingFlags.IgnoreCase | BindingFlags.Instance;
string[] entityProperties = typeof(T).GetProperties(flags).Select(x => x.Name).Where(x => !typeof(BaseEntity).GetProperties(flags).Select(y => y.Name).Contains(x)).ToArray();
string columnsOnlyInFile = String.Join(",", columns.Except(entityProperties));
if (!String.IsNullOrEmpty(columnsOnlyInFile))
{
fileValidationErrors.Add(new FileValidationError {
ErrorType = "Extra Columns", Description = columnsOnlyInFile
});
}
string columnsOnlyInEntity = String.Join(",", entityProperties.Except(columns));
if (!String.IsNullOrEmpty(columnsOnlyInFile))
{
fileValidationErrors.Add(new FileValidationError {
ErrorType = "Missing Columns", Description = columnsOnlyInEntity
});
}
}
return(fileValidationErrors);
}
/// <summary>
/// Method will persist file to backend and ignore any business rule validation
/// </summary>
/// <typeparam name="T">Any type which inherits from validation framework base entity</typeparam>
/// <param name="filePath">File path, which requires re-processing</param>
/// <returns>FileResult object</returns>
public async Task <FileResult> OmitAndIgnoreBusinessValidation <T>(string filePath) where T : BaseEntity, new()
{
List <T> finalOutput = null;
FileInfo fileInfo = new FileInfo(filePath);
string fileToBeReProcessed = Path.Combine(fileInfo.DirectoryName, Path.GetFileNameWithoutExtension(filePath) + "_Output.csv");
var csvFileReader = new CSVFileReader <T>(fileToBeReProcessed);
List <T> entities = new List <T>();
foreach (var entity in csvFileReader)
{
entities.Add(entity);
}
return(await ProcessFinalOutput(filePath, fileInfo, entities, new List <string>(csvFileReader.CSVColumns), true).ContinueWith((finalRecords) =>
{
finalOutput = finalRecords.Result;
//Persitance logic
//FileItem fileItem = new FileItem { FileName = Path.GetFileNameWithoutExtension(filePath), FileType = typeof(T).FullName, FileData = File.ReadAllBytes(fileToBeReProcessed) };
//DAOFactory.GetFileItemDAO().SaveFile(fileItem);
}).ContinueWith((t) =>
{
return new FileResult
{
FileName = Path.GetFileNameWithoutExtension(fileToBeReProcessed),
FilePath = fileInfo.FullName,
NumberOfValidRows = entities.Count,
NumberOfErrorRows = 0,
TypeOfError = "No Error"
};
}));
}
private void CompareToDataTable(CSVFileReader csvFileReader, DataTable dataTable)
{
if (!csvFileReader.MoveToNextLine())
{
Assert.AreEqual(0, dataTable.Columns.Count, "Data table should have no columns");
Assert.AreEqual(0, dataTable.Rows.Count, "Data table should have no rows");
return;
}
List <string> values = csvFileReader.GetValues();
Assert.AreEqual(dataTable.Columns.Count, values.Count, "The number of columns must be equal");
foreach (DataColumn column in dataTable.Columns)
{
string columnName = column.ColumnName;
Assert.IsTrue(values.Contains(columnName),
String.Format("The column '{0}' does not exist in the csv output.", columnName));
}
int counter = 0;
while (csvFileReader.MoveToNextLine())
{
values = csvFileReader.GetValues();
DataRow dataRow = dataTable.Rows[counter];
int counter2 = 0;
foreach (string value in values)
{
string dataValue = dataRow[counter2].ToString();
Assert.AreEqual(dataValue, value,
String.Format("Csv data value was not as expected at [{0},{1}](base 0).", counter, counter2));
counter2++;
}
;
counter++;
}
}
public void MustNotBeZeroLength()
{
var systemUnderTest = new CSVFileReader(_mockCalvingFileReader.Object);
systemUnderTest.DigestFile("");
Assert.IsTrue(false, "Should not have made here!");
}
public void Fails()
{
var systemUnderTest = new CSVFileReader(_mockCalvingFileReader.Object);
systemUnderTest.DigestFile(EmptyFile);
Assert.IsTrue(false, "Should not have made here!");
}
public void SimpleWrite_Test()
{
List <Shipment> outputData = new List <Shipment>();
List <Shipment> inputData = new List <Shipment>();
using (var csvFile = new CSVFile <Shipment>("Shipment_Output.csv"))
{
for (int i = 0; i < 10; i++)
{
var shipment = new Shipment()
{
PickupDate = DateTime.Now, ShipmentOrigin = "Origin-" + i, ShipmentDestination = "Destination" + i
};
outputData.Add(shipment);
csvFile.Append(shipment);
}
}
var csvFileReader = new CSVFileReader <Shipment>("Shipment_Output.csv");
foreach (Shipment shipment in csvFileReader)
{
inputData.Add(shipment);
}
Assert.AreEqual(outputData.Count, 10);
Assert.AreEqual(inputData.Count, 10);
}
/// <summary>
/// Метод для чтения файла и получения результата
/// </summary>
/// <param name="filePath">Путь к файлу</param>
/// <returns>Результат чтения</returns>
public static ReadFileResult GetResult(string filePath)
{
try
{
using (FileStream openFileStream = new FileStream(path: filePath, mode: FileMode.Open, access: FileAccess.Read))
{
IFileReader reader;
if (filePath.EndsWith(".xls") || filePath.EndsWith(".xlsx"))
{
reader = new XLSFileReader(openFileStream);
}
else
{
reader = new CSVFileReader();
}
return(reader.GetReadingResult());
}
}
catch (Exception e)
{
return(new ReadFileResult(errorMessage: e.Message));
}
}
private void Start()
{
m_PlayerStatsList = CSVFileReader.Read(m_PlayerCVSFileName + "_" + SceneManager.GetActiveScene().name);
nMoney = (int)m_PlayerStatsList[0]["Value"];
nLives = (int)m_PlayerStatsList[1]["Value"];
}
private void LoadTowerInfo()
{
m_TowerInfoList = CSVFileReader.Read(m_NodeCVSFileName);
for (int i = 0; i < m_TowerInfoList.Count; i++)
{
//DB에서 타워 정보 불러옴
int nId = (int)m_TowerInfoList[i]["id"];
int n1Row_Cost = (int)m_TowerInfoList[i]["1Row_IncreaseUpgradeCost"];
int n2Row_Cost = (int)m_TowerInfoList[i]["2Row_IncreaseUpgradeCost"];
if (nId == (int)E_TOWERTYPE.E_CANNON)
{
m_TowerUpgradeStats.m_nCannonDamageCost = n1Row_Cost * PlayerPrefs.GetInt("nCannonDamageUpgradeCount", 1);
m_TowerUpgradeStats.m_nCannonSpeedCost = n2Row_Cost * PlayerPrefs.GetInt("nCannonSpeedUpgradeCount", 1);
m_TowerUpgradeStats.m_nBasicCannonDamageCost = n1Row_Cost;
m_TowerUpgradeStats.m_nBasicCannonSpeedCost = n2Row_Cost;
}
else if (nId == (int)E_TOWERTYPE.E_LASER)
{
m_TowerUpgradeStats.m_nLaserDamageCost = n1Row_Cost * PlayerPrefs.GetInt("nLaserDamageUpgradeCount", 1);
m_TowerUpgradeStats.m_nLaserSlowCost = n2Row_Cost * PlayerPrefs.GetInt("nLaserSlowUpgradeCount", 1);
m_TowerUpgradeStats.m_nBasicLaserDamageCost = n1Row_Cost;
m_TowerUpgradeStats.m_nBasicLaserSlowCost = n2Row_Cost;
}
else if (nId == (int)E_TOWERTYPE.E_MAGIC)
{
m_TowerUpgradeStats.m_nMagicDamageCost = n1Row_Cost * PlayerPrefs.GetInt("nMagicDamageUpgradeCount", 1);
m_TowerUpgradeStats.m_nMagicSpeedCost = n2Row_Cost * PlayerPrefs.GetInt("nMagicSpeedUpgradeCount", 1);
m_TowerUpgradeStats.m_nBasicMagicDamageCost = n1Row_Cost;
m_TowerUpgradeStats.m_nBasicMagicSpeedCost = n2Row_Cost;
}
}
}
private void CompareToDataTable(string csvContents, DataTable dataTable)
{
StringReader stringReader = new StringReader(csvContents);
CSVFileReader csvFileReader = new CSVFileReader(stringReader);
CompareToDataTable(csvFileReader, dataTable);
csvFileReader.Close();
}
public void ReadEmptyFile()
{
var mockLogger = new Mock <ILogger <CSVProcessor> >();
CSVFileReader fileReader = new CSVFileReader(this.logger);
fileReader.Init(this.folderPath + "TOU_5.csv");
Assert.DoesNotThrow(() => fileReader.ReadFile());
Assert.True(fileReader.LinesRead.Count == 0);
}
private void Start()
{
m_NodesCanBuildList = CSVFileReader.Read(m_NodeCVSFileName);
for (int i = 0; i < m_NodesCanBuildList.Count; i++)
{
m_NodesListMGR.transform.GetChild(i).GetComponent <NodeMGR>().SetCanBuildTower(i);
//Debug.Log("ID : " + m_NodesCanBuildList[i][sData] + " lv1 : " + m_NodesCanBuildList[i]["lv_1"] + " lv2 : " + m_NodesCanBuildList[i]["lv_2"]);
}
}
public void ReadNonExistingFile()
{
var mockLogger = new Mock <ILogger <CSVProcessor> >();
CSVFileReader fileReader = new CSVFileReader(this.logger);
fileReader.Init(this.folderPath + "TOU_51.csv");
Assert.Throws(typeof(FileNotFoundException), () => fileReader.ReadFile());
Assert.True(fileReader.LinesRead.Count == 0);
}
public void TestRead2()
{
// Read in file and compare with known results
CSVFileReader reader = (CSVFileReader)DataFileReaderFactory.Create(DataFileType.csv);
List <Signal> signals = reader.Read2("Data\\ExData_20170203_000800.csv");
Assert.IsNotNull(signals);
Assert.AreEqual(signals.Count, 8);
Assert.AreEqual(signals[0].Data.Count, 1800);
}
static void Main(string[] args)
{
string path = @"C:\Users\Tytus\Desktop\TASKs\biostats.csv";
ListCreator nl = new ListCreator();
CSVFileReader fr = new CSVFileReader();
var listToSort = fr.ReadCSVFile(path, nl.CreateList());
ListSearcher ls = new ListSearcher();
ls.SearchTheList(listToSort);
}
public void ReadWhenFileNameInvalid()
{
var mockLogger = new Mock <ILogger <CSVProcessor> >();
CSVFileReader fileReader = new CSVFileReader(this.logger);
fileReader.Init("");
Assert.Throws(typeof(ArgumentException), () => fileReader.ReadFile());
}
public override void ReadTickets(string fileName)
{
CSVFileReader fr = new CSVFileReader(true);
fr.readFromFile(fileName);
var data = fr.Data;
this.TicketList = ParseContext.DoParseForTickets(data);
}
private void Application_Startup(object sender, StartupEventArgs e)
{
MainWindow = new MainWindow();
// Inject dependencies
IDataProvider dataProvider = new DataCollector();
IFileReader fileReader = new CSVFileReader();
IUIMainWindowService service = new MainWindowService(MainWindow);
MainWindow.DataContext = new MainWindowViewModel(service, fileReader, dataProvider);
MainWindow.Show();
}
void FetchPlayerInformations()
{
cmsInfos = CSVFileReader.fetchCMSFromFile(cmsTextAsset);
double hp;
cmsInfos.movements.TryGetValue("health", out hp);
health = Mathf.RoundToInt((float)hp);
healthSlider.maxValue = health;
healthSlider.value = health;
// There is a lot more informations to fetch here such as speed, height, etc..
}
public void SimpleRead_Test()
{
List <Shipment> shipments = new List <Shipment>();
var csvFileReader = new CSVFileReader <Shipment>("Shipment_Input.csv");
foreach (Shipment shipment in csvFileReader)
{
shipments.Add(shipment);
}
Assert.IsNotNull(shipments);
Assert.AreEqual(shipments.Count + csvFileReader.InvalidEntities.Count, 14);
}
private List <Earthquake> GetLocations()
{
List <Earthquake> quakeData = new List <Earthquake>();
WebClient client = new WebClient();
Uri quakeDataURL = new Uri("http://earthquake.usgs.gov/earthquakes/feed/v0.1/summary/2.5_day.csv");
string quakeDataFile = "C:/Users/carmenau/SkyDrive/Book/Code/MvcEarthquakeMap/MvcEarthquakeMap/quake.csv";
client.DownloadFile(quakeDataURL, quakeDataFile);
CSVFileReader reader = new CSVFileReader(quakeDataFile);
List <string> columns = new List <String>();
bool readHeader = false;
while (reader.ReadRow(columns))
{
Debug.Assert(true);
if (readHeader)
{
DateTime when = DateTime.Parse(columns[0]);
double lat = Convert.ToDouble(columns[1]);
double lon = Convert.ToDouble(columns[2]);
Location where = new Location(lat, lon);
float depth = columns[3] != "" ? Convert.ToSingle(columns[3]) : 0.0f;
float magnitude = columns[4] != "" ? Convert.ToSingle(columns[4]) : 0.0f;
string magType = columns[5];
int nbStation = columns[6] != "" ? Convert.ToInt16(columns[6]) : 0;
int gap = columns[7] != "" ? Convert.ToInt16(columns[7]) : 0;
float distance = columns[8] != "" ? Convert.ToSingle(columns[8]) : 0.0f;
float rms = columns[9] != "" ? Convert.ToSingle(columns[9]) : 0.0f;
string source = columns[10];
string eventId = columns[11];
float version = columns[12] != "" ? Convert.ToSingle(columns[12]) : 0.0f;
quakeData.Add(new Earthquake(when,
where,
depth,
magnitude,
magType,
nbStation,
gap,
distance,
rms,
source,
eventId,
version,
"M " + columns[4]));
}
else
{
readHeader = true;
}
}
return(quakeData);
}
static void Main(string[] args)
{
string logFile = "log.txt";
// delimiter config
char inFileDelimiter = ',';
char inFileEnclosure = '"';
char outFileDelimiter = ';';
char outFileEnclosure = '"';
using (StreamWriter logWriter = File.AppendText(logFile))
{
try
{
if (args.Length == 0)
{
throw new Exception("Das Programm benoetigt mindestens eine Eingabe-Datei!");
}
foreach (string inFile in args)
{
CSVFile inCsv = CSVFileReader.Open(inFile,
Encoding.GetEncoding("iso-8859-1"),
inFileDelimiter,
inFileEnclosure
);
CSVFile outCsv = CSVFileConverter.Convert(inCsv);
string outFile = inFile + ".konvertiert.csv";
CSVFileWriter writer = new CSVFileWriter(outFile,
Encoding.GetEncoding("iso-8859-1"),
outFileDelimiter,
outFileEnclosure
);
writer.WriteCsv(outCsv);
}
}
catch (Exception e)
{
logWriter.WriteLine(e.ToString());
Console.WriteLine("Ein Fehler ist aufgetreten. Weitere Informationen befinden sich in der Log-Datei.\n\n> {0}\n", e.Message);
Console.WriteLine("Enter zum Beenden druecken...");
Console.ReadLine();
}
}
}
/// <summary>
/// Method will proceed ahead with further validation for valid data and ignore invalid records
/// </summary>
/// <typeparam name="T">Any type which inherits from validation framework base entity</typeparam>
/// <param name="filePath">File path, which requires re-processing</param>
/// <returns>FileResult object</returns>
public async Task <FileResult> OmitAndIgnoreFormatValidation <T>(string filePath) where T : BaseEntity, new()
{
List <T> businessValidationErrors = null;
List <T> finalOutput = null;
FileInfo fileInfo = new FileInfo(filePath);
string fileToBeReProcessed = Path.Combine(fileInfo.DirectoryName, Path.GetFileNameWithoutExtension(filePath) + "_Output.csv");
List <T> entities = new List <T>();
var csvFileReader = new CSVFileReader <T>(fileToBeReProcessed);
foreach (var entity in csvFileReader)
{
entities.Add(entity);
}
var processTask = await ProcessBusinessValidation <T>(filePath, fileInfo, entities, new List <string>(csvFileReader.CSVColumns)).ContinueWith(async(validationErrors) =>
{
businessValidationErrors = await validationErrors;
if (businessValidationErrors.Count != 0)
{
await ProcessFinalOutput(filePath, fileInfo, entities, new List <string>(csvFileReader.CSVColumns), true).ContinueWith(async(finalRecords) =>
{
finalOutput = await finalRecords;
//Now we are having on-demand creation of Zip from UI
//CreateZip(filePath);
});
}
else
{
//If file is passing buiness validation, we send it to data access layer for persistance
//FileItem fileItem = new FileItem { FileName = Path.GetFileNameWithoutExtension(filePath), FileType = typeof(T).FullName, FileData = File.ReadAllBytes(filePath) };
//DAOFactory.GetFileItemDAO().SaveFile(fileItem);
}
});
return(await processTask.ContinueWith((t) =>
{
return new FileResult
{
FileName = Path.GetFileNameWithoutExtension(fileToBeReProcessed),
FilePath = fileInfo.FullName,
NumberOfValidRows = finalOutput != null ? finalOutput.Count : entities.Count,
NumberOfErrorRows = businessValidationErrors != null ? businessValidationErrors.Count : 0,
TypeOfError = businessValidationErrors != null && businessValidationErrors.Count > 0 ? "Business Validation" : "No Error"
};
}));
}
public static void TestFruit()
{
string path = @"..\..\Fruits.csv";
List <Fruit> fruits = new List <Fruit>();
CSVFileReader <Fruit> myFile = new CSVFileReader <Fruit>(path);
fruits = myFile.GetData();
foreach (Fruit f in fruits)
{
string lol = $"{f.Nom,-10}|{f.Prix,-10}";
Console.WriteLine(lol);
}
Console.WriteLine("---------------------------");
Fruit l = new Fruit()
{
Nom = "Bernard", Prix = 1000.32, Provenance = "Nord-ouest", Quantite = 150, Inutile = "Wesh"
};
Fruit m = new Fruit()
{
Nom = "Mangue", Prix = 145, Provenance = "Sud-est", Quantite = 90, Inutile = "Hello there"
};
List <Fruit> fl = new List <Fruit>();
fl.Add(l);
fl.Add(m);
myFile.AddData(fl);
fruits = myFile.GetData();
foreach (string h in myFile.Headers)
{
Console.Write($"{h,-10}|");
}
Console.WriteLine();
Console.WriteLine("----------+----------+----------+----------+");
foreach (Fruit f in fruits)
{
string lol = $"{f.Nom,-10}|{f.Provenance,-10}|{f.Prix,-10}|{f.Quantite,-10}";
Console.WriteLine(lol);
}
}
public static void TestLegume()
{
string path = @"..\..\prout\Legumes.csv";
List <Legumes> legumes = new List <Legumes>();
CSVFileReader <Legumes> myFile = new CSVFileReader <Legumes>(path);
legumes = myFile.GetData();
foreach (Legumes f in legumes)
{
string lol = $"{f.Nom,-10}|{f.Comestible}";
Console.WriteLine(lol);
}
Console.WriteLine("---------------------------");
Legumes l = new Legumes()
{
Nom = "Bernard", Provenance = "Nord-ouest", Comestible = true
};
Legumes m = new Legumes()
{
Nom = "Mangue", Provenance = "Sud-est", Comestible = false
};
List <Legumes> fl = new List <Legumes>();
fl.Add(l);
fl.Add(m);
myFile.AddData(fl);
legumes = myFile.GetData();
foreach (string h in myFile.Headers)
{
Console.Write($"{h,-10}|");
}
Console.WriteLine();
Console.WriteLine("----------+----------+----------+----------+");
foreach (Legumes f in legumes)
{
string lol = $"{f.Nom,-10}|{f.Provenance,-10}|{f.Comestible}";
Console.WriteLine(lol);
}
}
private static StringCollection LoadCSVStrings(string directory)
{
StringCollection collection = new StringCollection();
string[] fileList = Directory.GetFiles(directory); // may need to be made recursive/able to look through child directories when more string directories are added
var csvReader = new CSVFileReader();
foreach (var file in fileList)
{
if (file.EndsWith(".csv"))
{
csvReader.ReadCSVFile(file, collection);
}
}
return(collection);
}
public void CSVFileReader_ShouldWork()
{
string[] csvFileNamePath = { " ", " ", "coffee_shops.csv" };
List <string> actual = CSVFileReader.Read(csvFileNamePath);
List <string> expected = new List <string> {
"Starbucks Sibiu Oituz,45.7826201,24.1465759",
"Starbucks Bucuresti Calea Victoriei,44.4514467,26.0827712",
"Starbucks Vienna,48.1817174,16.3798455",
"Starbucks Sibiu Piata Mare,45.7973354,24.1503473",
"Starbucks Andorra la Vella,42.5080922,1.5291981",
"Starbucks Cluj Iulius Mall,46.771803,23.6234979"
};
Assert.Equal(expected, actual);
}
private void LoadTowerInfo()
{
m_builMGR = TowerBuildMGR.instance;
m_TowerInfoList = CSVFileReader.Read(m_TowerInfoCVSFileName);
for (int i = 0; i < m_TowerInfoList.Count; i++)
{
//DB에서 타워 정보 불러옴
int nId = (int)m_TowerInfoList[i]["id"];
TowerBuildPrint TempTowerBuildPrint = new TowerBuildPrint();
TempTowerBuildPrint.m_nCost = (int)m_TowerInfoList[i]["Price_lv1"];
TempTowerBuildPrint.m_nUpgrageCost = (int)m_TowerInfoList[i]["Price_lv2"];
TempTowerBuildPrint.m_nSellPrice = (int)m_TowerInfoList[i]["Price_Sell_lv1"];
TempTowerBuildPrint.m_nSellUpgradePrice = (int)m_TowerInfoList[i]["Price_Sell_lv2"];
if (nId == (int)E_TOWERTYPE.E_CANNON)
{
m_CannonTower = TempTowerBuildPrint;
m_CannonTower.m_prefab = m_Cannonprefab;
m_CannonTower.m_Upgradeprefab = m_CannonUpgradeprefab;
m_CannonPriceTxt.text = m_CannonTower.m_nCost.ToString();
}
else if (nId == (int)E_TOWERTYPE.E_LASER)
{
m_LaserTower = TempTowerBuildPrint;
m_LaserTower.m_prefab = m_Laserprefab;
m_LaserTower.m_Upgradeprefab = m_LaserUpgradeprefab;
m_LaserPriceTxt.text = m_LaserTower.m_nCost.ToString();
}
else if (nId == (int)E_TOWERTYPE.E_MAGIC)
{
m_MagicTower = TempTowerBuildPrint;
m_MagicTower.m_prefab = m_Magicprefab;
m_MagicTower.m_Upgradeprefab = m_MagicUpgradeprefab;
m_MagicPriceTxt.text = m_MagicTower.m_nCost.ToString();
}
}
}
public async Task <IActionResult> UploadAndProcessFile()
{
if (Request.Form.Files[0].Length > 0)
{
var file = Request.Form.Files[0];
string fileName = ContentDispositionHeaderValue.Parse(file.ContentDisposition).FileName.Trim('"');
using (var stream = new StreamReader(file.OpenReadStream()))
{
IFileProcessor fileProcessor = new CSVFileReader();
List <STORE_ORDER> processedRecrods = fileProcessor.ReadFile(stream);
await repository.AddRange(processedRecrods);
}
return(Ok("Upload Successful."));
}
else
{
return(BadRequest("No File Provided"));
}
}
