private string CLN(string str, GarbageType typ)
{
StringBuilder sb = new StringBuilder();
switch (typ)
{
case GarbageType.None:
return(str);
case GarbageType.Prestring:
sb.Append(str.Substring(str.Length / 2));
break;
case GarbageType.Alternate:
for (int i = 0; i < str.Length; i += 2)
{
sb.Append(str[i]);
}
break;
case GarbageType.Poststring:
sb.Append(str.Substring(0, str.Length / 2));
break;
}
return(sb.ToString());
}
public void AddGarbage(GarbageType garbageType)
{
switch (garbageType)
{
case GarbageType.Yellow:
yellowGarbage++;
break;
case GarbageType.Blue:
blueGarbage++;
break;
case GarbageType.Green:
greenGarbage++;
break;
case GarbageType.Brown:
brownGarbage++;
break;
case GarbageType.Gray:
grayGarbage++;
break;
}
}
private string GAR(string str, GarbageType typ)
{
StringBuilder gar = new StringBuilder(), sb = new StringBuilder();
for (int i = 0; i < str.Length && typ != GarbageType.None; ++i)
{
gar.Append((char)random.Next(33, 126));
}
switch (typ)
{
case GarbageType.None:
return(str);
case GarbageType.Prestring:
sb.Append(gar.ToString());
sb.Append(str);
break;
case GarbageType.Alternate:
string tmp = gar.ToString();
for (int i = 0; i < str.Length; ++i)
{
sb.Append(str[i]);
sb.Append(tmp[i]);
}
break;
case GarbageType.Poststring:
sb.Append(str);
sb.Append(gar.ToString());
break;
}
return(sb.ToString());
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Name")] GarbageType garbageType)
{
if (id != garbageType.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(garbageType);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!GarbageTypeExists(garbageType.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(garbageType));
}
public string ChangeGarbageToCheck(string type, double energyBalanceMin, double capitalBalanceMin)
{
if (!this.isManagementSet)
{
this.isManagementSet = true;
}
this.typeOfGarbageToCheck = (GarbageType)Enum.Parse(typeof(GarbageType), type);
this.energyBalanceMin = energyBalanceMin;
this.capitalBalanceMin = capitalBalanceMin;
return("Management requirement changed!");
}
public async Task <IActionResult> Create([Bind("Id,Name")] GarbageType garbageType)
{
if (ModelState.IsValid)
{
var garbagetype = _context.GarbageType.Where(g => g.Name == garbageType.Name).FirstOrDefault();
if (garbagetype != null)
{
ModelState.AddModelError(string.Empty, "Даний тип сміття вже існує");
}
else
{
_context.Add(garbageType);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
}
return(View(garbageType));
}
private void CheckResult(GarbageType garbageType)
{
if (_currentGarbageImage == null)
{
return;
}
if (garbageType == _currentGarbageImage.GarbageType)
{
_score++;
_currentGarbageImage = null;
StartCoroutine(ResultScript(true));
}
else
{
_currentGarbageImage = null;
StartCoroutine(ResultScript(false));
}
}
public static async Task <IActionResult> GetGarbageTypes(
[HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = "categorieen")] HttpRequest req,
ILogger log)
{
try
{
List <GarbageType> garbageTypeList = new List <GarbageType>();
string connectionString = Environment.GetEnvironmentVariable("ConnectionString");
using (SqlConnection connection = new SqlConnection(connectionString))
{
await connection.OpenAsync();
using (SqlCommand command = new SqlCommand())
{
command.Connection = connection;
command.CommandText = "SELECT * FROM GarbageType";
SqlDataReader reader = await command.ExecuteReaderAsync();
while (await reader.ReadAsync())
{
GarbageType garbageType = new GarbageType();
garbageType.GarbageTypeId = Guid.Parse(reader["GarbageTypeId"].ToString());
garbageType.Name = reader["Name"].ToString();
garbageTypeList.Add(garbageType);
}
}
}
return(new OkObjectResult(garbageTypeList)); //stuur object terug
}
catch (Exception ex)
{
log.LogError(ex.Message);
throw;
}
}
public ProcessingData(double capitalBalance, double energyBalance, GarbageType type)
{
this.CapitalBalance = capitalBalance;
this.EnergyBalance = energyBalance;
this.Type = type;
}
public GarbageImage(Sprite sprite, GarbageType garbageType)
{
Sprite = sprite;
GarbageType = garbageType;
}
/// <summary>
/// Garbage Constructor
/// </summary>
/// <param name="text">texture2D of the garbage</param>
/// <param name="pos">position of the garbage</param>
/// <param name="ma">mass of the garbage</param>
/// <param name="rad">radius of the garbage</param>
/// <param name="t">type of garbage</param>
public Garbage(Texture2D text, Vector2 pos, float ma, float rad, GarbageType t)
: base(text, pos, ma, rad)
{
type = t;
velocity = new Vector2(-10.0f, 0.0f);
}
public async Task <IActionResult> Import(IFormFile fileExcel)
{
int errorCount = 0;
if (ModelState.IsValid)
{
if (fileExcel != null)
{
using (var stream = new FileStream(fileExcel.FileName, FileMode.Create))
{
await fileExcel.CopyToAsync(stream);
using (XLWorkbook workBook = new XLWorkbook(stream, XLEventTracking.Disabled))
{
//перегляд усіх листів (в даному випадку категорій)
foreach (IXLWorksheet worksheet in workBook.Worksheets)
{
//worksheet.Name - назва категорії. Пробуємо знайти в БД, якщо відсутня, то створюємо нову
GarbageType newtype;
var t = (from typ in _context.GarbageType
where typ.Name.Contains(worksheet.Name)
select typ).ToList();
if (t.Count > 0)
{
newtype = t[0];
}
else
{
newtype = new GarbageType();
newtype.Name = worksheet.Name;
if (TryValidateModel(newtype, nameof(GarbageType)))
{
_context.GarbageType.Add(newtype);
}
else
{
errorCount++;
continue;
}
}
//перегляд усіх рядків
foreach (IXLRow row in worksheet.RowsUsed().Skip(1))
{
try
{
Garbage garbage;
var g = (from gar in _context.Garbage
where gar.Name.Contains(row.Cell(1).Value.ToString())
select gar).ToList();
if (g.Count > 0)
{
garbage = g[0];
}
else
{
garbage = new Garbage();
garbage.Name = row.Cell(1).Value.ToString();
if (TryValidateModel(garbage, nameof(Garbage)))
{
_context.Garbage.Add(garbage);
}
else
{
errorCount++;
continue;
}
}
//у разі наявності автора знайти його, у разі відсутності - додати
for (int i = 2; i <= 5; i++)
{
if (row.Cell(i).Value.ToString().Length > 0)
{
Material material;
var a = (from aut in _context.Material
where aut.Name.Contains(row.Cell(i).Value.ToString())
select aut).ToList();
if (a.Count > 0)
{
material = a[0];
GarbageMaterial gm;
var b = (from garmat in _context.GarbageMaterial
where garmat.IdGarbageNavigation.Name == garbage.Name &&
garmat.IdMaterialNavigation.Name == material.Name
select garmat).ToList();
if (a.Count > 0)
{
errorCount++;
}
else
{
gm = new GarbageMaterial();
gm.IdGarbageNavigation = garbage;
gm.IdMaterialNavigation = material;
_context.GarbageMaterial.Add(gm);
}
}
else
{
++errorCount;
}
}
}
}
catch (Exception e)
{
++errorCount;
}
}
}
}
}
}
await _context.SaveChangesAsync();
}
return(RedirectToAction(nameof(Index), new { errorCount = errorCount }));
}
// [ValidateAntiForgeryToken]
public async Task <IActionResult> Import(IFormFile fileExcel)
{
int errorCount = 0;
if (ModelState.IsValid)
{
if (fileExcel != null)
{
using (var stream = new FileStream(fileExcel.FileName, FileMode.Create))
{
await fileExcel.CopyToAsync(stream);
using (XLWorkbook workBook = new XLWorkbook(stream, XLEventTracking.Disabled))
{
foreach (IXLWorksheet worksheet in workBook.Worksheets)
{
foreach (IXLRow row in worksheet.RowsUsed().Skip(1))
{
try
{
Factory factory;
var f = (from fab in _context.Factory
where fab.Name.Contains(row.Cell(1).Value.ToString())
select fab).ToList();
if (f.Count > 0)
{
factory = f[0];
}
else
{
factory = new Factory();
factory.Name = row.Cell(1).Value.ToString();
factory.Website = row.Cell(2).Value.ToString();
factory.Address = row.Cell(3).Value.ToString();
if (TryValidateModel(factory, nameof(Factory)))
{
_context.Factory.Add(factory);
}
else
{
errorCount++;
continue;
}
}
int i = 4;
while (true)
{
if (row.Cell(i).Value.ToString().Length != 0)
{
GarbageType type;
var t = (from typ in _context.GarbageType
where typ.Name.Contains(row.Cell(i).Value.ToString())
select typ).ToList();
if (t.Count > 0)
{
type = t[0];
}
else
{
type = new GarbageType();
type.Name = row.Cell(i).Value.ToString();
if (!TryValidateModel(type, nameof(GarbageType)))
{
errorCount++;
}
_context.Add(type);
}
FactoryGarbageType ft = new FactoryGarbageType();
ft.IdFactoryNavigation = factory;
ft.IdGarbageTypeNavigation = type;
_context.FactoryGarbageType.Add(ft);
++i;
}
else
{
break;
}
}
}
catch (Exception e)
{
++errorCount;
}
}
}
}
}
}
await _context.SaveChangesAsync();
}
return(RedirectToAction(nameof(Index), new { errorCount = errorCount }));
}
//[ValidateAntiForgeryToken]
public async Task <IActionResult> Import(IFormFile fileExcel)
{
int errorCount = 0;
if (ModelState.IsValid)
{
if (fileExcel != null)
{
using (var stream = new FileStream(fileExcel.FileName, FileMode.Create))
{
await fileExcel.CopyToAsync(stream);
using (XLWorkbook workBook = new XLWorkbook(stream, XLEventTracking.Disabled))
{
//перегляд усіх листів (в даному випадку категорій)
foreach (IXLWorksheet worksheet in workBook.Worksheets)
{
foreach (IXLRow row in worksheet.RowsUsed().Skip(1))
{
GarbageType newtype;
var t = (from typ in _context.GarbageType
where typ.Name.Contains(row.Cell(1).Value.ToString())
select typ).ToList();
if (t.Count > 0)
{
newtype = t[0];
}
else
{
newtype = new GarbageType();
newtype.Name = row.Cell(1).Value.ToString();
if (TryValidateModel(newtype, nameof(GarbageType)))
{
_context.GarbageType.Add(newtype);
}
else
{
++errorCount;
continue;
}
}
int i = 2;
//while(true)
for (i = 2; i < 5; ++i)
{
if (row.Cell(i).Value.ToString().Length != 0)
{
try
{
Material material;
var m = (from mat in _context.Material
where mat.Name.Contains(row.Cell(1).Value.ToString())
select mat).ToList();
if (m.Count > 0)
{
material = m[0];
}
else
{
errorCount++;
}
}
catch (Exception e)
{
++errorCount;
}
}
else
{
break;
}
}
}
}
}
}
await _context.SaveChangesAsync();
}
}
return(RedirectToAction(nameof(Index), new { errorCount = errorCount }));
}
