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

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2015 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
 *
 * This file is part of HeuristicLab.
 *
 * HeuristicLab is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * HeuristicLab is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
 */
#endregion

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

namespace HeuristicLab.Clients.Hive.WebJobManager.Controllers
{
    /// <summary>
    /// Controller for everything Job related (includes uploads and uploader)
    /// </summary>
    public class JobController : Controller
    {
        private WebLoginService weblog;

        private HiveServiceLocatorWeb serviceLocator;
        private HiveServiceClient serviceClient;
        private HiveClientWeb clientWeb;
        private Guid userId;


        private JobViewModel vm;
        private UploadedJobViewModel upper;
        private IHostingEnvironment _environment;



        public JobController(IHostingEnvironment env)
        {
            weblog = WebLoginService.Instance;

            _environment = env;
        }

        /// <summary>
        /// initializes the connection for the right user. Not constructor because httpcontext is needed.
        /// </summary>
        private bool init()
        {
            var u = HttpContext.Session.GetString("UserId");

            if (u == null || u == "" || Guid.Parse(u) == Guid.Empty)
            {
                return false;
            }
            else
            {
                userId = Guid.Parse(u);
                vm = new JobViewModel(weblog.getCurrentUser(userId));
                upper = new UploadedJobViewModel(weblog.getCurrentUser(userId));
                try
                {
                    serviceLocator = weblog.getServiceLocator(userId);
                    serviceClient = serviceLocator.getHiveServiceClient();
                    clientWeb = weblog.getClientWeb(userId);
                    if (serviceLocator != null && serviceClient != null && clientWeb != null)
                        return serviceLocator.CheckLogin();
                }
                catch (NullReferenceException)
                {
                    return false;
                }
            }
            return false;
        }

        #region Jobs
        /// <summary>
        /// initial job page, shows all jobs
        /// </summary>
        /// <returns></returns>
        public IActionResult Index()
        {
            if (init())
            {
                clientWeb.Refresh();
                vm.userJobs = clientWeb.Jobs.ToList();

                ViewBag.SessionId = HttpContext.Session.GetString("UserId");
                ViewBag.Title = "Jobs";
                return View("Index", vm);
            }
            else
            {
                return RedirectToAction("Index", "Home");
            }
        }
        /// <summary>
        /// Initial page and a selected job
        /// </summary>
        /// <param name="id">Job id selected</param>
        /// <returns></returns>
        public IActionResult Selected(Guid id)
        {
            if (init())
            {
                clientWeb.Refresh();

                vm.userJobs = clientWeb.Jobs.ToList();
                foreach (var j in vm.userJobs)
                {
                    if (j.Id == id)
                    {
                        vm.selectedJob = j;
                    }
                }
                //vm.selectedJob.RefreshAutomatically = true;
                clientWeb.LoadJob(vm.selectedJob);
                weblog.getJobOpener(userId).NewModel();
                weblog.getJobOpener(userId).Job = vm.selectedJob;
                ViewBag.Title = vm.selectedJob.Job.Name + " - Jobs";
                ViewBag.SessionId = HttpContext.Session.GetString("UserId");
                return View("Index", vm);
            }
            else
            {
                return RedirectToAction("Index", "Home");
            }
        }
        /// <summary>
        /// Deletes a job
        /// </summary>
        /// <param name="id">Job id</param>
        /// <returns></returns>
        public IActionResult Delete(Guid id)
        {
            if (init())
            {

                vm.message = serviceClient.GetJob(id).Name + " deleted";
                serviceClient.DeleteJob(id);
                clientWeb.Refresh();

                vm.userJobs = clientWeb.Jobs.ToList();
                ViewBag.Title = vm.message + " - Jobs";
                return View("Index", vm);
            }
            else
            {
                return RedirectToAction("Index", "Home");
            }
        }
        #endregion

        #region Uploads
        /// <summary>
        /// Shows the uploaded directories
        /// </summary>
        /// <returns></returns>
        public IActionResult Uploads()
        {
            if (init())
            {
                fillUploadsPaths(upper, -1);
                ViewBag.Name = serviceClient.ClientCredentials.UserName.UserName;
                ViewBag.Title = "Uploads";
                //Recently opened
                if (weblog.getFileOpener(userId).Job != null)
                    ViewBag.active = true;
                return View("Uploads", upper);
            }
            else
            {
                return RedirectToAction("Index", "Home");
            }
        }
        /// <summary>
        /// //Shows content of selected dir
        /// </summary>
        /// <param name="index">Array index selected directory</param>
        /// <returns></returns>
        public IActionResult UploadDir(int index)
        {
            if (init())
            {
                fillUploadsPaths(upper, index);
                if (index != -1)
                    ViewBag.Title = upper.DisplayDatePaths[index] + " - Uploads";
                else
                    ViewBag.Title = "Add files - Uploads";
                //Recently opened
                if (weblog.getFileOpener(userId).Job != null)
                    ViewBag.active = true;
                return View("Uploads", upper);
            }
            else
            {
                return RedirectToAction("Index", "Home");
            }
        }
        [HttpPost]
        public IActionResult changeDirName(string olddir, string dirname)
        {
            if (init())
            {
                fillUploadsPaths(upper, -1);
                var ind = upper.DisplayDatePaths.IndexOf(olddir);
                try
                {


                    var start = Path.Combine(_environment.WebRootPath, "uploads", serviceClient.ClientCredentials.UserName.UserName, dirname);
                    if (Directory.Exists(start))
                    {
                        var files = Directory.GetFiles(upper.FullDatePaths[ind]);
                        foreach (var f in files)
                        {
                            var target = start + "\\" + f.Split('\\').Last();
                            if (System.IO.File.Exists(target))
                                System.IO.File.Delete(target);
                            System.IO.File.Move(f, target);
                        }
                    }
                    else
                    {
                        Directory.Move(upper.FullDatePaths[ind], start);
                    }

                    upper.clear();
                    fillUploadsPaths(upper, -1);
                    ind = upper.DisplayDatePaths.IndexOf(dirname);
                    upper.clear();
                    return RedirectToAction("UploadDir", new { index = ind });
                }
                catch (IOException e)
                {
                    upper.clear();
                    fillUploadsPaths(upper, ind);
                    upper.message = "Error in new directory name. Try again and don't use any special signs";
                    ViewBag.Title = "Error renaming - " + upper.DisplayDatePaths[ind] + " - Uploads";
                    if (weblog.getFileOpener(userId).Job != null)
                        ViewBag.active = true;
                    return View("Uploads", upper);
                }
            }
            else
            {
                return RedirectToAction("Index", "Home");
            }
        }
        /// <summary>
        /// Loads all the paths from the selected uploads folder
        /// </summary>
        /// <param name="vm">Viewmodel to save every directory path</param>
        /// <param name="index">Index selected directory</param>
        private void fillUploadsPaths(UploadedJobViewModel vm, int index)
        {

            var tempdex = index; //Fix when maps gets deleted
            var start = Path.Combine(_environment.WebRootPath, "uploads", serviceClient.ClientCredentials.UserName.UserName);
            try
            {
                Directory.GetDirectories(start);
            }
            catch (DirectoryNotFoundException e)
            {
                Directory.CreateDirectory(start);
            }
            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]);
                }
            }
        }
        /// <summary>
        /// Deletes a file
        /// </summary>
        /// <param name="index">Index directory</param>
        /// <param name="filedex">Index file to delete</param>
        /// <returns></returns>
        public IActionResult DeleteFile(int index, int filedex)
        {
            if (init())
            {
                fillUploadsPaths(upper, index);
                System.IO.File.Delete(upper.FullFilesPaths[filedex]);
                var message = upper.DisplayFilesPaths[filedex] + " has been deleted";

                upper = new UploadedJobViewModel(weblog.getCurrentUser(userId));
                fillUploadsPaths(upper, index);
                upper.message = message;
                //recently opened
                if (weblog.getFileOpener(userId).Job != null)
                    ViewBag.active = true;
                ViewBag.Title = "File deleted - Uploads";

                return View("Uploads", upper);
            }
            else
            {
                return RedirectToAction("Index", "Home");
            }
        }
        /// <summary>
        /// Opens a selected file
        /// </summary>
        /// <param name="index">Index directory</param>
        /// <param name="filedex">Index selected file</param>
        /// <returns></returns>
        public IActionResult OpenFile(int index, int filedex)
        {
            if (init())
            {
                fillUploadsPaths(upper, index);

                var serve = weblog.getFileOpener(userId);
                serve.NewModel();
                serve.env = (Microsoft.AspNetCore.Hosting.IHostingEnvironment)_environment;
                serve.vm.directories = upper.DisplayDatePaths;
                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.JobsCount = serve.Job.Job.JobCount;
                ViewBag.Title = serve.vm.SelectedTask.ItemTask.Name + " - Uploads";
                ViewBag.SessionId = HttpContext.Session.GetString("UserId");
                return View("OpenFile", serve.vm);
            }
            else
            {
                return RedirectToAction("Index", "Home");
            }
        }
        /// <summary>
        /// Opens the last opened file in the fileopening service
        /// </summary>
        /// <returns></returns>
        public IActionResult OpenRecent()
        {
            if (init())
            {
                var serve = weblog.getFileOpener(userId);
                fillUploadsPaths(upper, -1);
                serve.vm.directories = upper.DisplayDatePaths;
                ViewBag.JobsCount = serve.Job.Job.JobCount;
                ViewBag.Title = serve.vm.SelectedTask.ItemTask.Name + " - Uploads";
                ViewBag.SessionId = HttpContext.Session.GetString("UserId");
                return View("OpenFile", serve.vm);
            }
            else
            {
                return RedirectToAction("Index", "Home");
            }
        }
        /// <summary>
        /// Adds current opened file to hive, uses FileOpeningService singleton
        /// </summary>
        /// <returns></returns>
        public IActionResult AddToHive()
        {
            if (init())
            {
                var job = weblog.getFileOpener(userId).AddCurrentModelToHive();
                while (job.Progress.ProgressValue != 1)
                { }

                Thread.Sleep(1000);
                job.Progress.Status = "Upload finished";
                Thread.Sleep(2000);
                return RedirectToAction("Index", "Job");
            }
            else
            {
                return RedirectToAction("Index", "Home");
            }
        }
        [HttpPost]
        public IActionResult saveToFile(string fname, string dname)
        {
            if (init())
            {
                weblog.getFileOpener(userId).SaveToFile(fname, dname);
                fillUploadsPaths(upper, -1);
                var ind = upper.DisplayDatePaths.IndexOf(dname);
                return RedirectToAction("UploadDir", new { index = ind });
            }
            else
            {
                return RedirectToAction("Index", "Home");
            }
        }

        public FileResult DownloadFile(int index, int filedex)
        {
            if (init())
            {
                fillUploadsPaths(upper, index);

                System.IO.FileInfo Dfile = new System.IO.FileInfo(upper.FullFilesPaths[filedex]);
                var fileName = Dfile.Name;
                byte[] fileBytes = System.IO.File.ReadAllBytes(upper.FullFilesPaths[filedex]);
                return File(fileBytes, "application/x-msdownload", fileName);
            }
            else
            {
                return null;
            }
        }

        #endregion

        #region Uploader

        /// <summary>
        /// Uploads file onto server directory
        /// </summary>
        /// <param name="files">Files</param>
        /// <param name="directory">Directory path for server</param>
        /// <returns></returns>
        [HttpPost]
        public async Task<IActionResult> Uploader(ICollection<IFormFile> files, string directory)
        {
            if (init())
            {
                var uploads = Path.Combine(_environment.WebRootPath, "uploads", serviceClient.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.CopyToAsync(new FileStream(Path.Combine(uploads, fileName),FileMode.OpenOrCreate));
                        // var ioptimizer = ContentManager.Load(Path.Combine(uploads, fileName));
                        //OptimizerHiveTask task = new OptimizerHiveTask((IOptimizer)ioptimizer);
                        //upper.Tasks.Add(task);
                    }
                }
                ViewBag.Title = "Upload complete - Uploads";
                return RedirectToAction("Uploads", "Job");
            }
            else
            {
                return RedirectToAction("Index", "Home");
            }
        }
        #endregion
    }
}