Разработка расширения для DVWebTool и DVSupService

        public HttpResponseMessage GetFile(Guid fileCardID)
        {
            FileReader fileReader = fileService.GetFileReader(fileCardID);

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

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

        [HttpPost]
        public async Task<ActionResult> AddFile([FromForm(Name = "file")] FormFileCollection formFiles, Guid cardId) (2)
        {

            string rootPath = CreateAndGetTempFolder();
            try
            {
                List<string> files = await SaveFilesFromResponse(formFiles); (3)

                await fileService.AddFilesToCard(cardId, files);
                return Ok();

            }
            catch (Exception e)
            {
                return Problem(statusCode: (int)HttpStatusCode.InternalServerError, detail: 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)
            ObjectContext objectContext = GetObjectContext();

            ILockService lockService = GetLockService(objectContext);

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

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

            IDocumentService documentService = GetDocumentService(objectContext);

            return await System.Threading.Tasks.Task.Run(() =>
            {
                IEnumerable<Guid> documentFileIds;
                try
                {
                    IEnumerable<DocumentFile> documentsFiles = documentService.AddAdditionalFiles(document, files);
                    objectContext.AcceptChanges();
                    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) (4)
        {
            ObjectContext objectContext = GetObjectContext();
            IVersionedFileCardService versionedFileCardService = GetVersionedFileCardService(objectContext);

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

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

            UserSession userSession = GetUserSession();

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

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

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

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

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

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

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

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

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

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

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

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

            string doneInfo;

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

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


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

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

            foreach (var fileId in request.FileIDs) (6)
            {
                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(); (7)

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

            foreach (var file in files)
            {
                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); (9)
            }
            catch (Exception ex)
            {
                Logger.Error(ex.Message);
                throw new Exception($"Не удалось сохранить файлы в карточке");
            }
            return doneInfo;
        }

export class WatermarkService { (1)

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

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

        const accessToken = await this.services.jwtTokenController.getAccessToken(); (4)

        const data: any = { (5)
            data: {
                cardID: cardID,
                fileIDs: fileIDs,
                userID: this.services.currentEmployeeId,
                serverAddress: this.services.siteUrl,
                accessToken
            },
            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) { (1)
   showNotify("Запущен процесс добавления водяных знаков");

   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();
      }
   }
}

"Docsvision": {
    "WebClient": {
      "SettingGroups": {
        "System": {
          "JwtAccessTokenLifetime": 300, (1)
          "JwtClockSkew": 300 (2)
        }
      }
    }
  }