FarmMapsApiClient_KB34_MAST/FarmmapsApi/Services/GeneralService.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using FarmmapsApi.Models;
using Google.Apis.Upload;
using Microsoft.Extensions.Logging;
using static FarmmapsApi.Extensions;
using static FarmmapsApiSamples.Constants;

namespace FarmmapsApi.Services
{
    public class GeneralService
    {
        private readonly ILogger<GeneralService> _logger;
        private readonly FarmmapsApiService _farmmapsApiService;

        private readonly string _downloadFolder = "Downloads";

        public GeneralService(ILogger<GeneralService> logger, FarmmapsApiService farmmapsApiService)
        {
            _logger = logger;
            _farmmapsApiService = farmmapsApiService;
        }
        
        public async Task<Item> UploadDataAsync(UserRoot root, string itemType, string filePath, string itemName)
        {
            var startUpload = DateTime.UtcNow;
            var result = await _farmmapsApiService.UploadFile(filePath, root.Code,
                progress => _logger.LogInformation($"Status: {progress.Status} - BytesSent: {progress.BytesSent}"));

            if (result.Progress.Status == UploadStatus.Failed)
                return null;

            return await FindChildItemAsync(root.Code, itemType, itemName, 
                i => i.Created >= startUpload && 
                     i.Name.ToLower().Contains(itemName.ToLower()));
        }

        public async Task<Item> UploadZipWithShapeAsync(UserRoot root, string filePath, string itemName)
        {
            
            var startUpload = DateTime.UtcNow;
            var result = await _farmmapsApiService.UploadFile(filePath, root.Code,
                progress => _logger.LogInformation($"Status: {progress.Status} - BytesSent: {progress.BytesSent}"));

            if (result.Progress.Status == UploadStatus.Failed)
                return null;

            var zipName = Path.GetFileName(filePath);
            Item shapeItem = null;
            await PollTask(TimeSpan.FromSeconds(3), async source =>
            {
                _logger.LogInformation($"Searching for {itemName} item");
                var uploadedFilesChildren = await _farmmapsApiService.GetItemChildrenAsync(root.Code);
                var zipItems = uploadedFilesChildren.Where(i => i.Name.Contains(zipName));

                foreach (var zipItem in zipItems)
                {
                    List<Item> items = await _farmmapsApiService.GetItemChildrenAsync(zipItem.Code,
                        SHAPE_PROCESSED_ITEMTYPE);

                    items = items.Where(i => i.Created >= startUpload).OrderByDescending(i => i.Created).ToList();
                    
                    if (items.Any())
                    {
                        shapeItem = items.First(i => i.Name.Contains(itemName));
                        if(shapeItem != null)
                        {
                            source.Cancel();
                            break;
                        }
                    }
                }
            });

            return shapeItem;
        }

        public async Task<Item> ShapeToGeotiff(Item shapeItem)
        {
            var shapeToGeotiffRequest = new TaskRequest()
            {
                TaskType = "vnd.farmmaps.task.shapetogeotiff"
            };
            var taskCode = await _farmmapsApiService.QueueTaskAsync(shapeItem.Code, shapeToGeotiffRequest);

            await PollTask(TimeSpan.FromSeconds(3), async (tokenSource) =>
            {
                _logger.LogInformation("Checking shapetogeotiff task status");
                var itemTaskStatus = await _farmmapsApiService.GetTaskStatusAsync(shapeItem.Code, taskCode);
                if (itemTaskStatus.IsFinished)
                    tokenSource.Cancel();
            });

            _logger.LogInformation("Data shape converted to geotiff");

            // the parent of the shape item is now the tiff item
            shapeItem = await _farmmapsApiService.GetItemAsync(shapeItem.Code);
            return await _farmmapsApiService.GetItemAsync(shapeItem.ParentCode);
        }

        public async Task<Item> FindChildItemAsync(string parentCode, string itemType, string containsName,
            Func<Item, bool> filter = null, int maxTries = 10)
        {
            Item dataItem = null;
            int tries = 0;
            await PollTask(TimeSpan.FromSeconds(3), async source =>
            {
                _logger.LogInformation($"Trying to get {containsName} data");
                var uploadedFilesChildren = await _farmmapsApiService.GetItemChildrenAsync(parentCode, itemType);
                if (uploadedFilesChildren.Count > 0)
                {
                    Func<Item, bool> func = filter ?? (i => i.Name.ToLower().Contains(containsName.ToLower()));
                    dataItem = uploadedFilesChildren.FirstOrDefault(func);
                    source.Cancel();
                }
                else if (tries == maxTries)
                {
                    source.Cancel();
                }

                tries++;
            });

            if (dataItem == null)
            {
                _logger.LogError("dataItem not found");
                return null;
            }

            _logger.LogInformation($"Found {containsName} item");
            return dataItem;
        }
    }
}