cms_thermo_active/Step/Controllers/WebApi/NcFileController.cs

using Step.Model.DTOModels;
using Step.NC;
using Step.Utils;
using System;
using System.Collections.Generic;
using System.IO;
using System.Net;
using System.Net.Http;
using static Step.Model.Constants;
using System.Text;
using System.Threading.Tasks;
using System.Web.Http;
using static CMS_CORE_Library.DataStructures;
using System.Linq;
using static Step.Config.ServerConfig;
using System.ComponentModel.DataAnnotations;

namespace Step.Controllers.WebApi
{
    [RoutePrefix("api/file_manager")]
    public class NcFileController : ApiController
    {
        [Route("files"), HttpGet]
        public IHttpActionResult GetFileList(string filePath = "")
        {
            using (NcHandler ncHandler = new NcHandler())
            {
                ncHandler.Connect();

                CmsError cmsError = ncHandler.GetFileList(filePath, out List<PreviewFileModel> fileList);    
                if (cmsError.IsError())
                    return BadRequest(cmsError.localizationKey);

                return Ok(fileList);
            }
        }

        [Route("file/info"), HttpGet]
        public IHttpActionResult GetFileInfo([FromUri]string filePath) 
        {
            using (NcHandler ncHandler = new NcHandler())
            {
                ncHandler.Connect();

                CmsError cmsError = ncHandler.GetFileInfo(filePath, out InfoFile fileInfo);
                if (cmsError.IsError())
                    return BadRequest(cmsError.localizationKey);

                return Ok(fileInfo);
            }
        }

        [Route("file/active"), HttpPut]
        public IHttpActionResult SetActiveProgram([FromUri]string filePath)
        {
            using (NcHandler ncHandler = new NcHandler())
            {
                ncHandler.Connect();

                CmsError cmsError = ncHandler.SetActiveProgramInfo(filePath, out DTOActiveProgramDataModel fileInfo);
                if (cmsError.IsError())
                    return BadRequest(cmsError.localizationKey);

                return Ok(fileInfo);
            }
        }

        [Route("file/deactivate"), HttpPut]
        public IHttpActionResult DeactivateProgram()
        {
            using (NcHandler ncHandler = new NcHandler())
            {
                ncHandler.Connect();

                CmsError cmsError = ncHandler.DeactivateProgram(out DTOActiveProgramDataModel fileInfo);
                if (cmsError.IsError())
                    return BadRequest(cmsError.localizationKey);

                return Ok(fileInfo);
            }
        }

        [Route("upload"), HttpPost]
        public async Task<IHttpActionResult> UpdloadProgramWithImage()
        {
            if (!Request.Content.IsMimeMultipartContent())
            {
                throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);
            }

            List<FormItem> formItems = await MultipartHandler.ManageMultiPartFileAsync(Request);

            foreach (FormItem item in formItems)
            {
                if (item.IsAFile)
                {
                    if(item.ParameterName == "file")
                    {
                        using (NcHandler ncHandler = new NcHandler())
                        {
                            ncHandler.Connect();

                            File.WriteAllBytes(TEMP_FILE + item.FileName, item.Data);

                            CmsError cmsError = ncHandler.UploadPartProgramAndActivate(TEMP_FILE, item.FileName, out ActiveProgramDataModel programData);
                            if (cmsError.IsError())
                                return BadRequest(cmsError.localizationKey);
                        }
                    }
                    else if(item.ParameterName == "image")
                    {
                        File.WriteAllBytes(PART_PRG_IMAGES + item.FileName, item.Data);
                    }
                }
            }

            return Ok();
        }

        
        [Route("shared_files"), HttpGet] 
        public IHttpActionResult GetSharedFolderFileList(string sharedPath)
        {
            List<object> filelist = new List<object>();

            string sharedFullPath = NcConfig.SharedPath + sharedPath;

            if (!Directory.Exists(sharedFullPath))
            {
                return NotFound();
            }
             
            foreach (string item in Directory.GetDirectories(sharedFullPath))
            {
                filelist.Add(new
                {
                    Name = Path.GetFileName(item),
                    AbsolutePath = NcConfig.SharedPath + sharedPath,
                    Path = sharedPath,
                    IsDirectory = true
                });
            }

            string sharedNcPath = NcConfig.SharedName + sharedPath.Replace('\\', '/');

            foreach (string item in Directory.GetFiles(sharedFullPath))
            {
                if (VALID_FILE_EXTENSIONS.Contains(Path.GetExtension(item).ToLower()))
                    filelist.Add(new
                    {
                        Name = Path.GetFileName(item),
                        AbsolutePath = sharedNcPath + "/" + Path.GetFileName(item),
                        Path = sharedPath + "\\" + Path.GetFileName(item),
                        IsDirectory = false
                    });
            }

            return Ok(filelist);
        }


        #region Queue Manager

        [Route("queue/add"), HttpPost]
        public async Task<IHttpActionResult> UploadToQueue()
        {
            if (!Request.Content.IsMimeMultipartContent())
            {
                throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);
            }

            List<FormItem> formItems = await MultipartHandler.ManageMultiPartFileAsync(Request);
            DTOQueueModel queueItem = new DTOQueueModel();
            foreach (FormItem item in formItems)
            {
                if (item.IsAFile)
                {
                    if (item.ParameterName == "file")
                    {
                        using (NcHandler ncHandler = new NcHandler())
                        {
                            ncHandler.Connect();

                            File.WriteAllBytes(TEMP_FILE + item.FileName, item.Data);

                            // Get reps
                            var repsParam = formItems.Where(x => x.ParameterName == "reps").FirstOrDefault();
                            // Check if reps parameter is null or isn't a valid int
                            if (repsParam == null || !Int32.TryParse(repsParam.Value, out int reps))
                                return BadRequest();

                            CmsError cmsError = ncHandler.UploadPartProgramAddToQueue(TEMP_FILE, item.FileName, reps, out queueItem);
                            if (cmsError.IsError())
                                return BadRequest(cmsError.localizationKey);
                        }
                    }
                    else if (item.ParameterName == "image")
                    {
                        File.WriteAllBytes(PART_PRG_IMAGES + item.FileName, item.Data);
                    }
                }
            }

            return Ok(queueItem);
        }

        [Route("queue/{processId:int}/remove/{itemId:int}"), HttpDelete]
        public IHttpActionResult RemoveFromQueue(int processId, int itemId)
        {
            using (NcHandler ncHandler = new NcHandler())
            {
                ncHandler.Connect();

                CmsError cmsError = ncHandler.RemoveFromQueue(processId, itemId);
                if (cmsError.IsError())
                    return BadRequest(cmsError.localizationKey);
            }

            return Ok();
        }

        [Route("queue/{processId:int}/move"), HttpPut]
        public IHttpActionResult MoveQueueItems(int processId, MoveItems itemsPositions)
        {
            using (NcHandler ncHandler = new NcHandler())
            {
                CmsError cmsError = ncHandler.MoveQueueItems(processId, itemsPositions.OldPosition, itemsPositions.NewPosition, out List<DTOQueueModel> queue);
                if (cmsError.IsError())
                    return BadRequest(cmsError.localizationKey);

                
                return Ok(queue);
            }
        }

        [Route("queue/{processId:int}/edit/{positionId:int}"), HttpPut]
        public IHttpActionResult EditQueueItem(int processId, int positionId, RepsModel reps)
        {
            using (NcHandler ncHandler = new NcHandler())
            {
                CmsError cmsError = ncHandler.EditQueueItemReps(processId, positionId, reps.Reps, out DTOQueueModel queueItem);
                if (cmsError.IsError())
                    return BadRequest(cmsError.localizationKey);
                
                return Ok(queueItem);
            }
        }

        [Route("queue/{processId:int}/empty"), HttpPut]
        public IHttpActionResult EmptyQueue(int processId)
        {
            using (NcHandler ncHandler = new NcHandler())
            {
                CmsError cmsError = ncHandler.EmptyQueue(processId);
                if (cmsError.IsError())
                    return BadRequest(cmsError.localizationKey);

                return Ok();
            }
        }

        public class MoveItems
        {
            public int OldPosition;

            public int NewPosition;
        }

        public class RepsModel
        {
            public int Reps;
        }

        #endregion
    }
}