[HttpPost]
        [RequiredAuthorization(Order = 1)]
        public ActionResult Fix()
        {
            var configSet = JsonNetHelper.Desreialize<ConfigSet>(Request.Form["configSet"]);
            var inputParameters = configSet.InputParameters;
            var curveConfigs = configSet.CurveConfigs;

            var fixerParameters = new FixerParameters
            {
                Codepage = inputParameters.Codepage,
                ParameterNames = inputParameters.ParameterCurves,
                DoAddCurveNames = inputParameters.Mask == "WELL_CURVES",
                DoEncode = inputParameters.DoEncode,
                DoMerge = inputParameters.DoMerge,
                Upper = inputParameters.Upper,
                Lower = inputParameters.Lower,
                MergeFilterWells = inputParameters.MergeFilterWells ?? new List<string>(),
                MergeFilterCurves = inputParameters.MergeFilterCurves ?? new List<string>(),
                DoMergeFilterEdges = inputParameters.DoMergeFilterEdges
            };
            var curveFixes = curveConfigs
                .Select(x => new CurveFix
                {
                    Names = x.Name + "," + x.NameVariants,
                    TransformName = x.Name,
                    TransformDesc = x.Name,
                    TransformUnit = x.Unit
                }).ToList();

            var userId = Convert.ToInt64(User.Identity.Name);
            var cloudPath = Server.MapPath($"~/App_Data/{userId}/cloud");
            if (!Directory.Exists(cloudPath)) Directory.CreateDirectory(cloudPath);
            var fixerPath = Server.MapPath($"~/App_Data/{userId}/fixer");
            if (!Directory.Exists(fixerPath)) Directory.CreateDirectory(fixerPath);
            var archivePath = $"{fixerPath}/archive";
            if (Directory.Exists(archivePath)) Directory.Delete(archivePath, true);
            Directory.CreateDirectory(archivePath);

            foreach (var filePath in Directory.EnumerateFiles(cloudPath, "*.las", SearchOption.AllDirectories))
            {
                var file = new FileStream(filePath, FileMode.Open, FileAccess.Read);
                var fileState = _parserService.CheckFile(file);
                if (fileState != FileState.Ok)
                {
                    file.Close();
                    continue;
                }

                var parseResult = _parserService.ParseLasFile(file, fixerParameters.Codepage);
                if (parseResult.ParseState != ParseState.Ok)
                {
                    file.Close();
                    continue;
                }

                if (fixerParameters.DoMerge &&
                    fixerParameters.MergeFilterWells.Count != 0 &&
                    !fixerParameters.MergeFilterWells.Contains(parseResult.LasContent.WellInformation.Well))
                {
                    file.Close();
                    continue;
                }

                parseResult.LasContent = _fixerService.ApplyFixes(parseResult.LasContent, curveFixes);
                var fixedText = _serializerService.Serialize(parseResult.LasContent);

                var wellName = parseResult.LasContent.WellInformation.Well == "" ?
                    "UNKNOWNWELL" :
                    PathUtils.SanitizeFileName(parseResult.LasContent.WellInformation.Well);

                var curveName = "";
                if (fixerParameters.DoAddCurveNames)
                {
                    var sb = new StringBuilder();
                    var delimiter = '_';
                    for (int i = 1; i < parseResult.LasContent.CurveInformation.Curves.Count; i++)
                    {
                        var curve = parseResult.LasContent.CurveInformation.Curves[i];
                        sb.Append(delimiter);
                        sb.Append(curve.Mnem);
                    }
                    curveName = sb.ToString();
                }

                var wellPath = $"{archivePath}/{wellName}";
                var fixedFileNamePart = PathUtils.SanitizeFileName($"{wellName}{curveName}");
                var fixedFilePath = $"{wellPath}/{fixedFileNamePart}.las";
                if (fixedFilePath.Length > 240)
                {
                    fixedFileNamePart = fixedFileNamePart.Substring(0, fixedFileNamePart.Length - (fixedFilePath.Length - 240));
                }
                var fixedFileName = fixedFileNamePart;
                var index = 1;
                while (System.IO.File.Exists($"{wellPath}/{fixedFileName}.las"))
                {
                    index++;
                    fixedFileName = $"{fixedFileNamePart} ({index})";
                }

                if (!Directory.Exists(wellPath)) Directory.CreateDirectory(wellPath);
                using (var sw = new StreamWriter($"{wellPath}/{fixedFileName}.las", false, Encoding.GetEncoding(1251)))
                {
                    sw.Write(fixedText);
                    sw.Close();
                }

                file.Close();
            }

            if (fixerParameters.DoMerge)
            {
                var mergerPath = Server.MapPath($"~/App_Data/{userId}/merger");
                if (!Directory.Exists(mergerPath)) Directory.CreateDirectory(mergerPath);

                var mergerArchivePath = $"{mergerPath}/archive";
                if (Directory.Exists(mergerArchivePath)) Directory.Delete(mergerArchivePath, true);
                Directory.CreateDirectory(mergerArchivePath);

                foreach (var wellDirectory in Directory.EnumerateDirectories(archivePath))
                {
                    var wellName = Path.GetFileName(wellDirectory);
                    var mergedWellPath = $"{mergerArchivePath}/{wellName}";
                    if (!Directory.Exists(mergedWellPath)) Directory.CreateDirectory(mergedWellPath);

                    if (wellName == "UNKNOWNWELL")
                    {
                        foreach (var srcFile in Directory.EnumerateFiles(wellDirectory, "*.las", SearchOption.AllDirectories))
                        {
                            var srcFileName = Path.GetFileName(srcFile);
                            System.IO.File.Copy(srcFile, $"{mergedWellPath}/{srcFileName}", true);
                        }
                        continue;
                    }

                    List<LasContent> outContents;
                    foreach (var srcFile in Directory.EnumerateFiles(wellDirectory, "*.las", SearchOption.AllDirectories))
                    {
                        var file = new FileStream(srcFile, FileMode.Open, FileAccess.Read);
                        var parseResult = _parserService.ParseLasFile(file);
                        file.Close();
                        _mergerService.Merge(parseResult.LasContent, fixerParameters);
                    }
                    outContents = _mergerService.CompleteMerge();
                    _mergerService.EraseCurrentWorkflow();

                    foreach (var content in outContents)
                    {
                        if (content == null)
                        {
                            continue;
                        }
                        var mergedFileText = _serializerService.Serialize(content);

                        var curveName = "";
                        if (fixerParameters.DoAddCurveNames)
                        {
                            var sb = new StringBuilder();
                            var delimiter = '_';
                            for (int i = 1; i < content.CurveInformation.Curves.Count; i++)
                            {
                                var curve = content.CurveInformation.Curves[i];
                                sb.Append(delimiter);
                                sb.Append(curve.Mnem);
                            }
                            curveName = sb.ToString();
                        }

                        var mergedFileName = PathUtils.SanitizeFileName($"{wellName}{curveName}");
                        var mergedFilePath = $"{mergedWellPath}/{mergedFileName}.las";
                        if (mergedFilePath.Length > 251)
                        {
                            mergedFileName = mergedFileName.Substring(0, mergedFileName.Length - (mergedFilePath.Length - 251));
                            mergedFilePath = $"{mergedWellPath}/{mergedFileName}$.las";
                        }
                        using (var sw = new StreamWriter(mergedFilePath, false, Encoding.GetEncoding(1251)))
                        {
                            sw.Write(mergedFileText);
                            sw.Close();
                        }
                    }
                }

                archivePath = mergerArchivePath;
            }

            using (var archive = new FileStream(fixerPath + "/fixed_archive.zip", FileMode.Create))
            {
                using (var zipWriter = WriterFactory.Open(archive, ArchiveType.Zip, new WriterOptions(CompressionType.Deflate)))
                {
                    foreach (var filePath in Directory.EnumerateFiles(archivePath, "*.las", SearchOption.AllDirectories))
                    {
                        zipWriter.Write(filePath.Replace(archivePath, ""), filePath);
                    }
                }
            }

            return this.JsonNet(new { FileName = "fixed_archive" });
        }