Разработка расширения для программы DVWebTool

public class FileOperationsController : ApiController
{
    IFileService fileService; (1)

    public FileOperationsController(IFileService fileService)
    {
        this.fileService = fileService;
    }

    [HttpGet]
    public HttpResponseMessage GetFile(Guid fileCardID) (2)
    {
        FileReader fileReader = fileService.GetFileReader(fileCardID); (3)

        if (fileReader.FileID == Guid.Empty)
            return new HttpResponseMessage(HttpStatusCode.NotFound);

        HttpResponseMessage response = CreateResponseForFile(fileReader); (4)
        return response;
    }

    [HttpPost]
    public async Task<HttpResponseMessage> AddFile() (5)
    {

        if (!Request.Content.IsMimeMultipartContent()) (6)
        {
            return Request.CreateErrorResponse(HttpStatusCode.UnsupportedMediaType, "Ошибка в формате входных данных");
        }

        string rootPath = CreateAndGetTempFolder(); (7)

        MultipartFormDataStreamProvider provider; (8)

        try
        {
            provider = new MultipartFormDataStreamProvider(rootPath);
        }
        catch (Exception ex)
        {
            return Request.CreateErrorResponse(HttpStatusCode.InternalServerError, $"Ошибка при работе с временными данными: {ex.Message}");
        }

        try
        {
            await Request.Content.ReadAsMultipartAsync(provider); (9)

            if (provider.FileData.Count < 1) (10)
            {
                return Request.CreateErrorResponse(HttpStatusCode.InternalServerError, "В запросе не переданы файлы для получения");
            }

            Guid cardId = GetCardIdFromResponse(provider.FormData); (11)

            List<string> files = await SaveFilesFromResponse(provider.FileData); (12)

            await fileService.AddFilesToCard(cardId, files); (13)
            return Request.CreateResponse(HttpStatusCode.OK);

        }
        catch (Exception e)
        {
            return Request.CreateErrorResponse(HttpStatusCode.InternalServerError, e.Message);
        }
    }

}

public class FileService : IFileService
{
    private readonly ICurrentObjectContextProvider currentObjectContextProvider;
    private Guid DOCUMENT_CARD_ID = new Guid("B9F7BFD7-7429-455E-A3F1-94FFB569C794");

    public FileService(ICurrentObjectContextProvider currentObjectContextProvider) {
        this.currentObjectContextProvider = currentObjectContextProvider;
    }

    public async System.Threading.Tasks.Task<IEnumerable<Guid>> AddFilesToCard(Guid cardID, List<string> files) (1)
    {
        var document = GetDocumentCard(cardID); (2)

        ILockService lockService = GetLockService();

        if (lockService.IsObjectLockedByAnotherUser(document)) {
            throw new Exception($"Карточка {cardID} заблокирована другим пользователем");
        }

        if (lockService.LockObjectBase(document) == false) {
            throw new Exception($"Не удалось заблокировать карточку {cardID}");
        }

        IDocumentService documentService = GetDocumentService();

        return await System.Threading.Tasks.Task.Run(() =>
        {
            IEnumerable<Guid> documentFileIds;
            try
            {
                IEnumerable<DocumentFile> documentsFiles = documentService.AddAdditionalFiles(document, files);
                documentFileIds = documentsFiles.Select(t => t.FileId);
            }
            catch (Exception ex)
            {
                throw new Exception($"Ошибка при добавлении файлов в карточку {cardID}\n {ex.Message}");
            }
            finally
            {
                lockService.UnlockObject(document);
            }

            return documentFileIds; (3)
        });
    }

    public FileReader GetFileReader(Guid fileCardID)
    {
        IVersionedFileCardService versionedFileCardService = GetVersionedFileCardService();

        VersionedFileCard fileCard = versionedFileCardService.OpenCard(fileCardID); (4)

        Guid fileID = fileCard.CurrentVersion.Id; (5)

        UserSession userSession = GetUserSession();

        if (userSession.FileManager.FileExists(fileID) == false) (6)
            return new FileReader();

        var file = userSession.FileManager.GetFile(fileID); (7)

        return new FileReader() { (8)
            FileID = fileID,
            FileName = file.Name,
            Stream = file.OpenReadStream()
        };
    }

    (9)
}

public class WatermarkManager : IServiceManager
{
    public string DisplayName => "Watermark to PDF"; (1)

    public void Register(WebSocketServer server) (2)
    {
        server.AddWebSocketService<WatermarkController>("/Watermark"); (3)
    }
}

public class WatermarkController : BaseService (1)
{
    private readonly ServiceProvider serviceProvider;
    private static readonly Logger Logger = LogManager.GetCurrentClassLogger();

    private string WATERMARK = "Секретно"; (2)

    public WatermarkController()
    {
        serviceProvider = new ServiceProvider();
        Init();
    }

    private void Init() (3)
    {
        actions.Add(nameof(AddWatermarkToFiles), AddWatermarkToFiles);
    }

    private async Task<WebServiceResponse> AddWatermarkToFiles(WebServiceRequest webServiceRequest, JObject data) (4)
    {
        Logger.Info("Получено задание на добавление водяного знака");

        if (data == null)
        {
            return CreateBadResponse("С клиента не переданы данные для работы");
        }

        AddWatermarkRequest request; (5)
        try
        {
            request = data.ToObject<AddWatermarkRequest>();
        }
        catch
        {
            Logger.Error($"Ошибка преобразования полученного сообщения: {data}");
            return CreateBadResponse("Поступивший запрос не соответствует ожидаемому формату");
        }

        string doneInfo;

        try
        {
            doneInfo = await HandleRequest(request);
        }
        catch (Exception ex)
        {
            return CreateBadResponse(ex.Message);
        }

        return CreateEndProcessResponse(request.CardID, $"Водяные знаки добавлены в файлы:<p />{doneInfo}");
    }

    private async Task<string> HandleRequest(AddWatermarkRequest request) (6)
    {
        var connectionService = new ConnectionToWebClient(request.ServerAddress);

        try
        {
            await connectionService.Authentificate();
        }
        catch (Exception ex)
        {
            Logger.Error(ex.Message);
            throw new Exception("Не удалось подключиться к серверу {wc}а");
        }

        List<string> files = new List<string>();

        foreach (var fileId in request.FileIDs) (7)
        {
            try
            {
                string pathToFile = await connectionService.PullFile(fileId);
                files.Add(pathToFile);
            }
            catch (Exception ex)
            {
                Logger.Error(ex.Message);
                throw new Exception($"Не удалось получить из карточки файл с идентификатором {fileId}");
            }
        }

        var watermarkService = new WatermarkService(); (8)

        List<Task<string>> processes = new List<Task<string>>();
        string doneInfo = "";

        foreach (var file in files) (9)
        {
            try
            {
                processes.Add(watermarkService.AddWatermark(file, WATERMARK));
                doneInfo += $" {Path.GetFileName(file)}<p />";
            }
            catch (Exception ex)
            {
                Logger.Error(ex.Message);
                throw new Exception($"Не удалось добавить водяной знак в файл {Path.GetFileName(file)}");
            }
        }

        var filesWithWatermark = await Task.WhenAll(processes);

        try
        {
            await connectionService.PushFiles(request.CardID, filesWithWatermark); (10)
        }
        catch (Exception ex)
        {
            Logger.Error(ex.Message);
            throw new Exception($"Не удалось сохранить файлы в карточке");
        }
        return doneInfo;
    }

    (11)
}

export class WatermarkService { (1)

    constructor(private services: $RequestManager & $WebServices & $ApplicationSettings & $MessageBox & $SiteUrl & $CurrentEmployeeId) {
    }

    AddWatermarkToFiles(cardID: string, fileIDs: string[]): Promise<IWebServicesResponse<any>> { (2)

        const data: any = {
            data: { (3)
                cardID: cardID,
                fileIDs: fileIDs,
                userID: this.services.currentEmployeeId, (4)
                serverAddress: this.services.siteUrl (5)
            },
            action: 'AddWatermarkToFiles', (6)
            locale: this.services.applicationSettings.culture.twoLetterISOLanguageName (7)
        };

        return DVWebToolConnection.trySendData("Watermark", data, this.services); (8)
    }
}

export type $WatermarkService = { watermarkService: WatermarkService }; (9)
export const $WatermarkService = serviceName((s: $WatermarkService) => s.watermarkService);

export async function addWatermark(sender: LayoutControl) {
   showNotify("Запущен процесс добавления водяных знаков"); (1)

   let cardId = sender.layout.getService($CardId); (2)
   let files = sender.layout.getService($FileService).getFiles();

   let fileIDs = new Array();

   files.forEach((item) => { (3)
      if (item.data.isMain && item.data.name.toLowerCase().endsWith(".pdf")) { (4)
         fileIDs.push(item.data.fileId);
      }
   })

   let watermarkService = sender.layout.getService($WatermarkService); (5)

   let response = await watermarkService.AddWatermarkToFiles(cardId, fileIDs); (6)

   if (response.success == false) {
      showError(response.errorMessage);
   } else {
      showNotify(response.data.message);

      if (layoutManager.cardLayout == null)
         return;

      let currentCardId = sender.layout.getService($CardId);
      if (currentCardId == cardId) {
         let fileList = layoutManager.cardLayout.controls.get<FileListControl>("fileList"); (7)
         await fileList.reloadFromServer();
      }
   }
}