source: branches/WebJobManager/HeuristicLab.Clients.Hive.WebJobManager/Controllers/JobController.cs @ 13714

using Microsoft.AspNet.Mvc;
using HeuristicLab.Clients.Hive.WebJobManager.Services;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using HeuristicLab.Clients.Hive.WebJobManager.ViewModels;
using System.ServiceModel.Security;
using Microsoft.AspNet.Http;
using System.IO;
using Microsoft.Net.Http.Headers;
using Microsoft.AspNet.Hosting;
using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Optimization;
using System.Threading;

namespace HeuristicLab.Clients.Hive.WebJobManager.Controllers
{
    public class JobController : Controller
    {
        private HiveServiceClient client;
        private JobViewModel vm;
        private IHostingEnvironment _environment;

        public JobController(IHostingEnvironment env)
        {
            HiveServiceLocatorWebManagerService hiveServiceLocator = (HiveServiceLocatorWebManagerService)HiveServiceLocatorWebManagerService.Instance;
            client = hiveServiceLocator.getHiveServiceClient();
            vm = new JobViewModel();


            _environment = env;
        }
        #region Jobs
        public IActionResult Index()
        {
            try
            {
                HiveClientWeb.Instance.Refresh();

                vm.userJobs = HiveClientWeb.Instance.Jobs.ToList();
            }
            catch (Exception e)
            {
                if (e is MessageSecurityException || e is InvalidOperationException)
                {
                    HiveServiceLocatorWebManagerService.SetLoginErrorMessage();
                    return RedirectToAction("Index", "Home");
                }
                throw;
            }
            ViewBag.Title = "Jobs";
            return View(vm);
        }
        public IActionResult Selected(Guid id)
        {
            if (((HiveServiceLocatorWebManagerService)(HiveServiceLocatorWebManagerService.Instance)).CheckLogin())
            {
                HiveClientWeb.Instance.Refresh();
                
                vm.userJobs = HiveClientWeb.Instance.Jobs.ToList();
                foreach(var j in vm.userJobs)
                {
                    if(j.Id == id)
                    {
                        vm.selectedJob = j;
                    }
                }
                vm.selectedJob.RefreshAutomatically = true;
                 HiveClientWeb.LoadJob(vm.selectedJob);
                FileOpeningService.Instance.NewModel();
                FileOpeningService.Instance.Job = vm.selectedJob;
                ViewBag.Title = vm.selectedJob.Job.Name + " - Jobs";
                return View("Index", vm);
            }
            else
            {
                HiveServiceLocatorWebManagerService.SetLoginErrorMessage();
                return RedirectToAction("Index", "Home");
            }
        }
        public IActionResult Delete(Guid id)// delete a job
        {
            if (((HiveServiceLocatorWebManagerService)(HiveServiceLocatorWebManagerService.Instance)).CheckLogin())
            {

                vm.message = client.GetJob(id).Name + " deleted";
                client.DeleteJob(id);
                HiveClientWeb.Instance.Refresh();

                vm.userJobs = HiveClientWeb.Instance.Jobs.ToList();
                ViewBag.Title = "Jobs";
                return View("Index", vm);
            }
            else
            {
                HiveServiceLocatorWebManagerService.SetLoginErrorMessage();
                return RedirectToAction("Index", "Home");
            }
        }
        #endregion

        #region Uploads
        public IActionResult Uploads()
        {
            if (((HiveServiceLocatorWebManagerService)(HiveServiceLocatorWebManagerService.Instance)).CheckLogin())
            {
                UploadedJobViewModel upper = new UploadedJobViewModel();
                fillUploadsPaths(upper, -1);

                ViewBag.Title = "Uploaded files";
                return View("Uploads", upper);
            }
            else
            {
                HiveServiceLocatorWebManagerService.SetLoginErrorMessage();
                return RedirectToAction("Index", "Home");
            }
        }
        public IActionResult UploadDir(int index)
        {
            if (((HiveServiceLocatorWebManagerService)(HiveServiceLocatorWebManagerService.Instance)).CheckLogin())
            {
                UploadedJobViewModel upper = new UploadedJobViewModel();
                fillUploadsPaths(upper, index);

                ViewBag.Title = "Uploaded files";
                return View("Uploads", upper);
            }
            else
            {
                HiveServiceLocatorWebManagerService.SetLoginErrorMessage();
                return RedirectToAction("Index", "Home");
            }
        }
        private void fillUploadsPaths(UploadedJobViewModel vm, int index)
        {
            var tempdex = index; //Fix when maps gets deleted
            var start = Path.Combine(_environment.WebRootPath, "uploads", client.ClientCredentials.UserName.UserName);
            var dirs = Directory.GetDirectories(start);
            foreach (string dir in dirs)
            {
                if (Directory.GetFiles(dir).Length == 0 && Directory.GetDirectories(dir).Length == 0)
                {
                    Directory.Delete(dir, false);
                    tempdex = -1;
                }
                else {
                    vm.FullDatePaths.Add(dir);
                    var temp = dir.Split('\\');
                    vm.DisplayDatePaths.Add(temp[temp.Length - 1]);
                }
            }
            if (tempdex != -1)
            {
                vm.SelectedIndex = tempdex;
                dirs = Directory.GetFiles(vm.FullDatePaths[tempdex]);
                foreach (string dir in dirs)
                {
                    vm.FullFilesPaths.Add(dir);
                    var temp = dir.Split('\\');
                    vm.DisplayFilesPaths.Add(temp[temp.Length - 1]);
                }
            }
        }
        public IActionResult DeleteFile(int index, int filedex)
        {
            if (((HiveServiceLocatorWebManagerService)(HiveServiceLocatorWebManagerService.Instance)).CheckLogin())
            {
                UploadedJobViewModel upper = new UploadedJobViewModel();
                fillUploadsPaths(upper, index);
                System.IO.File.Delete(upper.FullFilesPaths[filedex]);
                var message = upper.DisplayFilesPaths[filedex] + " has been deleted";

                upper = new UploadedJobViewModel();
                fillUploadsPaths(upper, index);
                upper.message = message;
                ViewBag.Title = "Uploaded files";

                return View("Uploads", upper);
            }
            else
            {
                HiveServiceLocatorWebManagerService.SetLoginErrorMessage();
                return RedirectToAction("Index", "Home");
            }
        }

        public IActionResult OpenFile(int index, int filedex)
        {
            if (((HiveServiceLocatorWebManagerService)(HiveServiceLocatorWebManagerService.Instance)).CheckLogin())
            {
                UploadedJobViewModel upper = new UploadedJobViewModel();
                fillUploadsPaths(upper, index);

                FileOpeningService serve = FileOpeningService.Instance;
                serve.NewModel();
                serve.env = _environment;

                var ioptimizer = ContentManager.Load(upper.FullFilesPaths[filedex]);

                serve.vm.SelectedTask = new OptimizerHiveTask((IOptimizer)ioptimizer);
                if (serve.vm.SelectedTask.ItemTask.Item is IAlgorithm)
                {
                    serve.vm.SelectedAlgorithm = (IAlgorithm)serve.vm.SelectedTask.ItemTask.Item;
                }
                else if (serve.vm.SelectedTask.ItemTask.Item is BatchRun)
                {
                    serve.vm.SelectedBatchRun = (BatchRun)serve.vm.SelectedTask.ItemTask.Item;
                }
                else if (serve.vm.SelectedTask.ItemTask.Item is Experiment)
                {
                    serve.vm.SelectedExperiment = (Experiment)serve.vm.SelectedTask.ItemTask.Item;
                }
                serve.setTasks();
                ViewBag.Title = serve.vm.SelectedTask.ItemTask.Name + " - Open file";

                return View("OpenFile", serve.vm);
            }
            else
            {
                HiveServiceLocatorWebManagerService.SetLoginErrorMessage();
                return RedirectToAction("Index", "Home");
            }
        }

        public IActionResult AddToHive()
        {
            if (((HiveServiceLocatorWebManagerService)(HiveServiceLocatorWebManagerService.Instance)).CheckLogin())
            {
                    var job = FileOpeningService.Instance.AddCurrentModelToHive();
                    while (job.Progress.ProgressValue != 1)
                    { }

                    Thread.Sleep(1000);
                    job.Progress.Status = "Upload finished";
                    Thread.Sleep(2000);
                    return RedirectToAction("Index", "Job");
            }
            else
            {
                HiveServiceLocatorWebManagerService.SetLoginErrorMessage();
                return RedirectToAction("Index", "Home");
            }
        }
        //TODO Work in progress
        /* public async Task<IActionResult> DownloadFile(int index, int filedex)
         {
             if (((HiveServiceLocatorWebManagerService)(HiveServiceLocatorWebManagerService.Instance)).CheckLogin())
             {
                 UploadedJobViewModel upper = new UploadedJobViewModel();
                 fillUploadsPaths(upper, index);

                HttpContext.Response.ContentType = "APPLICATION/OCTET-STREAM";
                 String Header = "Attachment; Filename=" + upper.DisplayFilesPaths[filedex];
                 HttpContext.Response.Headers.Add("Content-Disposition", Header);
                 System.IO.FileInfo Dfile = new System.IO.FileInfo(upper.FullFilesPaths[filedex]);
                 await HttpContext.Response.WriteAsync(Dfile.FullName);
                 //HttpContext.Response.End();

                 var message = upper.DisplayFilesPaths[filedex] + " has been downloaded";

                 upper.message = message;
                 ViewBag.Title = "Downloaded file";

                 return View("Uploads", upper);
             }
             else
             {
                 HiveServiceLocatorWebManagerService.SetLoginErrorMessage();
                 return RedirectToAction("Index", "Home");
             }
         }*/

        #endregion

        #region Uploader
        public IActionResult Uploader()
        {
            if (((HiveServiceLocatorWebManagerService)(HiveServiceLocatorWebManagerService.Instance)).CheckLogin())
            {
                ViewBag.Title = "Upload Jobs";
                ViewBag.Name = client.ClientCredentials.UserName.UserName;
                return View("Uploader");
            }
            else
            {
                HiveServiceLocatorWebManagerService.SetLoginErrorMessage();
                return RedirectToAction("Index", "Home");
            }
        }
        [HttpPost]
        public async Task<IActionResult> Uploader(ICollection<IFormFile> files, string directory)
        {

            UploadedJobViewModel upper = new UploadedJobViewModel();
            var uploads = Path.Combine(_environment.WebRootPath, "uploads", client.ClientCredentials.UserName.UserName,
                directory);
            Directory.CreateDirectory(uploads);
            foreach (var file in files)
            {
                if (file.Length > 0)
                {
                    var fileName = ContentDispositionHeaderValue.Parse(file.ContentDisposition).FileName.Trim('"');
                    await file.SaveAsAsync(Path.Combine(uploads, fileName));
                    // var ioptimizer = ContentManager.Load(Path.Combine(uploads, fileName));
                    //OptimizerHiveTask task = new OptimizerHiveTask((IOptimizer)ioptimizer);
                    //upper.Tasks.Add(task);
                }
            }
            ViewBag.Title = "Upload complete";
            return RedirectToAction("Uploads", "Job");

        }
        #endregion
    }
}