commit b62d48b28175c876a90e0b12dd3c6a2ae9f66b05 · pyrox.dev/nixpkgs

+34

nixos/modules/services/misc/paperless.nix

···

       323
       323
        
             };

     

       324
       324
        
           };

     

       325
       325
        
       

     

       326
       326
       +
           configureNginx = lib.mkEnableOption "" // {

     

       327
       327
       +
             description = "Whether to configure nginx as a reverse proxy.";

     

       328
       328
       +
           };

     

       329
       329
       +
       

     

       330
       330
       +
           domain = lib.mkOption {

     

       331
       331
       +
             type = lib.types.str;

     

       332
       332
       +
             example = "paperless.example.com";

     

       333
       333
       +
             description = "Domain under which paperless will be available.";

     

       334
       334
       +
           };

     

       335
       335
       +
       

     

       326
       336
        
           exporter = {

     

       327
       337
        
             enable = lib.mkEnableOption "regular automatic document exports";

     

       328
       338
        
       

     
···

       380
       390
        
               services.paperless.manage = manage;

     

       381
       391
        
               environment.systemPackages = [ manage ];

     

       382
       392
        
       

     

       393
       393
       +
               services.nginx = lib.mkIf cfg.configureNginx {

     

       394
       394
       +
                 enable = true;

     

       395
       395
       +
                 upstreams.paperless.servers."${cfg.address}:${toString cfg.port}" = { };

     

       396
       396
       +
                 virtualHosts.${cfg.domain} = {

     

       397
       397
       +
                   forceSSL = lib.mkDefault true;

     

       398
       398
       +
                   locations = {

     

       399
       399
       +
                     "/".proxyPass = "http://paperless";

     

       400
       400
       +
                     "/static/" = {

     

       401
       401
       +
                       root = config.services.paperless.package;

     

       402
       402
       +
                       extraConfig = ''

     

       403
       403
       +
                         rewrite ^/(.*)$ /lib/paperless-ngx/$1 break;

     

       404
       404
       +
                       '';

     

       405
       405
       +
                     };

     

       406
       406
       +
                     "/ws/status" = {

     

       407
       407
       +
                       proxyPass = "http://paperless";

     

       408
       408
       +
                       proxyWebsockets = true;

     

       409
       409
       +
                     };

     

       410
       410
       +
                   };

     

       411
       411
       +
                 };

     

       412
       412
       +
               };

     

       413
       413
       +
       

     

       383
       414
        
               services.redis.servers.paperless.enable = lib.mkIf enableRedis true;

     

       384
       415
        
       

     

       385
       416
        
               services.postgresql = lib.mkIf cfg.database.createLocally {

     
···

       394
       425
        
               };

     

       395
       426
        
       

     

       396
       427
        
               services.paperless.settings = lib.mkMerge [

     

       428
       428
       +
                 (lib.mkIf (cfg.domain != "") {

     

       429
       429
       +
                   PAPERLESS_URL = "https://${cfg.domain}";

     

       430
       430
       +
                 })

     

       397
       431
        
                 (lib.mkIf cfg.database.createLocally {

     

       398
       432
        
                   PAPERLESS_DBENGINE = "postgresql";

     

       399
       433
        
                   PAPERLESS_DBHOST = "/run/postgresql";

+27 -24

nixos/tests/paperless.nix

···

       17
       17
        
                     imagemagick

     

       18
       18
        
                     jq

     

       19
       19
        
                   ];

     

       20
       20
       -
                   services.paperless = {

     

       21
       21
       -
                     enable = true;

     

       22
       22
       -
                     passwordFile = builtins.toFile "password" "admin";

     

       23
       23
       -
       

     

       24
       24
       -
                     exporter = {

     

       20
       20
       +
                   services = {

     

       21
       21
       +
                     nginx.virtualHosts."localhost".forceSSL = false;

     

       22
       22
       +
                     paperless = {

     

       25
       23
        
                       enable = true;

     

       24
       24
       +
                       configureNginx = true;

     

       25
       25
       +
                       domain = "localhost";

     

       26
       26
       +
                       passwordFile = builtins.toFile "password" "admin";

     

       26
       27
        
       

     

       27
       27
       -
                       settings = {

     

       28
       28
       -
                         "no-color" = lib.mkForce false; # override a default option

     

       29
       29
       -
                         "no-thumbnail" = true; # add a new option

     

       28
       28
       +
                       exporter = {

     

       29
       29
       +
                         enable = true;

     

       30
       30
       +
       

     

       31
       31
       +
                         settings = {

     

       32
       32
       +
                           "no-color" = lib.mkForce false; # override a default option

     

       33
       33
       +
                           "no-thumbnail" = true; # add a new option

     

       34
       34
       +
                         };

     

       30
       35
        
                       };

     

       31
       36
        
                     };

     

       32
       37
        
                   };

     

       33
       38
        
                 };

     

       34
       34
       -
               postgres =

     

       35
       35
       -
                 { config, pkgs, ... }:

     

       36
       36
       -
                 {

     

       37
       37
       -
                   imports = [ self.simple ];

     

       38
       38
       -
                   services.paperless.database.createLocally = true;

     

       39
       39
       -
                   services.paperless.settings = {

     

       40
       40
       -
                     PAPERLESS_OCR_LANGUAGE = "deu";

     

       41
       41
       -
                   };

     

       39
       39
       +
               postgres = {

     

       40
       40
       +
                 imports = [ self.simple ];

     

       41
       41
       +
                 services.paperless.database.createLocally = true;

     

       42
       42
       +
                 services.paperless.settings = {

     

       43
       43
       +
                   PAPERLESS_OCR_LANGUAGE = "deu";

     

       42
       44
        
                 };

     

       45
       45
       +
               };

     

       43
       46
        
             };

     

       44
       47
        
           in

     

       45
       48
        
           self;

     
···

       59
       62
        
             with subtest("Web interface gets ready"):

     

       60
       63
        
               node.wait_for_unit("paperless-web.service")

     

       61
       64
        
               # Wait until server accepts connections

     

       62
       62
       -
               node.wait_until_succeeds("curl -fs localhost:28981")

     

       65
       65
       +
               node.wait_until_succeeds("curl -fs localhost")

     

       63
       66
        
       

     

       64
       67
        
             # Required for consuming documents via the web interface

     

       65
       68
        
             with subtest("Task-queue gets ready"):

     
···

       70
       73
        
                 "convert -size 400x40 xc:white -font 'DejaVu-Sans' -pointsize 20 -fill black "

     

       71
       74
        
                 "-annotate +5+20 'hello web 16-10-2005' /tmp/webdoc.png"

     

       72
       75
        
               )

     

       73
       73
       -
               node.wait_until_succeeds("curl -u admin:admin -F document=@/tmp/webdoc.png -fs localhost:28981/api/documents/post_document/")

     

       76
       76
       +
               node.wait_until_succeeds("curl -u admin:admin -F document=@/tmp/webdoc.png -fs localhost/api/documents/post_document/")

     

       74
       77
        
       

     

       75
       78
        
             with subtest("Add a txt document via the web interface"):

     

       76
       79
        
               node.succeed(

     

       77
       80
        
                 "echo 'hello web 16-10-2005' > /tmp/webdoc.txt"

     

       78
       81
        
               )

     

       79
       79
       -
               node.wait_until_succeeds("curl -u admin:admin -F document=@/tmp/webdoc.txt -fs localhost:28981/api/documents/post_document/")

     

       82
       82
       +
               node.wait_until_succeeds("curl -u admin:admin -F document=@/tmp/webdoc.txt -fs localhost/api/documents/post_document/")

     

       80
       83
        
       

     

       81
       84
        
             with subtest("Documents are consumed"):

     

       82
       85
        
               node.wait_until_succeeds(

     

       83
       83
       -
                 "(($(curl -u admin:admin -fs localhost:28981/api/documents/ | jq .count) == 3))"

     

       86
       86
       +
                 "(($(curl -u admin:admin -fs localhost/api/documents/ | jq .count) == 3))"

     

       84
       87
        
               )

     

       85
       85
       -
               docs = json.loads(node.succeed("curl -u admin:admin -fs localhost:28981/api/documents/"))['results']

     

       88
       88
       +
               docs = json.loads(node.succeed("curl -u admin:admin -fs localhost/api/documents/"))['results']

     

       86
       89
        
               assert "2005-10-16" in docs[0]['created']

     

       87
       90
        
               assert "2005-10-16" in docs[1]['created']

     

       88
       91
        
               assert "2005-10-16" in docs[2]['created']

     

       89
       92
        
       

     

       90
       93
        
             # Detects gunicorn issues, see PR #190888

     

       91
       94
        
             with subtest("Document metadata can be accessed"):

     

       92
       92
       -
               metadata = json.loads(node.succeed("curl -u admin:admin -fs localhost:28981/api/documents/1/metadata/"))

     

       95
       95
       +
               metadata = json.loads(node.succeed("curl -u admin:admin -fs localhost/api/documents/1/metadata/"))

     

       93
       96
        
               assert "original_checksum" in metadata

     

       94
       97
        
       

     

       95
       95
       -
               metadata = json.loads(node.succeed("curl -u admin:admin -fs localhost:28981/api/documents/2/metadata/"))

     

       98
       98
       +
               metadata = json.loads(node.succeed("curl -u admin:admin -fs localhost/api/documents/2/metadata/"))

     

       96
       99
        
               assert "original_checksum" in metadata

     

       97
       100
        
       

     

       98
       98
       -
               metadata = json.loads(node.succeed("curl -u admin:admin -fs localhost:28981/api/documents/3/metadata/"))

     

       101
       101
       +
               metadata = json.loads(node.succeed("curl -u admin:admin -fs localhost/api/documents/3/metadata/"))

     

       99
       102
        
               assert "original_checksum" in metadata

     

       100
       103
        
       

     

       101
       104
        
             with subtest("Exporter"):