392 lines
20 KiB
C#
392 lines
20 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.IO.Compression;
|
|
using System.Linq;
|
|
using System.Threading.Tasks;
|
|
using FarmmapsApi;
|
|
using FarmmapsApi.Models;
|
|
using FarmmapsApi.Services;
|
|
using FarmmapsKPI.Models;
|
|
using Microsoft.Extensions.Logging;
|
|
using Newtonsoft.Json;
|
|
using Newtonsoft.Json.Linq;
|
|
using static FarmmapsApiSamples.Constants;
|
|
|
|
namespace FarmmapsKPI
|
|
{
|
|
public class KPIApplication : IApplication
|
|
{
|
|
//private const string DownloadFolder = "Downloads";
|
|
private const string SettingsFile = "settings.json";
|
|
|
|
private readonly ILogger<KPIApplication> _logger;
|
|
private readonly FarmmapsApiService _farmmapsApiService;
|
|
private readonly KPIService _kpiService;
|
|
private readonly GeneralService _generalService;
|
|
|
|
private Settings _settings;
|
|
|
|
public KPIApplication(ILogger<KPIApplication> logger, FarmmapsApiService farmmapsApiService,
|
|
GeneralService generalService, KPIService kpiService)
|
|
{
|
|
_logger = logger;
|
|
_farmmapsApiService = farmmapsApiService;
|
|
_generalService = generalService;
|
|
_kpiService = kpiService;
|
|
}
|
|
|
|
public async Task RunAsync()
|
|
{
|
|
// var fieldsInputJson = File.ReadAllText("KPIInputChemie.json"); // hier gebleven, bad gateway?!
|
|
string fnKPIinput;
|
|
|
|
Console.WriteLine("Type name of input json file. Example: KPIinput.json (in same directory as FarmmapsKPI.exe) or C:/temp/KPIinputChemieTmp.json");
|
|
fnKPIinput = Console.ReadLine();
|
|
if (string.IsNullOrEmpty(fnKPIinput))
|
|
fnKPIinput = "KPIinput.json";
|
|
|
|
var fieldsInputJson = File.ReadAllText(fnKPIinput);
|
|
|
|
List<KPIInput> fieldsInputs = JsonConvert.DeserializeObject<List<KPIInput>>(fieldsInputJson);
|
|
|
|
// !! this call is needed the first time an api is called with a fresh clientid and secret !!
|
|
await _farmmapsApiService.GetCurrentUserCodeAsync();
|
|
var roots = await _farmmapsApiService.GetCurrentUserRootsAsync();
|
|
|
|
//Where to write the output
|
|
string downloadFolder = fieldsInputs[0].DownloadFolder;
|
|
if (string.IsNullOrEmpty(downloadFolder))
|
|
{
|
|
downloadFolder = "Downloads";
|
|
}
|
|
if (!Directory.Exists(downloadFolder))
|
|
Directory.CreateDirectory(downloadFolder);
|
|
|
|
|
|
//Write the same info to a single csv file. Note this means existing file will be overwritten!
|
|
StreamWriter sw;
|
|
string KPIItemCsv = Path.GetFileNameWithoutExtension(fnKPIinput) + "_Items.csv";
|
|
string KPIItemPathCsv = Path.Combine(downloadFolder, KPIItemCsv);
|
|
List<string> headerList = new List<string> { "parentName", "area_ha", "cropTypeCode", "cropTypeName", "KPIid", "KPIvariable", "KPIvalue", "KPIunit", "KPItargetvalue", "KPIthresholdValue" };
|
|
//Create a new csv file. Means if existing then overwritten !!!
|
|
sw = new StreamWriter(KPIItemPathCsv);
|
|
sw.WriteLine(string.Join(",", headerList));
|
|
|
|
//Now loop through the list of cropfields in KPIinput.json and get the KPI's for each cropfield
|
|
foreach (var input in fieldsInputs)
|
|
{
|
|
try
|
|
{
|
|
await Process(roots, input, sw);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.LogError(ex.Message);
|
|
}
|
|
}
|
|
|
|
//Close the csv file, write message to screen
|
|
sw.Close();
|
|
_logger.LogInformation($"Done! Written all KPI for all fields in 'KPIinput.json' to output file '{KPIItemPathCsv}'");
|
|
}
|
|
|
|
private async Task Process(List<UserRoot> roots, KPIInput input, StreamWriter sw)
|
|
{
|
|
KPIOutput kpio;
|
|
KPIOutput kpioPrevious = new KPIOutput(); //creates a new empty
|
|
|
|
string downloadFolder = input.DownloadFolder;
|
|
if (string.IsNullOrEmpty(downloadFolder)) {
|
|
downloadFolder = "Downloads";
|
|
}
|
|
if (!Directory.Exists(downloadFolder))
|
|
Directory.CreateDirectory(downloadFolder);
|
|
|
|
// !!specify if you are using an already created cropfield:
|
|
bool useExistingCropfieldWithChildren = input.UseExistingCropfieldWithChildren;
|
|
int cropYear = input.CropYear;
|
|
string fieldName = input.fieldName;
|
|
string fieldGeom = input.GeometryJson.ToString(Formatting.None);
|
|
|
|
//Settings
|
|
string settingsfile = $"Settings_{fieldName}.json";
|
|
LoadSettings(settingsfile);
|
|
|
|
var uploadedRoot = roots.SingleOrDefault(r => r.Name == "USER_IN");
|
|
if (uploadedRoot == null)
|
|
{
|
|
_logger.LogError("Could not find a needed root item");
|
|
return;
|
|
}
|
|
|
|
var myDriveRoot = roots.SingleOrDefault(r => r.Name == "USER_FILES");
|
|
if (myDriveRoot == null)
|
|
{
|
|
_logger.LogError("Could not find a needed root item");
|
|
return;
|
|
}
|
|
|
|
// Use already created cropfield or create new one, added a Data input, with field specific data for the KPI calculation
|
|
Item cropfieldItem;
|
|
//1 useExistingCropfieldWithChildren = false -> create new
|
|
//2 useExistingCropfieldWithChildren = true && input.CropfieldItemCode = "" or absent -> read from settings json
|
|
//3 useExistingCropfieldWithChildren = true && input.CropfieldItemCode like "deb48a74c5b54299bb852f17288010e9" in KPIinput -> use this one
|
|
if (useExistingCropfieldWithChildren == false)
|
|
{
|
|
_logger.LogInformation("Creating cropfield, writting to settings file");
|
|
cropfieldItem = await _generalService.CreateCropfieldItemAsync(myDriveRoot.Code,
|
|
$"{fieldName}", cropYear, input.GeometryJson.ToString(Formatting.None), input.DataCropfield.ToString(Formatting.None));
|
|
_settings.CropfieldItemCode = cropfieldItem.Code;
|
|
SaveSettings(settingsfile);
|
|
}
|
|
else if (string.IsNullOrEmpty(input.CropfieldItemCode))
|
|
{
|
|
_logger.LogInformation("reading CropfieldItemCode from settings file");
|
|
cropfieldItem = await _farmmapsApiService.GetItemAsync(_settings.CropfieldItemCode);
|
|
}
|
|
else
|
|
{
|
|
_logger.LogInformation("reading CropfieldItemCode from KPIinput.json");
|
|
cropfieldItem = await _farmmapsApiService.GetItemAsync(input.CropfieldItemCode);
|
|
SaveSettings(settingsfile);
|
|
}
|
|
|
|
|
|
// Use already created croprecording or create new one, added a Data input, with field specific data for the KPI calculation
|
|
Item crprecItem;
|
|
//1 useExistingCropfieldWithChildren = false -> create new
|
|
//2 useExistingCropfieldWithChildren = true && input.CropRecordingItemCode = "" or absent -> read from settings json
|
|
//3 useExistingCropfieldWithChildren = true && input.CropRecordingItemCode like "deb48a74c5b54299bb852f17288010e9" in KPIinput -> use this one
|
|
if (useExistingCropfieldWithChildren == false)
|
|
{
|
|
_logger.LogInformation("RunCropRecordingTask ...");
|
|
crprecItem = await _generalService.RunCropRecordingTask(cropfieldItem);
|
|
_settings.CropRecordingItemCode = crprecItem.Code;
|
|
SaveSettings(settingsfile);
|
|
}
|
|
else if (string.IsNullOrEmpty(input.CropfieldItemCode))
|
|
{
|
|
_logger.LogInformation("reading CropRecordingItemCode from settings file");
|
|
crprecItem = await _farmmapsApiService.GetItemAsync(_settings.CropRecordingItemCode);
|
|
}
|
|
else
|
|
{
|
|
_logger.LogInformation("reading CropRecordingItemCode from KPIinput.json");
|
|
crprecItem = await _farmmapsApiService.GetItemAsync(input.CropRecordingItemCode);
|
|
SaveSettings(settingsfile);
|
|
}
|
|
|
|
// Use already created operations or create new one,s added a Data input, with field specific data for the KPI calculation
|
|
List<Item> crpOperationItems = new List<Item> { };
|
|
List<string> crpOperationItemCodes = new List<string> { };
|
|
Item crpOperationItem;
|
|
string dataOperation;
|
|
string codeOperation;
|
|
//1 useExistingCropfieldWithChildren = false -> create new
|
|
//2 useExistingCropfieldWithChildren = true && input.OperationItemCode = "" or absent -> read from settings json
|
|
//3 useExistingCropfieldWithChildren = true && input.OperationItemCode like "deb48a74c5b54299bb852f17288010e9" in KPIinput -> use this one
|
|
if (useExistingCropfieldWithChildren == false)
|
|
{
|
|
for (int i = 0; i < input.DataOperations.Length; i++)
|
|
{
|
|
dataOperation = input.DataOperations[i].ToString(Formatting.None);
|
|
dynamic data = JObject.Parse(dataOperation);
|
|
_logger.LogInformation($"CreateOperationItemAsync ... for operation {i}: '{data.name}', {data.n} kg N/ha, on date '{data.from}'");
|
|
crpOperationItem = await _generalService.CreateOperationItemAsync(crprecItem.Code, cropYear, fieldGeom, dataOperation);
|
|
crpOperationItems.Add(crpOperationItem);
|
|
crpOperationItemCodes.Add(crpOperationItem.Code);
|
|
}
|
|
_settings.OperationItemCodes = crpOperationItemCodes.ToArray();
|
|
SaveSettings(settingsfile);
|
|
}
|
|
else if (string.IsNullOrEmpty(input.CropfieldItemCode))
|
|
{
|
|
_logger.LogInformation("reading OperationItemCode from settings file");
|
|
for (int i = 0; i < _settings.OperationItemCodes.Length; i++)
|
|
{
|
|
codeOperation = _settings.OperationItemCodes[i];
|
|
crpOperationItem = await _farmmapsApiService.GetItemAsync(codeOperation);
|
|
crpOperationItems.Add(crpOperationItem);
|
|
crpOperationItemCodes.Add(crpOperationItem.Code);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
_logger.LogInformation("reading OperationItemCodes from KPIinput.json");
|
|
for (int i = 0; i < input.OperationItemCodes.Length; i++)
|
|
{
|
|
codeOperation = input.OperationItemCodes[i];
|
|
crpOperationItem = await _farmmapsApiService.GetItemAsync(codeOperation);
|
|
crpOperationItems.Add(crpOperationItem);
|
|
crpOperationItemCodes.Add(crpOperationItem.Code);
|
|
}
|
|
_settings.OperationItemCodes = crpOperationItemCodes.ToArray();
|
|
SaveSettings(settingsfile);
|
|
}
|
|
|
|
// The cropfieldCharacteristicItem is used to enter crop yields
|
|
// So once we have added an operation for fertilizer application and a crop yield, then KPIapp can calculate
|
|
// Nutrient balance.
|
|
// Use already created cropfieldCharacteristicItem or create new one, added a Data input, with field specific data for the KPI calculation
|
|
Item cropfieldCharacteristicItem;
|
|
//1 useExistingCropfieldWithChildren = false -> create new
|
|
//2 useExistingCropfieldWithChildren = true && input.CropfieldCharacteristicItemCode = "" or absent -> read from settings json
|
|
//3 useExistingCropfieldWithChildren = true && input.CropfieldCharacteristicItemCode like "deb48a74c5b54299bb852f17288010e9" in KPIinput -> use this one
|
|
if (useExistingCropfieldWithChildren == false)
|
|
{
|
|
_logger.LogInformation("CreateCropfieldCharacteristicItemAsync ...");
|
|
cropfieldCharacteristicItem = await _generalService.CreateCropfieldCharacteristicItemAsync(cropfieldItem.Code, cropYear, fieldGeom, input.DataCropfieldCharacteristic.ToString(Formatting.None));
|
|
_settings.CropfieldCharacteristicItemCode = cropfieldCharacteristicItem.Code;
|
|
SaveSettings(settingsfile);
|
|
}
|
|
else if (string.IsNullOrEmpty(input.CropfieldItemCode))
|
|
{
|
|
_logger.LogInformation("reading OperationItemCode from settings file");
|
|
cropfieldCharacteristicItem = await _farmmapsApiService.GetItemAsync(_settings.CropfieldCharacteristicItemCode);
|
|
}
|
|
else
|
|
{
|
|
_logger.LogInformation("reading CropfieldCharacteristicItemCode from KPIinput.json");
|
|
cropfieldCharacteristicItem = await _farmmapsApiService.GetItemAsync(input.CropfieldCharacteristicItemCode);
|
|
SaveSettings(settingsfile);
|
|
}
|
|
|
|
// Inspect the children and grandchildren. If all is well, cropfield will have:
|
|
// one crprec, with 0-many operations as children. And the Data of an operation will have specification of how much fertilizer was applied
|
|
// one edicrop.characteristic (with yield in the data)
|
|
var cropfieldChildren = await _farmmapsApiService.GetItemChildrenAsync(cropfieldItem.Code);
|
|
var crprecChildren = await _farmmapsApiService.GetItemChildrenAsync(crprecItem.Code);
|
|
|
|
//Now get the KPIs for this cropfield, mounted with operations & cropyield
|
|
// Get KPI data for saving it in a file, here the generalsedrvice is called to get the KPI data
|
|
_logger.LogInformation($"GetKpiItemsForCropField('{cropfieldItem.Code}')");
|
|
List<Item> KPIItems = await _generalService.GetKpiItemsForCropField(cropfieldItem);
|
|
_logger.LogInformation($"Found {KPIItems.Count} KPI items");
|
|
|
|
//Download KPI's into a json output file for this specific cropfield (with unique cropfieldItem.Code)
|
|
string KPIItemPathJson = Path.Combine(downloadFolder, $"KPIItems_{cropfieldItem.Code}.json");
|
|
var count = 0;
|
|
foreach (Item item in KPIItems)
|
|
{
|
|
//Console.WriteLine($"KPI item #{count}: {item.Name}");
|
|
File.AppendAllText(KPIItemPathJson, item.Data + Environment.NewLine);
|
|
count++;
|
|
}
|
|
_logger.LogInformation($"Downloaded file {KPIItemPathJson}");
|
|
|
|
//Write to the csv file that collects all KPI's for all the crop fields
|
|
List<string> dataList;
|
|
foreach (Item item in KPIItems)
|
|
{
|
|
dataList = new List<string> { };
|
|
kpio = JsonConvert.DeserializeObject<KPIOutput>(item.Data.ToString());
|
|
//Seems sometimes duplicate KPI items are returned. So check that here and only write if this kpio is different from previous
|
|
if (kpio.id != null)
|
|
{
|
|
if (kpio.id != kpioPrevious.id)
|
|
{
|
|
dataList.Add(kpio.parentName);
|
|
dataList.Add(kpio.data.area);
|
|
dataList.Add(kpio.data.cropTypeCode);
|
|
dataList.Add(kpio.data.cropTypeName);
|
|
dataList.Add(kpio.id);
|
|
dataList.Add(kpio.quantity);
|
|
dataList.Add(kpio.value);
|
|
dataList.Add(kpio.unit);
|
|
dataList.Add(kpio.targetValue);
|
|
dataList.Add(kpio.thresholdValue);
|
|
sw.WriteLine(string.Join(",", dataList));
|
|
}
|
|
}
|
|
kpioPrevious = kpio;
|
|
}
|
|
|
|
//Total N applied
|
|
double totalNapplied = 0.0;
|
|
double operationNapplied;
|
|
JObject opData;
|
|
for (int i = 0; i < crpOperationItemCodes.Count; i++)
|
|
{
|
|
codeOperation = crpOperationItemCodes[i];
|
|
crpOperationItem = await _farmmapsApiService.GetItemAsync(codeOperation);
|
|
dynamic data = JObject.Parse(crpOperationItem.Data.ToString(Formatting.None));
|
|
if (data.n != null)
|
|
{
|
|
operationNapplied = crpOperationItem.Data.GetValue("n").ToObject<double>();
|
|
totalNapplied = totalNapplied + operationNapplied;
|
|
}
|
|
}
|
|
//Also add totalNapplied to the csv
|
|
dataList = new List<string> { };
|
|
//Seems sometimes duplicate KPI items are returned. So check that here and only write if this kpio is different from previous
|
|
dataList.Add(kpioPrevious.parentName);
|
|
dataList.Add(kpioPrevious.data.area);
|
|
dataList.Add(kpioPrevious.data.cropTypeCode);
|
|
dataList.Add(kpioPrevious.data.cropTypeName);
|
|
dataList.Add("");
|
|
dataList.Add("totalNapplied");
|
|
dataList.Add(totalNapplied.ToString());
|
|
dataList.Add(kpioPrevious.unit);
|
|
dataList.Add("");
|
|
dataList.Add("");
|
|
sw.WriteLine(string.Join(",", dataList));
|
|
|
|
//Clean up. Only newly created fields
|
|
//Look up instruction in Swagger / api / v1 / items /{ code}
|
|
if (useExistingCropfieldWithChildren == false && input.DeleteNewlyCreatedAfterCalc == true)
|
|
{
|
|
// Tested and found that if I delete the parent (cropfieldItem) then
|
|
// automatically deletes children (crprecItem, cropfieldCharacteristicItem, KPIcontainer)
|
|
// and automatically deletes grand children (crprecItem: operations, KPIcontainer: KPI items)
|
|
await _farmmapsApiService.DeleteItemAsync(cropfieldItem.Code);
|
|
//Do we need to wait here for the task to be completed? Or does it continue in the background?
|
|
//await Task.Delay(60000); // wait 60 secs for task to be completed
|
|
//Before the GetItem you will see cropfieldItem, crprecItem etc exist (with data).
|
|
//After the GetItem these cropfieldItem, crprecItem etc are null which means they have been succesfully deleted.
|
|
//// Check if below works, i.e. is item really deleted?
|
|
//cropfieldItem = await _farmmapsApiService.GetItemAsync(cropfieldItem.Code);
|
|
//// Check if croprecording has also been deleted. If not also delete it
|
|
//crprecItem = await _farmmapsApiService.GetItemAsync(crprecItem.Code);
|
|
//// Check if 1 operation has also been deleted. If not also delete it
|
|
//crpOperationItem = await _farmmapsApiService.GetItemAsync(crpOperationItemCodes[0]);
|
|
//// Check if 1 cropfieldCharacteristicItem has also been deleted. If not also delete it
|
|
//cropfieldCharacteristicItem = await _farmmapsApiService.GetItemAsync(cropfieldCharacteristicItem.Code);
|
|
}
|
|
}
|
|
|
|
// Functions to save previously created cropfields
|
|
private void LoadSettings(string file)
|
|
{
|
|
if (File.Exists(file))
|
|
{
|
|
var jsonText = File.ReadAllText(file);
|
|
_settings = JsonConvert.DeserializeObject<Settings>(jsonText);
|
|
}
|
|
else
|
|
{
|
|
_settings = new Settings();
|
|
}
|
|
}
|
|
|
|
private void SaveSettings(string file)
|
|
{
|
|
if (_settings == null)
|
|
return;
|
|
|
|
var json = JsonConvert.SerializeObject(_settings);
|
|
File.WriteAllText(file, json);
|
|
}
|
|
private void SaveInfo(string file)
|
|
{
|
|
if (_settings == null)
|
|
return;
|
|
|
|
var json = JsonConvert.SerializeObject(_settings);
|
|
File.WriteAllText(file, json);
|
|
|
|
}
|
|
|
|
}
|
|
}
|