From c22ca78bdba55f1634eb938deca64c97f9863a24 Mon Sep 17 00:00:00 2001 From: demitrix Date: Tue, 14 Jan 2025 20:03:36 +0000 Subject: [PATCH 01/42] Metadata flow rework --- root/app/calibre-web/cps/static/css/style.css | 1155 ++++++++++------- .../app/calibre-web/cps/static/js/get_meta.js | 264 ++++ .../calibre-web/cps/templates/book_edit.html | 373 ++++++ 3 files changed, 1321 insertions(+), 471 deletions(-) create mode 100644 root/app/calibre-web/cps/static/js/get_meta.js create mode 100644 root/app/calibre-web/cps/templates/book_edit.html diff --git a/root/app/calibre-web/cps/static/css/style.css b/root/app/calibre-web/cps/static/css/style.css index d3cbe3e..8390b39 100644 --- a/root/app/calibre-web/cps/static/css/style.css +++ b/root/app/calibre-web/cps/static/css/style.css @@ -1,475 +1,688 @@ - .tooltip.bottom .tooltip-inner { - font-size: 13px; - font-family: Open Sans Semibold, Helvetica Neue, Helvetica, Arial, sans-serif; - -webkit-font-smoothing: antialiased; - -moz-osx-font-smoothing: grayscale; - padding: 3px 10px; - border-radius: 4px; - background-color: #fff; - -webkit-box-shadow: 0 4px 10px 0 rgba(0, 0, 0, 0.35); - box-shadow: 0 4px 10px 0 rgba(0, 0, 0, 0.35); - opacity: 1; - white-space: nowrap; - margin-top: -16px !important; - line-height: 1.71428571; - color: #ddd; - } - - @font-face { - font-family: 'Grand Hotel'; - font-style: normal; - font-weight: 400; - src: local('Grand Hotel'), local('GrandHotel-Regular'), url("fonts/GrandHotel-Regular.ttf") format('truetype'); - } - - html.http-error { - margin: 0; - height: 100%; - } - - body { - background: #f2f2f2; - margin-bottom: 40px; - } - - .http-error body { - margin: 0; - height: 100%; - display: table; - width: 100%; - } - - .http-error body > div { - display: table-cell; - vertical-align: middle; - text-align: center; - } - - body h2 { - font-weight: normal; - color: #444; - } - - a, - .danger, - .book-remove, - .editable-empty, - .editable-empty:hover { color: #45b29d; } - .book-remove:hover { color: #23527c; } - .user-remove:hover { color: #23527c; } - .btn-default a { color: #444; } - .panel-title > a { text-decoration: none; } - - .navigation li a { - color: #444; - text-decoration: none; - display: block; - padding: 10px; - } - - .btn-default a:hover { - color: #45b29d; - text-decoration: None; - } - - .btn-default:hover { - color: #45b29d; - } - - .editable-click, - a.editable-click, - a.editable-click:hover { border-bottom: None; } - - .navigation .nav-head { - text-transform: uppercase; - color: #999; - margin: 20px 0; - } - - .navigation .nav-head:nth-child(1n+2) { - border-top: 1px solid #ccc; - padding-top: 20px; - } - - .book-meta .tags a { display: inline; } - table .bg-primary a { color: #fff; } - table .bg-dark-danger a { color: #fff; } - .book-meta .identifiers a { display: inline; } - - .navigation .create-shelf a { - color: #fff; - background: #45b29d; - padding: 10px 20px; - border-radius: 5px; - text-decoration: none; - } - - .navigation li a:hover { - background: rgba(153, 153, 153, 0.4); - border-radius: 5px; - } - - .navigation li a span { margin-right: 10px; } - - .navigation .create-shelf { - margin: 30px 0; - font-size: 12px; - text-align: center; - } - - .row.display-flex { - display: flex; - flex-wrap: wrap; - } - - .row-fluid.text-center { - margin-top: -20px; - } - - .container-fluid img { - display: block; - max-width: 100%; - height: auto; - max-height: 100%; - } - - .container-fluid .discover { margin-bottom: 50px; } - .container-fluid .new-books { border-top: 1px solid #ccc; } - .container-fluid .new-books h2 { margin: 50px 0 0 0; } - - .container-fluid .book { - margin-top: 20px; - max-width: 180px; - display: flex; - flex-direction: column; - } - .cover { margin-bottom: 10px; } - - .container-fluid .book .cover { - height: 225px; - position: relative; - } - - .author-link img { - display: block; - height: 100%; - } - - .author-bio img { margin: 0 1em 1em 0; } - - .container-fluid .single .cover img { - border: 1px solid #fff; - box-sizing: border-box; - -webkit-box-shadow: 0 5px 8px -6px #777; - -moz-box-shadow: 0 5px 8px -6px #777; - box-shadow: 0 5px 8px -6px #777; - } - - .datepicker.form-control { - position: static; - } - - .container-fluid .book .cover span .img { - bottom: 0; - height: 100%; - position: absolute; - } - - .container-fluid .book .cover span img { - border: 1px solid #fff; - position: relative; - height: 100%; - - box-sizing: border-box; - -webkit-box-shadow: 0 5px 8px -6px #777; - -moz-box-shadow: 0 5px 8px -6px #777; - box-shadow: 0 5px 8px -6px #777; - } - - .container-fluid .book .meta { margin-top: 10px; } - .media-body p { text-align: justify; } - .container-fluid .book .meta p { margin: 0; } - - .container-fluid .book .meta .title { - font-weight: bold; - font-size: 15px; - color: #444; - } - - .container-fluid .book .meta .series { - font-weight: 400; - font-size: 12px; - color: #444; - } - - .container-fluid .book .meta .author { - font-size: 12px; - color: #999; - } - - .container-fluid .book .meta .rating { margin-top: 5px; } - .rating .glyphicon-star-empty { color: #444; } - .rating .glyphicon-star.good { color: #444; } - .rating-clear .glyphicon-remove { color: #333; } - - .container-fluid .author .author-hidden, - .container-fluid .author .author-hidden-divider { display: none; } - - .navbar-brand { - font-family: 'Grand Hotel', cursive; - font-size: 35px; - color: #45b29d !important; - } - - .more-stuff { - margin-top: 20px; - padding-top: 20px; - border-top: 1px solid #ccc; - } - - .more-stuff > li { margin-bottom: 10px; } - .navbar-collapse.in .navbar-nav { margin: 0; } - - span.glyphicon.glyphicon-tags { - padding-right: 5px; - color: #999; - vertical-align: text-top; - } - - .book-meta { padding-bottom: 20px; } - - .navbar-default .navbar-toggle .icon-bar { background-color: #000; } - .navbar-default .navbar-toggle { border-color: #000; } - - .cover .badge { - position: absolute; - top: 2px; - left: 2px; - color: #000; - border-radius: 10px; - background-color: #fff; - } - - .cover .read { - position: relative; - top: -20px; - /*left: auto; - right: 2px;*/ - width: 17px; - height: 17px; - display: inline-block; - padding: 2px; - } - .cover-height { max-height: 100px; } - - .col-sm-2 a .cover-small { - margin: 5px; - max-height: 200px; - } - - .btn-file { - position: relative; - overflow: hidden; - } - - .btn-file input[type=file] { - position: absolute; - top: 0; - right: 0; - min-width: 100%; - min-height: 100%; - font-size: 100px; - text-align: right; - filter: alpha(opacity=0); - opacity: 0; - outline: none; - background: white; - cursor: inherit; - display: block; - } - - .btn-toolbar .btn, - .discover .btn { margin-bottom: 5px; } - .button-link { color: #fff; } - - .btn-primary:hover, - .btn-primary:focus, - .btn-primary:active, - .btn-primary.active, - .open .dropdown-toggle.btn-primary { background-color: #1c5484; } - - .btn-primary.disabled, - .btn-primary[disabled], - fieldset[disabled] .btn-primary, - .btn-primary.disabled:hover, - .btn-primary[disabled]:hover, - fieldset[disabled] .btn-primary:hover, - .btn-primary.disabled:focus, - .btn-primary[disabled]:focus, - fieldset[disabled] .btn-primary:focus, - .btn-primary.disabled:active, - .btn-primary[disabled]:active, - fieldset[disabled] .btn-primary:active, - .btn-primary.disabled.active, - .btn-primary[disabled].active, - fieldset[disabled] .btn-primary.active { background-color: #89b9e2; } - - .btn-toolbar > .btn + .btn, - .btn-toolbar > .btn-group + .btn, - .btn-toolbar > .btn + .btn-group, - .btn-toolbar > .btn-group + .btn-group { margin-left: 0; } - - .panel-body { background-color: #f5f5f5; } - .spinner { margin: 0 41%; } - .spinner2 { margin: 0 41%; } - .intend-form { margin-left: 20px; } - - table .bg-dark-danger { - background-color: #d9534f; - color: #fff; - } - table .bg-dark-danger:hover { background-color: #c9302c; } - table .bg-primary:hover { background-color: #1c5484; } - .block-label { display: block; } - - .form-control.fake-input { - position: absolute; - pointer-events: none; - top: 0; - } - - input.pill { - position: absolute; - opacity: 0; - } - - input.pill + label { - border: 2px solid #45b29d; - border-radius: 15px; - color: #45b29d; - cursor: pointer; - display: inline-block; - padding: 3px 15px; - user-select: none; - -webkit-font-smoothing: antialiased; - -moz-osx-font-smoothing: grayscale; - } - - input.pill:checked + label { - background-color: #45b29d; - border-color: #fff; - color: #fff; - } - - input.pill:not(:checked) + label .glyphicon { display: none; } - - .author-link { - display: inline-block; - margin-top: 10px; - width: 100px; - } - - #remove-from-shelves .btn, - #shelf-action-errors { margin-left: 5px; } - - .tags_click, - .serie_click, - .language_click { margin-right: 5px; } - - #meta-info { - height: 600px; - overflow-y: scroll; - } - - .media-list { padding-right: 15px; } - - #meta-info img { - max-height: 150px; - max-width: 100px; - cursor: pointer; - } - - .padded-bottom { margin-bottom: 15px; } - .upload-format-input-text { display: initial; } - #btn-upload-format { display: none; } - .upload-cover-input-text { display: initial; } - #btn-upload-cover { display: none; } - - .editable-buttons { - display: inline-block; - margin-left: 7px; - } - - .editable-input { display: inline-block; } - - .editable-cancel { - margin-bottom: 0 !important; - margin-left: 7px !important; - } - - .editable-submit { margin-bottom: 0 !important; } - .filterheader { margin-bottom: 20px; } - .errorlink { margin-top: 20px; } - .emailconfig { margin-top: 10px; } - - .modal-body .comments { - max-height: 300px; - overflow-y: auto; - } - - div.log { - font-family: Courier New, serif; - font-size: 12px; - box-sizing: border-box; - height: 700px; - overflow-y: scroll; - border: 1px solid #ddd; - white-space: nowrap; - padding: 0.5em; - } - - #detailcover { cursor:zoom-in; } - #detailcover:-webkit-full-screen { cursor:zoom-out; border: 0; } - #detailcover:-moz-full-screen { cursor:zoom-out; border: 0; } - #detailcover:-ms-fullscreen { cursor:zoom-out; border: 0; } - #detailcover:fullscreen { cursor:zoom-out; border: 0; } - - .error-list { - margin-top: 5px; - } + font-size: 13px; + font-family: Open Sans Semibold, Helvetica Neue, Helvetica, Arial, sans-serif; + -webkit-font-smoothing: antialiased; + -moz-osx-font-smoothing: grayscale; + padding: 3px 10px; + border-radius: 4px; + background-color: #fff; + -webkit-box-shadow: 0 4px 10px 0 rgba(0, 0, 0, 0.35); + box-shadow: 0 4px 10px 0 rgba(0, 0, 0, 0.35); + opacity: 1; + white-space: nowrap; + margin-top: -16px !important; + line-height: 1.71428571; + color: #ddd; +} - :root { - --color-secondary: #45b29d; - } - - p.cwa-settings-tooltip { - margin: 1px 4px 16px 32px; - padding: 5px 10px; - line-height: normal; - color: #444444; - max-width: 100rem; - } +@font-face { + font-family: "Grand Hotel"; + font-style: normal; + font-weight: 400; + src: local("Grand Hotel"), local("GrandHotel-Regular"), + url("fonts/GrandHotel-Regular.ttf") format("truetype"); +} - p.cwa-settings-explanation { - color: #444444; - font-style: italic; - font-size: inherit; - line-height: normal; - padding-left: 10px; - max-width: 90rem; - } - p.cwa-settings-disclaimer { - font-size: small; - font-style: italic; - color: #444444; - padding-left: 10px; - line-height: normal; - } +html.http-error { + margin: 0; + height: 100%; +} - select.cwa-settings-select { - background-color: white; - color: #444444; - text-align: center; - border-radius: 6px; - } \ No newline at end of file +body { + background: #f2f2f2; + margin-bottom: 40px; +} + +.http-error body { + margin: 0; + height: 100%; + display: table; + width: 100%; +} + +.http-error body > div { + display: table-cell; + vertical-align: middle; + text-align: center; +} + +body h2 { + font-weight: normal; + color: #444; +} + +a, +.danger, +.book-remove, +.editable-empty, +.editable-empty:hover { + color: #45b29d; +} +.book-remove:hover { + color: #23527c; +} +.user-remove:hover { + color: #23527c; +} +.btn-default a { + color: #444; +} +.panel-title > a { + text-decoration: none; +} + +.navigation li a { + color: #444; + text-decoration: none; + display: block; + padding: 10px; +} + +.btn-default a:hover { + color: #45b29d; + text-decoration: None; +} + +.btn-default:hover { + color: #45b29d; +} + +.editable-click, +a.editable-click, +a.editable-click:hover { + border-bottom: None; +} + +.navigation .nav-head { + text-transform: uppercase; + color: #999; + margin: 20px 0; +} + +.navigation .nav-head:nth-child(1n + 2) { + border-top: 1px solid #ccc; + padding-top: 20px; +} + +.book-meta .tags a { + display: inline; +} +table .bg-primary a { + color: #fff; +} +table .bg-dark-danger a { + color: #fff; +} +.book-meta .identifiers a { + display: inline; +} + +.navigation .create-shelf a { + color: #fff; + background: #45b29d; + padding: 10px 20px; + border-radius: 5px; + text-decoration: none; +} + +.navigation li a:hover { + background: rgba(153, 153, 153, 0.4); + border-radius: 5px; +} + +.navigation li a span { + margin-right: 10px; +} + +.navigation .create-shelf { + margin: 30px 0; + font-size: 12px; + text-align: center; +} + +.row.display-flex { + display: flex; + flex-wrap: wrap; +} + +.row-fluid.text-center { + margin-top: -20px; +} + +.container-fluid img { + display: block; + max-width: 100%; + height: auto; + max-height: 100%; +} + +.container-fluid .discover { + margin-bottom: 50px; +} +.container-fluid .new-books { + border-top: 1px solid #ccc; +} +.container-fluid .new-books h2 { + margin: 50px 0 0 0; +} + +.container-fluid .book { + margin-top: 20px; + max-width: 180px; + display: flex; + flex-direction: column; +} +.cover { + margin-bottom: 10px; +} + +.container-fluid .book .cover { + height: 225px; + position: relative; +} + +.author-link img { + display: block; + height: 100%; +} + +.author-bio img { + margin: 0 1em 1em 0; +} + +.container-fluid .single .cover img { + border: 1px solid #fff; + box-sizing: border-box; + -webkit-box-shadow: 0 5px 8px -6px #777; + -moz-box-shadow: 0 5px 8px -6px #777; + box-shadow: 0 5px 8px -6px #777; +} + +.datepicker.form-control { + position: static; +} + +.container-fluid .book .cover span .img { + bottom: 0; + height: 100%; + position: absolute; +} + +.container-fluid .book .cover span img { + border: 1px solid #fff; + position: relative; + height: 100%; + + box-sizing: border-box; + -webkit-box-shadow: 0 5px 8px -6px #777; + -moz-box-shadow: 0 5px 8px -6px #777; + box-shadow: 0 5px 8px -6px #777; +} + +.container-fluid .book .meta { + margin-top: 10px; +} +.media-body p { + text-align: justify; +} +.container-fluid .book .meta p { + margin: 0; +} + +.container-fluid .book .meta .title { + font-weight: bold; + font-size: 15px; + color: #444; +} + +.container-fluid .book .meta .series { + font-weight: 400; + font-size: 12px; + color: #444; +} + +.container-fluid .book .meta .author { + font-size: 12px; + color: #999; +} + +.container-fluid .book .meta .rating { + margin-top: 5px; +} +.rating .glyphicon-star-empty { + color: #444; +} +.rating .glyphicon-star.good { + color: #444; +} +.rating-clear .glyphicon-remove { + color: #333; +} + +.container-fluid .author .author-hidden, +.container-fluid .author .author-hidden-divider { + display: none; +} + +.navbar-brand { + font-family: "Grand Hotel", cursive; + font-size: 35px; + color: #45b29d !important; +} + +.more-stuff { + margin-top: 20px; + padding-top: 20px; + border-top: 1px solid #ccc; +} + +.more-stuff > li { + margin-bottom: 10px; +} +.navbar-collapse.in .navbar-nav { + margin: 0; +} + +span.glyphicon.glyphicon-tags { + padding-right: 5px; + color: #999; + vertical-align: text-top; +} + +.book-meta { + padding-bottom: 20px; +} + +.navbar-default .navbar-toggle .icon-bar { + background-color: #000; +} +.navbar-default .navbar-toggle { + border-color: #000; +} + +.cover .badge { + position: absolute; + top: 2px; + left: 2px; + color: #000; + border-radius: 10px; + background-color: #fff; +} + +.cover .read { + position: relative; + top: -20px; + /*left: auto; + right: 2px;*/ + width: 17px; + height: 17px; + display: inline-block; + padding: 2px; +} +.cover-height { + max-height: 100px; +} + +.col-sm-2 a .cover-small { + margin: 5px; + max-height: 200px; +} + +.btn-file { + position: relative; + overflow: hidden; +} + +.btn-file input[type="file"] { + position: absolute; + top: 0; + right: 0; + min-width: 100%; + min-height: 100%; + font-size: 100px; + text-align: right; + filter: alpha(opacity=0); + opacity: 0; + outline: none; + background: white; + cursor: inherit; + display: block; +} + +.btn-toolbar .btn, +.discover .btn { + margin-bottom: 5px; +} +.button-link { + color: #fff; +} + +.btn-primary:hover, +.btn-primary:focus, +.btn-primary:active, +.btn-primary.active, +.open .dropdown-toggle.btn-primary { + background-color: #1c5484; +} + +.btn-primary.disabled, +.btn-primary[disabled], +fieldset[disabled] .btn-primary, +.btn-primary.disabled:hover, +.btn-primary[disabled]:hover, +fieldset[disabled] .btn-primary:hover, +.btn-primary.disabled:focus, +.btn-primary[disabled]:focus, +fieldset[disabled] .btn-primary:focus, +.btn-primary.disabled:active, +.btn-primary[disabled]:active, +fieldset[disabled] .btn-primary:active, +.btn-primary.disabled.active, +.btn-primary[disabled].active, +fieldset[disabled] .btn-primary.active { + background-color: #89b9e2; +} + +.btn-toolbar > .btn + .btn, +.btn-toolbar > .btn-group + .btn, +.btn-toolbar > .btn + .btn-group, +.btn-toolbar > .btn-group + .btn-group { + margin-left: 0; +} + +.panel-body { + background-color: #f5f5f5; +} +.spinner { + margin: 0 41%; +} +.spinner2 { + margin: 0 41%; +} +.intend-form { + margin-left: 20px; +} + +table .bg-dark-danger { + background-color: #d9534f; + color: #fff; +} +table .bg-dark-danger:hover { + background-color: #c9302c; +} +table .bg-primary:hover { + background-color: #1c5484; +} +.block-label { + display: block; +} + +.form-control.fake-input { + position: absolute; + pointer-events: none; + top: 0; +} + +input.pill { + position: absolute; + opacity: 0; +} + +input.pill + label { + border: 2px solid #45b29d; + border-radius: 15px; + color: #45b29d; + cursor: pointer; + display: inline-block; + padding: 3px 15px; + user-select: none; + -webkit-font-smoothing: antialiased; + -moz-osx-font-smoothing: grayscale; +} + +input.pill:checked + label { + background-color: #45b29d; + border-color: #fff; + color: #fff; +} + +input.pill:not(:checked) + label .glyphicon { + display: none; +} + +.author-link { + display: inline-block; + margin-top: 10px; + width: 100px; +} + +#remove-from-shelves .btn, +#shelf-action-errors { + margin-left: 5px; +} + +.tags_click, +.serie_click, +.language_click { + margin-right: 5px; +} + +#meta-info { + height: 600px; + overflow-y: scroll; +} + +#meta-info #book-list { + list-style-type: none; + padding: 0px 15px 0px 0px; +} + +#meta-info #book-list .media { + display: flex; + background-color: #f9f9f9; + margin-bottom: 20px; + border-radius: 8px; + overflow: hidden; + box-shadow: 0 2px 5px rgba(0, 0, 0, 0.1); +} + +#meta-info #book-list .media .media-image { + width: 200px; + padding: 20px; + display: flex; + flex-direction: column; + align-items: center; + position: relative; +} + +#meta-info #book-list .media .media-image-wrapper { + position: relative; + width: 100%; +} + +#meta-info #book-list .media .media-image img { + max-width: 100%; + height: auto; + border-radius: 4px; + display: block; +} +#meta-info #book-list .media .media-image .image-dimensions { + position: absolute; + bottom: 5px; + right: 5px; + background-color: rgba(0, 0, 0, 0.7); + color: white; + padding: 4px 8px; + border-radius: 4px; + font-size: 12px; +} +#meta-info #book-list .media .media-image .image-dimensions.larger { + background-color: rgba(0, 160, 0, 0.7); +} +#meta-info #book-list .media .media-image .image-dimensions.smaller { + background-color: rgba(160, 0, 0, 0.7); +} +#meta-info #book-list .media .media-image input { + position: absolute; + top: 5px; + right: 5px; + width: 20px; + height: 20px; +} + +#meta-info #book-list .media .media-image button { + margin-top: 10px; + /* padding: 8px 16px; */ + cursor: pointer; +} + +#meta-info #book-list .media .media-image div { + margin-top: 10px; + font-size: 0.9em; + color: #666; + text-align: center; +} + +#meta-info #book-list .media .media-body { + flex: 1; + padding: 20px; + display: grid; + grid-template-columns: auto 1fr; + gap: 10px; + align-content: start; +} + +#meta-info #book-list .media .media-body dt { + font-weight: bold; + color: #333; + display: flex; + align-items: center; +} + +#meta-info #book-list .media .media-body dt input { + margin-right: 5px; + margin-top: 0px; +} + +#meta-info #book-list .media .media-body dd { + margin: 0; + color: #666; +} + +.padded-bottom { + margin-bottom: 15px; +} +.upload-format-input-text { + display: initial; +} +#btn-upload-format { + display: none; +} +.upload-cover-input-text { + display: initial; +} +#btn-upload-cover { + display: none; +} + +.editable-buttons { + display: inline-block; + margin-left: 7px; +} + +.editable-input { + display: inline-block; +} + +.editable-cancel { + margin-bottom: 0 !important; + margin-left: 7px !important; +} + +.editable-submit { + margin-bottom: 0 !important; +} +.filterheader { + margin-bottom: 20px; +} +.errorlink { + margin-top: 20px; +} +.emailconfig { + margin-top: 10px; +} + +.modal-body .comments { + max-height: 300px; + overflow-y: auto; +} + +div.log { + font-family: Courier New, serif; + font-size: 12px; + box-sizing: border-box; + height: 700px; + overflow-y: scroll; + border: 1px solid #ddd; + white-space: nowrap; + padding: 0.5em; +} + +#detailcover { + cursor: zoom-in; +} +#detailcover:-webkit-full-screen { + cursor: zoom-out; + border: 0; +} +#detailcover:-moz-full-screen { + cursor: zoom-out; + border: 0; +} +#detailcover:-ms-fullscreen { + cursor: zoom-out; + border: 0; +} +#detailcover:fullscreen { + cursor: zoom-out; + border: 0; +} + +.error-list { + margin-top: 5px; +} + +:root { + --color-secondary: #45b29d; +} + +p.cwa-settings-tooltip { + margin: 1px 4px 16px 32px; + padding: 5px 10px; + line-height: normal; + color: #444444; + max-width: 100rem; +} + +p.cwa-settings-explanation { + color: #444444; + font-style: italic; + font-size: inherit; + line-height: normal; + padding-left: 10px; + max-width: 90rem; +} +p.cwa-settings-disclaimer { + font-size: small; + font-style: italic; + color: #444444; + padding-left: 10px; + line-height: normal; +} + +select.cwa-settings-select { + background-color: white; + color: #444444; + text-align: center; + border-radius: 6px; +} diff --git a/root/app/calibre-web/cps/static/js/get_meta.js b/root/app/calibre-web/cps/static/js/get_meta.js new file mode 100644 index 0000000..819b395 --- /dev/null +++ b/root/app/calibre-web/cps/static/js/get_meta.js @@ -0,0 +1,264 @@ +/* This file is part of the Calibre-Web (https://github.com/janeczku/calibre-web) + * Copyright (C) 2018 idalin + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ +/* global _, i18nMsg, tinymce, getPath */ + +$(function () { + var msg = i18nMsg; + var keyword = ""; + + var templates = { + bookResult: _.template($("#template-book-result").html()), + }; + + function getUniqueValues(attribute_name, book) { + var presentArray = $.map( + $("#" + attribute_name) + .val() + .split(","), + $.trim + ); + if (presentArray.length === 1 && presentArray[0] === "") { + presentArray = []; + } + $.each(book[attribute_name], function (i, el) { + if ($.inArray(el, presentArray) === -1) presentArray.push(el); + }); + return presentArray; + } + + function populateForm(book, idx) { + var updateItems = Object.fromEntries( + Array.from( + document.querySelectorAll(`[data-meta-index="${idx}"]`) + ).map((value) => [value.dataset.metaValue, value.checked]) + ); + if (updateItems.description) { + tinymce.get("comments").setContent(book.description); + } + if (updateItems.tags) { + var uniqueTags = getUniqueValues("tags", book); + $("#tags").val(uniqueTags.join(", ")); + } + var uniqueLanguages = getUniqueValues("languages", book); + if (updateItems.authors) { + var ampSeparatedAuthors = (book.authors || []).join(" & "); + $("#authors").val(ampSeparatedAuthors); + } + if (updateItems.titles) { + $("#title").val(book.title); + } + $("#languages").val(uniqueLanguages.join(", ")); + $("#rating").data("rating").setValue(Math.round(book.rating)); + + if (updateItems.cover && book.cover && $("#cover_url").length) { + $(".cover img").attr("src", book.cover); + $("#cover_url").val(book.cover); + } + if (updateItems.pubDate) { + $("#pubdate").val(book.publishedDate); + } + if (updateItems.publisher) { + $("#publisher").val(book.publisher); + } + if (updateItems.series && typeof book.series !== "undefined") { + $("#series").val(book.series); + } + if ( + updateItems.series_index && + typeof book.series_index !== "undefined" + ) { + $("#series_index").val(book.series_index); + } + if ( + updateItems.identifiers && + typeof book.identifiers !== "undefined" + ) { + populateIdentifiers(book.identifiers); + } + } + + function populateIdentifiers(identifiers) { + for (const property in identifiers) { + if (identifiers[property].length !== 0) { + console.log(`${property}: ${identifiers[property]}`); + if ( + $('input[name="identifier-type-' + property + '"]').length + ) { + $('input[name="identifier-val-' + property + '"]').val( + identifiers[property] + ); + } else { + addIdentifier(property, identifiers[property]); + } + } + } + } + + function addIdentifier(name, value) { + var line = ""; + line += + ''; + line += + ''; + line += + '' + + _("Remove") + + ""; + line += ""; + $("#identifier-table").append(line); + } + + function doSearch(keyword) { + if (keyword) { + $("#meta-info").text(msg.loading); + $.ajax({ + url: getPath() + "/metadata/search", + type: "POST", + data: { query: keyword }, + dataType: "json", + success: function success(data) { + if (data.length) { + $("#meta-info").html( + '
    ' + ); + data.forEach(function (book, idx) { + var $book = $( + templates.bookResult({ book: book, index: idx }) + ); + $book.find("button").on("click", function () { + populateForm(book, idx); + }); + $("#book-list").append($book); + }); + } else { + $("#meta-info").html( + '

    ' + + msg.no_result + + "!

    " + + $("#meta-info")[0].innerHTML + ); + } + }, + error: function error() { + $("#meta-info").html( + '

    ' + + msg.search_error + + "!

    " + + $("#meta-info")[0].innerHTML + ); + }, + }); + } + } + + function populate_provider() { + $("#metadata_provider").empty(); + $.ajax({ + url: getPath() + "/metadata/provider", + type: "get", + dataType: "json", + success: function success(data) { + data.forEach(function (provider) { + var checked = ""; + if (provider.active) { + checked = "checked"; + } + var $provider_button = + ''; + $("#metadata_provider").append($provider_button); + }); + }, + }); + } + + $(document).on("change", ".pill", function () { + var element = $(this); + var id = element.data("control"); + var initial = element.data("initial"); + var val = element.prop("checked"); + var params = { id: id, value: val }; + if (!initial) { + params["initial"] = initial; + params["query"] = keyword; + } + $.ajax({ + method: "post", + contentType: "application/json; charset=utf-8", + dataType: "json", + url: getPath() + "/metadata/provider/" + id, + data: JSON.stringify(params), + success: function success(data) { + element.data("initial", "true"); + data.forEach(function (book, idx) { + var $book = $( + templates.bookResult({ book: book, index: idx }) + ); + $book.find("button").on("click", function () { + populateForm(book, idx); + }); + $("#book-list").append($book); + }); + }, + }); + }); + + $("#meta-search").on("submit", function (e) { + e.preventDefault(); + keyword = $("#keyword").val(); + $(".pill").each(function () { + $(this).data("initial", $(this).prop("checked")); + }); + doSearch(keyword); + }); + + $("#get_meta").click(function () { + populate_provider(); + var bookTitle = $("#title").val(); + $("#keyword").val(bookTitle); + keyword = bookTitle; + doSearch(bookTitle); + }); + $("#metaModal").on("show.bs.modal", function (e) { + $(e.relatedTarget).one("focus", function (e) { + $(this).blur(); + }); + }); +}); diff --git a/root/app/calibre-web/cps/templates/book_edit.html b/root/app/calibre-web/cps/templates/book_edit.html new file mode 100644 index 0000000..2a1cbb1 --- /dev/null +++ b/root/app/calibre-web/cps/templates/book_edit.html @@ -0,0 +1,373 @@ +{% extends "layout.html" %} +{% block body %} +{% if book %} +
    +
    + + +
    +{% if current_user.role_delete_books() %} +
    + +
    + {% if book.data|length > 1 %} +

    {{_('Delete formats:')}}

    + {% for file in book.data %} +
    + +
    + {% endfor %} +
    + {% endif %} +{% endif %} + +{% if source_formats|length > 0 and conversion_formats|length > 0 %} +

    {{_('Convert book format:')}}

    +
    + +
    +
    + + + + +
    +
    + +
    +
    +{% endif %} +{% if current_user.role_upload() and g.allow_upload %} + +
    +
    +
    + + +
    + +
    + +
    +
    +
    +
    +{% endif %} +
    +
    + +
    +
    + + +
    +
    + +
    +
    + + +
    +
    + + +
    +
    + + +
    +
    + + +
    + +
    + + + + + +
    +
    + + +
    +
    + + +
    +
    + + +
    +
    + + +
    +
    + + + {% for identifier in book.identifiers %} + + + + + + {% endfor %} + +
    {{_('Remove')}}
    + {{_('Add Identifier')}} +
    + {% if current_user.role_upload() and g.allow_upload %} +
    + + +
    +
    + +
    + +
    + {% endif %} + {% if cc|length > 0 %} + {% for c in cc %} +
    + + {% if c.datatype == 'bool' %} + + {% endif %} + + {% if c.datatype == 'int' or c.datatype == 'float' %} + + {% endif %} + + {% if c.datatype == 'text' %} + 0 %} + value="{% for column in book['custom_column_' ~ c.id] %}{{ column.value.strip() }}{% if not loop.last %}, {% endif %}{% endfor %}"{% endif %}> + {% endif %} + + {% if c.datatype == 'series' %} + 0 %} + value="{% for column in book['custom_column_' ~ c.id] %} {{ '%s [%s]' % (book['custom_column_' ~ c.id][0].value, book['custom_column_' ~ c.id][0].extra|formatfloat(2)) }}{% if not loop.last %}, {% endif %}{% endfor %}" + {% endif %}> + {% endif %} + + {% if c.datatype == 'datetime' %} +
    + 0 %} + value="{% if book['custom_column_' ~ c.id][0].value %}{{ book['custom_column_' ~ c.id][0].value|formatdateinput}}{% endif %}" + {% endif %}> + 0 %} + value="{% if book['custom_column_' ~ c.id][0].value %}{{book['custom_column_' ~ c.id][0].value|formatdate}}{% endif %}" + {% endif %}> + + + +
    + {% endif %} + + {% if c.datatype == 'comments' %} + + {% endif %} + {% if c.datatype == 'enumeration' %} + + {% endif %} + + {% if c.datatype == 'rating' %} + 0 %} + value="{{ '%.1f' % (book['custom_column_' ~ c.id][0].value / 2) }}" + {% endif %}> + {% endif %} +
    + {% endfor %} + {% endif %} + +
    + +
    + {{_('Fetch Metadata')}} + + {{_('Cancel')}} +
    +
    + +{% endif %} +{% endblock %} + +{% block modal %} +{{ delete_book(current_user.role_delete_books()) }} +{{ delete_confirm_modal() }} + + +{% endblock %} + +{% block js %} + + + + + + + +{% if not current_user.locale == 'en' %} + +{% endif %} + + +{% endblock %} +{% block header %} + + + +{% endblock %} From 4b797e896f2135cd927258a47ade69c55d15c154 Mon Sep 17 00:00:00 2001 From: demitrix Date: Tue, 14 Jan 2025 20:39:03 +0000 Subject: [PATCH 02/42] Hardcover metadata and read sync --- root/app/calibre-web/cps/admin.py | 2 + root/app/calibre-web/cps/config_sql.py | 588 ++++++++ root/app/calibre-web/cps/db.py | 1101 ++++++++++++++ root/app/calibre-web/cps/kobo.py | 1286 +++++++++++++++++ .../cps/metadata_provider/amazon.py | 140 ++ .../cps/metadata_provider/comicvine.py | 92 ++ .../cps/metadata_provider/douban.py | 260 ++++ .../cps/metadata_provider/google.py | 129 ++ .../cps/metadata_provider/hardcover.py | 255 ++++ .../cps/metadata_provider/lubimyczytac.py | 359 +++++ .../cps/metadata_provider/scholar.py | 83 ++ root/app/calibre-web/cps/search_metadata.py | 139 ++ root/app/calibre-web/cps/services/Metadata.py | 112 ++ root/app/calibre-web/cps/services/__init__.py | 56 + .../app/calibre-web/cps/services/hardcover.py | 232 +++ root/app/calibre-web/cps/shelf.py | 492 +++++++ root/app/calibre-web/cps/static/css/style.css | 2 +- .../cps/templates/config_edit.html | 438 ++++++ .../app/calibre-web/cps/templates/detail.html | 377 +++++ .../calibre-web/cps/templates/user_edit.html | 189 +++ root/app/calibre-web/cps/ub.py | 778 ++++++++++ root/app/calibre-web/cps/web.py | 13 +- 22 files changed, 7118 insertions(+), 5 deletions(-) create mode 100644 root/app/calibre-web/cps/config_sql.py create mode 100644 root/app/calibre-web/cps/db.py create mode 100644 root/app/calibre-web/cps/kobo.py create mode 100644 root/app/calibre-web/cps/metadata_provider/amazon.py create mode 100644 root/app/calibre-web/cps/metadata_provider/comicvine.py create mode 100644 root/app/calibre-web/cps/metadata_provider/douban.py create mode 100644 root/app/calibre-web/cps/metadata_provider/google.py create mode 100644 root/app/calibre-web/cps/metadata_provider/hardcover.py create mode 100644 root/app/calibre-web/cps/metadata_provider/lubimyczytac.py create mode 100644 root/app/calibre-web/cps/metadata_provider/scholar.py create mode 100644 root/app/calibre-web/cps/search_metadata.py create mode 100644 root/app/calibre-web/cps/services/Metadata.py create mode 100644 root/app/calibre-web/cps/services/__init__.py create mode 100644 root/app/calibre-web/cps/services/hardcover.py create mode 100644 root/app/calibre-web/cps/shelf.py create mode 100644 root/app/calibre-web/cps/templates/config_edit.html create mode 100644 root/app/calibre-web/cps/templates/detail.html create mode 100644 root/app/calibre-web/cps/templates/user_edit.html create mode 100644 root/app/calibre-web/cps/ub.py diff --git a/root/app/calibre-web/cps/admin.py b/root/app/calibre-web/cps/admin.py index a04d555..41f853f 100644 --- a/root/app/calibre-web/cps/admin.py +++ b/root/app/calibre-web/cps/admin.py @@ -62,6 +62,7 @@ feature_support = { 'ldap': bool(services.ldap), 'goodreads': bool(services.goodreads_support), 'kobo': bool(services.kobo), + 'hardcover' : bool(services.hardcover), 'updater': constants.UPDATER_AVAILABLE, 'gmail': bool(services.gmail), 'scheduler': schedule.use_APScheduler, @@ -1831,6 +1832,7 @@ def _configuration_update_helper(): reboot_required |= _config_checkbox_int(to_save, "config_kobo_sync") _config_int(to_save, "config_external_port") _config_checkbox_int(to_save, "config_kobo_proxy") + _config_checkbox_int(to_save, "config_hardcover_sync") if "config_upload_formats" in to_save: to_save["config_upload_formats"] = ','.join( diff --git a/root/app/calibre-web/cps/config_sql.py b/root/app/calibre-web/cps/config_sql.py new file mode 100644 index 0000000..d0164a4 --- /dev/null +++ b/root/app/calibre-web/cps/config_sql.py @@ -0,0 +1,588 @@ +# -*- coding: utf-8 -*- + +# This file is part of the Calibre-Web (https://github.com/janeczku/calibre-web) +# Copyright (C) 2019 OzzieIsaacs, pwr +# +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . + +import os +import sys +import json + +from sqlalchemy import Column, String, Integer, SmallInteger, Boolean, BLOB, JSON +from sqlalchemy.exc import OperationalError +from sqlalchemy.sql.expression import text +from sqlalchemy import exists +from cryptography.fernet import Fernet +import cryptography.exceptions +from base64 import urlsafe_b64decode +try: + # Compatibility with sqlalchemy 2.0 + from sqlalchemy.orm import declarative_base +except ImportError: + from sqlalchemy.ext.declarative import declarative_base + +from . import constants, logger +from .subproc_wrapper import process_wait +from .string_helper import strip_whitespaces + +log = logger.create() +_Base = declarative_base() + + +class _Flask_Settings(_Base): + __tablename__ = 'flask_settings' + + id = Column(Integer, primary_key=True) + flask_session_key = Column(BLOB, default=b"") + + def __init__(self, key): + super().__init__() + self.flask_session_key = key + + +# Baseclass for representing settings in app.db with email server settings and Calibre database settings +# (application settings) +class _Settings(_Base): + __tablename__ = 'settings' + + id = Column(Integer, primary_key=True) + mail_server = Column(String, default=constants.DEFAULT_MAIL_SERVER) + mail_port = Column(Integer, default=25) + mail_use_ssl = Column(SmallInteger, default=0) + mail_login = Column(String, default='mail@example.com') + mail_password_e = Column(String) + mail_password = Column(String) + mail_from = Column(String, default='automailer ') + mail_size = Column(Integer, default=25*1024*1024) + mail_server_type = Column(SmallInteger, default=0) + mail_gmail_token = Column(JSON, default={}) + + config_calibre_dir = Column(String) + config_calibre_uuid = Column(String) + config_calibre_split = Column(Boolean, default=False) + config_calibre_split_dir = Column(String) + config_port = Column(Integer, default=constants.DEFAULT_PORT) + config_external_port = Column(Integer, default=constants.DEFAULT_PORT) + config_certfile = Column(String) + config_keyfile = Column(String) + config_trustedhosts = Column(String, default='') + config_calibre_web_title = Column(String, default='Calibre-Web') + config_books_per_page = Column(Integer, default=60) + config_random_books = Column(Integer, default=4) + config_authors_max = Column(Integer, default=0) + config_read_column = Column(Integer, default=0) + config_title_regex = Column(String, + default=r'^(A|The|An|Der|Die|Das|Den|Ein|Eine' + r'|Einen|Dem|Des|Einem|Eines|Le|La|Les|L\'|Un|Une)\s+') + config_theme = Column(Integer, default=0) + + config_log_level = Column(SmallInteger, default=logger.DEFAULT_LOG_LEVEL) + config_logfile = Column(String, default=logger.DEFAULT_LOG_FILE) + config_access_log = Column(SmallInteger, default=0) + config_access_logfile = Column(String, default=logger.DEFAULT_ACCESS_LOG) + + config_uploading = Column(SmallInteger, default=0) + config_anonbrowse = Column(SmallInteger, default=0) + config_public_reg = Column(SmallInteger, default=0) + config_remote_login = Column(Boolean, default=False) + config_kobo_sync = Column(Boolean, default=False) + config_hardcover_sync = Column(Boolean, default=False) + + config_default_role = Column(SmallInteger, default=0) + config_default_show = Column(SmallInteger, default=constants.ADMIN_USER_SIDEBAR) + config_default_language = Column(String(3), default="all") + config_default_locale = Column(String(2), default="en") + config_columns_to_ignore = Column(String) + + config_denied_tags = Column(String, default="") + config_allowed_tags = Column(String, default="") + config_restricted_column = Column(SmallInteger, default=0) + config_denied_column_value = Column(String, default="") + config_allowed_column_value = Column(String, default="") + + config_use_google_drive = Column(Boolean, default=False) + config_google_drive_folder = Column(String) + config_google_drive_watch_changes_response = Column(JSON, default={}) + + config_use_goodreads = Column(Boolean, default=False) + config_goodreads_api_key = Column(String) + config_register_email = Column(Boolean, default=False) + config_login_type = Column(Integer, default=0) + + config_kobo_proxy = Column(Boolean, default=False) + + config_ldap_provider_url = Column(String, default='example.org') + config_ldap_port = Column(SmallInteger, default=389) + config_ldap_authentication = Column(SmallInteger, default=constants.LDAP_AUTH_SIMPLE) + config_ldap_serv_username = Column(String, default='cn=admin,dc=example,dc=org') + config_ldap_serv_password_e = Column(String) + config_ldap_serv_password = Column(String) + config_ldap_encryption = Column(SmallInteger, default=0) + config_ldap_cacert_path = Column(String, default="") + config_ldap_cert_path = Column(String, default="") + config_ldap_key_path = Column(String, default="") + config_ldap_dn = Column(String, default='dc=example,dc=org') + config_ldap_user_object = Column(String, default='uid=%s') + config_ldap_member_user_object = Column(String, default='') + config_ldap_openldap = Column(Boolean, default=True) + config_ldap_group_object_filter = Column(String, default='(&(objectclass=posixGroup)(cn=%s))') + config_ldap_group_members_field = Column(String, default='memberUid') + config_ldap_group_name = Column(String, default='calibreweb') + + config_kepubifypath = Column(String, default=None) + config_converterpath = Column(String, default=None) + config_binariesdir = Column(String, default=None) + config_calibre = Column(String) + config_rarfile_location = Column(String, default=None) + config_upload_formats = Column(String, default=','.join(constants.EXTENSIONS_UPLOAD)) + config_unicode_filename = Column(Boolean, default=False) + config_embed_metadata = Column(Boolean, default=True) + + config_updatechannel = Column(Integer, default=constants.UPDATE_STABLE) + + config_reverse_proxy_login_header_name = Column(String) + config_allow_reverse_proxy_header_login = Column(Boolean, default=False) + + schedule_start_time = Column(Integer, default=4) + schedule_duration = Column(Integer, default=10) + schedule_generate_book_covers = Column(Boolean, default=False) + schedule_generate_series_covers = Column(Boolean, default=False) + schedule_reconnect = Column(Boolean, default=False) + schedule_metadata_backup = Column(Boolean, default=False) + + config_password_policy = Column(Boolean, default=True) + config_password_min_length = Column(Integer, default=8) + config_password_number = Column(Boolean, default=True) + config_password_lower = Column(Boolean, default=True) + config_password_upper = Column(Boolean, default=True) + config_password_character = Column(Boolean, default=True) + config_password_special = Column(Boolean, default=True) + config_session = Column(Integer, default=1) + config_ratelimiter = Column(Boolean, default=True) + config_limiter_uri = Column(String, default="") + config_limiter_options = Column(String, default="") + config_check_extensions = Column(Boolean, default=True) + + def __repr__(self): + return self.__class__.__name__ + + +# Class holds all application specific settings in calibre-web +class ConfigSQL(object): + # pylint: disable=no-member + def __init__(self): + self.__dict__["dirty"] = list() + + def init_config(self, session, secret_key, cli): + self._session = session + self._settings = None + self.db_configured = None + self.config_calibre_dir = None + self._fernet = Fernet(secret_key) + self.cli = cli + self.load() + + change = False + + if self.config_binariesdir is None: + change = True + self.config_binariesdir = autodetect_calibre_binaries() + self.config_converterpath = autodetect_converter_binary(self.config_binariesdir) + + if self.config_kepubifypath is None: + change = True + self.config_kepubifypath = autodetect_kepubify_binary() + + if self.config_rarfile_location is None: + change = True + self.config_rarfile_location = autodetect_unrar_binary() + if change: + self.save() + + def _read_from_storage(self): + if self._settings is None: + log.debug("_ConfigSQL._read_from_storage") + self._settings = self._session.query(_Settings).first() + return self._settings + + def get_config_certfile(self): + if self.cli.certfilepath: + return self.cli.certfilepath + if self.cli.certfilepath == "": + return None + return self.config_certfile + + def get_config_keyfile(self): + if self.cli.keyfilepath: + return self.cli.keyfilepath + if self.cli.certfilepath == "": + return None + return self.config_keyfile + + def get_config_ipaddress(self): + return self.cli.ip_address or "" + + def _has_role(self, role_flag): + return constants.has_flag(self.config_default_role, role_flag) + + def role_admin(self): + return self._has_role(constants.ROLE_ADMIN) + + def role_download(self): + return self._has_role(constants.ROLE_DOWNLOAD) + + def role_viewer(self): + return self._has_role(constants.ROLE_VIEWER) + + def role_upload(self): + return self._has_role(constants.ROLE_UPLOAD) + + def role_edit(self): + return self._has_role(constants.ROLE_EDIT) + + def role_passwd(self): + return self._has_role(constants.ROLE_PASSWD) + + def role_edit_shelfs(self): + return self._has_role(constants.ROLE_EDIT_SHELFS) + + def role_delete_books(self): + return self._has_role(constants.ROLE_DELETE_BOOKS) + + def show_element_new_user(self, value): + return constants.has_flag(self.config_default_show, value) + + def show_detail_random(self): + return self.show_element_new_user(constants.DETAIL_RANDOM) + + def list_denied_tags(self): + mct = self.config_denied_tags or "" + return [strip_whitespaces(t) for t in mct.split(",")] + + def list_allowed_tags(self): + mct = self.config_allowed_tags or "" + return [strip_whitespaces(t) for t in mct.split(",")] + + def list_denied_column_values(self): + mct = self.config_denied_column_value or "" + return [strip_whitespaces(t) for t in mct.split(",")] + + def list_allowed_column_values(self): + mct = self.config_allowed_column_value or "" + return [strip_whitespaces(t) for t in mct.split(",")] + + def get_log_level(self): + return logger.get_level_name(self.config_log_level) + + def get_mail_settings(self): + return {k: v for k, v in self.__dict__.items() if k.startswith('mail_')} + + def get_mail_server_configured(self): + return bool((self.mail_server != constants.DEFAULT_MAIL_SERVER and self.mail_server_type == 0) + or (self.mail_gmail_token != {} and self.mail_server_type == 1)) + + def get_scheduled_task_settings(self): + return {k: v for k, v in self.__dict__.items() if k.startswith('schedule_')} + + def set_from_dictionary(self, dictionary, field, convertor=None, default=None, encode=None): + """Possibly updates a field of this object. + The new value, if present, is grabbed from the given dictionary, and optionally passed through a convertor. + + :returns: `True` if the field has changed value + """ + new_value = dictionary.get(field, default) + if new_value is None: + return False + + if field not in self.__dict__: + log.warning("_ConfigSQL trying to set unknown field '%s' = %r", field, new_value) + return False + + if convertor is not None: + if encode: + new_value = convertor(new_value.encode(encode)) + else: + new_value = convertor(new_value) + + current_value = self.__dict__.get(field) + if current_value == new_value: + return False + + setattr(self, field, new_value) + return True + + def to_dict(self): + storage = {} + for k, v in self.__dict__.items(): + if k[0] != '_' and not k.endswith("_e") and not k == "cli": + storage[k] = v + return storage + + def load(self): + """Load all configuration values from the underlying storage.""" + s = self._read_from_storage() # type: _Settings + for k, v in s.__dict__.items(): + if k[0] != '_': + if v is None: + # if the storage column has no value, apply the (possible) default + column = s.__class__.__dict__.get(k) + if column.default is not None: + v = column.default.arg + if k.endswith("_e") and v is not None: + try: + setattr(self, k, self._fernet.decrypt(v).decode()) + except cryptography.fernet.InvalidToken: + setattr(self, k, "") + else: + setattr(self, k, v) + + have_metadata_db = bool(self.config_calibre_dir) + if have_metadata_db: + db_file = os.path.join(self.config_calibre_dir, 'metadata.db') + have_metadata_db = os.path.isfile(db_file) + self.db_configured = have_metadata_db + + from . import cli_param + if os.environ.get('FLASK_DEBUG'): + logfile = logger.setup(logger.LOG_TO_STDOUT, logger.logging.DEBUG) + else: + # pylint: disable=access-member-before-definition + logfile = logger.setup(cli_param.logpath or self.config_logfile, self.config_log_level) + if logfile != os.path.abspath(self.config_logfile): + if logfile != os.path.abspath(cli_param.logpath): + log.warning("Log path %s not valid, falling back to default", self.config_logfile) + self.config_logfile = logfile + s.config_logfile = logfile + self._session.merge(s) + try: + self._session.commit() + except OperationalError as e: + log.error('Database error: %s', e) + self._session.rollback() + self.__dict__["dirty"] = list() + + def save(self): + """Apply all configuration values to the underlying storage.""" + s = self._read_from_storage() # type: _Settings + + for k in self.dirty: + if k[0] == '_': + continue + if hasattr(s, k): + if k.endswith("_e"): + setattr(s, k, self._fernet.encrypt(self.__dict__[k].encode())) + else: + setattr(s, k, self.__dict__[k]) + + log.debug("_ConfigSQL updating storage") + self._session.merge(s) + try: + self._session.commit() + except OperationalError as e: + log.error('Database error: %s', e) + self._session.rollback() + self.load() + + def invalidate(self, error=None): + if error: + log.error(error) + log.warning("invalidating configuration") + self.db_configured = False + self.save() + + def get_book_path(self): + return self.config_calibre_split_dir if self.config_calibre_split_dir else self.config_calibre_dir + + def store_calibre_uuid(self, calibre_db, Library_table): + from . import app + try: + with app.app_context(): + calibre_uuid = calibre_db.session.query(Library_table).one_or_none() + if self.config_calibre_uuid != calibre_uuid.uuid: + self.config_calibre_uuid = calibre_uuid.uuid + self.save() + except AttributeError: + pass + + def __setattr__(self, attr_name, attr_value): + super().__setattr__(attr_name, attr_value) + self.__dict__["dirty"].append(attr_name) + + +def _encrypt_fields(session, secret_key): + try: + session.query(exists().where(_Settings.mail_password_e)).scalar() + except OperationalError: + with session.bind.connect() as conn: + conn.execute(text("ALTER TABLE settings ADD column 'mail_password_e' String")) + conn.execute(text("ALTER TABLE settings ADD column 'config_ldap_serv_password_e' String")) + session.commit() + crypter = Fernet(secret_key) + settings = session.query(_Settings.mail_password, _Settings.config_ldap_serv_password).first() + if settings.mail_password: + session.query(_Settings).update( + {_Settings.mail_password_e: crypter.encrypt(settings.mail_password.encode())}) + if settings.config_ldap_serv_password: + session.query(_Settings).update( + {_Settings.config_ldap_serv_password_e: crypter.encrypt(settings.config_ldap_serv_password.encode())}) + session.commit() + + +def _migrate_table(session, orm_class, secret_key=None): + if secret_key: + _encrypt_fields(session, secret_key) + changed = False + + for column_name, column in orm_class.__dict__.items(): + if column_name[0] != '_': + try: + session.query(column).first() + except OperationalError as err: + log.debug("%s: %s", column_name, err.args[0]) + if column.default is None: + column_default = "" + else: + if isinstance(column.default.arg, bool): + column_default = "DEFAULT {}".format(int(column.default.arg)) + else: + column_default = "DEFAULT `{}`".format(column.default.arg) + if isinstance(column.type, JSON): + column_type = "JSON" + else: + column_type = column.type + alter_table = text("ALTER TABLE %s ADD COLUMN `%s` %s %s" % (orm_class.__tablename__, + column_name, + column_type, + column_default)) + log.debug(alter_table) + session.execute(alter_table) + changed = True + except json.decoder.JSONDecodeError as e: + log.error("Database corrupt column: {}".format(column_name)) + log.debug(e) + + if changed: + try: + session.commit() + except OperationalError: + session.rollback() + + +def autodetect_calibre_binaries(): + if sys.platform == "win32": + calibre_path = ["C:\\program files\\calibre\\", + "C:\\program files(x86)\\calibre\\", + "C:\\program files(x86)\\calibre2\\", + "C:\\program files\\calibre2\\"] + elif sys.platform.startswith("freebsd"): + calibre_path = ["/usr/local/bin/"] + else: + calibre_path = ["/opt/calibre/"] + for element in calibre_path: + supported_binary_paths = [os.path.join(element, binary) + for binary in constants.SUPPORTED_CALIBRE_BINARIES.values()] + if all(os.path.isfile(binary_path) and os.access(binary_path, os.X_OK) + for binary_path in supported_binary_paths): + values = [process_wait([binary_path, "--version"], + pattern=r'\(calibre (.*)\)') for binary_path in supported_binary_paths] + if all(values): + version = values[0].group(1) + log.debug("calibre version %s", version) + return element + return "" + + +def autodetect_converter_binary(calibre_path): + if sys.platform == "win32": + converter_path = os.path.join(calibre_path, "ebook-convert.exe") + else: + converter_path = os.path.join(calibre_path, "ebook-convert") + if calibre_path and os.path.isfile(converter_path) and os.access(converter_path, os.X_OK): + return converter_path + return "" + + +def autodetect_unrar_binary(): + if sys.platform == "win32": + calibre_path = ["C:\\program files\\WinRar\\unRAR.exe", + "C:\\program files(x86)\\WinRar\\unRAR.exe"] + elif sys.platform.startswith("freebsd"): + calibre_path = ["/usr/local/bin/unrar"] + else: + calibre_path = ["/usr/bin/unrar"] + for element in calibre_path: + if os.path.isfile(element) and os.access(element, os.X_OK): + return element + return "" + + +def autodetect_kepubify_binary(): + if sys.platform == "win32": + calibre_path = ["C:\\program files\\kepubify\\kepubify-windows-64Bit.exe", + "C:\\program files(x86)\\kepubify\\kepubify-windows-64Bit.exe"] + elif sys.platform.startswith("freebsd"): + calibre_path = ["/usr/local/bin/kepubify"] + else: + calibre_path = ["/opt/kepubify/kepubify-linux-64bit", "/opt/kepubify/kepubify-linux-32bit"] + for element in calibre_path: + if os.path.isfile(element) and os.access(element, os.X_OK): + return element + return "" + + +def _migrate_database(session, secret_key): + # make sure the table is created, if it does not exist + _Base.metadata.create_all(session.bind) + _migrate_table(session, _Settings, secret_key) + _migrate_table(session, _Flask_Settings) + + +def load_configuration(session, secret_key): + _migrate_database(session, secret_key) + if not session.query(_Settings).count(): + session.add(_Settings()) + session.commit() + + +def get_flask_session_key(_session): + flask_settings = _session.query(_Flask_Settings).one_or_none() + if flask_settings is None: + flask_settings = _Flask_Settings(os.urandom(32)) + _session.add(flask_settings) + _session.commit() + return flask_settings.flask_session_key + + +def get_encryption_key(key_path): + key_file = os.path.join(key_path, ".key") + generate = True + error = "" + key = None + if os.path.exists(key_file) and os.path.getsize(key_file) > 32: + with open(key_file, "rb") as f: + key = f.read() + try: + urlsafe_b64decode(key) + generate = False + except ValueError: + pass + if generate: + key = Fernet.generate_key() + try: + with open(key_file, "wb") as f: + f.write(key) + except PermissionError as e: + error = e + return key, error diff --git a/root/app/calibre-web/cps/db.py b/root/app/calibre-web/cps/db.py new file mode 100644 index 0000000..f379ceb --- /dev/null +++ b/root/app/calibre-web/cps/db.py @@ -0,0 +1,1101 @@ +# -*- coding: utf-8 -*- + +# This file is part of the Calibre-Web (https://github.com/janeczku/calibre-web) +# Copyright (C) 2012-2019 mutschler, cervinko, ok11, jkrehm, nanu-c, Wineliva, +# pjeby, elelay, idalin, Ozzieisaacs +# +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . + +import os +import re +import json +from datetime import datetime, timezone +from urllib.parse import quote +import unidecode +# from weakref import WeakSet +from uuid import uuid4 + +from sqlite3 import OperationalError as sqliteOperationalError +from sqlalchemy import create_engine +from sqlalchemy import Table, Column, ForeignKey, CheckConstraint +from sqlalchemy import String, Integer, Boolean, TIMESTAMP, Float +from sqlalchemy.orm import relationship, sessionmaker, scoped_session +from sqlalchemy.orm.collections import InstrumentedList +from sqlalchemy.ext.declarative import DeclarativeMeta +from sqlalchemy.exc import OperationalError +try: + # Compatibility with sqlalchemy 2.0 + from sqlalchemy.orm import declarative_base +except ImportError: + from sqlalchemy.ext.declarative import declarative_base +from sqlalchemy.pool import StaticPool +from sqlalchemy.sql.expression import and_, true, false, text, func, or_ +from sqlalchemy.ext.associationproxy import association_proxy +from .cw_login import current_user +from flask_babel import gettext as _ +from flask_babel import get_locale +from flask import flash, g, Flask + +from . import logger, ub, isoLanguages +from .pagination import Pagination +from .string_helper import strip_whitespaces + +log = logger.create() + +cc_exceptions = ['composite', 'series'] +cc_classes = {} + +Base = declarative_base() + +books_authors_link = Table('books_authors_link', Base.metadata, + Column('book', Integer, ForeignKey('books.id'), primary_key=True), + Column('author', Integer, ForeignKey('authors.id'), primary_key=True) + ) + +books_tags_link = Table('books_tags_link', Base.metadata, + Column('book', Integer, ForeignKey('books.id'), primary_key=True), + Column('tag', Integer, ForeignKey('tags.id'), primary_key=True) + ) + +books_series_link = Table('books_series_link', Base.metadata, + Column('book', Integer, ForeignKey('books.id'), primary_key=True), + Column('series', Integer, ForeignKey('series.id'), primary_key=True) + ) + +books_ratings_link = Table('books_ratings_link', Base.metadata, + Column('book', Integer, ForeignKey('books.id'), primary_key=True), + Column('rating', Integer, ForeignKey('ratings.id'), primary_key=True) + ) + +books_languages_link = Table('books_languages_link', Base.metadata, + Column('book', Integer, ForeignKey('books.id'), primary_key=True), + Column('lang_code', Integer, ForeignKey('languages.id'), primary_key=True) + ) + +books_publishers_link = Table('books_publishers_link', Base.metadata, + Column('book', Integer, ForeignKey('books.id'), primary_key=True), + Column('publisher', Integer, ForeignKey('publishers.id'), primary_key=True) + ) + + +class Library_Id(Base): + __tablename__ = 'library_id' + id = Column(Integer, primary_key=True) + uuid = Column(String, nullable=False) + + +class Identifiers(Base): + __tablename__ = 'identifiers' + + id = Column(Integer, primary_key=True) + type = Column(String(collation='NOCASE'), nullable=False, default="isbn") + val = Column(String(collation='NOCASE'), nullable=False) + book = Column(Integer, ForeignKey('books.id'), nullable=False) + amazon = { + "jp": "co.jp", + "uk": "co.uk", + "us": "com", + "au": "com.au", + "be": "com.be", + "br": "com.br", + "tr": "com.tr", + "mx": "com.mx", + } + + def __init__(self, val, id_type, book): + super().__init__() + self.val = val + self.type = id_type + self.book = book + + def format_type(self): + format_type = self.type.lower() + if format_type == 'amazon': + return "Amazon" + elif format_type.startswith("amazon_"): + label_amazon = "Amazon.{0}" + country_code = format_type[7:].lower() + if country_code not in self.amazon: + return label_amazon.format(country_code) + return label_amazon.format(self.amazon[country_code]) + elif format_type == "isbn": + return "ISBN" + elif format_type == "doi": + return "DOI" + elif format_type == "douban": + return "Douban" + elif format_type == "goodreads": + return "Goodreads" + elif format_type == "babelio": + return "Babelio" + elif format_type == "google": + return "Google Books" + elif format_type == "kobo": + return "Kobo" + elif format_type == "barnesnoble": + return "Barnes & Noble" + elif format_type == "litres": + return "ЛитРес" + elif format_type == "issn": + return "ISSN" + elif format_type == "isfdb": + return "ISFDB" + if format_type == "lubimyczytac": + return "Lubimyczytac" + if format_type == "databazeknih": + return "Databáze knih" + if format_type == "hardcover-slug": + return "Hardcover" + else: + return self.type + + def __repr__(self): + format_type = self.type.lower() + if format_type == "amazon" or format_type == "asin": + return "https://amazon.com/dp/{0}".format(self.val) + elif format_type.startswith('amazon_'): + link_amazon = "https://amazon.{0}/dp/{1}" + country_code = format_type[7:].lower() + if country_code not in self.amazon: + return link_amazon.format(country_code, self.val) + return link_amazon.format(self.amazon[country_code], self.val) + elif format_type == "isbn": + return "https://www.worldcat.org/isbn/{0}".format(self.val) + elif format_type == "doi": + return "https://dx.doi.org/{0}".format(self.val) + elif format_type == "goodreads": + return "https://www.goodreads.com/book/show/{0}".format(self.val) + elif format_type == "babelio": + return "https://www.babelio.com/livres/titre/{0}".format(self.val) + elif format_type == "douban": + return "https://book.douban.com/subject/{0}".format(self.val) + elif format_type == "google": + return "https://books.google.com/books?id={0}".format(self.val) + elif format_type == "kobo": + return "https://www.kobo.com/ebook/{0}".format(self.val) + elif format_type == "barnesnoble": + return "https://www.barnesandnoble.com/w/{0}".format(self.val) + elif format_type == "lubimyczytac": + return "https://lubimyczytac.pl/ksiazka/{0}/ksiazka".format(self.val) + elif format_type == "litres": + return "https://www.litres.ru/{0}".format(self.val) + elif format_type == "issn": + return "https://portal.issn.org/resource/ISSN/{0}".format(self.val) + elif format_type == "isfdb": + return "http://www.isfdb.org/cgi-bin/pl.cgi?{0}".format(self.val) + elif format_type == "databazeknih": + return "https://www.databazeknih.cz/knihy/{0}".format(self.val) + elif format_type == "hardcover-slug": + return "https://hardcover.app/books/{0}".format(self.val) + elif self.val.lower().startswith("javascript:"): + return quote(self.val) + elif self.val.lower().startswith("data:"): + link, __, __ = str.partition(self.val, ",") + return link + else: + return "{0}".format(self.val) + + +class Comments(Base): + __tablename__ = 'comments' + + id = Column(Integer, primary_key=True) + book = Column(Integer, ForeignKey('books.id'), nullable=False, unique=True) + text = Column(String(collation='NOCASE'), nullable=False) + + def __init__(self, comment, book): + super().__init__() + self.text = comment + self.book = book + + def get(self): + return self.text + + def __repr__(self): + return "".format(self.text) + + +class Tags(Base): + __tablename__ = 'tags' + + id = Column(Integer, primary_key=True, autoincrement=True) + name = Column(String(collation='NOCASE'), unique=True, nullable=False) + + def __init__(self, name): + super().__init__() + self.name = name + + def get(self): + return self.name + + def __eq__(self, other): + return self.name == other + + def __repr__(self): + return "".format(self.name) + + +class Authors(Base): + __tablename__ = 'authors' + + id = Column(Integer, primary_key=True) + name = Column(String(collation='NOCASE'), unique=True, nullable=False) + sort = Column(String(collation='NOCASE')) + link = Column(String, nullable=False, default="") + + def __init__(self, name, sort, link=""): + super().__init__() + self.name = name + self.sort = sort + self.link = link + + def get(self): + return self.name + + def __eq__(self, other): + return self.name == other + + def __repr__(self): + return "".format(self.name, self.sort, self.link) + + +class Series(Base): + __tablename__ = 'series' + + id = Column(Integer, primary_key=True) + name = Column(String(collation='NOCASE'), unique=True, nullable=False) + sort = Column(String(collation='NOCASE')) + + def __init__(self, name, sort): + super().__init__() + self.name = name + self.sort = sort + + def get(self): + return self.name + + def __eq__(self, other): + return self.name == other + + def __repr__(self): + return "".format(self.name, self.sort) + + +class Ratings(Base): + __tablename__ = 'ratings' + + id = Column(Integer, primary_key=True) + rating = Column(Integer, CheckConstraint('rating>-1 AND rating<11'), unique=True) + + def __init__(self, rating): + super().__init__() + self.rating = rating + + def get(self): + return self.rating + + def __eq__(self, other): + return self.rating == other + + def __repr__(self): + return "".format(self.rating) + + +class Languages(Base): + __tablename__ = 'languages' + + id = Column(Integer, primary_key=True) + lang_code = Column(String(collation='NOCASE'), nullable=False, unique=True) + + def __init__(self, lang_code): + super().__init__() + self.lang_code = lang_code + + def get(self): + if hasattr(self, "language_name"): + return self.language_name + else: + return self.lang_code + + def __eq__(self, other): + return self.lang_code == other + + def __repr__(self): + return "".format(self.lang_code) + + +class Publishers(Base): + __tablename__ = 'publishers' + + id = Column(Integer, primary_key=True) + name = Column(String(collation='NOCASE'), nullable=False, unique=True) + sort = Column(String(collation='NOCASE')) + + def __init__(self, name, sort): + super().__init__() + self.name = name + self.sort = sort + + def get(self): + return self.name + + def __eq__(self, other): + return self.name == other + + def __repr__(self): + return "".format(self.name, self.sort) + + +class Data(Base): + __tablename__ = 'data' + __table_args__ = {'schema': 'calibre'} + + id = Column(Integer, primary_key=True) + book = Column(Integer, ForeignKey('books.id'), nullable=False) + format = Column(String(collation='NOCASE'), nullable=False) + uncompressed_size = Column(Integer, nullable=False) + name = Column(String, nullable=False) + + def __init__(self, book, book_format, uncompressed_size, name): + super().__init__() + self.book = book + self.format = book_format + self.uncompressed_size = uncompressed_size + self.name = name + + # ToDo: Check + def get(self): + return self.name + + def __repr__(self): + return "".format(self.book, self.format, self.uncompressed_size, self.name) + + +class Metadata_Dirtied(Base): + __tablename__ = 'metadata_dirtied' + id = Column(Integer, primary_key=True, autoincrement=True) + book = Column(Integer, ForeignKey('books.id'), nullable=False, unique=True) + + def __init__(self, book): + super().__init__() + self.book = book + + +class Books(Base): + __tablename__ = 'books' + + DEFAULT_PUBDATE = datetime(101, 1, 1, 0, 0, 0, 0) # ("0101-01-01 00:00:00+00:00") + + id = Column(Integer, primary_key=True, autoincrement=True) + title = Column(String(collation='NOCASE'), nullable=False, default='Unknown') + sort = Column(String(collation='NOCASE')) + author_sort = Column(String(collation='NOCASE')) + timestamp = Column(TIMESTAMP, default=lambda: datetime.now(timezone.utc)) + pubdate = Column(TIMESTAMP, default=DEFAULT_PUBDATE) + series_index = Column(String, nullable=False, default="1.0") + last_modified = Column(TIMESTAMP, default=lambda: datetime.now(timezone.utc)) + path = Column(String, default="", nullable=False) + has_cover = Column(Integer, default=0) + uuid = Column(String) + isbn = Column(String(collation='NOCASE'), default="") + flags = Column(Integer, nullable=False, default=1) + + authors = relationship(Authors, secondary=books_authors_link, backref='books') + tags = relationship(Tags, secondary=books_tags_link, backref='books', order_by="Tags.name") + comments = relationship(Comments, backref='books') + data = relationship(Data, backref='books') + series = relationship(Series, secondary=books_series_link, backref='books') + ratings = relationship(Ratings, secondary=books_ratings_link, backref='books') + languages = relationship(Languages, secondary=books_languages_link, backref='books') + publishers = relationship(Publishers, secondary=books_publishers_link, backref='books') + identifiers = relationship(Identifiers, backref='books') + + def __init__(self, title, sort, author_sort, timestamp, pubdate, series_index, last_modified, path, has_cover, + authors, tags, languages=None): + super().__init__() + self.title = title + self.sort = sort + self.author_sort = author_sort + self.timestamp = timestamp + self.pubdate = pubdate + self.series_index = series_index + self.last_modified = last_modified + self.path = path + self.has_cover = (has_cover is not None) + + def __repr__(self): + return "".format(self.title, self.sort, self.author_sort, + self.timestamp, self.pubdate, self.series_index, + self.last_modified, self.path, self.has_cover) + + @property + def atom_timestamp(self): + return self.timestamp.strftime('%Y-%m-%dT%H:%M:%S+00:00') or '' + + +class CustomColumns(Base): + __tablename__ = 'custom_columns' + + id = Column(Integer, primary_key=True) + label = Column(String) + name = Column(String) + datatype = Column(String) + mark_for_delete = Column(Boolean) + editable = Column(Boolean) + display = Column(String) + is_multiple = Column(Boolean) + normalized = Column(Boolean) + + def get_display_dict(self): + display_dict = json.loads(self.display) + return display_dict + + def to_json(self, value, extra, sequence): + content = dict() + content['table'] = "custom_column_" + str(self.id) + content['column'] = "value" + content['datatype'] = self.datatype + content['is_multiple'] = None if not self.is_multiple else "|" + content['kind'] = "field" + content['name'] = self.name + content['search_terms'] = ['#' + self.label] + content['label'] = self.label + content['colnum'] = self.id + content['display'] = self.get_display_dict() + content['is_custom'] = True + content['is_category'] = self.datatype in ['text', 'rating', 'enumeration', 'series'] + content['link_column'] = "value" + content['category_sort'] = "value" + content['is_csp'] = False + content['is_editable'] = self.editable + content['rec_index'] = sequence + 22 # toDo why ?? + if isinstance(value, datetime): + content['#value#'] = {"__class__": "datetime.datetime", + "__value__": value.strftime("%Y-%m-%dT%H:%M:%S+00:00")} + else: + content['#value#'] = value + content['#extra#'] = extra + content['is_multiple2'] = {} if not self.is_multiple else {"cache_to_list": "|", "ui_to_list": ",", + "list_to_ui": ", "} + return json.dumps(content, ensure_ascii=False) + + +class AlchemyEncoder(json.JSONEncoder): + + def default(self, o): + if isinstance(o.__class__, DeclarativeMeta): + # an SQLAlchemy class + fields = {} + for field in [x for x in dir(o) if not x.startswith('_') and x != 'metadata' and x != "password"]: + if field == 'books': + continue + data = o.__getattribute__(field) + try: + if isinstance(data, str): + data = data.replace("'", "\'") + elif isinstance(data, InstrumentedList): + el = list() + # ele = None + for ele in data: + if hasattr(ele, 'value'): # converter for custom_column values + el.append(str(ele.value)) + elif ele.get: + el.append(ele.get()) + else: + el.append(json.dumps(ele, cls=AlchemyEncoder)) + if field == 'authors': + data = " & ".join(el) + else: + data = ",".join(el) + if data == '[]': + data = "" + else: + json.dumps(data) + fields[field] = data + except Exception: + fields[field] = "" + # a json-encodable dict + return fields + + return json.JSONEncoder.default(self, o) + + +class CalibreDB: + config = None + config_calibre_dir = None + app_db_path = None + + def __init__(self, _app: Flask=None): # , expire_on_commit=True, init=False): + """ Initialize a new CalibreDB session + """ + self.Session = None + #if init: + # self.init_db(expire_on_commit) + if _app is not None and not _app._got_first_request: + self.init_app(_app) + + def init_app(self, _app): + _app.teardown_appcontext(self.teardown) + + @classmethod + def setup_db_cc_classes(cls, cc): + global cc_classes + cc_ids = [] + books_custom_column_links = {} + for row in cc: + if row.datatype not in cc_exceptions: + if row.datatype == 'series': + dicttable = {'__tablename__': 'books_custom_column_' + str(row.id) + '_link', + 'id': Column(Integer, primary_key=True), + 'book': Column(Integer, ForeignKey('books.id'), + primary_key=True), + 'map_value': Column('value', Integer, + ForeignKey('custom_column_' + + str(row.id) + '.id'), + primary_key=True), + 'extra': Column(Float), + 'asoc': relationship('custom_column_' + str(row.id), uselist=False), + 'value': association_proxy('asoc', 'value') + } + books_custom_column_links[row.id] = type(str('books_custom_column_' + str(row.id) + '_link'), + (Base,), dicttable) + if row.datatype in ['rating', 'text', 'enumeration']: + books_custom_column_links[row.id] = Table('books_custom_column_' + str(row.id) + '_link', + Base.metadata, + Column('book', Integer, ForeignKey('books.id'), + primary_key=True), + Column('value', Integer, + ForeignKey('custom_column_' + + str(row.id) + '.id'), + primary_key=True) + ) + cc_ids.append([row.id, row.datatype]) + + ccdict = {'__tablename__': 'custom_column_' + str(row.id), + 'id': Column(Integer, primary_key=True)} + if row.datatype == 'float': + ccdict['value'] = Column(Float) + elif row.datatype == 'int': + ccdict['value'] = Column(Integer) + elif row.datatype == 'datetime': + ccdict['value'] = Column(TIMESTAMP) + elif row.datatype == 'bool': + ccdict['value'] = Column(Boolean) + else: + ccdict['value'] = Column(String) + if row.datatype in ['float', 'int', 'bool', 'datetime', 'comments']: + ccdict['book'] = Column(Integer, ForeignKey('books.id')) + cc_classes[row.id] = type(str('custom_column_' + str(row.id)), (Base,), ccdict) + + for cc_id in cc_ids: + if cc_id[1] in ['bool', 'int', 'float', 'datetime', 'comments']: + setattr(Books, + 'custom_column_' + str(cc_id[0]), + relationship(cc_classes[cc_id[0]], + primaryjoin=( + Books.id == cc_classes[cc_id[0]].book), + backref='books')) + elif cc_id[1] == 'series': + setattr(Books, + 'custom_column_' + str(cc_id[0]), + relationship(books_custom_column_links[cc_id[0]], + backref='books')) + else: + setattr(Books, + 'custom_column_' + str(cc_id[0]), + relationship(cc_classes[cc_id[0]], + secondary=books_custom_column_links[cc_id[0]], + backref='books')) + + @classmethod + def check_valid_db(cls, config_calibre_dir, app_db_path, config_calibre_uuid): + if not config_calibre_dir: + return False, False + dbpath = os.path.join(config_calibre_dir, "metadata.db") + if not os.path.exists(dbpath): + return False, False + try: + check_engine = create_engine('sqlite://', + echo=False, + isolation_level="SERIALIZABLE", + connect_args={'check_same_thread': False}, + poolclass=StaticPool) + with check_engine.begin() as connection: + connection.execute(text("attach database '{}' as calibre;".format(dbpath))) + connection.execute(text("attach database '{}' as app_settings;".format(app_db_path))) + local_session = scoped_session(sessionmaker()) + local_session.configure(bind=connection) + database_uuid = local_session().query(Library_Id).one_or_none() + + check_engine.connect() + db_change = config_calibre_uuid != database_uuid.uuid + except Exception: + return False, False + return True, db_change + + def teardown(self, exception): + ctx = g.get("lib_sql") + if ctx: + ctx.close() + + @property + def session(self): + # connect or get active connection + if not g.get("lib_sql"): + g.lib_sql = self.connect() + return g.lib_sql + + @classmethod + def update_config(cls, config, config_calibre_dir, app_db_path): + cls.config = config + cls.config_calibre_dir = config_calibre_dir + cls.app_db_path = app_db_path + + + def connect(self): + return self.setup_db(self.config_calibre_dir, self.app_db_path) + + @classmethod + def setup_db(cls, config_calibre_dir, app_db_path): + + if not config_calibre_dir: + cls.config.invalidate() + return None + + dbpath = os.path.join(config_calibre_dir, "metadata.db") + if not os.path.exists(dbpath): + cls.config.invalidate() + return None + + try: + engine = create_engine('sqlite://', + echo=False, + isolation_level="SERIALIZABLE", + connect_args={'check_same_thread': False}, + poolclass=StaticPool) + with engine.begin() as connection: + connection.execute(text('PRAGMA cache_size = 10000;')) + connection.execute(text("attach database '{}' as calibre;".format(dbpath))) + connection.execute(text("attach database '{}' as app_settings;".format(app_db_path))) + + conn = engine.connect() + # conn.text_factory = lambda b: b.decode(errors = 'ignore') possible fix for #1302 + except Exception as ex: + cls.config.invalidate(ex) + return None + + cls.config.db_configured = True + + if not cc_classes: + try: + cc = conn.execute(text("SELECT id, datatype FROM custom_columns")) + cls.setup_db_cc_classes(cc) + except OperationalError as e: + log.error_or_exception(e) + return None + + return scoped_session(sessionmaker(autocommit=False, + autoflush=False, + bind=engine, future=True)) + + + def get_book(self, book_id): + return self.session.query(Books).filter(Books.id == book_id).first() + + def get_filtered_book(self, book_id, allow_show_archived=False): + return self.session.query(Books).filter(Books.id == book_id). \ + filter(self.common_filters(allow_show_archived)).first() + + def get_book_read_archived(self, book_id, read_column, allow_show_archived=False): + if not read_column: + bd = (self.session.query(Books, ub.ReadBook.read_status, ub.ArchivedBook.is_archived).select_from(Books) + .join(ub.ReadBook, and_(ub.ReadBook.user_id == int(current_user.id), ub.ReadBook.book_id == book_id), + isouter=True)) + else: + try: + read_column = cc_classes[read_column] + bd = (self.session.query(Books, read_column.value, ub.ArchivedBook.is_archived).select_from(Books) + .join(read_column, read_column.book == book_id, + isouter=True)) + except (KeyError, AttributeError, IndexError): + log.error("Custom Column No.{} does not exist in calibre database".format(read_column)) + # Skip linking read column and return None instead of read status + bd = self.session.query(Books, None, ub.ArchivedBook.is_archived) + return (bd.filter(Books.id == book_id) + .join(ub.ArchivedBook, and_(Books.id == ub.ArchivedBook.book_id, + int(current_user.id) == ub.ArchivedBook.user_id), isouter=True) + .filter(self.common_filters(allow_show_archived)).first()) + + def get_book_by_uuid(self, book_uuid): + return self.session.query(Books).filter(Books.uuid == book_uuid).first() + + def get_book_format(self, book_id, file_format): + return self.session.query(Data).filter(Data.book == book_id).filter(Data.format == file_format).first() + + def set_metadata_dirty(self, book_id): + if not self.session.query(Metadata_Dirtied).filter(Metadata_Dirtied.book == book_id).one_or_none(): + self.session.add(Metadata_Dirtied(book_id)) + + def delete_dirty_metadata(self, book_id): + try: + self.session.query(Metadata_Dirtied).filter(Metadata_Dirtied.book == book_id).delete() + self.session.commit() + except (OperationalError) as e: + self.session.rollback() + log.error("Database error: {}".format(e)) + + # Language and content filters for displaying in the UI + def common_filters(self, allow_show_archived=False, return_all_languages=False): + if not allow_show_archived: + archived_books = (ub.session.query(ub.ArchivedBook) + .filter(ub.ArchivedBook.user_id==int(current_user.id)) + .filter(ub.ArchivedBook.is_archived==True) + .all()) + archived_book_ids = [archived_book.book_id for archived_book in archived_books] + archived_filter = Books.id.notin_(archived_book_ids) + else: + archived_filter = true() + + if current_user.filter_language() == "all" or return_all_languages: + lang_filter = true() + else: + lang_filter = Books.languages.any(Languages.lang_code == current_user.filter_language()) + negtags_list = current_user.list_denied_tags() + postags_list = current_user.list_allowed_tags() + neg_content_tags_filter = false() if negtags_list == [''] else Books.tags.any(Tags.name.in_(negtags_list)) + pos_content_tags_filter = true() if postags_list == [''] else Books.tags.any(Tags.name.in_(postags_list)) + if self.config.config_restricted_column: + try: + pos_cc_list = current_user.allowed_column_value.split(',') + pos_content_cc_filter = true() if pos_cc_list == [''] else \ + getattr(Books, 'custom_column_' + str(self.config.config_restricted_column)). \ + any(cc_classes[self.config.config_restricted_column].value.in_(pos_cc_list)) + neg_cc_list = current_user.denied_column_value.split(',') + neg_content_cc_filter = false() if neg_cc_list == [''] else \ + getattr(Books, 'custom_column_' + str(self.config.config_restricted_column)). \ + any(cc_classes[self.config.config_restricted_column].value.in_(neg_cc_list)) + except (KeyError, AttributeError, IndexError): + pos_content_cc_filter = false() + neg_content_cc_filter = true() + log.error("Custom Column No.{} does not exist in calibre database".format( + self.config.config_restricted_column)) + flash(_("Custom Column No.%(column)d does not exist in calibre database", + column=self.config.config_restricted_column), + category="error") + + else: + pos_content_cc_filter = true() + neg_content_cc_filter = false() + return and_(lang_filter, pos_content_tags_filter, ~neg_content_tags_filter, + pos_content_cc_filter, ~neg_content_cc_filter, archived_filter) + + def generate_linked_query(self, config_read_column, database): + if not config_read_column: + query = (self.session.query(database, ub.ArchivedBook.is_archived, ub.ReadBook.read_status) + .select_from(Books) + .outerjoin(ub.ReadBook, + and_(ub.ReadBook.user_id == int(current_user.id), ub.ReadBook.book_id == Books.id))) + else: + try: + read_column = cc_classes[config_read_column] + query = (self.session.query(database, ub.ArchivedBook.is_archived, read_column.value) + .select_from(Books) + .outerjoin(read_column, read_column.book == Books.id)) + except (KeyError, AttributeError, IndexError): + log.error("Custom Column No.{} does not exist in calibre database".format(config_read_column)) + # Skip linking read column and return None instead of read status + query = self.session.query(database, None, ub.ArchivedBook.is_archived) + return query.outerjoin(ub.ArchivedBook, and_(Books.id == ub.ArchivedBook.book_id, + int(current_user.id) == ub.ArchivedBook.user_id)) + + @staticmethod + def get_checkbox_sorted(inputlist, state, offset, limit, order, combo=False): + outcome = list() + if combo: + elementlist = {ele[0].id: ele for ele in inputlist} + else: + elementlist = {ele.id: ele for ele in inputlist} + for entry in state: + try: + outcome.append(elementlist[entry]) + except KeyError: + pass + del elementlist[entry] + for entry in elementlist: + outcome.append(elementlist[entry]) + if order == "asc": + outcome.reverse() + return outcome[offset:offset + limit] + + # Fill indexpage with all requested data from database + def fill_indexpage(self, page, pagesize, database, db_filter, order, + join_archive_read=False, config_read_column=0, *join): + return self.fill_indexpage_with_archived_books(page, database, pagesize, db_filter, order, False, + join_archive_read, config_read_column, *join) + + def fill_indexpage_with_archived_books(self, page, database, pagesize, db_filter, order, allow_show_archived, + join_archive_read, config_read_column, *join): + pagesize = pagesize or self.config.config_books_per_page + if current_user.show_detail_random(): + random_query = self.generate_linked_query(config_read_column, database) + randm = (random_query.filter(self.common_filters(allow_show_archived)) + .order_by(func.random()) + .limit(self.config.config_random_books).all()) + else: + randm = false() + if join_archive_read: + query = self.generate_linked_query(config_read_column, database) + else: + query = self.session.query(database) + off = int(int(pagesize) * (page - 1)) + + indx = len(join) + element = 0 + while indx: + if indx >= 3: + query = query.outerjoin(join[element], join[element+1]).outerjoin(join[element+2]) + indx -= 3 + element += 3 + elif indx == 2: + query = query.outerjoin(join[element], join[element+1]) + indx -= 2 + element += 2 + elif indx == 1: + query = query.outerjoin(join[element]) + indx -= 1 + element += 1 + query = query.filter(db_filter)\ + .filter(self.common_filters(allow_show_archived)) + entries = list() + pagination = list() + try: + pagination = Pagination(page, pagesize, query.count()) + entries = query.order_by(*order).offset(off).limit(pagesize).all() + except Exception as ex: + log.error_or_exception(ex) + # display authors in right order + entries = self.order_authors(entries, True, join_archive_read) + return entries, randm, pagination + + # Orders all Authors in the list according to authors sort + def order_authors(self, entries, list_return=False, combined=False): + for entry in entries: + if combined: + sort_authors = entry.Books.author_sort.split('&') + ids = [a.id for a in entry.Books.authors] + + else: + sort_authors = entry.author_sort.split('&') + ids = [a.id for a in entry.authors] + authors_ordered = list() + # error = False + for auth in sort_authors: + auth = strip_whitespaces(auth) + results = self.session.query(Authors).filter(Authors.sort == auth).all() + # ToDo: How to handle not found author name + if not len(results): + log.error("Author {} not found to display name in right order".format(auth)) + # error = True + break + for r in results: + if r.id in ids: + authors_ordered.append(r) + ids.remove(r.id) + for author_id in ids: + result = self.session.query(Authors).filter(Authors.id == author_id).first() + authors_ordered.append(result) + + if list_return: + if combined: + entry.Books.authors = authors_ordered + else: + entry.ordered_authors = authors_ordered + else: + return authors_ordered + return entries + + def get_typeahead(self, database, query, replace=('', ''), tag_filter=true()): + query = query or '' + self.create_functions() + # self.session.connection().connection.connection.create_function("lower", 1, lcase) + entries = self.session.query(database).filter(tag_filter). \ + filter(func.lower(database.name).ilike("%" + query + "%")).all() + # json_dumps = json.dumps([dict(name=escape(r.name.replace(*replace))) for r in entries]) + json_dumps = json.dumps([dict(name=r.name.replace(*replace)) for r in entries]) + return json_dumps + + def check_exists_book(self, authr, title): + self.create_functions() + # self.session.connection().connection.connection.create_function("lower", 1, lcase) + q = list() + author_terms = re.split(r'\s*&\s*', authr) + for author_term in author_terms: + q.append(Books.authors.any(func.lower(Authors.name).ilike("%" + author_term + "%"))) + + return self.session.query(Books) \ + .filter(and_(Books.authors.any(and_(*q)), func.lower(Books.title).ilike("%" + title + "%"))).first() + + def search_query(self, term, config, *join): + strip_whitespaces(term).lower() + self.create_functions() + # self.session.connection().connection.connection.create_function("lower", 1, lcase) + q = list() + author_terms = re.split("[, ]+", term) + for author_term in author_terms: + q.append(Books.authors.any(func.lower(Authors.name).ilike("%" + author_term + "%"))) + query = self.generate_linked_query(config.config_read_column, Books) + if len(join) == 6: + query = query.outerjoin(join[0], join[1]).outerjoin(join[2]).outerjoin(join[3], join[4]).outerjoin(join[5]) + if len(join) == 3: + query = query.outerjoin(join[0], join[1]).outerjoin(join[2]) + elif len(join) == 2: + query = query.outerjoin(join[0], join[1]) + elif len(join) == 1: + query = query.outerjoin(join[0]) + + cc = self.get_cc_columns(config, filter_config_custom_read=True) + filter_expression = [Books.tags.any(func.lower(Tags.name).ilike("%" + term + "%")), + Books.series.any(func.lower(Series.name).ilike("%" + term + "%")), + Books.authors.any(and_(*q)), + Books.publishers.any(func.lower(Publishers.name).ilike("%" + term + "%")), + func.lower(Books.title).ilike("%" + term + "%")] + for c in cc: + if c.datatype not in ["datetime", "rating", "bool", "int", "float"]: + filter_expression.append( + getattr(Books, + 'custom_column_' + str(c.id)).any( + func.lower(cc_classes[c.id].value).ilike("%" + term + "%"))) + return query.filter(self.common_filters(True)).filter(or_(*filter_expression)) + + def get_cc_columns(self, config, filter_config_custom_read=False): + tmp_cc = self.session.query(CustomColumns).filter(CustomColumns.datatype.notin_(cc_exceptions)).all() + cc = [] + r = None + if config.config_columns_to_ignore: + r = re.compile(config.config_columns_to_ignore) + + for col in tmp_cc: + if filter_config_custom_read and config.config_read_column and config.config_read_column == col.id: + continue + if r and r.match(col.name): + continue + cc.append(col) + + return cc + + # read search results from calibre-database and return it (function is used for feed and simple search + def get_search_results(self, term, config, offset=None, order=None, limit=None, *join): + order = order[0] if order else [Books.sort] + pagination = None + result = self.search_query(term, config, *join).order_by(*order).all() + result_count = len(result) + if offset is not None and limit is not None: + offset = int(offset) + limit_all = offset + int(limit) + pagination = Pagination((offset / (int(limit)) + 1), limit, result_count) + else: + offset = 0 + limit_all = result_count + + ub.store_combo_ids(result) + entries = self.order_authors(result[offset:limit_all], list_return=True, combined=True) + + return entries, result_count, pagination + + # Creates for all stored languages a translated speaking name in the array for the UI + def speaking_language(self, languages=None, return_all_languages=False, with_count=False, reverse_order=False): + + if with_count: + if not languages: + languages = self.session.query(Languages, func.count('books_languages_link.book'))\ + .join(books_languages_link).join(Books)\ + .filter(self.common_filters(return_all_languages=return_all_languages)) \ + .group_by(text('books_languages_link.lang_code')).all() + tags = list() + for lang in languages: + tag = Category(isoLanguages.get_language_name(get_locale(), lang[0].lang_code), lang[0].lang_code) + tags.append([tag, lang[1]]) + # Append all books without language to list + if not return_all_languages: + no_lang_count = (self.session.query(Books) + .outerjoin(books_languages_link).outerjoin(Languages) + .filter(Languages.lang_code==None) + .filter(self.common_filters()) + .count()) + if no_lang_count: + tags.append([Category(_("None"), "none"), no_lang_count]) + return sorted(tags, key=lambda x: x[0].name.lower(), reverse=reverse_order) + else: + if not languages: + languages = self.session.query(Languages) \ + .join(books_languages_link) \ + .join(Books) \ + .filter(self.common_filters(return_all_languages=return_all_languages)) \ + .group_by(text('books_languages_link.lang_code')).all() + for lang in languages: + lang.name = isoLanguages.get_language_name(get_locale(), lang.lang_code) + return sorted(languages, key=lambda x: x.name, reverse=reverse_order) + + def create_functions(self, config=None): + # user defined sort function for calibre databases (Series, etc.) + def _title_sort(title): + # calibre sort stuff + title_pat = re.compile(config.config_title_regex, re.IGNORECASE) + match = title_pat.search(title) + if match: + prep = match.group(1) + title = title[len(prep):] + ', ' + prep + return strip_whitespaces(title) + + try: + # sqlalchemy <1.4.24 and sqlalchemy 2.0 + conn = self.session.connection().connection.driver_connection + except AttributeError: + # sqlalchemy >1.4.24 + conn = self.session.connection().connection.connection + try: + if config: + conn.create_function("title_sort", 1, _title_sort) + conn.create_function('uuid4', 0, lambda: str(uuid4())) + conn.create_function("lower", 1, lcase) + except sqliteOperationalError: + pass + + def reconnect_db(self, config, app_db_path): + # self.dispose() + # self.engine.dispose() + self.setup_db(config.config_calibre_dir, app_db_path) + self.update_config(config, config.config_calibre_dir, app_db_path) + + +def lcase(s): + try: + return unidecode.unidecode(s.lower()) + except Exception as ex: + _log = logger.create() + _log.error_or_exception(ex) + return s.lower() + + +class Category: + name = None + id = None + count = None + rating = None + + def __init__(self, name, cat_id, rating=None): + self.name = name + self.id = cat_id + self.rating = rating + self.count = 1 diff --git a/root/app/calibre-web/cps/kobo.py b/root/app/calibre-web/cps/kobo.py new file mode 100644 index 0000000..ff188ad --- /dev/null +++ b/root/app/calibre-web/cps/kobo.py @@ -0,0 +1,1286 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- + +# This file is part of the Calibre-Web (https://github.com/janeczku/calibre-web) +# Copyright (C) 2018-2019 shavitmichael, OzzieIsaacs +# +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . + +import base64 +from datetime import datetime, timezone +import os +import uuid +import zipfile +from time import gmtime, strftime +import json +from urllib.parse import unquote + +from flask import ( + Blueprint, + request, + make_response, + jsonify, + current_app, + url_for, + redirect, + abort +) +from .cw_login import current_user +from werkzeug.datastructures import Headers +from sqlalchemy import func +from sqlalchemy.sql.expression import and_, or_ +from sqlalchemy.exc import StatementError +from sqlalchemy.sql import select +import requests + +from . import config, logger, kobo_auth, db, calibre_db, helper, shelf as shelf_lib, ub, csrf, kobo_sync_status +from . import isoLanguages +from .epub import get_epub_layout +from .constants import COVER_THUMBNAIL_SMALL, COVER_THUMBNAIL_MEDIUM, COVER_THUMBNAIL_LARGE +from .helper import get_download_link +from .services import SyncToken as SyncToken, hardcover +from .web import download_required +from .kobo_auth import requires_kobo_auth, get_auth_token + +KOBO_FORMATS = {"KEPUB": ["KEPUB"], "EPUB": ["EPUB3", "EPUB"]} +KOBO_STOREAPI_URL = "https://storeapi.kobo.com" +KOBO_IMAGEHOST_URL = "https://cdn.kobo.com/book-images" + +SYNC_ITEM_LIMIT = 100 + +kobo = Blueprint("kobo", __name__, url_prefix="/kobo/") +kobo_auth.disable_failed_auth_redirect_for_blueprint(kobo) +kobo_auth.register_url_value_preprocessor(kobo) + +log = logger.create() + + +def get_store_url_for_current_request(): + # Programmatically modify the current url to point to the official Kobo store + __, __, request_path_with_auth_token = request.full_path.rpartition("/kobo/") + __, __, request_path = request_path_with_auth_token.rstrip("?").partition( + "/" + ) + return KOBO_STOREAPI_URL + "/" + request_path + + +CONNECTION_SPECIFIC_HEADERS = [ + "connection", + "content-encoding", + "content-length", + "transfer-encoding", +] + + +def get_kobo_activated(): + return config.config_kobo_sync + + +def make_request_to_kobo_store(sync_token=None): + outgoing_headers = Headers(request.headers) + outgoing_headers.remove("Host") + if sync_token: + sync_token.set_kobo_store_header(outgoing_headers) + + store_response = requests.request( + method=request.method, + url=get_store_url_for_current_request(), + headers=outgoing_headers, + data=request.get_data(), + allow_redirects=False, + timeout=(2, 10) + ) + log.debug("Content: " + str(store_response.content)) + log.debug("StatusCode: " + str(store_response.status_code)) + return store_response + + +def redirect_or_proxy_request(): + if config.config_kobo_proxy: + if request.method == "GET": + return redirect(get_store_url_for_current_request(), 307) + else: + # The Kobo device turns other request types into GET requests on redirects, + # so we instead proxy to the Kobo store ourselves. + store_response = make_request_to_kobo_store() + + response_headers = store_response.headers + for header_key in CONNECTION_SPECIFIC_HEADERS: + response_headers.pop(header_key, default=None) + + return make_response( + store_response.content, store_response.status_code, response_headers.items() + ) + else: + return make_response(jsonify({})) + + +def convert_to_kobo_timestamp_string(timestamp): + try: + return timestamp.strftime("%Y-%m-%dT%H:%M:%SZ") + except AttributeError as exc: + log.debug("Timestamp not valid: {}".format(exc)) + return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ") + + +@kobo.route("/v1/library/sync") +@requires_kobo_auth +# @download_required +def HandleSyncRequest(): + if not current_user.role_download(): + log.info("Users need download permissions for syncing library to Kobo reader") + return abort(403) + sync_token = SyncToken.SyncToken.from_headers(request.headers) + log.info("Kobo library sync request received") + log.debug("SyncToken: {}".format(sync_token)) + log.debug("Download link format {}".format(get_download_url_for_book('[bookid]', '[bookformat]'))) + if not current_app.wsgi_app.is_proxied: + log.debug('Kobo: Received unproxied request, changed request port to external server port') + + # if no books synced don't respect sync_token + if not ub.session.query(ub.KoboSyncedBooks).filter(ub.KoboSyncedBooks.user_id == current_user.id).count(): + sync_token.books_last_modified = datetime.min + sync_token.books_last_created = datetime.min + sync_token.reading_state_last_modified = datetime.min + + new_books_last_modified = sync_token.books_last_modified # needed for sync selected shelfs only + new_books_last_created = sync_token.books_last_created # needed to distinguish between new and changed entitlement + new_reading_state_last_modified = sync_token.reading_state_last_modified + + new_archived_last_modified = datetime.min + sync_results = [] + + # We reload the book database so that the user gets a fresh view of the library + # in case of external changes (e.g: adding a book through Calibre). + calibre_db.reconnect_db(config, ub.app_DB_path) + + only_kobo_shelves = current_user.kobo_only_shelves_sync + + if only_kobo_shelves: + changed_entries = calibre_db.session.query(db.Books, + ub.ArchivedBook.last_modified, + ub.BookShelf.date_added, + ub.ArchivedBook.is_archived) + changed_entries = (changed_entries + .join(db.Data).outerjoin(ub.ArchivedBook, and_(db.Books.id == ub.ArchivedBook.book_id, + ub.ArchivedBook.user_id == current_user.id)) + .filter(db.Books.id.notin_(calibre_db.session.query(ub.KoboSyncedBooks.book_id) + .filter(ub.KoboSyncedBooks.user_id == current_user.id))) + .filter(ub.BookShelf.date_added > sync_token.books_last_modified) + .filter(db.Data.format.in_(KOBO_FORMATS)) + .filter(calibre_db.common_filters(allow_show_archived=True)) + .order_by(db.Books.id) + .order_by(ub.ArchivedBook.last_modified) + .join(ub.BookShelf, db.Books.id == ub.BookShelf.book_id) + .join(ub.Shelf) + .filter(ub.Shelf.user_id == current_user.id) + .filter(ub.Shelf.kobo_sync) + .distinct()) + else: + changed_entries = calibre_db.session.query(db.Books, + ub.ArchivedBook.last_modified, + ub.ArchivedBook.is_archived) + changed_entries = (changed_entries + .join(db.Data).outerjoin(ub.ArchivedBook, and_(db.Books.id == ub.ArchivedBook.book_id, + ub.ArchivedBook.user_id == current_user.id)) + .filter(db.Books.id.notin_(calibre_db.session.query(ub.KoboSyncedBooks.book_id) + .filter(ub.KoboSyncedBooks.user_id == current_user.id))) + .filter(calibre_db.common_filters(allow_show_archived=True)) + .filter(db.Data.format.in_(KOBO_FORMATS)) + .order_by(db.Books.last_modified) + .order_by(db.Books.id)) + + reading_states_in_new_entitlements = [] + books = changed_entries.limit(SYNC_ITEM_LIMIT) + log.debug("Books to Sync: {}".format(len(books.all()))) + for book in books: + formats = [data.format for data in book.Books.data] + if 'KEPUB' not in formats and config.config_kepubifypath and 'EPUB' in formats: + helper.convert_book_format(book.Books.id, config.get_book_path(), 'EPUB', 'KEPUB', current_user.name) + + kobo_reading_state = get_or_create_reading_state(book.Books.id) + entitlement = { + "BookEntitlement": create_book_entitlement(book.Books, archived=(book.is_archived==True)), + "BookMetadata": get_metadata(book.Books), + } + + if kobo_reading_state.last_modified > sync_token.reading_state_last_modified: + entitlement["ReadingState"] = get_kobo_reading_state_response(book.Books, kobo_reading_state) + new_reading_state_last_modified = max(new_reading_state_last_modified, kobo_reading_state.last_modified) + reading_states_in_new_entitlements.append(book.Books.id) + + ts_created = book.Books.timestamp.replace(tzinfo=None) + + try: + ts_created = max(ts_created, book.date_added) + except AttributeError: + pass + + if ts_created > sync_token.books_last_created: + sync_results.append({"NewEntitlement": entitlement}) + else: + sync_results.append({"ChangedEntitlement": entitlement}) + + new_books_last_modified = max( + book.Books.last_modified.replace(tzinfo=None), new_books_last_modified + ) + try: + new_books_last_modified = max( + new_books_last_modified, book.date_added + ) + except AttributeError: + pass + + new_books_last_created = max(ts_created, new_books_last_created) + kobo_sync_status.add_synced_books(book.Books.id) + + max_change = changed_entries.filter(ub.ArchivedBook.is_archived)\ + .filter(ub.ArchivedBook.user_id == current_user.id) \ + .order_by(func.datetime(ub.ArchivedBook.last_modified).desc()).first() + + max_change = max_change.last_modified if max_change else new_archived_last_modified + + new_archived_last_modified = max(new_archived_last_modified, max_change) + + # no. of books returned + book_count = changed_entries.count() + # last entry: + cont_sync = bool(book_count) + log.debug("Remaining books to Sync: {}".format(book_count)) + # generate reading state data + changed_reading_states = ub.session.query(ub.KoboReadingState) + + if only_kobo_shelves: + changed_reading_states = changed_reading_states.join(ub.BookShelf, + ub.KoboReadingState.book_id == ub.BookShelf.book_id)\ + .join(ub.Shelf)\ + .filter(current_user.id == ub.Shelf.user_id)\ + .filter(ub.Shelf.kobo_sync, + or_( + ub.KoboReadingState.last_modified > sync_token.reading_state_last_modified, + func.datetime(ub.BookShelf.date_added) > sync_token.books_last_modified + )).distinct() + else: + changed_reading_states = changed_reading_states.filter( + ub.KoboReadingState.last_modified > sync_token.reading_state_last_modified) + + changed_reading_states = changed_reading_states.filter( + and_(ub.KoboReadingState.user_id == current_user.id, + ub.KoboReadingState.book_id.notin_(reading_states_in_new_entitlements)))\ + .order_by(ub.KoboReadingState.last_modified) + cont_sync |= bool(changed_reading_states.count() > SYNC_ITEM_LIMIT) + for kobo_reading_state in changed_reading_states.limit(SYNC_ITEM_LIMIT).all(): + book = calibre_db.session.query(db.Books).filter(db.Books.id == kobo_reading_state.book_id).one_or_none() + if book: + sync_results.append({ + "ChangedReadingState": { + "ReadingState": get_kobo_reading_state_response(book, kobo_reading_state) + } + }) + new_reading_state_last_modified = max(new_reading_state_last_modified, kobo_reading_state.last_modified) + + sync_shelves(sync_token, sync_results, only_kobo_shelves) + + # update last created timestamp to distinguish between new and changed entitlements + if not cont_sync: + sync_token.books_last_created = new_books_last_created + sync_token.books_last_modified = new_books_last_modified + sync_token.archive_last_modified = new_archived_last_modified + sync_token.reading_state_last_modified = new_reading_state_last_modified + + return generate_sync_response(sync_token, sync_results, cont_sync) + + +def generate_sync_response(sync_token, sync_results, set_cont=False): + extra_headers = {} + if config.config_kobo_proxy and not set_cont: + # Merge in sync results from the official Kobo store. + try: + store_response = make_request_to_kobo_store(sync_token) + + store_sync_results = store_response.json() + sync_results += store_sync_results + sync_token.merge_from_store_response(store_response) + extra_headers["x-kobo-sync"] = store_response.headers.get("x-kobo-sync") + extra_headers["x-kobo-sync-mode"] = store_response.headers.get("x-kobo-sync-mode") + extra_headers["x-kobo-recent-reads"] = store_response.headers.get("x-kobo-recent-reads") + + except Exception as ex: + log.error_or_exception("Failed to receive or parse response from Kobo's sync endpoint: {}".format(ex)) + if set_cont: + extra_headers["x-kobo-sync"] = "continue" + sync_token.to_headers(extra_headers) + + # log.debug("Kobo Sync Content: {}".format(sync_results)) + # jsonify decodes the unicode string different to what kobo expects + response = make_response(json.dumps(sync_results), extra_headers) + response.headers["Content-Type"] = "application/json; charset=utf-8" + return response + + +@kobo.route("/v1/library//metadata") +@requires_kobo_auth +@download_required +def HandleMetadataRequest(book_uuid): + if not current_app.wsgi_app.is_proxied: + log.debug('Kobo: Received unproxied request, changed request port to external server port') + log.info("Kobo library metadata request received for book %s" % book_uuid) + book = calibre_db.get_book_by_uuid(book_uuid) + if not book or not book.data: + log.info("Book %s not found in database", book_uuid) + return redirect_or_proxy_request() + + metadata = get_metadata(book) + response = make_response(json.dumps([metadata], ensure_ascii=False)) + response.headers["Content-Type"] = "application/json; charset=utf-8" + return response + + +def get_download_url_for_book(book_id, book_format): + if not current_app.wsgi_app.is_proxied: + if ':' in request.host and not request.host.endswith(']'): + host = "".join(request.host.split(':')[:-1]) + else: + host = request.host + + return "{url_scheme}://{url_base}:{url_port}/kobo/{auth_token}/download/{book_id}/{book_format}".format( + url_scheme=request.scheme, + url_base=host, + url_port=config.config_external_port, + auth_token=get_auth_token(), + book_id=book_id, + book_format=book_format.lower() + ) + return url_for( + "kobo.download_book", + auth_token=kobo_auth.get_auth_token(), + book_id=book_id, + book_format=book_format.lower(), + _external=True, + ) + + +def create_book_entitlement(book, archived): + book_uuid = str(book.uuid) + return { + "Accessibility": "Full", + "ActivePeriod": {"From": convert_to_kobo_timestamp_string(datetime.now(timezone.utc))}, + "Created": convert_to_kobo_timestamp_string(book.timestamp), + "CrossRevisionId": book_uuid, + "Id": book_uuid, + "IsRemoved": archived, + "IsHiddenFromArchive": False, + "IsLocked": False, + "LastModified": convert_to_kobo_timestamp_string(book.last_modified), + "OriginCategory": "Imported", + "RevisionId": book_uuid, + "Status": "Active", + } + + +def current_time(): + return strftime("%Y-%m-%dT%H:%M:%SZ", gmtime()) + + +def get_description(book): + if not book.comments: + return None + return book.comments[0].text + + +def get_author(book): + if not book.authors: + return {"Contributors": None} + author_list = [] + autor_roles = [] + for author in book.authors: + autor_roles.append({"Name": author.name}) + author_list.append(author.name) + return {"ContributorRoles": autor_roles, "Contributors": author_list} + + +def get_publisher(book): + if not book.publishers: + return None + return book.publishers[0].name + + +def get_series(book): + if not book.series: + return None + return book.series[0].name + + +def get_seriesindex(book): + return book.series_index if isinstance(book.series_index, float) else 1 + + +def get_language(book): + if not book.languages: + return 'en' + return isoLanguages.get(part3=book.languages[0].lang_code).part1 + + +def get_metadata(book): + download_urls = [] + kepub = [data for data in book.data if data.format == 'KEPUB'] + + for book_data in kepub if len(kepub) > 0 else book.data: + if book_data.format not in KOBO_FORMATS: + continue + for kobo_format in KOBO_FORMATS[book_data.format]: + # log.debug('Id: %s, Format: %s' % (book.id, kobo_format)) + try: + if get_epub_layout(book, book_data) == 'pre-paginated': + kobo_format = 'EPUB3FL' + download_urls.append( + { + "Format": kobo_format, + "Size": book_data.uncompressed_size, + "Url": get_download_url_for_book(book.id, book_data.format), + # The Kobo forma accepts platforms: (Generic, Android) + "Platform": "Generic", + # "DrmType": "None", # Not required + } + ) + except (zipfile.BadZipfile, FileNotFoundError) as e: + log.error(e) + + book_uuid = book.uuid + metadata = { + "Categories": ["00000000-0000-0000-0000-000000000001", ], + # "Contributors": get_author(book), + "CoverImageId": book_uuid, + "CrossRevisionId": book_uuid, + "CurrentDisplayPrice": {"CurrencyCode": "USD", "TotalAmount": 0}, + "CurrentLoveDisplayPrice": {"TotalAmount": 0}, + "Description": get_description(book), + "DownloadUrls": download_urls, + "EntitlementId": book_uuid, + "ExternalIds": [], + "Genre": "00000000-0000-0000-0000-000000000001", + "IsEligibleForKoboLove": False, + "IsInternetArchive": False, + "IsPreOrder": False, + "IsSocialEnabled": True, + "Language": get_language(book), + "PhoneticPronunciations": {}, + "PublicationDate": convert_to_kobo_timestamp_string(book.pubdate), + "Publisher": {"Imprint": "", "Name": get_publisher(book), }, + "RevisionId": book_uuid, + "Title": book.title, + "WorkId": book_uuid, + } + metadata.update(get_author(book)) + + if get_series(book): + name = get_series(book) + try: + metadata["Series"] = { + "Name": get_series(book), + "Number": get_seriesindex(book), # ToDo Check int() ? + "NumberFloat": float(get_seriesindex(book)), + # Get a deterministic id based on the series name. + "Id": str(uuid.uuid3(uuid.NAMESPACE_DNS, name)), + } + except Exception as e: + print(e) + return metadata + + +@csrf.exempt +@kobo.route("/v1/library/tags", methods=["POST", "DELETE"]) +@requires_kobo_auth +# Creates a Shelf with the given items, and returns the shelf's uuid. +def HandleTagCreate(): + # catch delete requests, otherwise they are handled in the book delete handler + if request.method == "DELETE": + abort(405) + name, items = None, None + try: + shelf_request = request.json + name = shelf_request["Name"] + items = shelf_request["Items"] + if not name: + raise TypeError + except (KeyError, TypeError): + log.debug("Received malformed v1/library/tags request.") + abort(400, description="Malformed tags POST request. Data has empty 'Name', missing 'Name' or 'Items' field") + + shelf = ub.session.query(ub.Shelf).filter(ub.Shelf.name == name, ub.Shelf.user_id == + current_user.id).one_or_none() + if shelf and not shelf_lib.check_shelf_edit_permissions(shelf): + abort(401, description="User is unauthaurized to create shelf.") + + if not shelf: + shelf = ub.Shelf(user_id=current_user.id, name=name, uuid=str(uuid.uuid4())) + ub.session.add(shelf) + + items_unknown_to_calibre = add_items_to_shelf(items, shelf) + if items_unknown_to_calibre: + log.debug("Received request to add unknown books to a collection. Silently ignoring items.") + ub.session_commit() + return make_response(jsonify(str(shelf.uuid)), 201) + + +@csrf.exempt +@kobo.route("/v1/library/tags/", methods=["DELETE", "PUT"]) +@requires_kobo_auth +def HandleTagUpdate(tag_id): + shelf = ub.session.query(ub.Shelf).filter(ub.Shelf.uuid == tag_id, + ub.Shelf.user_id == current_user.id).one_or_none() + if not shelf: + log.debug("Received Kobo tag update request on a collection unknown to CalibreWeb") + if config.config_kobo_proxy: + return redirect_or_proxy_request() + else: + abort(404, description="Collection isn't known to CalibreWeb") + + if request.method == "DELETE": + if not shelf_lib.delete_shelf_helper(shelf): + abort(401, description="Error deleting Shelf") + else: + name = None + try: + shelf_request = request.json + name = shelf_request["Name"] + except (KeyError, TypeError): + log.debug("Received malformed v1/library/tags rename request.") + abort(400, description="Malformed tags POST request. Data is missing 'Name' field") + + shelf.name = name + ub.session.merge(shelf) + ub.session_commit() + return make_response(' ', 200) + + +# Adds items to the given shelf. +def add_items_to_shelf(items, shelf): + book_ids_already_in_shelf = set([book_shelf.book_id for book_shelf in shelf.books]) + items_unknown_to_calibre = [] + for item in items: + try: + if item["Type"] != "ProductRevisionTagItem": + items_unknown_to_calibre.append(item) + continue + + book = calibre_db.get_book_by_uuid(item["RevisionId"]) + if not book: + items_unknown_to_calibre.append(item) + continue + + book_id = book.id + if book_id not in book_ids_already_in_shelf: + shelf.books.append(ub.BookShelf(book_id=book_id)) + except KeyError: + items_unknown_to_calibre.append(item) + return items_unknown_to_calibre + + +@csrf.exempt +@kobo.route("/v1/library/tags//items", methods=["POST"]) +@requires_kobo_auth +def HandleTagAddItem(tag_id): + items = None + try: + tag_request = request.json + items = tag_request["Items"] + except (KeyError, TypeError): + log.debug("Received malformed v1/library/tags//items/delete request.") + abort(400, description="Malformed tags POST request. Data is missing 'Items' field") + + shelf = ub.session.query(ub.Shelf).filter(ub.Shelf.uuid == tag_id, + ub.Shelf.user_id == current_user.id).one_or_none() + if not shelf: + log.debug("Received Kobo request on a collection unknown to CalibreWeb") + abort(404, description="Collection isn't known to CalibreWeb") + + if not shelf_lib.check_shelf_edit_permissions(shelf): + abort(401, description="User is unauthaurized to edit shelf.") + + items_unknown_to_calibre = add_items_to_shelf(items, shelf) + if items_unknown_to_calibre: + log.debug("Received request to add an unknown book to a collection. Silently ignoring item.") + + ub.session.merge(shelf) + ub.session_commit() + return make_response('', 201) + + +@csrf.exempt +@kobo.route("/v1/library/tags//items/delete", methods=["POST"]) +@requires_kobo_auth +def HandleTagRemoveItem(tag_id): + items = None + try: + tag_request = request.json + items = tag_request["Items"] + except (KeyError, TypeError): + log.debug("Received malformed v1/library/tags//items/delete request.") + abort(400, description="Malformed tags POST request. Data is missing 'Items' field") + + shelf = ub.session.query(ub.Shelf).filter(ub.Shelf.uuid == tag_id, + ub.Shelf.user_id == current_user.id).one_or_none() + if not shelf: + log.debug( + "Received a request to remove an item from a Collection unknown to CalibreWeb.") + abort(404, description="Collection isn't known to CalibreWeb") + + if not shelf_lib.check_shelf_edit_permissions(shelf): + abort(401, description="User is unauthaurized to edit shelf.") + + items_unknown_to_calibre = [] + for item in items: + try: + if item["Type"] != "ProductRevisionTagItem": + items_unknown_to_calibre.append(item) + continue + + book = calibre_db.get_book_by_uuid(item["RevisionId"]) + if not book: + items_unknown_to_calibre.append(item) + continue + + shelf.books.filter(ub.BookShelf.book_id == book.id).delete() + except KeyError: + items_unknown_to_calibre.append(item) + ub.session_commit() + + if items_unknown_to_calibre: + log.debug("Received request to remove an unknown book to a collecition. Silently ignoring item.") + + return make_response('', 200) + + +# Add new, changed, or deleted shelves to the sync_results. +# Note: Public shelves that aren't owned by the user aren't supported. +def sync_shelves(sync_token, sync_results, only_kobo_shelves=False): + new_tags_last_modified = sync_token.tags_last_modified + # transmit all archived shelfs independent of last sync (why should this matter?) + for shelf in ub.session.query(ub.ShelfArchive).filter(ub.ShelfArchive.user_id == current_user.id): + new_tags_last_modified = max(shelf.last_modified, new_tags_last_modified) + sync_results.append({ + "DeletedTag": { + "Tag": { + "Id": shelf.uuid, + "LastModified": convert_to_kobo_timestamp_string(shelf.last_modified) + } + } + }) + ub.session.delete(shelf) + ub.session_commit() + + extra_filters = [] + if only_kobo_shelves: + for shelf in ub.session.query(ub.Shelf).filter( + func.datetime(ub.Shelf.last_modified) > sync_token.tags_last_modified, + ub.Shelf.user_id == current_user.id, + not ub.Shelf.kobo_sync + ): + sync_results.append({ + "DeletedTag": { + "Tag": { + "Id": shelf.uuid, + "LastModified": convert_to_kobo_timestamp_string(shelf.last_modified) + } + } + }) + extra_filters.append(ub.Shelf.kobo_sync) + + shelflist = ub.session.query(ub.Shelf).outerjoin(ub.BookShelf).filter( + or_(func.datetime(ub.Shelf.last_modified) > sync_token.tags_last_modified, + func.datetime(ub.BookShelf.date_added) > sync_token.tags_last_modified), + ub.Shelf.user_id == current_user.id, + *extra_filters + ).distinct().order_by(func.datetime(ub.Shelf.last_modified).asc()) + + for shelf in shelflist: + if not shelf_lib.check_shelf_view_permissions(shelf): + continue + + new_tags_last_modified = max(shelf.last_modified, new_tags_last_modified) + + tag = create_kobo_tag(shelf) + if not tag: + continue + + if shelf.created > sync_token.tags_last_modified: + sync_results.append({ + "NewTag": tag + }) + else: + sync_results.append({ + "ChangedTag": tag + }) + sync_token.tags_last_modified = new_tags_last_modified + ub.session_commit() + + +# Creates a Kobo "Tag" object from a ub.Shelf object +def create_kobo_tag(shelf): + tag = { + "Created": convert_to_kobo_timestamp_string(shelf.created), + "Id": shelf.uuid, + "Items": [], + "LastModified": convert_to_kobo_timestamp_string(shelf.last_modified), + "Name": shelf.name, + "Type": "UserTag" + } + for book_shelf in shelf.books: + book = calibre_db.get_book(book_shelf.book_id) + if not book: + log.info("Book (id: %s) in BookShelf (id: %s) not found in book database", book_shelf.book_id, shelf.id) + continue + tag["Items"].append( + { + "RevisionId": book.uuid, + "Type": "ProductRevisionTagItem" + } + ) + return {"Tag": tag} + + +@csrf.exempt +@kobo.route("/v1/library//state", methods=["GET", "PUT"]) +@requires_kobo_auth +def HandleStateRequest(book_uuid): + book = calibre_db.get_book_by_uuid(book_uuid) + if not book or not book.data: + log.info("Book %s not found in database", book_uuid) + return redirect_or_proxy_request() + + kobo_reading_state = get_or_create_reading_state(book.id) + + if request.method == "GET": + return jsonify([get_kobo_reading_state_response(book, kobo_reading_state)]) + else: + update_results_response = {"EntitlementId": book_uuid} + + try: + request_data = request.json + request_reading_state = request_data["ReadingStates"][0] + + request_bookmark = request_reading_state["CurrentBookmark"] + if request_bookmark: + current_bookmark = kobo_reading_state.current_bookmark + current_bookmark.progress_percent = request_bookmark["ProgressPercent"] + current_bookmark.content_source_progress_percent = request_bookmark["ContentSourceProgressPercent"] + location = request_bookmark["Location"] + if location: + current_bookmark.location_value = location["Value"] + current_bookmark.location_type = location["Type"] + current_bookmark.location_source = location["Source"] + update_results_response["CurrentBookmarkResult"] = {"Result": "Success"} + + request_statistics = request_reading_state["Statistics"] + if request_statistics: + statistics = kobo_reading_state.statistics + statistics.spent_reading_minutes = int(request_statistics["SpentReadingMinutes"]) + statistics.remaining_time_minutes = int(request_statistics["RemainingTimeMinutes"]) + update_results_response["StatisticsResult"] = {"Result": "Success"} + + request_status_info = request_reading_state["StatusInfo"] + if request_status_info: + book_read = kobo_reading_state.book_read_link + new_book_read_status = get_ub_read_status(request_status_info["Status"]) + if new_book_read_status == ub.ReadBook.STATUS_IN_PROGRESS \ + and new_book_read_status != book_read.read_status: + book_read.times_started_reading += 1 + book_read.last_time_started_reading = datetime.now(timezone.utc) + book_read.read_status = new_book_read_status + update_results_response["StatusInfoResult"] = {"Result": "Success"} + except (KeyError, TypeError, ValueError, StatementError): + log.debug("Received malformed v1/library//state request.") + ub.session.rollback() + abort(400, description="Malformed request data is missing 'ReadingStates' key") + + if config.config_hardcover_sync and bool(hardcover): + hardcoverClient = hardcover.HardcoverClient(current_user.hardcover_token) + hardcoverClient.update_reading_progress(book.identifiers, request_bookmark["ProgressPercent"]) + + ub.session.merge(kobo_reading_state) + ub.session_commit() + return jsonify({ + "RequestResult": "Success", + "UpdateResults": [update_results_response], + }) + + +def get_read_status_for_kobo(ub_book_read): + enum_to_string_map = { + None: "ReadyToRead", + ub.ReadBook.STATUS_UNREAD: "ReadyToRead", + ub.ReadBook.STATUS_FINISHED: "Finished", + ub.ReadBook.STATUS_IN_PROGRESS: "Reading", + } + return enum_to_string_map[ub_book_read.read_status] + + +def get_ub_read_status(kobo_read_status): + string_to_enum_map = { + None: None, + "ReadyToRead": ub.ReadBook.STATUS_UNREAD, + "Finished": ub.ReadBook.STATUS_FINISHED, + "Reading": ub.ReadBook.STATUS_IN_PROGRESS, + } + return string_to_enum_map[kobo_read_status] + + +def get_or_create_reading_state(book_id): + book_read = ub.session.query(ub.ReadBook).filter(ub.ReadBook.book_id == book_id, + ub.ReadBook.user_id == int(current_user.id)).one_or_none() + if not book_read: + book_read = ub.ReadBook(user_id=current_user.id, book_id=book_id) + if not book_read.kobo_reading_state: + kobo_reading_state = ub.KoboReadingState(user_id=book_read.user_id, book_id=book_id) + kobo_reading_state.current_bookmark = ub.KoboBookmark() + kobo_reading_state.statistics = ub.KoboStatistics() + book_read.kobo_reading_state = kobo_reading_state + ub.session.add(book_read) + ub.session_commit() + return book_read.kobo_reading_state + + +def get_kobo_reading_state_response(book, kobo_reading_state): + return { + "EntitlementId": book.uuid, + "Created": convert_to_kobo_timestamp_string(book.timestamp), + "LastModified": convert_to_kobo_timestamp_string(kobo_reading_state.last_modified), + # AFAICT PriorityTimestamp is always equal to LastModified. + "PriorityTimestamp": convert_to_kobo_timestamp_string(kobo_reading_state.priority_timestamp), + "StatusInfo": get_status_info_response(kobo_reading_state.book_read_link), + "Statistics": get_statistics_response(kobo_reading_state.statistics), + "CurrentBookmark": get_current_bookmark_response(kobo_reading_state.current_bookmark), + } + + +def get_status_info_response(book_read): + resp = { + "LastModified": convert_to_kobo_timestamp_string(book_read.last_modified), + "Status": get_read_status_for_kobo(book_read), + "TimesStartedReading": book_read.times_started_reading, + } + if book_read.last_time_started_reading: + resp["LastTimeStartedReading"] = convert_to_kobo_timestamp_string(book_read.last_time_started_reading) + return resp + + +def get_statistics_response(statistics): + resp = { + "LastModified": convert_to_kobo_timestamp_string(statistics.last_modified), + } + if statistics.spent_reading_minutes: + resp["SpentReadingMinutes"] = statistics.spent_reading_minutes + if statistics.remaining_time_minutes: + resp["RemainingTimeMinutes"] = statistics.remaining_time_minutes + return resp + + +def get_current_bookmark_response(current_bookmark): + resp = { + "LastModified": convert_to_kobo_timestamp_string(current_bookmark.last_modified), + } + if current_bookmark.progress_percent: + resp["ProgressPercent"] = current_bookmark.progress_percent + if current_bookmark.content_source_progress_percent: + resp["ContentSourceProgressPercent"] = current_bookmark.content_source_progress_percent + if current_bookmark.location_value: + resp["Location"] = { + "Value": current_bookmark.location_value, + "Type": current_bookmark.location_type, + "Source": current_bookmark.location_source, + } + return resp + + +@kobo.route("/////image.jpg", defaults={'Quality': ""}) +@kobo.route("//////image.jpg") +@requires_kobo_auth +def HandleCoverImageRequest(book_uuid, width, height, Quality, isGreyscale): + try: + if int(height) > 1000: + resolution = COVER_THUMBNAIL_LARGE + elif int(height) > 500: + resolution = COVER_THUMBNAIL_MEDIUM + else: + resolution = COVER_THUMBNAIL_SMALL + except ValueError: + log.error("Requested height %s of book %s is invalid" % (book_uuid, height)) + resolution = COVER_THUMBNAIL_SMALL + book_cover = helper.get_book_cover_with_uuid(book_uuid, resolution=resolution) + if book_cover: + log.debug("Serving local cover image of book %s" % book_uuid) + return book_cover + + if not config.config_kobo_proxy: + log.debug("Returning 404 for cover image of unknown book %s" % book_uuid) + # additional proxy request make no sense, -> direct return + return abort(404) + + log.debug("Redirecting request for cover image of unknown book %s to Kobo" % book_uuid) + return redirect(KOBO_IMAGEHOST_URL + + "/{book_uuid}/{width}/{height}/false/image.jpg".format(book_uuid=book_uuid, + width=width, + height=height), 307) + + +@kobo.route("") +def TopLevelEndpoint(): + return make_response(jsonify({})) + + +@csrf.exempt +@kobo.route("/v1/library/", methods=["DELETE"]) +@requires_kobo_auth +def HandleBookDeletionRequest(book_uuid): + log.info("Kobo book delete request received for book %s" % book_uuid) + book = calibre_db.get_book_by_uuid(book_uuid) + if not book: + log.info("Book %s not found in database", book_uuid) + return redirect_or_proxy_request() + + book_id = book.id + is_archived = kobo_sync_status.change_archived_books(book_id, True) + if is_archived: + kobo_sync_status.remove_synced_book(book_id) + return "", 204 + + +# TODO: Implement the following routes +@csrf.exempt +@kobo.route("/v1/library/", methods=["DELETE", "GET"]) +def HandleUnimplementedRequest(dummy=None): + log.debug("Unimplemented Library Request received: %s (request is forwarded to kobo if configured)", + request.base_url) + return redirect_or_proxy_request() + + +# TODO: Implement the following routes +@csrf.exempt +@kobo.route("/v1/user/loyalty/", methods=["GET", "POST"]) +@kobo.route("/v1/user/profile", methods=["GET", "POST"]) +@kobo.route("/v1/user/wishlist", methods=["GET", "POST"]) +@kobo.route("/v1/user/recommendations", methods=["GET", "POST"]) +@kobo.route("/v1/analytics/", methods=["GET", "POST"]) +@kobo.route("/v1/assets", methods=["GET"]) +def HandleUserRequest(dummy=None): + log.debug("Unimplemented User Request received: %s (request is forwarded to kobo if configured)", request.base_url) + return redirect_or_proxy_request() + + +@csrf.exempt +@kobo.route("/v1/user/loyalty/benefits", methods=["GET"]) +def handle_benefits(): + if config.config_kobo_proxy: + return redirect_or_proxy_request() + else: + return make_response(jsonify({"Benefits": {}})) + + +@csrf.exempt +@kobo.route("/v1/analytics/gettests", methods=["GET", "POST"]) +def handle_getests(): + if config.config_kobo_proxy: + return redirect_or_proxy_request() + else: + testkey = request.headers.get("X-Kobo-userkey", "") + return make_response(jsonify({"Result": "Success", "TestKey": testkey, "Tests": {}})) + + +@csrf.exempt +@kobo.route("/v1/products//prices", methods=["GET", "POST"]) +@kobo.route("/v1/products//recommendations", methods=["GET", "POST"]) +@kobo.route("/v1/products//nextread", methods=["GET", "POST"]) +@kobo.route("/v1/products//reviews", methods=["GET", "POST"]) +@kobo.route("/v1/products/featured/", methods=["GET", "POST"]) +@kobo.route("/v1/products/featured/", methods=["GET", "POST"]) +@kobo.route("/v1/products/books/external/", methods=["GET", "POST"]) +@kobo.route("/v1/products/books/series/", methods=["GET", "POST"]) +@kobo.route("/v1/products/books/", methods=["GET", "POST"]) +@kobo.route("/v1/products/books//", methods=["GET", "POST"]) +@kobo.route("/v1/products/dailydeal", methods=["GET", "POST"]) +@kobo.route("/v1/products/deals", methods=["GET", "POST"]) +@kobo.route("/v1/products", methods=["GET", "POST"]) +@kobo.route("/v1/affiliate", methods=["GET", "POST"]) +@kobo.route("/v1/deals", methods=["GET", "POST"]) +def HandleProductsRequest(dummy=None): + log.debug("Unimplemented Products Request received: %s (request is forwarded to kobo if configured)", + request.base_url) + return redirect_or_proxy_request() + + +def make_calibre_web_auth_response(): + # As described in kobo_auth.py, CalibreWeb doesn't make use practical use of this auth/device API call for + # authentation (nor for authorization). We return a dummy response just to keep the device happy. + content = request.get_json() + AccessToken = base64.b64encode(os.urandom(24)).decode('utf-8') + RefreshToken = base64.b64encode(os.urandom(24)).decode('utf-8') + return make_response( + jsonify( + { + "AccessToken": AccessToken, + "RefreshToken": RefreshToken, + "TokenType": "Bearer", + "TrackingId": str(uuid.uuid4()), + "UserKey": content.get('UserKey', ""), + } + ) + ) + + +@csrf.exempt +@kobo.route("/v1/auth/device", methods=["POST"]) +@requires_kobo_auth +def HandleAuthRequest(): + log.debug('Kobo Auth request') + if config.config_kobo_proxy: + try: + return redirect_or_proxy_request() + except Exception: + log.error("Failed to receive or parse response from Kobo's auth endpoint. Falling back to un-proxied mode.") + return make_calibre_web_auth_response() + + +@kobo.route("/v1/initialization") +@requires_kobo_auth +def HandleInitRequest(): + log.info('Init') + + kobo_resources = None + if config.config_kobo_proxy: + try: + store_response = make_request_to_kobo_store() + store_response_json = store_response.json() + if "Resources" in store_response_json: + kobo_resources = store_response_json["Resources"] + except Exception: + log.error("Failed to receive or parse response from Kobo's init endpoint. Falling back to un-proxied mode.") + if not kobo_resources: + kobo_resources = NATIVE_KOBO_RESOURCES() + + if not current_app.wsgi_app.is_proxied: + log.debug('Kobo: Received unproxied request, changed request port to external server port') + if ':' in request.host and not request.host.endswith(']'): + host = "".join(request.host.split(':')[:-1]) + else: + host = request.host + calibre_web_url = "{url_scheme}://{url_base}:{url_port}".format( + url_scheme=request.scheme, + url_base=host, + url_port=config.config_external_port + ) + log.debug('Kobo: Received unproxied request, changed request url to %s', calibre_web_url) + kobo_resources["image_host"] = calibre_web_url + kobo_resources["image_url_quality_template"] = unquote(calibre_web_url + + url_for("kobo.HandleCoverImageRequest", + auth_token=kobo_auth.get_auth_token(), + book_uuid="{ImageId}", + width="{width}", + height="{height}", + Quality='{Quality}', + isGreyscale='isGreyscale')) + kobo_resources["image_url_template"] = unquote(calibre_web_url + + url_for("kobo.HandleCoverImageRequest", + auth_token=kobo_auth.get_auth_token(), + book_uuid="{ImageId}", + width="{width}", + height="{height}", + isGreyscale='false')) + else: + kobo_resources["image_host"] = url_for("web.index", _external=True).strip("/") + kobo_resources["image_url_quality_template"] = unquote(url_for("kobo.HandleCoverImageRequest", + auth_token=kobo_auth.get_auth_token(), + book_uuid="{ImageId}", + width="{width}", + height="{height}", + Quality='{Quality}', + isGreyscale='isGreyscale', + _external=True)) + kobo_resources["image_url_template"] = unquote(url_for("kobo.HandleCoverImageRequest", + auth_token=kobo_auth.get_auth_token(), + book_uuid="{ImageId}", + width="{width}", + height="{height}", + isGreyscale='false', + _external=True)) + + response = make_response(jsonify({"Resources": kobo_resources})) + response.headers["x-kobo-apitoken"] = "e30=" + + return response + + +@kobo.route("/download//") +@requires_kobo_auth +@download_required +def download_book(book_id, book_format): + return get_download_link(book_id, book_format, "kobo") + + +def NATIVE_KOBO_RESOURCES(): + return { + "account_page": "https://www.kobo.com/account/settings", + "account_page_rakuten": "https://my.rakuten.co.jp/", + "add_device": "https://storeapi.kobo.com/v1/user/add-device", + "add_entitlement": "https://storeapi.kobo.com/v1/library/{RevisionIds}", + "affiliaterequest": "https://storeapi.kobo.com/v1/affiliate", + "assets": "https://storeapi.kobo.com/v1/assets", + "audiobook": "https://storeapi.kobo.com/v1/products/audiobooks/{ProductId}", + "audiobook_detail_page": "https://www.kobo.com/{region}/{language}/audiobook/{slug}", + "audiobook_landing_page": "https://www.kobo.com/{region}/{language}/audiobooks", + "audiobook_preview": "https://storeapi.kobo.com/v1/products/audiobooks/{Id}/preview", + "audiobook_purchase_withcredit": "https://storeapi.kobo.com/v1/store/audiobook/{Id}", + "audiobook_subscription_orange_deal_inclusion_url": "https://authorize.kobo.com/inclusion", + "authorproduct_recommendations": "https://storeapi.kobo.com/v1/products/books/authors/recommendations", + "autocomplete": "https://storeapi.kobo.com/v1/products/autocomplete", + "blackstone_header": { + "key": "x-amz-request-payer", + "value": "requester" + }, + "book": "https://storeapi.kobo.com/v1/products/books/{ProductId}", + "book_detail_page": "https://www.kobo.com/{region}/{language}/ebook/{slug}", + "book_detail_page_rakuten": "http://books.rakuten.co.jp/rk/{crossrevisionid}", + "book_landing_page": "https://www.kobo.com/ebooks", + "book_subscription": "https://storeapi.kobo.com/v1/products/books/subscriptions", + "browse_history": "https://storeapi.kobo.com/v1/user/browsehistory", + "categories": "https://storeapi.kobo.com/v1/categories", + "categories_page": "https://www.kobo.com/ebooks/categories", + "category": "https://storeapi.kobo.com/v1/categories/{CategoryId}", + "category_featured_lists": "https://storeapi.kobo.com/v1/categories/{CategoryId}/featured", + "category_products": "https://storeapi.kobo.com/v1/categories/{CategoryId}/products", + "checkout_borrowed_book": "https://storeapi.kobo.com/v1/library/borrow", + "client_authd_referral": "https://authorize.kobo.com/api/AuthenticatedReferral/client/v1/getLink", + "configuration_data": "https://storeapi.kobo.com/v1/configuration", + "content_access_book": "https://storeapi.kobo.com/v1/products/books/{ProductId}/access", + "customer_care_live_chat": "https://v2.zopim.com/widget/livechat.html?key=Y6gwUmnu4OATxN3Tli4Av9bYN319BTdO", + "daily_deal": "https://storeapi.kobo.com/v1/products/dailydeal", + "deals": "https://storeapi.kobo.com/v1/deals", + "delete_entitlement": "https://storeapi.kobo.com/v1/library/{Ids}", + "delete_tag": "https://storeapi.kobo.com/v1/library/tags/{TagId}", + "delete_tag_items": "https://storeapi.kobo.com/v1/library/tags/{TagId}/items/delete", + "device_auth": "https://storeapi.kobo.com/v1/auth/device", + "device_refresh": "https://storeapi.kobo.com/v1/auth/refresh", + "dictionary_host": "https://ereaderfiles.kobo.com", + "discovery_host": "https://discovery.kobobooks.com", + "ereaderdevices": "https://storeapi.kobo.com/v2/products/EReaderDeviceFeeds", + "eula_page": "https://www.kobo.com/termsofuse?style=onestore", + "exchange_auth": "https://storeapi.kobo.com/v1/auth/exchange", + "external_book": "https://storeapi.kobo.com/v1/products/books/external/{Ids}", + "facebook_sso_page": "https://authorize.kobo.com/signin/provider/Facebook/login?returnUrl=http://kobo.com/", + "featured_list": "https://storeapi.kobo.com/v1/products/featured/{FeaturedListId}", + "featured_lists": "https://storeapi.kobo.com/v1/products/featured", + "free_books_page": { + "EN": "https://www.kobo.com/{region}/{language}/p/free-ebooks", + "FR": "https://www.kobo.com/{region}/{language}/p/livres-gratuits", + "IT": "https://www.kobo.com/{region}/{language}/p/libri-gratuiti", + "NL": "https://www.kobo.com/{region}/{language}/List/bekijk-het-overzicht-van-gratis-ebooks/QpkkVWnUw8sxmgjSlCbJRg", + "PT": "https://www.kobo.com/{region}/{language}/p/livros-gratis" + }, + "fte_feedback": "https://storeapi.kobo.com/v1/products/ftefeedback", + "funnel_metrics": "https://storeapi.kobo.com/v1/funnelmetrics", + "get_download_keys": "https://storeapi.kobo.com/v1/library/downloadkeys", + "get_download_link": "https://storeapi.kobo.com/v1/library/downloadlink", + "get_tests_request": "https://storeapi.kobo.com/v1/analytics/gettests", + "giftcard_epd_redeem_url": "https://www.kobo.com/{storefront}/{language}/redeem-ereader", + "giftcard_redeem_url": "https://www.kobo.com/{storefront}/{language}/redeem", + "gpb_flow_enabled": "False", + "help_page": "http://www.kobo.com/help", + "image_host": "//cdn.kobo.com/book-images/", + "image_url_quality_template": "https://cdn.kobo.com/book-images/{ImageId}/{Width}/{Height}/{Quality}/{IsGreyscale}/image.jpg", + "image_url_template": "https://cdn.kobo.com/book-images/{ImageId}/{Width}/{Height}/false/image.jpg", + "kobo_audiobooks_credit_redemption": "False", + "kobo_audiobooks_enabled": "True", + "kobo_audiobooks_orange_deal_enabled": "False", + "kobo_audiobooks_subscriptions_enabled": "False", + "kobo_display_price": "True", + "kobo_dropbox_link_account_enabled": "False", + "kobo_google_tax": "False", + "kobo_googledrive_link_account_enabled": "False", + "kobo_nativeborrow_enabled": "False", + "kobo_onedrive_link_account_enabled": "False", + "kobo_onestorelibrary_enabled": "False", + "kobo_privacyCentre_url": "https://www.kobo.com/privacy", + "kobo_redeem_enabled": "True", + "kobo_shelfie_enabled": "False", + "kobo_subscriptions_enabled": "True", + "kobo_superpoints_enabled": "True", + "kobo_wishlist_enabled": "True", + "library_book": "https://storeapi.kobo.com/v1/user/library/books/{LibraryItemId}", + "library_items": "https://storeapi.kobo.com/v1/user/library", + "library_metadata": "https://storeapi.kobo.com/v1/library/{Ids}/metadata", + "library_prices": "https://storeapi.kobo.com/v1/user/library/previews/prices", + "library_search": "https://storeapi.kobo.com/v1/library/search", + "library_sync": "https://storeapi.kobo.com/v1/library/sync", + "love_dashboard_page": "https://www.kobo.com/{region}/{language}/kobosuperpoints", + "love_points_redemption_page": "https://www.kobo.com/{region}/{language}/KoboSuperPointsRedemption?productId={ProductId}", + "magazine_landing_page": "https://www.kobo.com/emagazines", + "more_sign_in_options": "https://authorize.kobo.com/signin?returnUrl=http://kobo.com/#allProviders", + "notebooks": "https://storeapi.kobo.com/api/internal/notebooks", + "notifications_registration_issue": "https://storeapi.kobo.com/v1/notifications/registration", + "oauth_host": "https://oauth.kobo.com", + "password_retrieval_page": "https://www.kobo.com/passwordretrieval.html", + "personalizedrecommendations": "https://storeapi.kobo.com/v2/users/personalizedrecommendations", + "pocket_link_account_start": "https://authorize.kobo.com/{region}/{language}/linkpocket", + "post_analytics_event": "https://storeapi.kobo.com/v1/analytics/event", + "ppx_purchasing_url": "https://purchasing.kobo.com", + "privacy_page": "https://www.kobo.com/privacypolicy?style=onestore", + "product_nextread": "https://storeapi.kobo.com/v1/products/{ProductIds}/nextread", + "product_prices": "https://storeapi.kobo.com/v1/products/{ProductIds}/prices", + "product_recommendations": "https://storeapi.kobo.com/v1/products/{ProductId}/recommendations", + "product_reviews": "https://storeapi.kobo.com/v1/products/{ProductIds}/reviews", + "products": "https://storeapi.kobo.com/v1/products", + "productsv2": "https://storeapi.kobo.com/v2/products", + "provider_external_sign_in_page": "https://authorize.kobo.com/ExternalSignIn/{providerName}?returnUrl=http://kobo.com/", + "quickbuy_checkout": "https://storeapi.kobo.com/v1/store/quickbuy/{PurchaseId}/checkout", + "quickbuy_create": "https://storeapi.kobo.com/v1/store/quickbuy/purchase", + "rakuten_token_exchange": "https://storeapi.kobo.com/v1/auth/rakuten_token_exchange", + "rating": "https://storeapi.kobo.com/v1/products/{ProductId}/rating/{Rating}", + "reading_services_host": "https://readingservices.kobo.com", + "reading_state": "https://storeapi.kobo.com/v1/library/{Ids}/state", + "redeem_interstitial_page": "https://www.kobo.com", + "registration_page": "https://authorize.kobo.com/signup?returnUrl=http://kobo.com/", + "related_items": "https://storeapi.kobo.com/v1/products/{Id}/related", + "remaining_book_series": "https://storeapi.kobo.com/v1/products/books/series/{SeriesId}", + "rename_tag": "https://storeapi.kobo.com/v1/library/tags/{TagId}", + "review": "https://storeapi.kobo.com/v1/products/reviews/{ReviewId}", + "review_sentiment": "https://storeapi.kobo.com/v1/products/reviews/{ReviewId}/sentiment/{Sentiment}", + "shelfie_recommendations": "https://storeapi.kobo.com/v1/user/recommendations/shelfie", + "sign_in_page": "https://authorize.kobo.com/signin?returnUrl=http://kobo.com/", + "social_authorization_host": "https://social.kobobooks.com:8443", + "social_host": "https://social.kobobooks.com", + "store_home": "www.kobo.com/{region}/{language}", + "store_host": "www.kobo.com", + "store_newreleases": "https://www.kobo.com/{region}/{language}/List/new-releases/961XUjtsU0qxkFItWOutGA", + "store_search": "https://www.kobo.com/{region}/{language}/Search?Query={query}", + "store_top50": "https://www.kobo.com/{region}/{language}/ebooks/Top", + "subs_landing_page": "https://www.kobo.com/{region}/{language}/plus", + "subs_management_page": "https://www.kobo.com/{region}/{language}/account/subscriptions", + "subs_plans_page": "https://www.kobo.com/{region}/{language}/plus/plans", + "subs_purchase_buy_templated": "https://www.kobo.com/{region}/{language}/Checkoutoption/{ProductId}/{TierId}", + "tag_items": "https://storeapi.kobo.com/v1/library/tags/{TagId}/Items", + "tags": "https://storeapi.kobo.com/v1/library/tags", + "taste_profile": "https://storeapi.kobo.com/v1/products/tasteprofile", + "terms_of_sale_page": "https://authorize.kobo.com/{region}/{language}/terms/termsofsale", + "update_accessibility_to_preview": "https://storeapi.kobo.com/v1/library/{EntitlementIds}/preview", + "use_one_store": "True", + "user_loyalty_benefits": "https://storeapi.kobo.com/v1/user/loyalty/benefits", + "user_platform": "https://storeapi.kobo.com/v1/user/platform", + "user_profile": "https://storeapi.kobo.com/v1/user/profile", + "user_ratings": "https://storeapi.kobo.com/v1/user/ratings", + "user_recommendations": "https://storeapi.kobo.com/v1/user/recommendations", + "user_reviews": "https://storeapi.kobo.com/v1/user/reviews", + "user_wishlist": "https://storeapi.kobo.com/v1/user/wishlist", + "userguide_host": "https://ereaderfiles.kobo.com", + "wishlist_page": "https://www.kobo.com/{region}/{language}/account/wishlist" + } diff --git a/root/app/calibre-web/cps/metadata_provider/amazon.py b/root/app/calibre-web/cps/metadata_provider/amazon.py new file mode 100644 index 0000000..09ef1eb --- /dev/null +++ b/root/app/calibre-web/cps/metadata_provider/amazon.py @@ -0,0 +1,140 @@ +# -*- coding: utf-8 -*- + +# This file is part of the Calibre-Web (https://github.com/janeczku/calibre-web) +# Copyright (C) 2022 quarz12 +# +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . + +import concurrent.futures +import requests +from bs4 import BeautifulSoup as BS # requirement +from typing import List, Optional + +try: + import cchardet #optional for better speed +except ImportError: + pass + +from cps.services.Metadata import MetaRecord, MetaSourceInfo, Metadata +import cps.logger as logger + +#from time import time +from operator import itemgetter +log = logger.create() + + +class Amazon(Metadata): + __name__ = "Amazon" + __id__ = "amazon" + headers = {'upgrade-insecure-requests': '1', + 'user-agent': 'Mozilla/5.0 (X11; Linux x86_64; rv:130.0) Gecko/20100101 Firefox/130.0', + 'accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/png,image/svg+xml,*/*;q=0.8', + 'Sec-Fetch-Site': 'same-origin', + 'Sec-Fetch-Mode': 'navigate', + 'Sec-Fetch-User': '?1', + 'Sec-Fetch-Dest': 'document', + 'Upgrade-Insecure-Requests': '1', + 'Alt-Used' : 'www.amazon.com', + 'Priority' : 'u=0, i', + 'accept-encoding': 'gzip, deflate, br, zstd', + 'accept-language': 'en-US,en;q=0.9'} + session = requests.Session() + session.headers=headers + + def search( + self, query: str, generic_cover: str = "", locale: str = "en",**kwargs + ) -> Optional[List[MetaRecord]]: + def inner(link, index) -> [dict, int]: + with self.session as session: + try: + r = session.get(f"https://www.amazon.com/{link}") + r.raise_for_status() + except Exception as ex: + log.warning(ex) + return [] + long_soup = BS(r.text, "lxml") #~4sec :/ + soup2 = long_soup.find("div", attrs={"cel_widget_id": "dpx-ppd_csm_instrumentation_wrapper"}) + if soup2 is None: + return [] + try: + match = MetaRecord( + title = "", + authors = "", + source=MetaSourceInfo( + id=self.__id__, + description="Amazon Books", + link="https://amazon.com/" + ), + url = f"https://www.amazon.com{link}", + #the more searches the slower, these are too hard to find in reasonable time or might not even exist + publisher= "", # very unreliable + publishedDate= "", # very unreliable + id = None, # ? + tags = [] # dont exist on amazon + ) + + try: + match.description = "\n".join( + soup2.find("div", attrs={"data-feature-name": "bookDescription"}).stripped_strings)\ + .replace("\xa0"," ")[:-9].strip().strip("\n") + except (AttributeError, TypeError): + return [] # if there is no description it is not a book and therefore should be ignored + try: + match.title = soup2.find("span", attrs={"id": "productTitle"}).text + except (AttributeError, TypeError): + match.title = "" + try: + match.authors = [next( + filter(lambda i: i != " " and i != "\n" and not i.startswith("{"), + x.findAll(string=True))).strip() + for x in soup2.findAll("span", attrs={"class": "author"})] + except (AttributeError, TypeError, StopIteration): + match.authors = "" + try: + match.rating = int( + soup2.find("span", class_="a-icon-alt").text.split(" ")[0].split(".")[ + 0]) # first number in string + except (AttributeError, ValueError): + match.rating = 0 + try: + match.cover = soup2.find("img", attrs={"class": "a-dynamic-image"})["src"] + except (AttributeError, TypeError): + match.cover = "" + return match, index + except Exception as e: + log.error_or_exception(e) + return [] + + val = list() + if self.active: + try: + results = self.session.get( + f"https://www.amazon.com/s?k={query.replace(' ', '+')}&i=digital-text&sprefix={query.replace(' ', '+')}" + f"%2Cdigital-text&ref=nb_sb_noss", + headers=self.headers) + results.raise_for_status() + except requests.exceptions.HTTPError as e: + log.error_or_exception(e) + return [] + except Exception as e: + log.warning(e) + return [] + soup = BS(results.text, 'html.parser') + links_list = [next(filter(lambda i: "digital-text" in i["href"], x.findAll("a")))["href"] for x in + soup.findAll("div", attrs={"data-component-type": "s-search-result"})] + with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor: + fut = {executor.submit(inner, link, index) for index, link in enumerate(links_list[:3])} + val = list(map(lambda x : x.result(), concurrent.futures.as_completed(fut))) + result = list(filter(lambda x: x, val)) + return [x[0] for x in sorted(result, key=itemgetter(1))] #sort by amazons listing order for best relevance diff --git a/root/app/calibre-web/cps/metadata_provider/comicvine.py b/root/app/calibre-web/cps/metadata_provider/comicvine.py new file mode 100644 index 0000000..b51c1c9 --- /dev/null +++ b/root/app/calibre-web/cps/metadata_provider/comicvine.py @@ -0,0 +1,92 @@ +# -*- coding: utf-8 -*- + +# This file is part of the Calibre-Web (https://github.com/janeczku/calibre-web) +# Copyright (C) 2021 OzzieIsaacs +# +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . + +# ComicVine api document: https://comicvine.gamespot.com/api/documentation +from typing import Dict, List, Optional +from urllib.parse import quote + +import requests +from cps import logger +from cps.services.Metadata import MetaRecord, MetaSourceInfo, Metadata + +log = logger.create() + + +class ComicVine(Metadata): + __name__ = "ComicVine" + __id__ = "comicvine" + DESCRIPTION = "ComicVine Books" + META_URL = "https://comicvine.gamespot.com/" + API_KEY = "57558043c53943d5d1e96a9ad425b0eb85532ee6" + BASE_URL = ( + f"https://comicvine.gamespot.com/api/search?api_key={API_KEY}" + f"&resources=issue&query=" + ) + QUERY_PARAMS = "&sort=name:desc&format=json" + HEADERS = {"User-Agent": "Not Evil Browser"} + + def search( + self, query: str, generic_cover: str = "", locale: str = "en",**kwargs + ) -> Optional[List[MetaRecord]]: + val = list() + if self.active: + title_tokens = list(self.get_title_tokens(query, strip_joiners=False)) + if title_tokens: + tokens = [quote(t.encode("utf-8")) for t in title_tokens] + query = "%20".join(tokens) + try: + result = requests.get( + f"{ComicVine.BASE_URL}{query}{ComicVine.QUERY_PARAMS}", + headers=ComicVine.HEADERS, + ) + result.raise_for_status() + except Exception as e: + log.warning(e) + return None + for result in result.json()["results"]: + match = self._parse_search_result( + result=result, generic_cover=generic_cover, locale=locale + ) + val.append(match) + return val + + def _parse_search_result( + self, result: Dict, generic_cover: str, locale: str + ) -> MetaRecord: + series = result["volume"].get("name", "") + series_index = result.get("issue_number", 0) + issue_name = result.get("name", "") + match = MetaRecord( + id=result["id"], + title=f"{series}#{series_index} - {issue_name}", + authors=result.get("authors", []), + url=result.get("site_detail_url", ""), + source=MetaSourceInfo( + id=self.__id__, + description=ComicVine.DESCRIPTION, + link=ComicVine.META_URL, + ), + series=series, + ) + match.cover = result["image"].get("original_url", generic_cover) + match.description = result.get("description", "") + match.publishedDate = result.get("store_date", result.get("date_added")) + match.series_index = series_index + match.tags = ["Comics", series] + match.identifiers = {"comicvine": match.id} + return match diff --git a/root/app/calibre-web/cps/metadata_provider/douban.py b/root/app/calibre-web/cps/metadata_provider/douban.py new file mode 100644 index 0000000..316fbea --- /dev/null +++ b/root/app/calibre-web/cps/metadata_provider/douban.py @@ -0,0 +1,260 @@ +# -*- coding: utf-8 -*- + +# This file is part of the Calibre-Web (https://github.com/janeczku/calibre-web) +# Copyright (C) 2022 xlivevil +# +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . +import re +from concurrent import futures +from typing import List, Optional + +import requests +from html2text import HTML2Text +from lxml import etree + +from cps import logger +from cps.services.Metadata import Metadata, MetaRecord, MetaSourceInfo + +log = logger.create() + + +def html2text(html: str) -> str: + + h2t = HTML2Text() + h2t.body_width = 0 + h2t.single_line_break = True + h2t.emphasis_mark = "*" + return h2t.handle(html) + + +class Douban(Metadata): + __name__ = "豆瓣" + __id__ = "douban" + DESCRIPTION = "豆瓣" + META_URL = "https://book.douban.com/" + SEARCH_JSON_URL = "https://www.douban.com/j/search" + SEARCH_URL = "https://www.douban.com/search" + + ID_PATTERN = re.compile(r"sid: (?P\d+),") + AUTHORS_PATTERN = re.compile(r"作者|译者") + PUBLISHER_PATTERN = re.compile(r"出版社") + SUBTITLE_PATTERN = re.compile(r"副标题") + PUBLISHED_DATE_PATTERN = re.compile(r"出版年") + SERIES_PATTERN = re.compile(r"丛书") + IDENTIFIERS_PATTERN = re.compile(r"ISBN|统一书号") + CRITERIA_PATTERN = re.compile("criteria = '(.+)'") + + TITTLE_XPATH = "//span[@property='v:itemreviewed']" + COVER_XPATH = "//a[@class='nbg']" + INFO_XPATH = "//*[@id='info']//span[@class='pl']" + TAGS_XPATH = "//a[contains(@class, 'tag')]" + DESCRIPTION_XPATH = "//div[@id='link-report']//div[@class='intro']" + RATING_XPATH = "//div[@class='rating_self clearfix']/strong" + + session = requests.Session() + session.headers = { + 'user-agent': + 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/98.0.4758.102 Safari/537.36 Edg/98.0.1108.56', + } + + def search(self, + query: str, + generic_cover: str = "", + locale: str = "en",**kwargs) -> List[MetaRecord]: + val = [] + if self.active: + log.debug(f"start searching {query} on douban") + if title_tokens := list( + self.get_title_tokens(query, strip_joiners=False)): + query = "+".join(title_tokens) + + book_id_list = self._get_book_id_list_from_html(query) + + if not book_id_list: + log.debug("No search results in Douban") + return [] + + with futures.ThreadPoolExecutor( + max_workers=5, thread_name_prefix='douban') as executor: + + fut = [ + executor.submit(self._parse_single_book, book_id, + generic_cover) for book_id in book_id_list + ] + + val = [ + future.result() for future in futures.as_completed(fut) + if future.result() + ] + + return val + + def _get_book_id_list_from_html(self, query: str) -> List[str]: + try: + r = self.session.get(self.SEARCH_URL, + params={ + "cat": 1001, + "q": query + }) + r.raise_for_status() + + except Exception as e: + log.warning(e) + return [] + + html = etree.HTML(r.content.decode("utf8")) + result_list = html.xpath(self.COVER_XPATH) + + return [ + self.ID_PATTERN.search(item.get("onclick")).group("id") + for item in result_list[:10] + if self.ID_PATTERN.search(item.get("onclick")) + ] + + def _get_book_id_list_from_json(self, query: str) -> List[str]: + try: + r = self.session.get(self.SEARCH_JSON_URL, + params={ + "cat": 1001, + "q": query + }) + r.raise_for_status() + + except Exception as e: + log.warning(e) + return [] + + results = r.json() + if results["total"] == 0: + return [] + + return [ + self.ID_PATTERN.search(item).group("id") + for item in results["items"][:10] if self.ID_PATTERN.search(item) + ] + + def _parse_single_book(self, + id: str, + generic_cover: str = "") -> Optional[MetaRecord]: + url = f"https://book.douban.com/subject/{id}/" + log.debug(f"start parsing {url}") + + try: + r = self.session.get(url) + r.raise_for_status() + except Exception as e: + log.warning(e) + return None + + match = MetaRecord( + id=id, + title="", + authors=[], + url=url, + source=MetaSourceInfo( + id=self.__id__, + description=self.DESCRIPTION, + link=self.META_URL, + ), + ) + + decode_content = r.content.decode("utf8") + html = etree.HTML(decode_content) + + match.title = html.xpath(self.TITTLE_XPATH)[0].text + match.cover = html.xpath( + self.COVER_XPATH)[0].attrib["href"] or generic_cover + try: + rating_num = float(html.xpath(self.RATING_XPATH)[0].text.strip()) + except Exception: + rating_num = 0 + match.rating = int(-1 * rating_num // 2 * -1) if rating_num else 0 + + tag_elements = html.xpath(self.TAGS_XPATH) + if len(tag_elements): + match.tags = [tag_element.text for tag_element in tag_elements] + else: + match.tags = self._get_tags(decode_content) + + description_element = html.xpath(self.DESCRIPTION_XPATH) + if len(description_element): + match.description = html2text( + etree.tostring(description_element[-1]).decode("utf8")) + + info = html.xpath(self.INFO_XPATH) + + for element in info: + text = element.text + if self.AUTHORS_PATTERN.search(text): + next_element = element.getnext() + while next_element is not None and next_element.tag != "br": + match.authors.append(next_element.text) + next_element = next_element.getnext() + elif self.PUBLISHER_PATTERN.search(text): + if publisher := element.tail.strip(): + match.publisher = publisher + else: + match.publisher = element.getnext().text + elif self.SUBTITLE_PATTERN.search(text): + match.title = f'{match.title}:{element.tail.strip()}' + elif self.PUBLISHED_DATE_PATTERN.search(text): + match.publishedDate = self._clean_date(element.tail.strip()) + elif self.SERIES_PATTERN.search(text): + match.series = element.getnext().text + elif i_type := self.IDENTIFIERS_PATTERN.search(text): + match.identifiers[i_type.group()] = element.tail.strip() + + return match + + @staticmethod + def _clean_date(date: str) -> str: + """ + Clean up the date string to be in the format YYYY-MM-DD + + Examples of possible patterns: + '2014-7-16', '1988年4月', '1995-04', '2021-8', '2020-12-1', '1996年', + '1972', '2004/11/01', '1959年3月北京第1版第1印' + """ + year = date[:4] + moon = "01" + day = "01" + + if len(date) > 5: + digit = [] + ls = [] + for i in range(5, len(date)): + if date[i].isdigit(): + digit.append(date[i]) + elif digit: + ls.append("".join(digit) if len(digit) == + 2 else f"0{digit[0]}") + digit = [] + if digit: + ls.append("".join(digit) if len(digit) == + 2 else f"0{digit[0]}") + + moon = ls[0] + if len(ls) > 1: + day = ls[1] + + return f"{year}-{moon}-{day}" + + def _get_tags(self, text: str) -> List[str]: + tags = [] + if criteria := self.CRITERIA_PATTERN.search(text): + tags.extend( + item.replace('7:', '') for item in criteria.group().split('|') + if item.startswith('7:')) + + return tags diff --git a/root/app/calibre-web/cps/metadata_provider/google.py b/root/app/calibre-web/cps/metadata_provider/google.py new file mode 100644 index 0000000..150dab5 --- /dev/null +++ b/root/app/calibre-web/cps/metadata_provider/google.py @@ -0,0 +1,129 @@ +# -*- coding: utf-8 -*- + +# This file is part of the Calibre-Web (https://github.com/janeczku/calibre-web) +# Copyright (C) 2021 OzzieIsaacs +# +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . + +# Google Books api document: https://developers.google.com/books/docs/v1/using +from typing import Dict, List, Optional +from urllib.parse import quote +from datetime import datetime + +import requests + +from cps import logger +from cps.isoLanguages import get_lang3, get_language_name +from cps.services.Metadata import MetaRecord, MetaSourceInfo, Metadata + +log = logger.create() + + +class Google(Metadata): + __name__ = "Google" + __id__ = "google" + DESCRIPTION = "Google Books" + META_URL = "https://books.google.com/" + BOOK_URL = "https://books.google.com/books?id=" + SEARCH_URL = "https://www.googleapis.com/books/v1/volumes?q=" + ISBN_TYPE = "ISBN_13" + + def search( + self, query: str, generic_cover: str = "", locale: str = "en",**kwargs + ) -> Optional[List[MetaRecord]]: + val = list() + if self.active: + + title_tokens = list(self.get_title_tokens(query, strip_joiners=False)) + if title_tokens: + tokens = [quote(t.encode("utf-8")) for t in title_tokens] + query = "+".join(tokens) + try: + results = requests.get(Google.SEARCH_URL + query) + results.raise_for_status() + except Exception as e: + log.warning(e) + return [] + for result in results.json().get("items", []): + val.append( + self._parse_search_result( + result=result, generic_cover=generic_cover, locale=locale + ) + ) + return val + + def _parse_search_result( + self, result: Dict, generic_cover: str, locale: str + ) -> MetaRecord: + match = MetaRecord( + id=result["id"], + title=result["volumeInfo"]["title"], + authors=result["volumeInfo"].get("authors", []), + url=Google.BOOK_URL + result["id"], + source=MetaSourceInfo( + id=self.__id__, + description=Google.DESCRIPTION, + link=Google.META_URL, + ), + ) + + match.cover = self._parse_cover(result=result, generic_cover=generic_cover) + match.description = result["volumeInfo"].get("description", "") + match.languages = self._parse_languages(result=result, locale=locale) + match.publisher = result["volumeInfo"].get("publisher", "") + try: + datetime.strptime(result["volumeInfo"].get("publishedDate", ""), "%Y-%m-%d") + match.publishedDate = result["volumeInfo"].get("publishedDate", "") + except ValueError: + match.publishedDate = "" + match.rating = result["volumeInfo"].get("averageRating", 0) + match.series, match.series_index = "", 1 + match.tags = result["volumeInfo"].get("categories", []) + + match.identifiers = {"google": match.id} + match = self._parse_isbn(result=result, match=match) + return match + + @staticmethod + def _parse_isbn(result: Dict, match: MetaRecord) -> MetaRecord: + identifiers = result["volumeInfo"].get("industryIdentifiers", []) + for identifier in identifiers: + if identifier.get("type") == Google.ISBN_TYPE: + match.identifiers["isbn"] = identifier.get("identifier") + break + return match + + @staticmethod + def _parse_cover(result: Dict, generic_cover: str) -> str: + if result["volumeInfo"].get("imageLinks"): + cover_url = result["volumeInfo"]["imageLinks"]["thumbnail"] + + # strip curl in cover + cover_url = cover_url.replace("&edge=curl", "") + + # request 800x900 cover image (higher resolution) + cover_url += "&fife=w800-h900" + + return cover_url.replace("http://", "https://") + return generic_cover + + @staticmethod + def _parse_languages(result: Dict, locale: str) -> List[str]: + language_iso2 = result["volumeInfo"].get("language", "") + languages = ( + [get_language_name(locale, get_lang3(language_iso2))] + if language_iso2 + else [] + ) + return languages diff --git a/root/app/calibre-web/cps/metadata_provider/hardcover.py b/root/app/calibre-web/cps/metadata_provider/hardcover.py new file mode 100644 index 0000000..9e36f0c --- /dev/null +++ b/root/app/calibre-web/cps/metadata_provider/hardcover.py @@ -0,0 +1,255 @@ +# -*- coding: utf-8 -*- + +# This file is part of the Calibre-Web (https://github.com/janeczku/calibre-web) +# Copyright (C) 2021 OzzieIsaacs +# +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . + +# Hardcover api document: https://Hardcover.gamespot.com/api/documentation +from typing import Dict, List, Optional +from urllib.parse import quote + +import requests +from cps import logger +from cps.services.Metadata import MetaRecord, MetaSourceInfo, Metadata +from importlib import reload + +from flask import g + +log = logger.create() + + +class Hardcover(Metadata): + __name__ = "Hardcover" + __id__ = "hardcover" + DESCRIPTION = "Hardcover Books" + META_URL = "https://hardcover.app" + BASE_URL = "https://api.hardcover.app/v1/graphql" + # SEARCH_QUERY = """{ + # books( + # where: {title: {_eq: "%s"}} + # limit: 10 + # order_by: {users_read_count: desc} + # ) { + # title + # book_series { + # series { + # name + # } + # position + # } + # cached_contributors + # id + # cached_image + # slug + # description + # release_date + # cached_tags + # } + # }""" + SEARCH_QUERY = """query Search($query: String!) { + search(query: $query, query_type: "Book", per_page: 50) { + results + } + } + """ + EDITION_QUERY = """query getEditions($query: Int!) { + books( + where: { id: { _eq: $query } } + order_by: { users_read_count: desc_nulls_last } + ) { + title + slug + id + + book_series { + series { + name + } + position + } + rating + editions( + where: { + _or: [{ reading_format_id: { _neq: 2 } }, { edition_format: { _is_null: true } }] + } + order_by: [{ reading_format_id: desc_nulls_last },{users_count: desc_nulls_last }] + ) { + id + isbn_13 + isbn_10 + title + reading_format_id + contributions { + author { + name + } + } + image { + url + } + language { + code3 + } + publisher { + name + } + release_date + + } + description + cached_tags(path: "Genre") + } + } + """ + HEADERS = { + "Content-Type": "application/json", + } + FORMATS = ["","Physical Book","","","E-Book"] # Map reading_format_id to text equivelant. + + def search( + self, query: str, generic_cover: str = "", locale: str = "en", **kwargs + ) -> Optional[List[MetaRecord]]: + token = kwargs.get("token") + if not token: + log.warning("Hardcover token not set for user") + return None + val = list() + if self.active: + try: + if (token == ""): + raise Exception("Current user does not have Hardcover API token") + else: + edition_seach = query.split(":")[0] == "hardcover-id" + Hardcover.HEADERS["Authorization"] = "Bearer %s" % token + result = requests.post( + Hardcover.BASE_URL, + json={ + "query":Hardcover.SEARCH_QUERY if not edition_seach else Hardcover.EDITION_QUERY, + "variables":{"query":query if not edition_seach else query.split(":")[1]} + }, + headers=Hardcover.HEADERS, + ) + result.raise_for_status() + except Exception as e: + log.warning(e) + return None + if edition_seach: + result = result.json()["data"]["books"][0] + log.debug(result) + val = self._parse_edition_results(result=result, generic_cover=generic_cover, locale=locale) + else: + for result in result.json()["data"]["search"]["results"]["hits"]: + match = self._parse_title_result( + result=result, generic_cover=generic_cover, locale=locale + ) + val.append(match) + return val + + def _parse_title_result( + self, result: Dict, generic_cover: str, locale: str + ) -> MetaRecord: + series = result["document"].get("featured_series",{}).get("series_name", "") + series_index = result["document"].get("featured_series",{}).get("position", "") + match = MetaRecord( + id=result["document"].get("id",""), + title=result["document"].get("title",""), + authors=result["document"].get("author_names", []), + url=self._parse_title_url(result, ""), + source=MetaSourceInfo( + id=self.__id__, + description=Hardcover.DESCRIPTION, + link=Hardcover.META_URL, + ), + series=series, + ) + # TODO Add parse cover function to get better size + match.cover = result["document"]["image"].get("url", generic_cover) + + match.description = result["document"].get("description","") + match.publishedDate = result["document"].get( + "release_date", "") + match.series_index = series_index + match.tags = result["document"].get("genres",[]) + match.identifiers = { + "hardcover-id": match.id, + "hardcover-slug": result["document"].get("slug", "") + } + return match + + def _parse_edition_results( + self, result: Dict, generic_cover: str, locale: str + ) -> MetaRecord: + editions = list() + id = result.get("id","") + for edition in result["editions"]: + match = MetaRecord( + id=id, + title=edition.get("title",""), + authors=self._parse_edition_authors(edition,[]), + url=self._parse_edition_url(edition, ""), + source=MetaSourceInfo( + id=self.__id__, + description=Hardcover.DESCRIPTION, + link=Hardcover.META_URL, + ), + series=result.get("book_series",[{}])[0].get("series",{}).get("name", ""), + ) + # TODO Add parse cover function to get better size + match.cover = (edition.get("image") or {}).get("url", generic_cover) + match.description = result.get("description","") + match.publisher = (edition.get("publisher") or {}).get("name","") + match.publishedDate = edition.get("release_date", "") + match.series_index = result.get("book_series",[{}])[0].get("position", "") + match.tags = self._parse_tags(result,[]) + match.languages = (edition.get("language") or {}).get("code3","") + match.identifiers = { + "hardcover-id": id, + "hardcover-slug": result.get("slug", ""), + "hardcover-edition": edition.get("id",""), + "isbn": (edition.get("isbn_13",edition.get("isbn_10")) or "") + } + match.format = Hardcover.FORMATS[edition.get("reading_format_id",0)] + editions.append(match) + return editions + + @staticmethod + def _parse_title_url(result: Dict, url: str) -> str: + hardcover_slug = result["document"].get("slug", "") + if hardcover_slug: + return f"https://hardcover.app/books/{hardcover_slug}" + return url + + @staticmethod + def _parse_edition_url(edition: Dict, url: str) -> str: + hardcover_edition = edition.get("id", "") + if hardcover_edition: + return f"https://hardcover.app/books/jurassic-park/editions/{hardcover_edition}" + return url + + @staticmethod + def _parse_edition_authors(edition: Dict, authors: List[str]) -> List[str]: + try: + return [author["author"]["name"] for author in edition.get("contributions",[]) if "author" in author and "name" in author["author"]] + except Exception as e: + log.warning(e) + return authors + + @staticmethod + def _parse_tags(result: Dict, tags: List[str]) -> List[str]: + try: + return [item["tag"] for item in result["cached_tags"] if "tag" in item] + except Exception as e: + log.warning(e) + return tags diff --git a/root/app/calibre-web/cps/metadata_provider/lubimyczytac.py b/root/app/calibre-web/cps/metadata_provider/lubimyczytac.py new file mode 100644 index 0000000..003a732 --- /dev/null +++ b/root/app/calibre-web/cps/metadata_provider/lubimyczytac.py @@ -0,0 +1,359 @@ +# -*- coding: utf-8 -*- +# This file is part of the Calibre-Web (https://github.com/janeczku/calibre-web) +# Copyright (C) 2021 OzzieIsaacs +# +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . +import datetime +import json +import re +from multiprocessing.pool import ThreadPool +from typing import List, Optional, Tuple, Union +from urllib.parse import quote + +import requests +from dateutil import parser +from html2text import HTML2Text +from lxml.html import HtmlElement, fromstring, tostring +from markdown2 import Markdown + +from cps import logger +from cps.isoLanguages import get_language_name +from cps.services.Metadata import MetaRecord, MetaSourceInfo, Metadata + +log = logger.create() + +SYMBOLS_TO_TRANSLATE = ( + "öÖüÜóÓőŐúÚéÉáÁűŰíÍąĄćĆęĘłŁńŃóÓśŚźŹżŻ", + "oOuUoOoOuUeEaAuUiIaAcCeElLnNoOsSzZzZ", +) +SYMBOL_TRANSLATION_MAP = dict( + [(ord(a), ord(b)) for (a, b) in zip(*SYMBOLS_TO_TRANSLATE)] +) + + +def get_int_or_float(value: str) -> Union[int, float]: + number_as_float = float(value) + number_as_int = int(number_as_float) + return number_as_int if number_as_float == number_as_int else number_as_float + + +def strip_accents(s: Optional[str]) -> Optional[str]: + return s.translate(SYMBOL_TRANSLATION_MAP) if s is not None else s + + +def sanitize_comments_html(html: str) -> str: + text = html2text(html) + md = Markdown() + html = md.convert(text) + return html + + +def html2text(html: str) -> str: + # replace tags with as becomes emphasis in html2text + if isinstance(html, bytes): + html = html.decode("utf-8") + html = re.sub( + r"<\s*(?P/?)\s*[uU]\b(?P[^>]*)>", + r"<\gspan\g>", + html, + ) + h2t = HTML2Text() + h2t.body_width = 0 + h2t.single_line_break = True + h2t.emphasis_mark = "*" + return h2t.handle(html) + + +class LubimyCzytac(Metadata): + __name__ = "LubimyCzytac.pl" + __id__ = "lubimyczytac" + + BASE_URL = "https://lubimyczytac.pl" + + BOOK_SEARCH_RESULT_XPATH = ( + "*//div[@class='listSearch']//div[@class='authorAllBooks__single']" + ) + SINGLE_BOOK_RESULT_XPATH = ".//div[contains(@class,'authorAllBooks__singleText')]" + TITLE_PATH = "/div/a[contains(@class,'authorAllBooks__singleTextTitle')]" + TITLE_TEXT_PATH = f"{TITLE_PATH}//text()" + URL_PATH = f"{TITLE_PATH}/@href" + AUTHORS_PATH = "/div/a[contains(@href,'autor')]//text()" + + SIBLINGS = "/following-sibling::dd" + + CONTAINER = "//section[@class='container book']" + PUBLISHER = f"{CONTAINER}//dt[contains(text(),'Wydawnictwo:')]{SIBLINGS}/a/text()" + LANGUAGES = f"{CONTAINER}//dt[contains(text(),'Język:')]{SIBLINGS}/text()" + DESCRIPTION = f"{CONTAINER}//div[@class='collapse-content']" + SERIES = f"{CONTAINER}//span/a[contains(@href,'/cykl/')]/text()" + TRANSLATOR = f"{CONTAINER}//dt[contains(text(),'Tłumacz:')]{SIBLINGS}/a/text()" + + DETAILS = "//div[@id='book-details']" + PUBLISH_DATE = "//dt[contains(@title,'Data pierwszego wydania" + FIRST_PUBLISH_DATE = f"{DETAILS}{PUBLISH_DATE} oryginalnego')]{SIBLINGS}[1]/text()" + FIRST_PUBLISH_DATE_PL = f"{DETAILS}{PUBLISH_DATE} polskiego')]{SIBLINGS}[1]/text()" + TAGS = "//a[contains(@href,'/ksiazki/t/')]/text()" # "//nav[@aria-label='breadcrumbs']//a[contains(@href,'/ksiazki/k/')]/span/text()" + + + RATING = "//meta[@property='books:rating:value']/@content" + COVER = "//meta[@property='og:image']/@content" + ISBN = "//meta[@property='books:isbn']/@content" + META_TITLE = "//meta[@property='og:description']/@content" + + SUMMARY = "//script[@type='application/ld+json']//text()" + + def search( + self, query: str, generic_cover: str = "", locale: str = "en",**kwargs + ) -> Optional[List[MetaRecord]]: + if self.active: + try: + result = requests.get(self._prepare_query(title=query)) + result.raise_for_status() + except Exception as e: + log.warning(e) + return None + root = fromstring(result.text) + lc_parser = LubimyCzytacParser(root=root, metadata=self) + matches = lc_parser.parse_search_results() + if matches: + with ThreadPool(processes=10) as pool: + final_matches = pool.starmap( + lc_parser.parse_single_book, + [(match, generic_cover, locale) for match in matches], + ) + return final_matches + return matches + + def _prepare_query(self, title: str) -> str: + query = "" + characters_to_remove = r"\?()\/" + pattern = "[" + characters_to_remove + "]" + title = re.sub(pattern, "", title) + title = title.replace("_", " ") + if '"' in title or ",," in title: + title = title.split('"')[0].split(",,")[0] + + if "/" in title: + title_tokens = [ + token for token in title.lower().split(" ") if len(token) > 1 + ] + else: + title_tokens = list(self.get_title_tokens(title, strip_joiners=False)) + if title_tokens: + tokens = [quote(t.encode("utf-8")) for t in title_tokens] + query = query + "%20".join(tokens) + if not query: + return "" + return f"{LubimyCzytac.BASE_URL}/szukaj/ksiazki?phrase={query}" + + +class LubimyCzytacParser: + PAGES_TEMPLATE = "

    Książka ma {0} stron(y).

    " + TRANSLATOR_TEMPLATE = "

    Tłumacz: {0}

    " + PUBLISH_DATE_TEMPLATE = "

    Data pierwszego wydania: {0}

    " + PUBLISH_DATE_PL_TEMPLATE = ( + "

    Data pierwszego wydania w Polsce: {0}

    " + ) + + def __init__(self, root: HtmlElement, metadata: Metadata) -> None: + self.root = root + self.metadata = metadata + + def parse_search_results(self) -> List[MetaRecord]: + matches = [] + results = self.root.xpath(LubimyCzytac.BOOK_SEARCH_RESULT_XPATH) + for result in results: + title = self._parse_xpath_node( + root=result, + xpath=f"{LubimyCzytac.SINGLE_BOOK_RESULT_XPATH}" + f"{LubimyCzytac.TITLE_TEXT_PATH}", + ) + + book_url = self._parse_xpath_node( + root=result, + xpath=f"{LubimyCzytac.SINGLE_BOOK_RESULT_XPATH}" + f"{LubimyCzytac.URL_PATH}", + ) + authors = self._parse_xpath_node( + root=result, + xpath=f"{LubimyCzytac.SINGLE_BOOK_RESULT_XPATH}" + f"{LubimyCzytac.AUTHORS_PATH}", + take_first=False, + ) + if not all([title, book_url, authors]): + continue + matches.append( + MetaRecord( + id=book_url.replace(f"/ksiazka/", "").split("/")[0], + title=title, + authors=[strip_accents(author) for author in authors], + url=LubimyCzytac.BASE_URL + book_url, + source=MetaSourceInfo( + id=self.metadata.__id__, + description=self.metadata.__name__, + link=LubimyCzytac.BASE_URL, + ), + ) + ) + return matches + + def parse_single_book( + self, match: MetaRecord, generic_cover: str, locale: str + ) -> MetaRecord: + try: + response = requests.get(match.url) + response.raise_for_status() + except Exception as e: + log.warning(e) + return None + self.root = fromstring(response.text) + match.cover = self._parse_cover(generic_cover=generic_cover) + match.description = self._parse_description() + match.languages = self._parse_languages(locale=locale) + match.publisher = self._parse_publisher() + match.publishedDate = self._parse_from_summary(attribute_name="datePublished") + match.rating = self._parse_rating() + match.series, match.series_index = self._parse_series() + match.tags = self._parse_tags() + match.identifiers = { + "isbn": self._parse_isbn(), + "lubimyczytac": match.id, + } + return match + + def _parse_xpath_node( + self, + xpath: str, + root: HtmlElement = None, + take_first: bool = True, + strip_element: bool = True, + ) -> Optional[Union[str, List[str]]]: + root = root if root is not None else self.root + node = root.xpath(xpath) + if not node: + return None + return ( + (node[0].strip() if strip_element else node[0]) + if take_first + else [x.strip() for x in node] + ) + + def _parse_cover(self, generic_cover) -> Optional[str]: + return ( + self._parse_xpath_node(xpath=LubimyCzytac.COVER, take_first=True) + or generic_cover + ) + + def _parse_publisher(self) -> Optional[str]: + return self._parse_xpath_node(xpath=LubimyCzytac.PUBLISHER, take_first=True) + + def _parse_languages(self, locale: str) -> List[str]: + languages = list() + lang = self._parse_xpath_node(xpath=LubimyCzytac.LANGUAGES, take_first=True) + if lang: + if "polski" in lang: + languages.append("pol") + if "angielski" in lang: + languages.append("eng") + return [get_language_name(locale, language) for language in languages] + + def _parse_series(self) -> Tuple[Optional[str], Optional[Union[float, int]]]: + series_index = 0 + series = self._parse_xpath_node(xpath=LubimyCzytac.SERIES, take_first=True) + if series: + if "tom " in series: + series_name, series_info = series.split(" (tom ", 1) + series_info = series_info.replace(" ", "").replace(")", "") + # Check if book is not a bundle, i.e. chapter 1-3 + if "-" in series_info: + series_info = series_info.split("-", 1)[0] + if series_info.replace(".", "").isdigit() is True: + series_index = get_int_or_float(series_info) + return series_name, series_index + return None, None + + def _parse_tags(self) -> List[str]: + tags = self._parse_xpath_node(xpath=LubimyCzytac.TAGS, take_first=False) + if tags: + return [ + strip_accents(w.replace(", itd.", " itd.")) + for w in tags + if isinstance(w, str) + ] + return None + + def _parse_from_summary(self, attribute_name: str) -> Optional[str]: + value = None + summary_text = self._parse_xpath_node(xpath=LubimyCzytac.SUMMARY) + if summary_text: + data = json.loads(summary_text) + value = data.get(attribute_name) + return value.strip() if value is not None else value + + def _parse_rating(self) -> Optional[str]: + rating = self._parse_xpath_node(xpath=LubimyCzytac.RATING) + return round(float(rating.replace(",", ".")) / 2) if rating else rating + + def _parse_date(self, xpath="first_publish") -> Optional[datetime.datetime]: + options = { + "first_publish": LubimyCzytac.FIRST_PUBLISH_DATE, + "first_publish_pl": LubimyCzytac.FIRST_PUBLISH_DATE_PL, + } + date = self._parse_xpath_node(xpath=options.get(xpath)) + return parser.parse(date) if date else None + + def _parse_isbn(self) -> Optional[str]: + return self._parse_xpath_node(xpath=LubimyCzytac.ISBN) + + def _parse_description(self) -> str: + description = "" + description_node = self._parse_xpath_node( + xpath=LubimyCzytac.DESCRIPTION, strip_element=False + ) + if description_node is not None: + for source in self.root.xpath('//p[@class="source"]'): + source.getparent().remove(source) + description = tostring(description_node, method="html") + description = sanitize_comments_html(description) + + else: + description_node = self._parse_xpath_node(xpath=LubimyCzytac.META_TITLE) + if description_node is not None: + description = description_node + description = sanitize_comments_html(description) + description = self._add_extra_info_to_description(description=description) + return description + + def _add_extra_info_to_description(self, description: str) -> str: + pages = self._parse_from_summary(attribute_name="numberOfPages") + if pages: + description += LubimyCzytacParser.PAGES_TEMPLATE.format(pages) + + first_publish_date = self._parse_date() + if first_publish_date: + description += LubimyCzytacParser.PUBLISH_DATE_TEMPLATE.format( + first_publish_date.strftime("%d.%m.%Y") + ) + + first_publish_date_pl = self._parse_date(xpath="first_publish_pl") + if first_publish_date_pl: + description += LubimyCzytacParser.PUBLISH_DATE_PL_TEMPLATE.format( + first_publish_date_pl.strftime("%d.%m.%Y") + ) + translator = self._parse_xpath_node(xpath=LubimyCzytac.TRANSLATOR) + if translator: + description += LubimyCzytacParser.TRANSLATOR_TEMPLATE.format(translator) + + + return description diff --git a/root/app/calibre-web/cps/metadata_provider/scholar.py b/root/app/calibre-web/cps/metadata_provider/scholar.py new file mode 100644 index 0000000..b3bfbb7 --- /dev/null +++ b/root/app/calibre-web/cps/metadata_provider/scholar.py @@ -0,0 +1,83 @@ +# -*- coding: utf-8 -*- + +# This file is part of the Calibre-Web (https://github.com/janeczku/calibre-web) +# Copyright (C) 2021 OzzieIsaacs +# +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . +import itertools +from typing import Dict, List, Optional +from urllib.parse import quote, unquote + +try: + from fake_useragent.errors import FakeUserAgentError +except (ImportError): + FakeUserAgentError = BaseException +try: + from scholarly import scholarly +except FakeUserAgentError: + raise ImportError("No module named 'scholarly'") + +from cps import logger +from cps.services.Metadata import MetaRecord, MetaSourceInfo, Metadata + +log = logger.create() + + +class scholar(Metadata): + __name__ = "Google Scholar" + __id__ = "googlescholar" + META_URL = "https://scholar.google.com/" + + def search( + self, query: str, generic_cover: str = "", locale: str = "en",**kwargs + ) -> Optional[List[MetaRecord]]: + val = list() + if self.active: + title_tokens = list(self.get_title_tokens(query, strip_joiners=False)) + if title_tokens: + tokens = [quote(t.encode("utf-8")) for t in title_tokens] + query = " ".join(tokens) + try: + scholarly.set_timeout(20) + scholarly.set_retries(2) + scholar_gen = itertools.islice(scholarly.search_pubs(query), 10) + except Exception as e: + log.warning(e) + return list() + for result in scholar_gen: + match = self._parse_search_result( + result=result, generic_cover="", locale=locale + ) + val.append(match) + return val + + def _parse_search_result( + self, result: Dict, generic_cover: str, locale: str + ) -> MetaRecord: + match = MetaRecord( + id=result.get("pub_url", result.get("eprint_url", "")), + title=result["bib"].get("title"), + authors=result["bib"].get("author", []), + url=result.get("pub_url", result.get("eprint_url", "")), + source=MetaSourceInfo( + id=self.__id__, description=self.__name__, link=scholar.META_URL + ), + ) + + match.cover = result.get("image", {}).get("original_url", generic_cover) + match.description = unquote(result["bib"].get("abstract", "")) + match.publisher = result["bib"].get("venue", "") + match.publishedDate = result["bib"].get("pub_year") + "-01-01" + match.identifiers = {"scholar": match.id} + return match diff --git a/root/app/calibre-web/cps/search_metadata.py b/root/app/calibre-web/cps/search_metadata.py new file mode 100644 index 0000000..9700c9c --- /dev/null +++ b/root/app/calibre-web/cps/search_metadata.py @@ -0,0 +1,139 @@ +# -*- coding: utf-8 -*- + +# This file is part of the Calibre-Web (https://github.com/janeczku/calibre-web) +# Copyright (C) 2021 OzzieIsaacs +# +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . + +import concurrent.futures +import importlib +import inspect +import json +import os +import sys + +from flask import Blueprint, request, url_for, make_response, jsonify +from .cw_login import current_user +from flask_babel import get_locale +from sqlalchemy.exc import InvalidRequestError, OperationalError +from sqlalchemy.orm.attributes import flag_modified + +from cps.services.Metadata import Metadata +from . import constants, logger, ub, web_server +from .usermanagement import user_login_required + + +meta = Blueprint("metadata", __name__) + +log = logger.create() + +try: + from dataclasses import asdict +except ImportError: + log.info('*** "dataclasses" is needed for calibre-web to run. Please install it using pip: "pip install dataclasses" ***') + print('*** "dataclasses" is needed for calibre-web to run. Please install it using pip: "pip install dataclasses" ***') + web_server.stop(True) + sys.exit(6) + +new_list = list() +meta_dir = os.path.join(constants.BASE_DIR, "cps", "metadata_provider") +modules = os.listdir(os.path.join(constants.BASE_DIR, "cps", "metadata_provider")) +for f in modules: + if os.path.isfile(os.path.join(meta_dir, f)) and not f.endswith("__init__.py"): + a = os.path.basename(f)[:-3] + try: + importlib.import_module("cps.metadata_provider." + a) + new_list.append(a) + except (IndentationError, SyntaxError) as e: + log.error("Syntax error for metadata source: {} - {}".format(a, e)) + except ImportError as e: + log.debug("Import error for metadata source: {} - {}".format(a, e)) + + +def list_classes(provider_list): + classes = list() + for element in provider_list: + for name, obj in inspect.getmembers( + sys.modules["cps.metadata_provider." + element] + ): + if ( + inspect.isclass(obj) + and name != "Metadata" + and issubclass(obj, Metadata) + ): + classes.append(obj()) + return classes + + +cl = list_classes(new_list) + + +@meta.route("/metadata/provider") +@user_login_required +def metadata_provider(): + active = current_user.view_settings.get("metadata", {}) + provider = list() + for c in cl: + ac = active.get(c.__id__, True) + provider.append( + {"name": c.__name__, "active": ac, "initial": ac, "id": c.__id__} + ) + return make_response(jsonify(provider)) + + +@meta.route("/metadata/provider", methods=["POST"]) +@meta.route("/metadata/provider/", methods=["POST"]) +@user_login_required +def metadata_change_active_provider(prov_name): + new_state = request.get_json() + active = current_user.view_settings.get("metadata", {}) + active[new_state["id"]] = new_state["value"] + current_user.view_settings["metadata"] = active + try: + try: + flag_modified(current_user, "view_settings") + except AttributeError: + pass + ub.session.commit() + except (InvalidRequestError, OperationalError): + log.error("Invalid request received: {}".format(request)) + return "Invalid request", 400 + if "initial" in new_state and prov_name: + data = [] + provider = next((c for c in cl if c.__id__ == prov_name), None) + if provider is not None: + data = provider.search(new_state.get("query", "")) + return make_response(jsonify([asdict(x) for x in data])) + return "" + + +@meta.route("/metadata/search", methods=["POST"]) +@user_login_required +def metadata_search(): + query = request.form.to_dict().get("query") + data = list() + active = current_user.view_settings.get("metadata", {}) + locale = get_locale() + if query: + static_cover = url_for("static", filename="generic_cover.jpg") + # ret = cl[0].search(query, static_cover, locale) + with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor: + meta = { + executor.submit(c.search, query, static_cover, locale, token=getattr(current_user,f'{c.__id__}_token',None)): c + for c in cl + if active.get(c.__id__, True) + } + for future in concurrent.futures.as_completed(meta): + data.extend([asdict(x) for x in future.result() if x]) + return make_response(jsonify(data)) diff --git a/root/app/calibre-web/cps/services/Metadata.py b/root/app/calibre-web/cps/services/Metadata.py new file mode 100644 index 0000000..d975092 --- /dev/null +++ b/root/app/calibre-web/cps/services/Metadata.py @@ -0,0 +1,112 @@ +# -*- coding: utf-8 -*- + +# This file is part of the Calibre-Web (https://github.com/janeczku/calibre-web) +# Copyright (C) 2021 OzzieIsaacs +# +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . +import abc +import dataclasses +import os +import re +from typing import Dict, Generator, List, Optional, Union + +from cps import constants + + +@dataclasses.dataclass +class MetaSourceInfo: + id: str + description: str + link: str + + +@dataclasses.dataclass +class MetaRecord: + id: Union[str, int] + title: str + authors: List[str] + url: str + source: MetaSourceInfo + cover: str = os.path.join(constants.STATIC_DIR, 'generic_cover.jpg') + description: Optional[str] = "" + series: Optional[str] = None + series_index: Optional[Union[int, float]] = 0 + identifiers: Dict[str, Union[str, int]] = dataclasses.field(default_factory=dict) + publisher: Optional[str] = None + publishedDate: Optional[str] = None + rating: Optional[int] = 0 + languages: Optional[List[str]] = dataclasses.field(default_factory=list) + tags: Optional[List[str]] = dataclasses.field(default_factory=list) + format: Optional[str] = None + + +class Metadata: + __name__ = "Generic" + __id__ = "generic" + + def __init__(self): + self.active = True + + def set_status(self, state): + self.active = state + + @abc.abstractmethod + def search( + self, query: str, generic_cover: str = "", locale: str = "en" + ) -> Optional[List[MetaRecord]]: + pass + + @staticmethod + def get_title_tokens( + title: str, strip_joiners: bool = True + ) -> Generator[str, None, None]: + """ + Taken from calibre source code + It's a simplified (cut out what is unnecessary) version of + https://github.com/kovidgoyal/calibre/blob/99d85b97918625d172227c8ffb7e0c71794966c0/ + src/calibre/ebooks/metadata/sources/base.py#L363-L367 + (src/calibre/ebooks/metadata/sources/base.py - lines 363-398) + """ + title_patterns = [ + (re.compile(pat, re.IGNORECASE), repl) + for pat, repl in [ + # Remove things like: (2010) (Omnibus) etc. + ( + r"(?i)[({\[](\d{4}|omnibus|anthology|hardcover|" + r"audiobook|audio\scd|paperback|turtleback|" + r"mass\s*market|edition|ed\.)[\])}]", + "", + ), + # Remove any strings that contain the substring edition inside + # parentheses + (r"(?i)[({\[].*?(edition|ed.).*?[\]})]", ""), + # Remove commas used a separators in numbers + (r"(\d+),(\d+)", r"\1\2"), + # Remove hyphens only if they have whitespace before them + (r"(\s-)", " "), + # Replace other special chars with a space + (r"""[:,;!@$%^&*(){}.`~"\s\[\]/]《》「」“”""", " "), + ] + ] + + for pat, repl in title_patterns: + title = pat.sub(repl, title) + + tokens = title.split() + for token in tokens: + token = token.strip().strip('"').strip("'") + if token and ( + not strip_joiners or token.lower() not in ("a", "and", "the", "&") + ): + yield token diff --git a/root/app/calibre-web/cps/services/__init__.py b/root/app/calibre-web/cps/services/__init__.py new file mode 100644 index 0000000..000a6f9 --- /dev/null +++ b/root/app/calibre-web/cps/services/__init__.py @@ -0,0 +1,56 @@ +# -*- coding: utf-8 -*- + +# This file is part of the Calibre-Web (https://github.com/janeczku/calibre-web) +# Copyright (C) 2019 pwr +# +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . + +from .. import logger + +log = logger.create() + +try: + from . import goodreads_support +except ImportError as err: + log.debug("Cannot import goodreads, showing authors-metadata will not work: %s", err) + goodreads_support = None + + +try: + from . import simpleldap as ldap + from .simpleldap import ldapVersion +except ImportError as err: + log.debug("Cannot import simpleldap, logging in with ldap will not work: %s", err) + ldap = None + ldapVersion = None + +try: + from . import SyncToken as SyncToken + kobo = True +except ImportError as err: + log.debug("Cannot import SyncToken, syncing books with Kobo Devices will not work: %s", err) + kobo = None + SyncToken = None + +try: + from . import gmail +except ImportError as err: + log.debug("Cannot import gmail, sending books via Gmail Oauth2 Verification will not work: %s", err) + gmail = None + +try: + from . import hardcover +except ImportError as err: + log.debug("Cannot import hardcover, syncing Kobo read progress to Hardcover will not work: %s", err) + hardcover = None \ No newline at end of file diff --git a/root/app/calibre-web/cps/services/hardcover.py b/root/app/calibre-web/cps/services/hardcover.py new file mode 100644 index 0000000..040289f --- /dev/null +++ b/root/app/calibre-web/cps/services/hardcover.py @@ -0,0 +1,232 @@ +# -*- coding: utf-8 -*- + +# This file is part of the Calibre-Web (https://github.com/janeczku/calibre-web) +# Copyright (C) 2018-2019 OzzieIsaacs, pwr +# +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . + +from datetime import datetime +import requests + +from .. import logger + +log = logger.create() + +GRAPHQL_ENDPOINT = "https://api.hardcover.app/v1/graphql" + +USER_BOOK_FRAGMENT = """ + fragment userBookFragment on user_books { + id + status_id + book_id + book { + slug + title + } + edition { + id + pages + } + user_book_reads(order_by: {started_at: desc}, limit: 1) { + id + started_at + finished_at + edition_id + progress_pages + } + }""" + +class HardcoverClient: + def __init__(self, token): + self.endpoint = GRAPHQL_ENDPOINT + self.headers = { + "Content-Type": "application/json", + "Authorization" : f"Bearer {token}" + } + self.privacy = self.get_privacy() + + def get_privacy(self): + query = """ + { + me { + account_privacy_setting_id + } + }""" + response = self.execute(query) + return (response.get("me")[0] or [{}]).get("account_privacy_setting_id",1) + + def get_user_book(self, ids): + query = "" + variables={} + if "hardcover-edition" in ids: + query = """ + query ($query: Int) { + me { + user_books(where: {edition_id: {_eq: $query}}) { + ...userBookFragment + } + } + }""" + variables["query"] = ids["hardcover-edition"] + elif "hardcover-id" in ids: + query = """ + query ($query: Int) { + me { + user_books(where: {book: {id: {_eq: $query}}}) { + ...userBookFragment + } + } + }""" + variables["query"] = ids["hardcover-id"] + elif "hardcover-slug" in ids: + query = """ + query ($slug: String!) { + me { + user_books(where: {book: {slug: {_eq: $query}}}) { + ...userBookFragment + } + } + }""" + variables["query"] = ids["hardcover-slug"] + query += USER_BOOK_FRAGMENT + response = self.execute(query,variables) + return next(iter(response.get("me")[0].get("user_books")),None) + + + # TODO Add option for autocreate if missing books instead of forcing it. + def update_reading_progress(self, identifiers, progress_percent): + ids = self.parse_identifiers(identifiers) + book = self.get_user_book(ids) + if not book: + book = self.add_book(ids, status=2) + if book.get("status_id") is not 2: + book = self.change_book_status(book, 2) + pages = round(book.get("edition",{}).get("pages",0)) + if pages: + pages_read = pages * (progress_percent / 100) + read = next(iter(book.get("user_book_reads")),None) + if not read: + read = self.add_read(book, pages_read) + mutation = """ + mutation ($readId: Int!, $pages: Int, $editionId: Int, $startedAt: date, $finishedAt: date) { + update_user_book_read(id: $readId, object: { + progress_pages: $pages, + edition_id: $editionId, + started_at: $startedAt, + finished_at: $finishedAt + }) { + id + } + }""" + variables = { + "readId": int(read.get("id")), + "pages": pages_read, + "editionId": int(book.get("edition").get("id")), + "startedAt":read.get("started_at",datetime.now().strftime("%Y-%m-%d")), + "finishedAt": datetime.now().strftime("%Y-%m-%d") if progress_percent is 100 else None + } + if progress_percent is 100: + self.change_book_status(book, 3) + return self.execute(query=mutation, variables=variables) + return + + def change_book_status(self, book, status): + mutation = """ + mutation ($id:Int!, $status_id: Int!) { + update_user_book(id: $id, object: {status_id: $status_id}) { + error + user_book { + ...userBookFragment + } + } + }""" + USER_BOOK_FRAGMENT + variables = { + "id":book.get("id"), + "status_id":status + } + response = self.execute(query=mutation, variables=variables) + return response.get("update_user_book",{}).get("user_book",{}) + + def add_book(self, identifiers, status=1): + ids = self.parse_identifiers(identifiers) + mutation = """ + mutation ($object: UserBookCreateInput!) { + insert_user_book(object: $object) { + error + user_book { + ...userBookFragment + } + } + }""" + USER_BOOK_FRAGMENT + variables = { + "object": { + "book_id":int(ids.get("hardcover-id")), + "edition_id":int(ids.get("hardcover-edition")) if ids.get("hardcover-edition") else None, + "status_id": status, + "privacy_setting_id": self.privacy + } + } + response = self.execute(query=mutation, variables=variables) + return response.get("insert_user_book",{}).get("user_book",{}) + + def add_read(self, book, pages=0): + mutation = """ + mutation ($id: Int!, $pages: Int, $editionId: Int, $startedAt: date) { + insert_user_book_read(user_book_id: $id, user_book_read: { + progress_pages: $pages, + edition_id: $editionId, + started_at: $startedAt, + }) { + error + user_book_read { + id + started_at + finished_at + edition_id + progress_pages + } + } + }""" + variables = { + "id":int(book.get("id")), + "editionId":int(book.get("edition").get("id")) if book.get("edition").get("id") else None, + "pages": pages, + "startedAt": datetime.now().strftime("%Y-%m-%d") + } + response = self.execute(query=mutation, variables=variables) + return response.get("insert_user_book_read").get("user_book_read") + + def parse_identifiers(self, identifiers): + if type(identifiers) != dict: + return {id.type:id.val for id in identifiers if "hardcover" in id.type} + return identifiers + + def execute(self, query, variables=None): + payload = { + "query": query, + "variables": variables or {} + } + + + response = requests.post(self.endpoint, json=payload, headers=self.headers) + try: + response.raise_for_status() + except requests.exceptions.HTTPError as e: + raise Exception(f"HTTP error occurred: {e}") + + result = response.json() + if "errors" in result: + raise Exception(f"GraphQL error: {result['errors']}") + + return result.get("data", {}) diff --git a/root/app/calibre-web/cps/shelf.py b/root/app/calibre-web/cps/shelf.py new file mode 100644 index 0000000..94deaa7 --- /dev/null +++ b/root/app/calibre-web/cps/shelf.py @@ -0,0 +1,492 @@ +# -*- coding: utf-8 -*- + +# This file is part of the Calibre-Web (https://github.com/janeczku/calibre-web) +# Copyright (C) 2018-2019 OzzieIsaacs, cervinko, jkrehm, bodybybuddha, ok11, +# andy29485, idalin, Kyosfonica, wuqi, Kennyl, lemmsh, +# falgh1, grunjol, csitko, ytils, xybydy, trasba, vrabe, +# ruben-herold, marblepebble, JackED42, SiphonSquirrel, +# apetresc, nanu-c, mutschler +# +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . + +import sys +from datetime import datetime, timezone + +from flask import Blueprint, flash, redirect, request, url_for, abort +from flask_babel import gettext as _ +from .cw_login import current_user +from sqlalchemy.exc import InvalidRequestError, OperationalError +from sqlalchemy.sql.expression import func, true + +from . import calibre_db, config, db, logger, ub +from .render_template import render_title_template +from .usermanagement import login_required_if_no_ano, user_login_required +from .services import hardcover +log = logger.create() + +shelf = Blueprint('shelf', __name__) + + +@shelf.route("/shelf/add//", methods=["POST"]) +@user_login_required +def add_to_shelf(shelf_id, book_id): + xhr = request.headers.get('X-Requested-With') == 'XMLHttpRequest' + shelf = ub.session.query(ub.Shelf).filter(ub.Shelf.id == shelf_id).first() + if shelf is None: + log.error("Invalid shelf specified: %s", shelf_id) + if not xhr: + flash(_("Invalid shelf specified"), category="error") + return redirect(url_for('web.index')) + return "Invalid shelf specified", 400 + + if not check_shelf_edit_permissions(shelf): + if not xhr: + flash(_("Sorry you are not allowed to add a book to that shelf"), category="error") + return redirect(url_for('web.index')) + return "Sorry you are not allowed to add a book to the that shelf", 403 + + book_in_shelf = ub.session.query(ub.BookShelf).filter(ub.BookShelf.shelf == shelf_id, + ub.BookShelf.book_id == book_id).first() + if book_in_shelf: + log.error("Book %s is already part of %s", book_id, shelf) + if not xhr: + flash(_("Book is already part of the shelf: %(shelfname)s", shelfname=shelf.name), category="error") + return redirect(url_for('web.index')) + return "Book is already part of the shelf: %s" % shelf.name, 400 + + maxOrder = ub.session.query(func.max(ub.BookShelf.order)).filter(ub.BookShelf.shelf == shelf_id).first() + if maxOrder[0] is None: + maxOrder = 0 + else: + maxOrder = maxOrder[0] + + book = calibre_db.session.query(db.Books).filter(db.Books.id == book_id).one_or_none() + if not book: + log.error("Invalid Book Id: %s. Could not be added to shelf %s", book_id, shelf.name) + if not xhr: + flash(_("%(book_id)s is a invalid Book Id. Could not be added to Shelf", book_id=book_id), + category="error") + return redirect(url_for('web.index')) + return "%s is a invalid Book Id. Could not be added to Shelf" % book_id, 400 + + shelf.books.append(ub.BookShelf(shelf=shelf.id, book_id=book_id, order=maxOrder + 1)) + shelf.last_modified = datetime.now(timezone.utc) + try: + ub.session.merge(shelf) + ub.session.commit() + except (OperationalError, InvalidRequestError) as e: + ub.session.rollback() + log.error_or_exception("Settings Database error: {}".format(e)) + flash(_("Oops! Database Error: %(error)s.", error=e.orig), category="error") + if "HTTP_REFERER" in request.environ: + return redirect(request.environ["HTTP_REFERER"]) + else: + return redirect(url_for('web.index')) + if not xhr: + log.debug("Book has been added to shelf: {}".format(shelf.name)) + flash(_("Book has been added to shelf: %(sname)s", sname=shelf.name), category="success") + if "HTTP_REFERER" in request.environ: + return redirect(request.environ["HTTP_REFERER"]) + else: + return redirect(url_for('web.index')) + if shelf.kobo_sync and config.config_hardcover_sync and bool(hardcover): + hardcoverClient = hardcover.HardcoverClient(current_user.hardcover_token) + hardcoverClient.add_book(book.identifiers) + return "", 204 + + +@shelf.route("/shelf/massadd/", methods=["POST"]) +@user_login_required +def search_to_shelf(shelf_id): + shelf = ub.session.query(ub.Shelf).filter(ub.Shelf.id == shelf_id).first() + if shelf is None: + log.error("Invalid shelf specified: {}".format(shelf_id)) + flash(_("Invalid shelf specified"), category="error") + return redirect(url_for('web.index')) + + if not check_shelf_edit_permissions(shelf): + log.warning("You are not allowed to add a book to the shelf".format(shelf.name)) + flash(_("You are not allowed to add a book to the shelf"), category="error") + return redirect(url_for('web.index')) + + if current_user.id in ub.searched_ids and ub.searched_ids[current_user.id]: + books_for_shelf = list() + books_in_shelf = ub.session.query(ub.BookShelf).filter(ub.BookShelf.shelf == shelf_id).all() + if books_in_shelf: + book_ids = list() + for book_id in books_in_shelf: + book_ids.append(book_id.book_id) + for searchid in ub.searched_ids[current_user.id]: + if searchid not in book_ids: + books_for_shelf.append(searchid) + else: + books_for_shelf = ub.searched_ids[current_user.id] + + if not books_for_shelf: + log.error("Books are already part of {}".format(shelf.name)) + flash(_("Books are already part of the shelf: %(name)s", name=shelf.name), category="error") + return redirect(url_for('web.index')) + + maxOrder = ub.session.query(func.max(ub.BookShelf.order)).filter(ub.BookShelf.shelf == shelf_id).first()[0] or 0 + + for book in books_for_shelf: + maxOrder += 1 + shelf.books.append(ub.BookShelf(shelf=shelf.id, book_id=book, order=maxOrder)) + shelf.last_modified = datetime.now(timezone.utc) + try: + ub.session.merge(shelf) + ub.session.commit() + flash(_("Books have been added to shelf: %(sname)s", sname=shelf.name), category="success") + except (OperationalError, InvalidRequestError) as e: + ub.session.rollback() + log.error_or_exception("Settings Database error: {}".format(e)) + flash(_("Oops! Database Error: %(error)s.", error=e.orig), category="error") + else: + log.error("Could not add books to shelf: {}".format(shelf.name)) + flash(_("Could not add books to shelf: %(sname)s", sname=shelf.name), category="error") + return redirect(url_for('web.index')) + + +@shelf.route("/shelf/remove//", methods=["POST"]) +@user_login_required +def remove_from_shelf(shelf_id, book_id): + xhr = request.headers.get('X-Requested-With') == 'XMLHttpRequest' + shelf = ub.session.query(ub.Shelf).filter(ub.Shelf.id == shelf_id).first() + if shelf is None: + log.error("Invalid shelf specified: {}".format(shelf_id)) + if not xhr: + return redirect(url_for('web.index')) + return "Invalid shelf specified", 400 + + # if shelf is public and use is allowed to edit shelfs, or if shelf is private and user is owner + # allow editing shelfs + # result shelf public user allowed user owner + # false 1 0 x + # true 1 1 x + # true 0 x 1 + # false 0 x 0 + + if check_shelf_edit_permissions(shelf): + book_shelf = ub.session.query(ub.BookShelf).filter(ub.BookShelf.shelf == shelf_id, + ub.BookShelf.book_id == book_id).first() + + if book_shelf is None: + log.error("Book %s already removed from %s", book_id, shelf) + if not xhr: + return redirect(url_for('web.index')) + return "Book already removed from shelf", 410 + + try: + ub.session.delete(book_shelf) + shelf.last_modified = datetime.now(timezone.utc) + ub.session.commit() + except (OperationalError, InvalidRequestError) as e: + ub.session.rollback() + log.error_or_exception("Settings Database error: {}".format(e)) + flash(_("Oops! Database Error: %(error)s.", error=e.orig), category="error") + if "HTTP_REFERER" in request.environ: + return redirect(request.environ["HTTP_REFERER"]) + else: + return redirect(url_for('web.index')) + if not xhr: + flash(_("Book has been removed from shelf: %(sname)s", sname=shelf.name), category="success") + if "HTTP_REFERER" in request.environ: + return redirect(request.environ["HTTP_REFERER"]) + else: + return redirect(url_for('web.index')) + return "", 204 + else: + if not xhr: + log.warning("You are not allowed to remove a book from shelf: {}".format(shelf.name)) + flash(_("Sorry you are not allowed to remove a book from this shelf"), + category="error") + return redirect(url_for('web.index')) + return "Sorry you are not allowed to remove a book from this shelf", 403 + + +@shelf.route("/shelf/create", methods=["GET", "POST"]) +@user_login_required +def create_shelf(): + shelf = ub.Shelf() + return create_edit_shelf(shelf, page_title=_("Create a Shelf"), page="shelfcreate") + + +@shelf.route("/shelf/edit/", methods=["GET", "POST"]) +@user_login_required +def edit_shelf(shelf_id): + shelf = ub.session.query(ub.Shelf).filter(ub.Shelf.id == shelf_id).first() + if not check_shelf_edit_permissions(shelf): + flash(_("Sorry you are not allowed to edit this shelf"), category="error") + return redirect(url_for('web.index')) + return create_edit_shelf(shelf, page_title=_("Edit a shelf"), page="shelfedit", shelf_id=shelf_id) + + +@shelf.route("/shelf/delete/", methods=["POST"]) +@user_login_required +def delete_shelf(shelf_id): + cur_shelf = ub.session.query(ub.Shelf).filter(ub.Shelf.id == shelf_id).first() + try: + if not delete_shelf_helper(cur_shelf): + flash(_("Error deleting Shelf"), category="error") + else: + flash(_("Shelf successfully deleted"), category="success") + except InvalidRequestError as e: + ub.session.rollback() + log.error_or_exception("Settings Database error: {}".format(e)) + flash(_("Oops! Database Error: %(error)s.", error=e.orig), category="error") + return redirect(url_for('web.index')) + + +@shelf.route("/simpleshelf/") +@login_required_if_no_ano +def show_simpleshelf(shelf_id): + return render_show_shelf(2, shelf_id, 1, None) + + +@shelf.route("/shelf/", defaults={"sort_param": "stored", 'page': 1}) +@shelf.route("/shelf//", defaults={'page': 1}) +@shelf.route("/shelf///") +@login_required_if_no_ano +def show_shelf(shelf_id, sort_param, page): + return render_show_shelf(1, shelf_id, page, sort_param) + + +@shelf.route("/shelf/order/", methods=["GET", "POST"]) +@user_login_required +def order_shelf(shelf_id): + shelf = ub.session.query(ub.Shelf).filter(ub.Shelf.id == shelf_id).first() + if shelf and check_shelf_view_permissions(shelf): + if request.method == "POST": + to_save = request.form.to_dict() + books_in_shelf = ub.session.query(ub.BookShelf).filter(ub.BookShelf.shelf == shelf_id).order_by( + ub.BookShelf.order.asc()).all() + counter = 0 + for book in books_in_shelf: + setattr(book, 'order', to_save[str(book.book_id)]) + counter += 1 + # if order different from before -> shelf.last_modified = datetime.now(timezone.utc) + try: + ub.session.commit() + except (OperationalError, InvalidRequestError) as e: + ub.session.rollback() + log.error_or_exception("Settings Database error: {}".format(e)) + flash(_("Oops! Database Error: %(error)s.", error=e.orig), category="error") + + result = list() + if shelf: + result = calibre_db.session.query(db.Books) \ + .join(ub.BookShelf, ub.BookShelf.book_id == db.Books.id, isouter=True) \ + .add_columns(calibre_db.common_filters().label("visible")) \ + .filter(ub.BookShelf.shelf == shelf_id).order_by(ub.BookShelf.order.asc()).all() + return render_title_template('shelf_order.html', entries=result, + title=_("Change order of Shelf: '%(name)s'", name=shelf.name), + shelf=shelf, page="shelforder") + else: + abort(404) + + +def check_shelf_edit_permissions(cur_shelf): + if not cur_shelf.is_public and not cur_shelf.user_id == int(current_user.id): + log.error("User {} not allowed to edit shelf: {}".format(current_user.id, cur_shelf.name)) + return False + if cur_shelf.is_public and not current_user.role_edit_shelfs(): + log.info("User {} not allowed to edit public shelves".format(current_user.id)) + return False + return True + + +def check_shelf_view_permissions(cur_shelf): + try: + if cur_shelf.is_public: + return True + if current_user.is_anonymous or cur_shelf.user_id != current_user.id: + log.error("User is unauthorized to view non-public shelf: {}".format(cur_shelf.name)) + return False + except Exception as e: + log.error(e) + return True + + +# if shelf ID is set, we are editing a shelf +def create_edit_shelf(shelf, page_title, page, shelf_id=False): + sync_only_selected_shelves = current_user.kobo_only_shelves_sync + # calibre_db.session.query(ub.Shelf).filter(ub.Shelf.user_id == current_user.id).filter(ub.Shelf.kobo_sync).count() + if request.method == "POST": + to_save = request.form.to_dict() + if not current_user.role_edit_shelfs() and to_save.get("is_public") == "on": + flash(_("Sorry you are not allowed to create a public shelf"), category="error") + return redirect(url_for('web.index')) + is_public = 1 if to_save.get("is_public") == "on" else 0 + if config.config_kobo_sync: + shelf.kobo_sync = True if to_save.get("kobo_sync") else False + if shelf.kobo_sync: + ub.session.query(ub.ShelfArchive).filter(ub.ShelfArchive.user_id == current_user.id).filter( + ub.ShelfArchive.uuid == shelf.uuid).delete() + ub.session_commit() + shelf_title = to_save.get("title", "") + if check_shelf_is_unique(shelf_title, is_public, shelf_id): + shelf.name = shelf_title + shelf.is_public = is_public + if not shelf_id: + shelf.user_id = int(current_user.id) + ub.session.add(shelf) + shelf_action = "created" + flash_text = _("Shelf %(title)s created", title=shelf_title) + else: + shelf_action = "changed" + flash_text = _("Shelf %(title)s changed", title=shelf_title) + try: + ub.session.commit() + log.info("Shelf {} {}".format(shelf_title, shelf_action)) + flash(flash_text, category="success") + return redirect(url_for('shelf.show_shelf', shelf_id=shelf.id)) + except (OperationalError, InvalidRequestError) as ex: + ub.session.rollback() + log.error_or_exception(ex) + log.error_or_exception("Settings Database error: {}".format(ex)) + flash(_("Oops! Database Error: %(error)s.", error=ex.orig), category="error") + except Exception as ex: + ub.session.rollback() + log.error_or_exception(ex) + flash(_("There was an error"), category="error") + return render_title_template('shelf_edit.html', + shelf=shelf, + title=page_title, + page=page, + kobo_sync_enabled=config.config_kobo_sync, + sync_only_selected_shelves=sync_only_selected_shelves) + + +def check_shelf_is_unique(title, is_public, shelf_id=False): + if shelf_id: + ident = ub.Shelf.id != shelf_id + else: + ident = true() + if is_public == 1: + is_shelf_name_unique = ub.session.query(ub.Shelf) \ + .filter((ub.Shelf.name == title) & (ub.Shelf.is_public == 1)) \ + .filter(ident) \ + .first() is None + + if not is_shelf_name_unique: + log.error("A public shelf with the name '{}' already exists.".format(title)) + flash(_("A public shelf with the name '%(title)s' already exists.", title=title), + category="error") + else: + is_shelf_name_unique = ub.session.query(ub.Shelf) \ + .filter((ub.Shelf.name == title) & (ub.Shelf.is_public == 0) & + (ub.Shelf.user_id == int(current_user.id))) \ + .filter(ident) \ + .first() is None + + if not is_shelf_name_unique: + log.error("A private shelf with the name '{}' already exists.".format(title)) + flash(_("A private shelf with the name '%(title)s' already exists.", title=title), + category="error") + return is_shelf_name_unique + + +def delete_shelf_helper(cur_shelf): + if not cur_shelf or not check_shelf_edit_permissions(cur_shelf): + return False + shelf_id = cur_shelf.id + ub.session.delete(cur_shelf) + ub.session.query(ub.BookShelf).filter(ub.BookShelf.shelf == shelf_id).delete() + ub.session.add(ub.ShelfArchive(uuid=cur_shelf.uuid, user_id=cur_shelf.user_id)) + ub.session_commit("successfully deleted Shelf {}".format(cur_shelf.name)) + return True + + +def change_shelf_order(shelf_id, order): + result = calibre_db.session.query(db.Books).outerjoin(db.books_series_link, + db.Books.id == db.books_series_link.c.book)\ + .outerjoin(db.Series).join(ub.BookShelf, ub.BookShelf.book_id == db.Books.id) \ + .filter(ub.BookShelf.shelf == shelf_id).order_by(*order).all() + for index, entry in enumerate(result): + book = ub.session.query(ub.BookShelf).filter(ub.BookShelf.shelf == shelf_id) \ + .filter(ub.BookShelf.book_id == entry.id).first() + book.order = index + ub.session_commit("Shelf-id:{} - Order changed".format(shelf_id)) + + +def render_show_shelf(shelf_type, shelf_id, page_no, sort_param): + shelf = ub.session.query(ub.Shelf).filter(ub.Shelf.id == shelf_id).first() + status = current_user.get_view_property("shelf", 'man') + # check user is allowed to access shelf + if shelf and check_shelf_view_permissions(shelf): + if shelf_type == 1: + if status != 'on': + if sort_param == 'stored': + sort_param = current_user.get_view_property("shelf", 'stored') + else: + current_user.set_view_property("shelf", 'stored', sort_param) + if sort_param == 'pubnew': + change_shelf_order(shelf_id, [db.Books.pubdate.desc()]) + if sort_param == 'pubold': + change_shelf_order(shelf_id, [db.Books.pubdate]) + if sort_param == 'shelfnew': + change_shelf_order(shelf_id, [ub.BookShelf.date_added.desc()]) + if sort_param == 'shelfold': + change_shelf_order(shelf_id, [ub.BookShelf.date_added]) + if sort_param == 'abc': + change_shelf_order(shelf_id, [db.Books.sort]) + if sort_param == 'zyx': + change_shelf_order(shelf_id, [db.Books.sort.desc()]) + if sort_param == 'new': + change_shelf_order(shelf_id, [db.Books.timestamp.desc()]) + if sort_param == 'old': + change_shelf_order(shelf_id, [db.Books.timestamp]) + if sort_param == 'authaz': + change_shelf_order(shelf_id, [db.Books.author_sort.asc(), db.Series.name, db.Books.series_index]) + if sort_param == 'authza': + change_shelf_order(shelf_id, [db.Books.author_sort.desc(), + db.Series.name.desc(), + db.Books.series_index.desc()]) + page = "shelf.html" + pagesize = 0 + else: + pagesize = sys.maxsize + page = 'shelfdown.html' + + result, __, pagination = calibre_db.fill_indexpage(page_no, pagesize, + db.Books, + ub.BookShelf.shelf == shelf_id, + [ub.BookShelf.order.asc()], + True, config.config_read_column, + ub.BookShelf, ub.BookShelf.book_id == db.Books.id) + # delete shelf entries where book is not existent anymore, can happen if book is deleted outside calibre-web + wrong_entries = calibre_db.session.query(ub.BookShelf) \ + .join(db.Books, ub.BookShelf.book_id == db.Books.id, isouter=True) \ + .filter(db.Books.id == None).all() + for entry in wrong_entries: + log.info('Not existing book {} in {} deleted'.format(entry.book_id, shelf)) + try: + ub.session.query(ub.BookShelf).filter(ub.BookShelf.book_id == entry.book_id).delete() + ub.session.commit() + except (OperationalError, InvalidRequestError) as e: + ub.session.rollback() + log.error_or_exception("Settings Database error: {}".format(e)) + flash(_("Oops! Database Error: %(error)s.", error=e.orig), category="error") + + return render_title_template(page, + entries=result, + pagination=pagination, + title=_("Shelf: '%(name)s'", name=shelf.name), + shelf=shelf, + page="shelf", + status=status, + order=sort_param) + else: + flash(_("Error opening shelf. Shelf does not exist or is not accessible"), category="error") + return redirect(url_for("web.index")) diff --git a/root/app/calibre-web/cps/static/css/style.css b/root/app/calibre-web/cps/static/css/style.css index 8390b39..e40589b 100644 --- a/root/app/calibre-web/cps/static/css/style.css +++ b/root/app/calibre-web/cps/static/css/style.css @@ -313,7 +313,7 @@ span.glyphicon.glyphicon-tags { position: relative; top: -20px; /*left: auto; - right: 2px;*/ + right: 2px;*/ width: 17px; height: 17px; display: inline-block; diff --git a/root/app/calibre-web/cps/templates/config_edit.html b/root/app/calibre-web/cps/templates/config_edit.html new file mode 100644 index 0000000..5d93f17 --- /dev/null +++ b/root/app/calibre-web/cps/templates/config_edit.html @@ -0,0 +1,438 @@ +{% extends "layout.html" %} +{% block flash %} + +{% endblock %} +{% block body %} +
    +

    {{title}}

    +
    + +
    +
    +
    +

    + + + {{_('Server Configuration')}} + +

    +
    +
    +
    +
    + + +
    + +
    + + + + +
    + +
    + + + + +
    +
    + + +
    +
    + + +
    +
    +
    +
    +
    +
    +

    + + + {{_('Logfile Configuration')}} + +

    +
    +
    +
    +
    + + +
    +
    + + +
    +
    + + +
    +
    + + +
    +
    +
    +
    +
    +
    +

    + + + {{_('Feature Configuration')}} + +

    +
    +
    +
    +
    + + +
    +
    + + +
    +
    + + +
    +
    +
    + + +
    +
    +
    + + +
    +
    + + +
    +
    +
    + + +
    +
    +
    + + +
    + {% if feature_support['kobo'] %} +
    + + +
    +
    +
    + + +
    +
    + + +
    +
    + + +
    +
    + {% endif %} + {% if feature_support['goodreads'] %} +
    + + +
    +
    +
    + + +
    +
    + {% endif %} +
    + + +
    +
    +
    + + +
    +
    + {% if not config.config_is_initial %} + {% if feature_support['ldap'] or feature_support['oauth'] %} +
    + + +
    + {% if feature_support['ldap'] %} +
    +
    + + +
    +
    + + +
    +
    + + +
    +
    + +
    + + + + +
    + +
    + + + + +
    + +
    + + + + +
    +
    +
    + + +
    +
    +
    + + +
    +
    +
    +
    + + +
    +
    +
    + + +
    +
    + + +
    +
    + + +
    +

    {{_('Following Settings are Needed For User Import')}}

    +
    + + +
    +
    + + +
    +
    + + +
    +
    + + +
    +
    +
    + + +
    +
    + +
    + {% endif %} + {% if feature_support['oauth'] %} +
    + {% for prov in provider %} +
    + {{_('Obtain %(provider)s OAuth Credential', provider=prov['provider_name'])}} +
    +
    + + +
    +
    + + +
    + {% endfor %} +
    + {% endif %} + {% endif %} + {% endif %} +
    +
    +
    +
    +
    +

    + + + {{_('External binaries')}} + +

    +
    +
    +
    + +
    + + + + +
    +
    + + +
    + +
    + + + + +
    + {% if feature_support['rar'] %} + +
    + + + + +
    + {% endif %} +
    +
    +
    +
    +
    +

    + + + {{_('Security Settings')}} + +

    +
    +
    +
    +
    + + +
    +
    +
    + + +
    +
    + + +
    +
    +
    + + +
    +
    + + +
    +
    + + +
    +
    +
    + + +
    +
    + + +
    +
    + + +
    +
    + + +
    +
    + + +
    +
    + + +
    +
    +
    +
    +
    +
    +
    + + {{_('Cancel')}} +
    +
    +
    +{% endblock %} +{% block modal %} +{{ filechooser_modal() }} +{% endblock %} diff --git a/root/app/calibre-web/cps/templates/detail.html b/root/app/calibre-web/cps/templates/detail.html new file mode 100644 index 0000000..bc3ab48 --- /dev/null +++ b/root/app/calibre-web/cps/templates/detail.html @@ -0,0 +1,377 @@ +{% extends is_xhr|yesno("fragment.html", "layout.html") %} +{% block header %} + + + {% if entry.comments|length > 0 and entry.comments[0].text|length > 0 %} + + + {% endif %} +{% endblock %} +{% block body %} +
    +
    +
    +
    + + +
    +
    +
    + +

    {{ entry.title }}

    +

    + {% for author in entry.ordered_authors %} + {{ author.name.replace('|',',') }} + {% if not loop.last %} + & + {% endif %} + {% endfor %} +

    + {% if entry.ratings.__len__() > 0 %} +
    +

    + {% for number in range((entry.ratings[0].rating/2)|int(2)) %} + + {% if loop.last and loop.index < 5 %} + {% for numer in range(5 - loop.index) %} + + {% endfor %} + {% endif %} + {% endfor %} +

    +
    + {% endif %} + {% if entry.series|length > 0 %} +

    {{ _("Book %(index)s of %(range)s", index=entry.series_index|formatfloat(2), range=(url_for('web.books_list', data='series', sort_param='stored', book_id=entry.series[0].id)|escapedlink(entry.series[0].name))|safe) }}

    + + {% endif %} + + {% if entry.languages|length > 0 %} +
    +

    + {{_('Language')}}: {% for language in entry.languages %}{{language.language_name}}{% if not loop.last %}, {% endif %}{% endfor %} +

    +
    + {% endif %} + + {% if entry.identifiers|length > 0 %} +
    +

    + + {% for identifier in entry.identifiers if identifier.__repr__() != identifier.val %} + {{ identifier.format_type() }} + {% endfor %} +

    +
    + {% endif %} + + {% if entry.tags|length > 0 %} + +
    +

    + + + {% for tag in entry.tags %} + {{ tag.name }} + {% endfor %} +

    + +
    + {% endif %} + + {% if entry.publishers|length > 0 %} +
    +

    + {{ _('Publisher') }}: + {{ entry.publishers[0].name }} + +

    +
    + {% endif %} + + {% if (entry.pubdate|string)[:10] != '0101-01-01' %} +
    +

    {{ _('Published') }}: {{ entry.pubdate|formatdate }}

    +
    + {% endif %} + {% if cc|length > 0 %} + + + {% for c in cc %} + {% if entry['custom_column_' ~ c.id]|length > 0 %} +
    + {{ c.name }}: + {% for column in entry['custom_column_' ~ c.id] %} + {% if c.datatype == 'rating' %} + {{ (column.value / 2)|formatfloat }} + {% else %} + {% if c.datatype == 'bool' %} + {% if column.value == true %} + + {% else %} + + {% endif %} + {% else %} + {% if c.datatype == 'float' %} + {{ column.value|formatfloat(2) }} + {% elif c.datatype == 'datetime' %} + {{ column.value|formatdate }} + {% elif c.datatype == 'comments' %} + {{ column.value|safe }} + {% elif c.datatype == 'series' %} + {{ '%s [%s]' % (column.value, column.extra|formatfloat(2)) }} + {% elif c.datatype == 'text' %} + {{ column.value.strip() }}{% if not loop.last %}, {% endif %} + {% else %} + {{ column.value }} + {% endif %} + {% endif %} + {% endif %} + {% endfor %} + +
    + {% endif %} + {% endfor %} + {% endif %} + {% if not current_user.is_anonymous %} + +
    +

    +

    + + +
    +

    + {% if current_user.check_visibility(32768) %} +

    +

    + + +
    +

    + {% endif %} +
    + {% endif %} + + + {% if entry.comments|length > 0 and entry.comments[0].text|length > 0 %} +
    +

    {{ _('Description:') }}

    + {{ entry.comments[0].text|safe }} +
    + {% endif %} + + +
    + + {% if current_user.is_authenticated %} + {% if current_user.shelf.all() or g.shelves_access %} + + {% endif %} + + {% endif %} + {% if current_user.role_edit() %} +
    +
    + {{ _('Edit Metadata') }} +
    +
    {{_('Cancel')}}
    +
    + {% endif %} +
    +
    +
    +{% endblock %} + +{% block js %} + + + + + + +{% endblock %} diff --git a/root/app/calibre-web/cps/templates/user_edit.html b/root/app/calibre-web/cps/templates/user_edit.html new file mode 100644 index 0000000..ed3b7b1 --- /dev/null +++ b/root/app/calibre-web/cps/templates/user_edit.html @@ -0,0 +1,189 @@ +{% extends "layout.html" %} +{% block body %} +
    +

    {{title}}

    +
    + +
    + {% if new_user or ( current_user and content.name != "Guest" and current_user.role_admin() ) %} +
    + + +
    + {% endif %} +
    + + +
    + {% if ( current_user and current_user.role_passwd() or current_user.role_admin() ) and not content.role_anonymous() %} + {% if current_user and current_user.role_admin() and not new_user and not profile and ( mail_configured and content.email if content.email != None ) %} + {{_('Reset user Password')}} + {% endif %} +
    + + +
    + {% endif %} +
    + + +
    + {% if not content.role_anonymous() %} +
    + + +
    + {% endif %} + +
    + + +
    + {% if registered_oauth.keys()| length > 0 and not new_user and profile %} + {% for id, name in registered_oauth.items() %} +
    + + {% if id not in oauth_status %} + {{_('Link')}} + {% else %} + {{_('Unlink')}} + {% endif %} + {% endfor %} +
    + {% endif %} + {% if kobo_support and hardcover_support and not new_user %} +
    + + +
    + {% endif %} + {% if kobo_support and not new_user %} + +
    + {{_('Create/View')}} + +
    +
    + +
    + {% endif %} +
    + {% for element in sidebar %} + {% if element['config_show'] %} +
    + + +
    + {% endif %} + {% endfor %} +
    + + +
    + {% if ( current_user and current_user.role_admin() and not new_user ) and not simple %} + {{_('Add Allowed/Denied Tags')}} + {{_('Add allowed/Denied Custom Column Values')}} + {% endif %} +
    +
    + {% if current_user and current_user.role_admin() and not profile %} + {% if not content.role_anonymous() %} +
    + + +
    + {% endif %} +
    + + +
    +
    + + +
    + {% if config.config_uploading %} +
    + + +
    + {% endif %} +
    + + +
    +
    +
    + + +
    +
    + {% if not content.role_anonymous() %} +
    + + +
    +
    + + +
    + {% endif %} + {% endif %} + {% if kobo_support and not content.role_anonymous() and not simple%} +
    + + +
    + {% endif %} +
    +
    +
    {{_('Save')}}
    + {% if not profile %} +
    {{_('Cancel')}}
    + {% endif %} + {% if current_user and current_user.role_admin() and not profile and not new_user and not content.role_anonymous() %} +
    {{_('Delete User')}}
    + {% endif %} +
    +
    +
    +
    + + + +{% endblock %} +{% block modal %} +{{ restrict_modal() }} +{{ delete_confirm_modal() }} +{% endblock %} +{% block js %} + + + + + + + + +{% endblock %} diff --git a/root/app/calibre-web/cps/ub.py b/root/app/calibre-web/cps/ub.py new file mode 100644 index 0000000..f0ba832 --- /dev/null +++ b/root/app/calibre-web/cps/ub.py @@ -0,0 +1,778 @@ +# -*- coding: utf-8 -*- + +# This file is part of the Calibre-Web (https://github.com/janeczku/calibre-web) +# Copyright (C) 2012-2019 mutschler, jkrehm, cervinko, janeczku, OzzieIsaacs, csitko +# ok11, issmirnov, idalin +# +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . + +import atexit +import os +import sys +from datetime import datetime, timezone, timedelta +import itertools +import uuid +from flask import session as flask_session +from binascii import hexlify + +from .cw_login import AnonymousUserMixin, current_user +from .cw_login import user_logged_in + +try: + from flask_dance.consumer.backend.sqla import OAuthConsumerMixin + oauth_support = True +except ImportError as e: + # fails on flask-dance >1.3, due to renaming + try: + from flask_dance.consumer.storage.sqla import OAuthConsumerMixin + oauth_support = True + except ImportError as e: + OAuthConsumerMixin = BaseException + oauth_support = False +from sqlalchemy import create_engine, exc, exists, event, text +from sqlalchemy import Column, ForeignKey +from sqlalchemy import String, Integer, SmallInteger, Boolean, DateTime, Float, JSON +from sqlalchemy.orm.attributes import flag_modified +from sqlalchemy.sql.expression import func +try: + # Compatibility with sqlalchemy 2.0 + from sqlalchemy.orm import declarative_base +except ImportError: + from sqlalchemy.ext.declarative import declarative_base +from sqlalchemy.orm import backref, relationship, sessionmaker, Session, scoped_session +from werkzeug.security import generate_password_hash + +from . import constants, logger +from .string_helper import strip_whitespaces + +log = logger.create() + +session = None +app_DB_path = None +Base = declarative_base() +searched_ids = {} + +logged_in = dict() + + +def signal_store_user_session(object, user): + store_user_session() + + +def store_user_session(): + _user = flask_session.get('_user_id', "") + _id = flask_session.get('_id', "") + _random = flask_session.get('_random', "") + if flask_session.get('_user_id', ""): + try: + if not check_user_session(_user, _id, _random): + expiry = int((datetime.now() + timedelta(days=31)).timestamp()) + user_session = User_Sessions(_user, _id, _random, expiry) + session.add(user_session) + session.commit() + log.debug("Login and store session : " + _id) + else: + log.debug("Found stored session: " + _id) + except (exc.OperationalError, exc.InvalidRequestError) as e: + session.rollback() + log.exception(e) + else: + log.error("No user id in session") + + +def delete_user_session(user_id, session_key): + try: + log.debug("Deleted session_key: " + session_key) + session.query(User_Sessions).filter(User_Sessions.user_id == user_id, + User_Sessions.session_key == session_key).delete() + session.commit() + except (exc.OperationalError, exc.InvalidRequestError) as ex: + session.rollback() + log.exception(ex) + + +def check_user_session(user_id, session_key, random): + try: + found = session.query(User_Sessions).filter(User_Sessions.user_id==user_id, + User_Sessions.session_key==session_key, + User_Sessions.random == random, + ).one_or_none() + if found is not None: + new_expiry = int((datetime.now() + timedelta(days=31)).timestamp()) + if new_expiry - found.expiry > 86400: + found.expiry = new_expiry + session.merge(found) + session.commit() + return bool(found) + except (exc.OperationalError, exc.InvalidRequestError) as e: + session.rollback() + log.exception(e) + return False + + +user_logged_in.connect(signal_store_user_session) + +def store_ids(result): + ids = list() + for element in result: + ids.append(element.id) + searched_ids[current_user.id] = ids + +def store_combo_ids(result): + ids = list() + for element in result: + ids.append(element[0].id) + searched_ids[current_user.id] = ids + + +class UserBase: + + @property + def is_authenticated(self): + return self.is_active + + def _has_role(self, role_flag): + return constants.has_flag(self.role, role_flag) + + def role_admin(self): + return self._has_role(constants.ROLE_ADMIN) + + def role_download(self): + return self._has_role(constants.ROLE_DOWNLOAD) + + def role_upload(self): + return self._has_role(constants.ROLE_UPLOAD) + + def role_edit(self): + return self._has_role(constants.ROLE_EDIT) + + def role_passwd(self): + return self._has_role(constants.ROLE_PASSWD) + + def role_anonymous(self): + return self._has_role(constants.ROLE_ANONYMOUS) + + def role_edit_shelfs(self): + return self._has_role(constants.ROLE_EDIT_SHELFS) + + def role_delete_books(self): + return self._has_role(constants.ROLE_DELETE_BOOKS) + + def role_viewer(self): + return self._has_role(constants.ROLE_VIEWER) + + @property + def is_active(self): + return True + + @property + def is_anonymous(self): + return self.role_anonymous() + + def get_id(self): + return str(self.id) + + def filter_language(self): + return self.default_language + + def check_visibility(self, value): + if value == constants.SIDEBAR_RECENT: + return True + return constants.has_flag(self.sidebar_view, value) + + def show_detail_random(self): + return self.check_visibility(constants.DETAIL_RANDOM) + + def list_denied_tags(self): + mct = self.denied_tags or "" + return [strip_whitespaces(t) for t in mct.split(",")] + + def list_allowed_tags(self): + mct = self.allowed_tags or "" + return [strip_whitespaces(t) for t in mct.split(",")] + + def list_denied_column_values(self): + mct = self.denied_column_value or "" + return [strip_whitespaces(t) for t in mct.split(",")] + + def list_allowed_column_values(self): + mct = self.allowed_column_value or "" + return [strip_whitespaces(t) for t in mct.split(",")] + + def get_view_property(self, page, prop): + if not self.view_settings.get(page): + return None + return self.view_settings[page].get(prop) + + def set_view_property(self, page, prop, value): + if not self.view_settings.get(page): + self.view_settings[page] = dict() + self.view_settings[page][prop] = value + try: + flag_modified(self, "view_settings") + except AttributeError: + pass + try: + session.commit() + except (exc.OperationalError, exc.InvalidRequestError) as e: + session.rollback() + log.error_or_exception(e) + + def __repr__(self): + return '' % self.name + + +# Baseclass for Users in Calibre-Web, settings which are depending on certain users are stored here. It is derived from +# User Base (all access methods are declared there) +class User(UserBase, Base): + __tablename__ = 'user' + __table_args__ = {'sqlite_autoincrement': True} + + id = Column(Integer, primary_key=True) + name = Column(String(64), unique=True) + email = Column(String(120), unique=True, default="") + role = Column(SmallInteger, default=constants.ROLE_USER) + password = Column(String) + kindle_mail = Column(String(120), default="") + shelf = relationship('Shelf', backref='user', lazy='dynamic', order_by='Shelf.name') + downloads = relationship('Downloads', backref='user', lazy='dynamic') + locale = Column(String(2), default="en") + sidebar_view = Column(Integer, default=1) + default_language = Column(String(3), default="all") + denied_tags = Column(String, default="") + allowed_tags = Column(String, default="") + denied_column_value = Column(String, default="") + allowed_column_value = Column(String, default="") + remote_auth_token = relationship('RemoteAuthToken', backref='user', lazy='dynamic') + view_settings = Column(JSON, default={}) + kobo_only_shelves_sync = Column(Integer, default=0) + hardcover_token = Column(String, unique=True, default="") + + +if oauth_support: + class OAuth(OAuthConsumerMixin, Base): + provider_user_id = Column(String(256)) + user_id = Column(Integer, ForeignKey(User.id)) + user = relationship(User) + + +class OAuthProvider(Base): + __tablename__ = 'oauthProvider' + + id = Column(Integer, primary_key=True) + provider_name = Column(String) + oauth_client_id = Column(String) + oauth_client_secret = Column(String) + active = Column(Boolean) + + +# Class for anonymous user is derived from User base and completely overrides methods and properties for the +# anonymous user +class Anonymous(AnonymousUserMixin, UserBase): + def __init__(self): + self.kobo_only_shelves_sync = None + self.view_settings = None + self.allowed_column_value = None + self.allowed_tags = None + self.denied_tags = None + self.kindle_mail = None + self.locale = None + self.default_language = None + self.sidebar_view = None + self.id = None + self.role = None + self.name = None + self.loadSettings() + + def loadSettings(self): + data = session.query(User).filter(User.role.op('&')(constants.ROLE_ANONYMOUS) == constants.ROLE_ANONYMOUS)\ + .first() # type: User + self.name = data.name + self.role = data.role + self.id=data.id + self.sidebar_view = data.sidebar_view + self.default_language = data.default_language + self.locale = data.locale + self.kindle_mail = data.kindle_mail + self.denied_tags = data.denied_tags + self.allowed_tags = data.allowed_tags + self.denied_column_value = data.denied_column_value + self.allowed_column_value = data.allowed_column_value + self.view_settings = data.view_settings + self.kobo_only_shelves_sync = data.kobo_only_shelves_sync + + def role_admin(self): + return False + + @property + def is_active(self): + return False + + @property + def is_anonymous(self): + return True + + @property + def is_authenticated(self): + return False + + def get_view_property(self, page, prop): + if 'view' in flask_session: + if not flask_session['view'].get(page): + return None + return flask_session['view'][page].get(prop) + return None + + def set_view_property(self, page, prop, value): + if not 'view' in flask_session: + flask_session['view'] = dict() + if not flask_session['view'].get(page): + flask_session['view'][page] = dict() + flask_session['view'][page][prop] = value + +class User_Sessions(Base): + __tablename__ = 'user_session' + + id = Column(Integer, primary_key=True) + user_id = Column(Integer, ForeignKey('user.id')) + session_key = Column(String, default="") + random = Column(String, default="") + expiry = Column(Integer) + + + def __init__(self, user_id, session_key, random, expiry): + super().__init__() + self.user_id = user_id + self.session_key = session_key + self.random = random + self.expiry = expiry + + +# Baseclass representing Shelfs in calibre-web in app.db +class Shelf(Base): + __tablename__ = 'shelf' + + id = Column(Integer, primary_key=True) + uuid = Column(String, default=lambda: str(uuid.uuid4())) + name = Column(String) + is_public = Column(Integer, default=0) + user_id = Column(Integer, ForeignKey('user.id')) + kobo_sync = Column(Boolean, default=False) + books = relationship("BookShelf", backref="ub_shelf", cascade="all, delete-orphan", lazy="dynamic") + created = Column(DateTime, default=lambda: datetime.now(timezone.utc)) + last_modified = Column(DateTime, default=lambda: datetime.now(timezone.utc), onupdate=lambda: datetime.now(timezone.utc)) + + def __repr__(self): + return '' % (self.id, self.name) + + +# Baseclass representing Relationship between books and Shelfs in Calibre-Web in app.db (N:M) +class BookShelf(Base): + __tablename__ = 'book_shelf_link' + + id = Column(Integer, primary_key=True) + book_id = Column(Integer) + order = Column(Integer) + shelf = Column(Integer, ForeignKey('shelf.id')) + date_added = Column(DateTime, default=lambda: datetime.now(timezone.utc)) + + def __repr__(self): + return '' % self.id + + +# This table keeps track of deleted Shelves so that deletes can be propagated to any paired Kobo device. +class ShelfArchive(Base): + __tablename__ = 'shelf_archive' + + id = Column(Integer, primary_key=True) + uuid = Column(String) + user_id = Column(Integer, ForeignKey('user.id')) + last_modified = Column(DateTime, default=lambda: datetime.now(timezone.utc)) + + +class ReadBook(Base): + __tablename__ = 'book_read_link' + + STATUS_UNREAD = 0 + STATUS_FINISHED = 1 + STATUS_IN_PROGRESS = 2 + + id = Column(Integer, primary_key=True) + book_id = Column(Integer, unique=False) + user_id = Column(Integer, ForeignKey('user.id'), unique=False) + read_status = Column(Integer, unique=False, default=STATUS_UNREAD, nullable=False) + kobo_reading_state = relationship("KoboReadingState", uselist=False, + primaryjoin="and_(ReadBook.user_id == foreign(KoboReadingState.user_id), " + "ReadBook.book_id == foreign(KoboReadingState.book_id))", + cascade="all", + backref=backref("book_read_link", + uselist=False)) + last_modified = Column(DateTime, default=lambda: datetime.now(timezone.utc), onupdate=lambda: datetime.now(timezone.utc)) + last_time_started_reading = Column(DateTime, nullable=True) + times_started_reading = Column(Integer, default=0, nullable=False) + + +class Bookmark(Base): + __tablename__ = 'bookmark' + + id = Column(Integer, primary_key=True) + user_id = Column(Integer, ForeignKey('user.id')) + book_id = Column(Integer) + format = Column(String(collation='NOCASE')) + bookmark_key = Column(String) + + +# Baseclass representing books that are archived on the user's Kobo device. +class ArchivedBook(Base): + __tablename__ = 'archived_book' + + id = Column(Integer, primary_key=True) + user_id = Column(Integer, ForeignKey('user.id')) + book_id = Column(Integer) + is_archived = Column(Boolean, unique=False) + last_modified = Column(DateTime, default=lambda: datetime.now(timezone.utc)) + + +class KoboSyncedBooks(Base): + __tablename__ = 'kobo_synced_books' + id = Column(Integer, primary_key=True, autoincrement=True) + user_id = Column(Integer, ForeignKey('user.id')) + book_id = Column(Integer) + +# The Kobo ReadingState API keeps track of 4 timestamped entities: +# ReadingState, StatusInfo, Statistics, CurrentBookmark +# Which we map to the following 4 tables: +# KoboReadingState, ReadBook, KoboStatistics and KoboBookmark +class KoboReadingState(Base): + __tablename__ = 'kobo_reading_state' + + id = Column(Integer, primary_key=True, autoincrement=True) + user_id = Column(Integer, ForeignKey('user.id')) + book_id = Column(Integer) + last_modified = Column(DateTime, default=lambda: datetime.now(timezone.utc), onupdate=lambda: datetime.now(timezone.utc)) + priority_timestamp = Column(DateTime, default=lambda: datetime.now(timezone.utc), onupdate=lambda: datetime.now(timezone.utc)) + current_bookmark = relationship("KoboBookmark", uselist=False, backref="kobo_reading_state", cascade="all, delete") + statistics = relationship("KoboStatistics", uselist=False, backref="kobo_reading_state", cascade="all, delete") + + +class KoboBookmark(Base): + __tablename__ = 'kobo_bookmark' + + id = Column(Integer, primary_key=True) + kobo_reading_state_id = Column(Integer, ForeignKey('kobo_reading_state.id')) + last_modified = Column(DateTime, default=lambda: datetime.now(timezone.utc), onupdate=lambda: datetime.now(timezone.utc)) + location_source = Column(String) + location_type = Column(String) + location_value = Column(String) + progress_percent = Column(Float) + content_source_progress_percent = Column(Float) + + +class KoboStatistics(Base): + __tablename__ = 'kobo_statistics' + + id = Column(Integer, primary_key=True) + kobo_reading_state_id = Column(Integer, ForeignKey('kobo_reading_state.id')) + last_modified = Column(DateTime, default=lambda: datetime.now(timezone.utc), onupdate=lambda: datetime.now(timezone.utc)) + remaining_time_minutes = Column(Integer) + spent_reading_minutes = Column(Integer) + + +# Updates the last_modified timestamp in the KoboReadingState table if any of its children tables are modified. +@event.listens_for(Session, 'before_flush') +def receive_before_flush(session, flush_context, instances): + for change in itertools.chain(session.new, session.dirty): + if isinstance(change, (ReadBook, KoboStatistics, KoboBookmark)): + if change.kobo_reading_state: + change.kobo_reading_state.last_modified = datetime.now(timezone.utc) + # Maintain the last_modified_bit for the Shelf table. + for change in itertools.chain(session.new, session.deleted): + if isinstance(change, BookShelf): + change.ub_shelf.last_modified = datetime.now(timezone.utc) + + +# Baseclass representing Downloads from calibre-web in app.db +class Downloads(Base): + __tablename__ = 'downloads' + + id = Column(Integer, primary_key=True) + book_id = Column(Integer) + user_id = Column(Integer, ForeignKey('user.id')) + + def __repr__(self): + return '".format(self.domain) + + +class RemoteAuthToken(Base): + __tablename__ = 'remote_auth_token' + + id = Column(Integer, primary_key=True) + auth_token = Column(String, unique=True) + user_id = Column(Integer, ForeignKey('user.id')) + verified = Column(Boolean, default=False) + expiration = Column(DateTime) + token_type = Column(Integer, default=0) + + def __init__(self): + super().__init__() + self.auth_token = (hexlify(os.urandom(4))).decode('utf-8') + self.expiration = datetime.now() + timedelta(minutes=10) # 10 min from now + + def __repr__(self): + return '' % self.id + + +def filename(context): + file_format = context.get_current_parameters()['format'] + if file_format == 'jpeg': + return context.get_current_parameters()['uuid'] + '.jpg' + else: + return context.get_current_parameters()['uuid'] + '.' + file_format + + +class Thumbnail(Base): + __tablename__ = 'thumbnail' + + id = Column(Integer, primary_key=True) + entity_id = Column(Integer) + uuid = Column(String, default=lambda: str(uuid.uuid4()), unique=True) + format = Column(String, default='jpeg') + type = Column(SmallInteger, default=constants.THUMBNAIL_TYPE_COVER) + resolution = Column(SmallInteger, default=constants.COVER_THUMBNAIL_SMALL) + filename = Column(String, default=filename) + generated_at = Column(DateTime, default=lambda: datetime.now(timezone.utc)) + expiration = Column(DateTime, nullable=True) + + +# Add missing tables during migration of database +def add_missing_tables(engine, _session): + if not engine.dialect.has_table(engine.connect(), "archived_book"): + ArchivedBook.__table__.create(bind=engine) + if not engine.dialect.has_table(engine.connect(), "thumbnail"): + Thumbnail.__table__.create(bind=engine) + + +# migrate all settings missing in registration table +def migrate_registration_table(engine, _session): + try: + # Handle table exists, but no content + cnt = _session.query(Registration).count() + if not cnt: + with engine.connect() as conn: + trans = conn.begin() + conn.execute(text("insert into registration (domain, allow) values('%.%',1)")) + trans.commit() + except exc.OperationalError: # Database is not writeable + print('Settings database is not writeable. Exiting...') + sys.exit(2) + + +def migrate_user_session_table(engine, _session): + try: + _session.query(exists().where(User_Sessions.random)).scalar() + _session.commit() + except exc.OperationalError: # Database is not compatible, some columns are missing + with engine.connect() as conn: + trans = conn.begin() + conn.execute(text("ALTER TABLE user_session ADD column 'random' String")) + conn.execute(text("ALTER TABLE user_session ADD column 'expiry' Integer")) + trans.commit() + +def migrate_user_table(engine, _session): + try: + _session.query(exists().where(User.hardcover_token)).scalar() + _session.commit() + except exc.OperationalError: # Database is not compatible, some columns are missing + with engine.connect() as conn: + trans = conn.begin() + conn.execute(text("ALTER TABLE user ADD column 'hardcover_token' String")) + trans.commit() + +# Migrate database to current version, has to be updated after every database change. Currently migration from +# maybe 4/5 versions back to current should work. +# Migration is done by checking if relevant columns are existing, and then adding rows with SQL commands +def migrate_Database(_session): + engine = _session.bind + add_missing_tables(engine, _session) + migrate_registration_table(engine, _session) + migrate_user_session_table(engine, _session) + + +def clean_database(_session): + # Remove expired remote login tokens + now = datetime.now() + try: + _session.query(RemoteAuthToken).filter(now > RemoteAuthToken.expiration).\ + filter(RemoteAuthToken.token_type != 1).delete() + _session.commit() + except exc.OperationalError: # Database is not writeable + print('Settings database is not writeable. Exiting...') + sys.exit(2) + + +# Save downloaded books per user in calibre-web's own database +def update_download(book_id, user_id): + check = session.query(Downloads).filter(Downloads.user_id == user_id).filter(Downloads.book_id == book_id).first() + + if not check: + new_download = Downloads(user_id=user_id, book_id=book_id) + session.add(new_download) + try: + session.commit() + except exc.OperationalError: + session.rollback() + + +# Delete non existing downloaded books in calibre-web's own database +def delete_download(book_id): + session.query(Downloads).filter(book_id == Downloads.book_id).delete() + try: + session.commit() + except exc.OperationalError: + session.rollback() + +# Generate user Guest (translated text), as anonymous user, no rights +def create_anonymous_user(_session): + user = User() + user.name = "Guest" + user.email = 'no@email' + user.role = constants.ROLE_ANONYMOUS + user.password = '' + + _session.add(user) + try: + _session.commit() + except Exception: + _session.rollback() + + +# Generate User admin with admin123 password, and access to everything +def create_admin_user(_session): + user = User() + user.name = "admin" + user.email = "admin@example.org" + user.role = constants.ADMIN_USER_ROLES + user.sidebar_view = constants.ADMIN_USER_SIDEBAR + + user.password = generate_password_hash(constants.DEFAULT_PASSWORD) + + _session.add(user) + try: + _session.commit() + except Exception: + _session.rollback() + +def init_db_thread(): + global app_DB_path + engine = create_engine('sqlite:///{0}'.format(app_DB_path), echo=False) + + Session = scoped_session(sessionmaker()) + Session.configure(bind=engine) + return Session() + + +def init_db(app_db_path): + # Open session for database connection + global session + global app_DB_path + + app_DB_path = app_db_path + engine = create_engine('sqlite:///{0}'.format(app_db_path), echo=False) + + Session = scoped_session(sessionmaker()) + Session.configure(bind=engine) + session = Session() + + if os.path.exists(app_db_path): + Base.metadata.create_all(engine) + migrate_Database(session) + clean_database(session) + else: + Base.metadata.create_all(engine) + create_admin_user(session) + create_anonymous_user(session) + +def password_change(user_credentials=None): + if user_credentials: + username, password = user_credentials.split(':', 1) + user = session.query(User).filter(func.lower(User.name) == username.lower()).first() + if user: + if not password: + print("Empty password is not allowed") + sys.exit(4) + try: + from .helper import valid_password + user.password = generate_password_hash(valid_password(password)) + except Exception: + print("Password doesn't comply with password validation rules") + sys.exit(4) + if session_commit() == "": + print("Password for user '{}' changed".format(username)) + sys.exit(0) + else: + print("Failed changing password") + sys.exit(3) + else: + print("Username '{}' not valid, can't change password".format(username)) + sys.exit(3) + + +def get_new_session_instance(): + new_engine = create_engine('sqlite:///{0}'.format(app_DB_path), echo=False) + new_session = scoped_session(sessionmaker()) + new_session.configure(bind=new_engine) + + atexit.register(lambda: new_session.remove() if new_session else True) + + return new_session + + +def dispose(): + global session + + old_session = session + session = None + if old_session: + try: + old_session.close() + except Exception: + pass + if old_session.bind: + try: + old_session.bind.dispose() + except Exception: + pass + +def session_commit(success=None, _session=None): + s = _session if _session else session + try: + s.commit() + if success: + log.info(success) + except (exc.OperationalError, exc.InvalidRequestError) as e: + s.rollback() + log.error_or_exception(e) + return "" diff --git a/root/app/calibre-web/cps/web.py b/root/app/calibre-web/cps/web.py index 558d768..1c16518 100644 --- a/root/app/calibre-web/cps/web.py +++ b/root/app/calibre-web/cps/web.py @@ -70,7 +70,8 @@ from .string_helper import strip_whitespaces feature_support = { 'ldap': bool(services.ldap), 'goodreads': bool(services.goodreads_support), - 'kobo': bool(services.kobo) + 'kobo': bool(services.kobo), + 'hardcover' : bool(services.hardcover) } try: @@ -1232,7 +1233,7 @@ def serve_book(book_id, book_format, anyname): try: headers = Headers() headers["Content-Type"] = mimetypes.types_map.get('.' + book_format, "application/octet-stream") - if not range_header: + if not range_header: log.info('Serving book: %s', data.name) headers['Accept-Ranges'] = 'bytes' df = getFileFromEbooksFolder(book.path, data.name + "." + book_format) @@ -1497,7 +1498,7 @@ def logout(): # ################################### Users own configuration ######################################################### -def change_profile(kobo_support, local_oauth_check, oauth_status, translations, languages): +def change_profile(kobo_support, hardcover_support, local_oauth_check, oauth_status, translations, languages): to_save = request.form.to_dict() current_user.random_books = 0 try: @@ -1525,6 +1526,7 @@ def change_profile(kobo_support, local_oauth_check, oauth_status, translations, current_user.kobo_only_shelves_sync = int(to_save.get("kobo_only_shelves_sync") == "on") or 0 if old_state == 0 and current_user.kobo_only_shelves_sync == 1: kobo_sync_status.update_on_sync_shelfs(current_user.id) + current_user.hardcover_token = to_save.get("hardcover_token","").replace("Bearer ","") except Exception as ex: flash(str(ex), category="error") @@ -1537,6 +1539,7 @@ def change_profile(kobo_support, local_oauth_check, oauth_status, translations, title=_("%(name)s's Profile", name=current_user.name), page="me", kobo_support=kobo_support, + hardcover_support=hardcover_support, registered_oauth=local_oauth_check, oauth_status=oauth_status) @@ -1568,6 +1571,7 @@ def profile(): languages = calibre_db.speaking_language() translations = get_available_locale() kobo_support = feature_support['kobo'] and config.config_kobo_sync + hardcover_support = feature_support['hardcover'] and config.config_hardcover_sync if feature_support['oauth'] and config.config_login_type == 2: oauth_status = get_oauth_status() local_oauth_check = oauth_check @@ -1576,7 +1580,7 @@ def profile(): local_oauth_check = {} if request.method == "POST": - change_profile(kobo_support, local_oauth_check, oauth_status, translations, languages) + change_profile(kobo_support, hardcover_support, local_oauth_check, oauth_status, translations, languages) return render_title_template("user_edit.html", translations=translations, profile=1, @@ -1584,6 +1588,7 @@ def profile(): content=current_user, config=config, kobo_support=kobo_support, + hardcover_support=hardcover_support, title=_("%(name)s's Profile", name=current_user.name), page="me", registered_oauth=local_oauth_check, From 1def4bd7e0d778af0e3d1940f5af1d469cce871c Mon Sep 17 00:00:00 2001 From: demitrix Date: Tue, 14 Jan 2025 22:56:01 +0000 Subject: [PATCH 03/42] Realign db.py to 0.6.24 Release --- root/app/calibre-web/cps/db.py | 137 ++++++++++++++++++--------------- 1 file changed, 74 insertions(+), 63 deletions(-) diff --git a/root/app/calibre-web/cps/db.py b/root/app/calibre-web/cps/db.py index f379ceb..333c7f0 100644 --- a/root/app/calibre-web/cps/db.py +++ b/root/app/calibre-web/cps/db.py @@ -23,7 +23,7 @@ import json from datetime import datetime, timezone from urllib.parse import quote import unidecode -# from weakref import WeakSet +from weakref import WeakSet from uuid import uuid4 from sqlite3 import OperationalError as sqliteOperationalError @@ -45,7 +45,7 @@ from sqlalchemy.ext.associationproxy import association_proxy from .cw_login import current_user from flask_babel import gettext as _ from flask_babel import get_locale -from flask import flash, g, Flask +from flask import flash from . import logger, ub, isoLanguages from .pagination import Pagination @@ -102,16 +102,6 @@ class Identifiers(Base): type = Column(String(collation='NOCASE'), nullable=False, default="isbn") val = Column(String(collation='NOCASE'), nullable=False) book = Column(Integer, ForeignKey('books.id'), nullable=False) - amazon = { - "jp": "co.jp", - "uk": "co.uk", - "us": "com", - "au": "com.au", - "be": "com.be", - "br": "com.br", - "tr": "com.tr", - "mx": "com.mx", - } def __init__(self, val, id_type, book): super().__init__() @@ -124,11 +114,7 @@ class Identifiers(Base): if format_type == 'amazon': return "Amazon" elif format_type.startswith("amazon_"): - label_amazon = "Amazon.{0}" - country_code = format_type[7:].lower() - if country_code not in self.amazon: - return label_amazon.format(country_code) - return label_amazon.format(self.amazon[country_code]) + return "Amazon.{0}".format(format_type[7:].lower().replace("uk","co.uk")) elif format_type == "isbn": return "ISBN" elif format_type == "doi": @@ -165,11 +151,7 @@ class Identifiers(Base): if format_type == "amazon" or format_type == "asin": return "https://amazon.com/dp/{0}".format(self.val) elif format_type.startswith('amazon_'): - link_amazon = "https://amazon.{0}/dp/{1}" - country_code = format_type[7:].lower() - if country_code not in self.amazon: - return link_amazon.format(country_code, self.val) - return link_amazon.format(self.amazon[country_code], self.val) + return "https://amazon.{0}/dp/{1}".format(format_type[7:].lower().replace("uk","co.uk"), self.val) elif format_type == "isbn": return "https://www.worldcat.org/isbn/{0}".format(self.val) elif format_type == "doi": @@ -532,25 +514,34 @@ class AlchemyEncoder(json.JSONEncoder): class CalibreDB: + _init = False + engine = None config = None - config_calibre_dir = None - app_db_path = None + session_factory = None + # This is a WeakSet so that references here don't keep other CalibreDB + # instances alive once they reach the end of their respective scopes + instances = WeakSet() - def __init__(self, _app: Flask=None): # , expire_on_commit=True, init=False): + def __init__(self, expire_on_commit=True, init=False): """ Initialize a new CalibreDB session """ - self.Session = None - #if init: - # self.init_db(expire_on_commit) - if _app is not None and not _app._got_first_request: - self.init_app(_app) + self.session = None + if init: + self.init_db(expire_on_commit) - def init_app(self, _app): - _app.teardown_appcontext(self.teardown) + def init_db(self, expire_on_commit=True): + if self._init: + self.init_session(expire_on_commit) + + self.instances.add(self) + + def init_session(self, expire_on_commit=True): + self.session = self.session_factory() + self.session.expire_on_commit = expire_on_commit + self.create_functions(self.config) @classmethod def setup_db_cc_classes(cls, cc): - global cc_classes cc_ids = [] books_custom_column_links = {} for row in cc: @@ -618,6 +609,8 @@ class CalibreDB: secondary=books_custom_column_links[cc_id[0]], backref='books')) + return cc_classes + @classmethod def check_valid_db(cls, config_calibre_dir, app_db_path, config_calibre_uuid): if not config_calibre_dir: @@ -637,6 +630,7 @@ class CalibreDB: local_session = scoped_session(sessionmaker()) local_session.configure(bind=connection) database_uuid = local_session().query(Library_Id).one_or_none() + # local_session.dispose() check_engine.connect() db_change = config_calibre_uuid != database_uuid.uuid @@ -644,30 +638,13 @@ class CalibreDB: return False, False return True, db_change - def teardown(self, exception): - ctx = g.get("lib_sql") - if ctx: - ctx.close() - - @property - def session(self): - # connect or get active connection - if not g.get("lib_sql"): - g.lib_sql = self.connect() - return g.lib_sql - @classmethod - def update_config(cls, config, config_calibre_dir, app_db_path): + def update_config(cls, config): cls.config = config - cls.config_calibre_dir = config_calibre_dir - cls.app_db_path = app_db_path - - - def connect(self): - return self.setup_db(self.config_calibre_dir, self.app_db_path) @classmethod def setup_db(cls, config_calibre_dir, app_db_path): + cls.dispose() if not config_calibre_dir: cls.config.invalidate() @@ -679,17 +656,16 @@ class CalibreDB: return None try: - engine = create_engine('sqlite://', + cls.engine = create_engine('sqlite://', echo=False, isolation_level="SERIALIZABLE", connect_args={'check_same_thread': False}, poolclass=StaticPool) - with engine.begin() as connection: - connection.execute(text('PRAGMA cache_size = 10000;')) + with cls.engine.begin() as connection: connection.execute(text("attach database '{}' as calibre;".format(dbpath))) connection.execute(text("attach database '{}' as app_settings;".format(app_db_path))) - conn = engine.connect() + conn = cls.engine.connect() # conn.text_factory = lambda b: b.decode(errors = 'ignore') possible fix for #1302 except Exception as ex: cls.config.invalidate(ex) @@ -705,10 +681,13 @@ class CalibreDB: log.error_or_exception(e) return None - return scoped_session(sessionmaker(autocommit=False, - autoflush=False, - bind=engine, future=True)) + cls.session_factory = scoped_session(sessionmaker(autocommit=False, + autoflush=True, + bind=cls.engine, future=True)) + for inst in cls.instances: + inst.init_session() + cls._init = True def get_book(self, book_id): return self.session.query(Books).filter(Books.id == book_id).first() @@ -1072,11 +1051,43 @@ class CalibreDB: except sqliteOperationalError: pass + @classmethod + def dispose(cls): + # global session + + for inst in cls.instances: + old_session = inst.session + inst.session = None + if old_session: + try: + old_session.close() + except Exception: + pass + if old_session.bind: + try: + old_session.bind.dispose() + except Exception: + pass + + for attr in list(Books.__dict__.keys()): + if attr.startswith("custom_column_"): + setattr(Books, attr, None) + + for db_class in cc_classes.values(): + Base.metadata.remove(db_class.__table__) + cc_classes.clear() + + for table in reversed(Base.metadata.sorted_tables): + name = table.key + if name.startswith("custom_column_") or name.startswith("books_custom_column_"): + if table is not None: + Base.metadata.remove(table) + def reconnect_db(self, config, app_db_path): - # self.dispose() - # self.engine.dispose() + self.dispose() + self.engine.dispose() self.setup_db(config.config_calibre_dir, app_db_path) - self.update_config(config, config.config_calibre_dir, app_db_path) + self.update_config(config) def lcase(s): @@ -1098,4 +1109,4 @@ class Category: self.name = name self.id = cat_id self.rating = rating - self.count = 1 + self.count = 1 \ No newline at end of file From 165e2e5ed685b08460242fe077ea7630af63eb59 Mon Sep 17 00:00:00 2001 From: demitrix Date: Sat, 18 Jan 2025 17:47:44 +0000 Subject: [PATCH 04/42] Remove necessity to change other metadata providers. --- .../cps/metadata_provider/amazon.py | 140 ------- .../cps/metadata_provider/comicvine.py | 92 ----- .../cps/metadata_provider/douban.py | 260 ------------- .../cps/metadata_provider/google.py | 129 ------- .../cps/metadata_provider/hardcover.py | 7 +- .../cps/metadata_provider/lubimyczytac.py | 359 ------------------ .../cps/metadata_provider/scholar.py | 83 ---- root/app/calibre-web/cps/search_metadata.py | 4 +- .../calibre-web/cps/templates/book_edit.html | 1 - 9 files changed, 5 insertions(+), 1070 deletions(-) delete mode 100644 root/app/calibre-web/cps/metadata_provider/amazon.py delete mode 100644 root/app/calibre-web/cps/metadata_provider/comicvine.py delete mode 100644 root/app/calibre-web/cps/metadata_provider/douban.py delete mode 100644 root/app/calibre-web/cps/metadata_provider/google.py delete mode 100644 root/app/calibre-web/cps/metadata_provider/lubimyczytac.py delete mode 100644 root/app/calibre-web/cps/metadata_provider/scholar.py diff --git a/root/app/calibre-web/cps/metadata_provider/amazon.py b/root/app/calibre-web/cps/metadata_provider/amazon.py deleted file mode 100644 index 09ef1eb..0000000 --- a/root/app/calibre-web/cps/metadata_provider/amazon.py +++ /dev/null @@ -1,140 +0,0 @@ -# -*- coding: utf-8 -*- - -# This file is part of the Calibre-Web (https://github.com/janeczku/calibre-web) -# Copyright (C) 2022 quarz12 -# -# This program is free software: you can redistribute it and/or modify -# it under the terms of the GNU General Public License as published by -# the Free Software Foundation, either version 3 of the License, or -# (at your option) any later version. -# -# This program is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -# GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License -# along with this program. If not, see . - -import concurrent.futures -import requests -from bs4 import BeautifulSoup as BS # requirement -from typing import List, Optional - -try: - import cchardet #optional for better speed -except ImportError: - pass - -from cps.services.Metadata import MetaRecord, MetaSourceInfo, Metadata -import cps.logger as logger - -#from time import time -from operator import itemgetter -log = logger.create() - - -class Amazon(Metadata): - __name__ = "Amazon" - __id__ = "amazon" - headers = {'upgrade-insecure-requests': '1', - 'user-agent': 'Mozilla/5.0 (X11; Linux x86_64; rv:130.0) Gecko/20100101 Firefox/130.0', - 'accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/png,image/svg+xml,*/*;q=0.8', - 'Sec-Fetch-Site': 'same-origin', - 'Sec-Fetch-Mode': 'navigate', - 'Sec-Fetch-User': '?1', - 'Sec-Fetch-Dest': 'document', - 'Upgrade-Insecure-Requests': '1', - 'Alt-Used' : 'www.amazon.com', - 'Priority' : 'u=0, i', - 'accept-encoding': 'gzip, deflate, br, zstd', - 'accept-language': 'en-US,en;q=0.9'} - session = requests.Session() - session.headers=headers - - def search( - self, query: str, generic_cover: str = "", locale: str = "en",**kwargs - ) -> Optional[List[MetaRecord]]: - def inner(link, index) -> [dict, int]: - with self.session as session: - try: - r = session.get(f"https://www.amazon.com/{link}") - r.raise_for_status() - except Exception as ex: - log.warning(ex) - return [] - long_soup = BS(r.text, "lxml") #~4sec :/ - soup2 = long_soup.find("div", attrs={"cel_widget_id": "dpx-ppd_csm_instrumentation_wrapper"}) - if soup2 is None: - return [] - try: - match = MetaRecord( - title = "", - authors = "", - source=MetaSourceInfo( - id=self.__id__, - description="Amazon Books", - link="https://amazon.com/" - ), - url = f"https://www.amazon.com{link}", - #the more searches the slower, these are too hard to find in reasonable time or might not even exist - publisher= "", # very unreliable - publishedDate= "", # very unreliable - id = None, # ? - tags = [] # dont exist on amazon - ) - - try: - match.description = "\n".join( - soup2.find("div", attrs={"data-feature-name": "bookDescription"}).stripped_strings)\ - .replace("\xa0"," ")[:-9].strip().strip("\n") - except (AttributeError, TypeError): - return [] # if there is no description it is not a book and therefore should be ignored - try: - match.title = soup2.find("span", attrs={"id": "productTitle"}).text - except (AttributeError, TypeError): - match.title = "" - try: - match.authors = [next( - filter(lambda i: i != " " and i != "\n" and not i.startswith("{"), - x.findAll(string=True))).strip() - for x in soup2.findAll("span", attrs={"class": "author"})] - except (AttributeError, TypeError, StopIteration): - match.authors = "" - try: - match.rating = int( - soup2.find("span", class_="a-icon-alt").text.split(" ")[0].split(".")[ - 0]) # first number in string - except (AttributeError, ValueError): - match.rating = 0 - try: - match.cover = soup2.find("img", attrs={"class": "a-dynamic-image"})["src"] - except (AttributeError, TypeError): - match.cover = "" - return match, index - except Exception as e: - log.error_or_exception(e) - return [] - - val = list() - if self.active: - try: - results = self.session.get( - f"https://www.amazon.com/s?k={query.replace(' ', '+')}&i=digital-text&sprefix={query.replace(' ', '+')}" - f"%2Cdigital-text&ref=nb_sb_noss", - headers=self.headers) - results.raise_for_status() - except requests.exceptions.HTTPError as e: - log.error_or_exception(e) - return [] - except Exception as e: - log.warning(e) - return [] - soup = BS(results.text, 'html.parser') - links_list = [next(filter(lambda i: "digital-text" in i["href"], x.findAll("a")))["href"] for x in - soup.findAll("div", attrs={"data-component-type": "s-search-result"})] - with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor: - fut = {executor.submit(inner, link, index) for index, link in enumerate(links_list[:3])} - val = list(map(lambda x : x.result(), concurrent.futures.as_completed(fut))) - result = list(filter(lambda x: x, val)) - return [x[0] for x in sorted(result, key=itemgetter(1))] #sort by amazons listing order for best relevance diff --git a/root/app/calibre-web/cps/metadata_provider/comicvine.py b/root/app/calibre-web/cps/metadata_provider/comicvine.py deleted file mode 100644 index b51c1c9..0000000 --- a/root/app/calibre-web/cps/metadata_provider/comicvine.py +++ /dev/null @@ -1,92 +0,0 @@ -# -*- coding: utf-8 -*- - -# This file is part of the Calibre-Web (https://github.com/janeczku/calibre-web) -# Copyright (C) 2021 OzzieIsaacs -# -# This program is free software: you can redistribute it and/or modify -# it under the terms of the GNU General Public License as published by -# the Free Software Foundation, either version 3 of the License, or -# (at your option) any later version. -# -# This program is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -# GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License -# along with this program. If not, see . - -# ComicVine api document: https://comicvine.gamespot.com/api/documentation -from typing import Dict, List, Optional -from urllib.parse import quote - -import requests -from cps import logger -from cps.services.Metadata import MetaRecord, MetaSourceInfo, Metadata - -log = logger.create() - - -class ComicVine(Metadata): - __name__ = "ComicVine" - __id__ = "comicvine" - DESCRIPTION = "ComicVine Books" - META_URL = "https://comicvine.gamespot.com/" - API_KEY = "57558043c53943d5d1e96a9ad425b0eb85532ee6" - BASE_URL = ( - f"https://comicvine.gamespot.com/api/search?api_key={API_KEY}" - f"&resources=issue&query=" - ) - QUERY_PARAMS = "&sort=name:desc&format=json" - HEADERS = {"User-Agent": "Not Evil Browser"} - - def search( - self, query: str, generic_cover: str = "", locale: str = "en",**kwargs - ) -> Optional[List[MetaRecord]]: - val = list() - if self.active: - title_tokens = list(self.get_title_tokens(query, strip_joiners=False)) - if title_tokens: - tokens = [quote(t.encode("utf-8")) for t in title_tokens] - query = "%20".join(tokens) - try: - result = requests.get( - f"{ComicVine.BASE_URL}{query}{ComicVine.QUERY_PARAMS}", - headers=ComicVine.HEADERS, - ) - result.raise_for_status() - except Exception as e: - log.warning(e) - return None - for result in result.json()["results"]: - match = self._parse_search_result( - result=result, generic_cover=generic_cover, locale=locale - ) - val.append(match) - return val - - def _parse_search_result( - self, result: Dict, generic_cover: str, locale: str - ) -> MetaRecord: - series = result["volume"].get("name", "") - series_index = result.get("issue_number", 0) - issue_name = result.get("name", "") - match = MetaRecord( - id=result["id"], - title=f"{series}#{series_index} - {issue_name}", - authors=result.get("authors", []), - url=result.get("site_detail_url", ""), - source=MetaSourceInfo( - id=self.__id__, - description=ComicVine.DESCRIPTION, - link=ComicVine.META_URL, - ), - series=series, - ) - match.cover = result["image"].get("original_url", generic_cover) - match.description = result.get("description", "") - match.publishedDate = result.get("store_date", result.get("date_added")) - match.series_index = series_index - match.tags = ["Comics", series] - match.identifiers = {"comicvine": match.id} - return match diff --git a/root/app/calibre-web/cps/metadata_provider/douban.py b/root/app/calibre-web/cps/metadata_provider/douban.py deleted file mode 100644 index 316fbea..0000000 --- a/root/app/calibre-web/cps/metadata_provider/douban.py +++ /dev/null @@ -1,260 +0,0 @@ -# -*- coding: utf-8 -*- - -# This file is part of the Calibre-Web (https://github.com/janeczku/calibre-web) -# Copyright (C) 2022 xlivevil -# -# This program is free software: you can redistribute it and/or modify -# it under the terms of the GNU General Public License as published by -# the Free Software Foundation, either version 3 of the License, or -# (at your option) any later version. -# -# This program is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -# GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License -# along with this program. If not, see . -import re -from concurrent import futures -from typing import List, Optional - -import requests -from html2text import HTML2Text -from lxml import etree - -from cps import logger -from cps.services.Metadata import Metadata, MetaRecord, MetaSourceInfo - -log = logger.create() - - -def html2text(html: str) -> str: - - h2t = HTML2Text() - h2t.body_width = 0 - h2t.single_line_break = True - h2t.emphasis_mark = "*" - return h2t.handle(html) - - -class Douban(Metadata): - __name__ = "豆瓣" - __id__ = "douban" - DESCRIPTION = "豆瓣" - META_URL = "https://book.douban.com/" - SEARCH_JSON_URL = "https://www.douban.com/j/search" - SEARCH_URL = "https://www.douban.com/search" - - ID_PATTERN = re.compile(r"sid: (?P\d+),") - AUTHORS_PATTERN = re.compile(r"作者|译者") - PUBLISHER_PATTERN = re.compile(r"出版社") - SUBTITLE_PATTERN = re.compile(r"副标题") - PUBLISHED_DATE_PATTERN = re.compile(r"出版年") - SERIES_PATTERN = re.compile(r"丛书") - IDENTIFIERS_PATTERN = re.compile(r"ISBN|统一书号") - CRITERIA_PATTERN = re.compile("criteria = '(.+)'") - - TITTLE_XPATH = "//span[@property='v:itemreviewed']" - COVER_XPATH = "//a[@class='nbg']" - INFO_XPATH = "//*[@id='info']//span[@class='pl']" - TAGS_XPATH = "//a[contains(@class, 'tag')]" - DESCRIPTION_XPATH = "//div[@id='link-report']//div[@class='intro']" - RATING_XPATH = "//div[@class='rating_self clearfix']/strong" - - session = requests.Session() - session.headers = { - 'user-agent': - 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/98.0.4758.102 Safari/537.36 Edg/98.0.1108.56', - } - - def search(self, - query: str, - generic_cover: str = "", - locale: str = "en",**kwargs) -> List[MetaRecord]: - val = [] - if self.active: - log.debug(f"start searching {query} on douban") - if title_tokens := list( - self.get_title_tokens(query, strip_joiners=False)): - query = "+".join(title_tokens) - - book_id_list = self._get_book_id_list_from_html(query) - - if not book_id_list: - log.debug("No search results in Douban") - return [] - - with futures.ThreadPoolExecutor( - max_workers=5, thread_name_prefix='douban') as executor: - - fut = [ - executor.submit(self._parse_single_book, book_id, - generic_cover) for book_id in book_id_list - ] - - val = [ - future.result() for future in futures.as_completed(fut) - if future.result() - ] - - return val - - def _get_book_id_list_from_html(self, query: str) -> List[str]: - try: - r = self.session.get(self.SEARCH_URL, - params={ - "cat": 1001, - "q": query - }) - r.raise_for_status() - - except Exception as e: - log.warning(e) - return [] - - html = etree.HTML(r.content.decode("utf8")) - result_list = html.xpath(self.COVER_XPATH) - - return [ - self.ID_PATTERN.search(item.get("onclick")).group("id") - for item in result_list[:10] - if self.ID_PATTERN.search(item.get("onclick")) - ] - - def _get_book_id_list_from_json(self, query: str) -> List[str]: - try: - r = self.session.get(self.SEARCH_JSON_URL, - params={ - "cat": 1001, - "q": query - }) - r.raise_for_status() - - except Exception as e: - log.warning(e) - return [] - - results = r.json() - if results["total"] == 0: - return [] - - return [ - self.ID_PATTERN.search(item).group("id") - for item in results["items"][:10] if self.ID_PATTERN.search(item) - ] - - def _parse_single_book(self, - id: str, - generic_cover: str = "") -> Optional[MetaRecord]: - url = f"https://book.douban.com/subject/{id}/" - log.debug(f"start parsing {url}") - - try: - r = self.session.get(url) - r.raise_for_status() - except Exception as e: - log.warning(e) - return None - - match = MetaRecord( - id=id, - title="", - authors=[], - url=url, - source=MetaSourceInfo( - id=self.__id__, - description=self.DESCRIPTION, - link=self.META_URL, - ), - ) - - decode_content = r.content.decode("utf8") - html = etree.HTML(decode_content) - - match.title = html.xpath(self.TITTLE_XPATH)[0].text - match.cover = html.xpath( - self.COVER_XPATH)[0].attrib["href"] or generic_cover - try: - rating_num = float(html.xpath(self.RATING_XPATH)[0].text.strip()) - except Exception: - rating_num = 0 - match.rating = int(-1 * rating_num // 2 * -1) if rating_num else 0 - - tag_elements = html.xpath(self.TAGS_XPATH) - if len(tag_elements): - match.tags = [tag_element.text for tag_element in tag_elements] - else: - match.tags = self._get_tags(decode_content) - - description_element = html.xpath(self.DESCRIPTION_XPATH) - if len(description_element): - match.description = html2text( - etree.tostring(description_element[-1]).decode("utf8")) - - info = html.xpath(self.INFO_XPATH) - - for element in info: - text = element.text - if self.AUTHORS_PATTERN.search(text): - next_element = element.getnext() - while next_element is not None and next_element.tag != "br": - match.authors.append(next_element.text) - next_element = next_element.getnext() - elif self.PUBLISHER_PATTERN.search(text): - if publisher := element.tail.strip(): - match.publisher = publisher - else: - match.publisher = element.getnext().text - elif self.SUBTITLE_PATTERN.search(text): - match.title = f'{match.title}:{element.tail.strip()}' - elif self.PUBLISHED_DATE_PATTERN.search(text): - match.publishedDate = self._clean_date(element.tail.strip()) - elif self.SERIES_PATTERN.search(text): - match.series = element.getnext().text - elif i_type := self.IDENTIFIERS_PATTERN.search(text): - match.identifiers[i_type.group()] = element.tail.strip() - - return match - - @staticmethod - def _clean_date(date: str) -> str: - """ - Clean up the date string to be in the format YYYY-MM-DD - - Examples of possible patterns: - '2014-7-16', '1988年4月', '1995-04', '2021-8', '2020-12-1', '1996年', - '1972', '2004/11/01', '1959年3月北京第1版第1印' - """ - year = date[:4] - moon = "01" - day = "01" - - if len(date) > 5: - digit = [] - ls = [] - for i in range(5, len(date)): - if date[i].isdigit(): - digit.append(date[i]) - elif digit: - ls.append("".join(digit) if len(digit) == - 2 else f"0{digit[0]}") - digit = [] - if digit: - ls.append("".join(digit) if len(digit) == - 2 else f"0{digit[0]}") - - moon = ls[0] - if len(ls) > 1: - day = ls[1] - - return f"{year}-{moon}-{day}" - - def _get_tags(self, text: str) -> List[str]: - tags = [] - if criteria := self.CRITERIA_PATTERN.search(text): - tags.extend( - item.replace('7:', '') for item in criteria.group().split('|') - if item.startswith('7:')) - - return tags diff --git a/root/app/calibre-web/cps/metadata_provider/google.py b/root/app/calibre-web/cps/metadata_provider/google.py deleted file mode 100644 index 150dab5..0000000 --- a/root/app/calibre-web/cps/metadata_provider/google.py +++ /dev/null @@ -1,129 +0,0 @@ -# -*- coding: utf-8 -*- - -# This file is part of the Calibre-Web (https://github.com/janeczku/calibre-web) -# Copyright (C) 2021 OzzieIsaacs -# -# This program is free software: you can redistribute it and/or modify -# it under the terms of the GNU General Public License as published by -# the Free Software Foundation, either version 3 of the License, or -# (at your option) any later version. -# -# This program is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -# GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License -# along with this program. If not, see . - -# Google Books api document: https://developers.google.com/books/docs/v1/using -from typing import Dict, List, Optional -from urllib.parse import quote -from datetime import datetime - -import requests - -from cps import logger -from cps.isoLanguages import get_lang3, get_language_name -from cps.services.Metadata import MetaRecord, MetaSourceInfo, Metadata - -log = logger.create() - - -class Google(Metadata): - __name__ = "Google" - __id__ = "google" - DESCRIPTION = "Google Books" - META_URL = "https://books.google.com/" - BOOK_URL = "https://books.google.com/books?id=" - SEARCH_URL = "https://www.googleapis.com/books/v1/volumes?q=" - ISBN_TYPE = "ISBN_13" - - def search( - self, query: str, generic_cover: str = "", locale: str = "en",**kwargs - ) -> Optional[List[MetaRecord]]: - val = list() - if self.active: - - title_tokens = list(self.get_title_tokens(query, strip_joiners=False)) - if title_tokens: - tokens = [quote(t.encode("utf-8")) for t in title_tokens] - query = "+".join(tokens) - try: - results = requests.get(Google.SEARCH_URL + query) - results.raise_for_status() - except Exception as e: - log.warning(e) - return [] - for result in results.json().get("items", []): - val.append( - self._parse_search_result( - result=result, generic_cover=generic_cover, locale=locale - ) - ) - return val - - def _parse_search_result( - self, result: Dict, generic_cover: str, locale: str - ) -> MetaRecord: - match = MetaRecord( - id=result["id"], - title=result["volumeInfo"]["title"], - authors=result["volumeInfo"].get("authors", []), - url=Google.BOOK_URL + result["id"], - source=MetaSourceInfo( - id=self.__id__, - description=Google.DESCRIPTION, - link=Google.META_URL, - ), - ) - - match.cover = self._parse_cover(result=result, generic_cover=generic_cover) - match.description = result["volumeInfo"].get("description", "") - match.languages = self._parse_languages(result=result, locale=locale) - match.publisher = result["volumeInfo"].get("publisher", "") - try: - datetime.strptime(result["volumeInfo"].get("publishedDate", ""), "%Y-%m-%d") - match.publishedDate = result["volumeInfo"].get("publishedDate", "") - except ValueError: - match.publishedDate = "" - match.rating = result["volumeInfo"].get("averageRating", 0) - match.series, match.series_index = "", 1 - match.tags = result["volumeInfo"].get("categories", []) - - match.identifiers = {"google": match.id} - match = self._parse_isbn(result=result, match=match) - return match - - @staticmethod - def _parse_isbn(result: Dict, match: MetaRecord) -> MetaRecord: - identifiers = result["volumeInfo"].get("industryIdentifiers", []) - for identifier in identifiers: - if identifier.get("type") == Google.ISBN_TYPE: - match.identifiers["isbn"] = identifier.get("identifier") - break - return match - - @staticmethod - def _parse_cover(result: Dict, generic_cover: str) -> str: - if result["volumeInfo"].get("imageLinks"): - cover_url = result["volumeInfo"]["imageLinks"]["thumbnail"] - - # strip curl in cover - cover_url = cover_url.replace("&edge=curl", "") - - # request 800x900 cover image (higher resolution) - cover_url += "&fife=w800-h900" - - return cover_url.replace("http://", "https://") - return generic_cover - - @staticmethod - def _parse_languages(result: Dict, locale: str) -> List[str]: - language_iso2 = result["volumeInfo"].get("language", "") - languages = ( - [get_language_name(locale, get_lang3(language_iso2))] - if language_iso2 - else [] - ) - return languages diff --git a/root/app/calibre-web/cps/metadata_provider/hardcover.py b/root/app/calibre-web/cps/metadata_provider/hardcover.py index 9e36f0c..5a85022 100644 --- a/root/app/calibre-web/cps/metadata_provider/hardcover.py +++ b/root/app/calibre-web/cps/metadata_provider/hardcover.py @@ -23,9 +23,8 @@ from urllib.parse import quote import requests from cps import logger from cps.services.Metadata import MetaRecord, MetaSourceInfo, Metadata -from importlib import reload -from flask import g +from ..cw_login import current_user log = logger.create() @@ -119,9 +118,9 @@ class Hardcover(Metadata): FORMATS = ["","Physical Book","","","E-Book"] # Map reading_format_id to text equivelant. def search( - self, query: str, generic_cover: str = "", locale: str = "en", **kwargs + self, query: str, generic_cover: str = "", locale: str = "en" ) -> Optional[List[MetaRecord]]: - token = kwargs.get("token") + token = current_user.hardcover_token if not token: log.warning("Hardcover token not set for user") return None diff --git a/root/app/calibre-web/cps/metadata_provider/lubimyczytac.py b/root/app/calibre-web/cps/metadata_provider/lubimyczytac.py deleted file mode 100644 index 003a732..0000000 --- a/root/app/calibre-web/cps/metadata_provider/lubimyczytac.py +++ /dev/null @@ -1,359 +0,0 @@ -# -*- coding: utf-8 -*- -# This file is part of the Calibre-Web (https://github.com/janeczku/calibre-web) -# Copyright (C) 2021 OzzieIsaacs -# -# This program is free software: you can redistribute it and/or modify -# it under the terms of the GNU General Public License as published by -# the Free Software Foundation, either version 3 of the License, or -# (at your option) any later version. -# -# This program is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -# GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License -# along with this program. If not, see . -import datetime -import json -import re -from multiprocessing.pool import ThreadPool -from typing import List, Optional, Tuple, Union -from urllib.parse import quote - -import requests -from dateutil import parser -from html2text import HTML2Text -from lxml.html import HtmlElement, fromstring, tostring -from markdown2 import Markdown - -from cps import logger -from cps.isoLanguages import get_language_name -from cps.services.Metadata import MetaRecord, MetaSourceInfo, Metadata - -log = logger.create() - -SYMBOLS_TO_TRANSLATE = ( - "öÖüÜóÓőŐúÚéÉáÁűŰíÍąĄćĆęĘłŁńŃóÓśŚźŹżŻ", - "oOuUoOoOuUeEaAuUiIaAcCeElLnNoOsSzZzZ", -) -SYMBOL_TRANSLATION_MAP = dict( - [(ord(a), ord(b)) for (a, b) in zip(*SYMBOLS_TO_TRANSLATE)] -) - - -def get_int_or_float(value: str) -> Union[int, float]: - number_as_float = float(value) - number_as_int = int(number_as_float) - return number_as_int if number_as_float == number_as_int else number_as_float - - -def strip_accents(s: Optional[str]) -> Optional[str]: - return s.translate(SYMBOL_TRANSLATION_MAP) if s is not None else s - - -def sanitize_comments_html(html: str) -> str: - text = html2text(html) - md = Markdown() - html = md.convert(text) - return html - - -def html2text(html: str) -> str: - # replace tags with as becomes emphasis in html2text - if isinstance(html, bytes): - html = html.decode("utf-8") - html = re.sub( - r"<\s*(?P/?)\s*[uU]\b(?P[^>]*)>", - r"<\gspan\g>", - html, - ) - h2t = HTML2Text() - h2t.body_width = 0 - h2t.single_line_break = True - h2t.emphasis_mark = "*" - return h2t.handle(html) - - -class LubimyCzytac(Metadata): - __name__ = "LubimyCzytac.pl" - __id__ = "lubimyczytac" - - BASE_URL = "https://lubimyczytac.pl" - - BOOK_SEARCH_RESULT_XPATH = ( - "*//div[@class='listSearch']//div[@class='authorAllBooks__single']" - ) - SINGLE_BOOK_RESULT_XPATH = ".//div[contains(@class,'authorAllBooks__singleText')]" - TITLE_PATH = "/div/a[contains(@class,'authorAllBooks__singleTextTitle')]" - TITLE_TEXT_PATH = f"{TITLE_PATH}//text()" - URL_PATH = f"{TITLE_PATH}/@href" - AUTHORS_PATH = "/div/a[contains(@href,'autor')]//text()" - - SIBLINGS = "/following-sibling::dd" - - CONTAINER = "//section[@class='container book']" - PUBLISHER = f"{CONTAINER}//dt[contains(text(),'Wydawnictwo:')]{SIBLINGS}/a/text()" - LANGUAGES = f"{CONTAINER}//dt[contains(text(),'Język:')]{SIBLINGS}/text()" - DESCRIPTION = f"{CONTAINER}//div[@class='collapse-content']" - SERIES = f"{CONTAINER}//span/a[contains(@href,'/cykl/')]/text()" - TRANSLATOR = f"{CONTAINER}//dt[contains(text(),'Tłumacz:')]{SIBLINGS}/a/text()" - - DETAILS = "//div[@id='book-details']" - PUBLISH_DATE = "//dt[contains(@title,'Data pierwszego wydania" - FIRST_PUBLISH_DATE = f"{DETAILS}{PUBLISH_DATE} oryginalnego')]{SIBLINGS}[1]/text()" - FIRST_PUBLISH_DATE_PL = f"{DETAILS}{PUBLISH_DATE} polskiego')]{SIBLINGS}[1]/text()" - TAGS = "//a[contains(@href,'/ksiazki/t/')]/text()" # "//nav[@aria-label='breadcrumbs']//a[contains(@href,'/ksiazki/k/')]/span/text()" - - - RATING = "//meta[@property='books:rating:value']/@content" - COVER = "//meta[@property='og:image']/@content" - ISBN = "//meta[@property='books:isbn']/@content" - META_TITLE = "//meta[@property='og:description']/@content" - - SUMMARY = "//script[@type='application/ld+json']//text()" - - def search( - self, query: str, generic_cover: str = "", locale: str = "en",**kwargs - ) -> Optional[List[MetaRecord]]: - if self.active: - try: - result = requests.get(self._prepare_query(title=query)) - result.raise_for_status() - except Exception as e: - log.warning(e) - return None - root = fromstring(result.text) - lc_parser = LubimyCzytacParser(root=root, metadata=self) - matches = lc_parser.parse_search_results() - if matches: - with ThreadPool(processes=10) as pool: - final_matches = pool.starmap( - lc_parser.parse_single_book, - [(match, generic_cover, locale) for match in matches], - ) - return final_matches - return matches - - def _prepare_query(self, title: str) -> str: - query = "" - characters_to_remove = r"\?()\/" - pattern = "[" + characters_to_remove + "]" - title = re.sub(pattern, "", title) - title = title.replace("_", " ") - if '"' in title or ",," in title: - title = title.split('"')[0].split(",,")[0] - - if "/" in title: - title_tokens = [ - token for token in title.lower().split(" ") if len(token) > 1 - ] - else: - title_tokens = list(self.get_title_tokens(title, strip_joiners=False)) - if title_tokens: - tokens = [quote(t.encode("utf-8")) for t in title_tokens] - query = query + "%20".join(tokens) - if not query: - return "" - return f"{LubimyCzytac.BASE_URL}/szukaj/ksiazki?phrase={query}" - - -class LubimyCzytacParser: - PAGES_TEMPLATE = "

    Książka ma {0} stron(y).

    " - TRANSLATOR_TEMPLATE = "

    Tłumacz: {0}

    " - PUBLISH_DATE_TEMPLATE = "

    Data pierwszego wydania: {0}

    " - PUBLISH_DATE_PL_TEMPLATE = ( - "

    Data pierwszego wydania w Polsce: {0}

    " - ) - - def __init__(self, root: HtmlElement, metadata: Metadata) -> None: - self.root = root - self.metadata = metadata - - def parse_search_results(self) -> List[MetaRecord]: - matches = [] - results = self.root.xpath(LubimyCzytac.BOOK_SEARCH_RESULT_XPATH) - for result in results: - title = self._parse_xpath_node( - root=result, - xpath=f"{LubimyCzytac.SINGLE_BOOK_RESULT_XPATH}" - f"{LubimyCzytac.TITLE_TEXT_PATH}", - ) - - book_url = self._parse_xpath_node( - root=result, - xpath=f"{LubimyCzytac.SINGLE_BOOK_RESULT_XPATH}" - f"{LubimyCzytac.URL_PATH}", - ) - authors = self._parse_xpath_node( - root=result, - xpath=f"{LubimyCzytac.SINGLE_BOOK_RESULT_XPATH}" - f"{LubimyCzytac.AUTHORS_PATH}", - take_first=False, - ) - if not all([title, book_url, authors]): - continue - matches.append( - MetaRecord( - id=book_url.replace(f"/ksiazka/", "").split("/")[0], - title=title, - authors=[strip_accents(author) for author in authors], - url=LubimyCzytac.BASE_URL + book_url, - source=MetaSourceInfo( - id=self.metadata.__id__, - description=self.metadata.__name__, - link=LubimyCzytac.BASE_URL, - ), - ) - ) - return matches - - def parse_single_book( - self, match: MetaRecord, generic_cover: str, locale: str - ) -> MetaRecord: - try: - response = requests.get(match.url) - response.raise_for_status() - except Exception as e: - log.warning(e) - return None - self.root = fromstring(response.text) - match.cover = self._parse_cover(generic_cover=generic_cover) - match.description = self._parse_description() - match.languages = self._parse_languages(locale=locale) - match.publisher = self._parse_publisher() - match.publishedDate = self._parse_from_summary(attribute_name="datePublished") - match.rating = self._parse_rating() - match.series, match.series_index = self._parse_series() - match.tags = self._parse_tags() - match.identifiers = { - "isbn": self._parse_isbn(), - "lubimyczytac": match.id, - } - return match - - def _parse_xpath_node( - self, - xpath: str, - root: HtmlElement = None, - take_first: bool = True, - strip_element: bool = True, - ) -> Optional[Union[str, List[str]]]: - root = root if root is not None else self.root - node = root.xpath(xpath) - if not node: - return None - return ( - (node[0].strip() if strip_element else node[0]) - if take_first - else [x.strip() for x in node] - ) - - def _parse_cover(self, generic_cover) -> Optional[str]: - return ( - self._parse_xpath_node(xpath=LubimyCzytac.COVER, take_first=True) - or generic_cover - ) - - def _parse_publisher(self) -> Optional[str]: - return self._parse_xpath_node(xpath=LubimyCzytac.PUBLISHER, take_first=True) - - def _parse_languages(self, locale: str) -> List[str]: - languages = list() - lang = self._parse_xpath_node(xpath=LubimyCzytac.LANGUAGES, take_first=True) - if lang: - if "polski" in lang: - languages.append("pol") - if "angielski" in lang: - languages.append("eng") - return [get_language_name(locale, language) for language in languages] - - def _parse_series(self) -> Tuple[Optional[str], Optional[Union[float, int]]]: - series_index = 0 - series = self._parse_xpath_node(xpath=LubimyCzytac.SERIES, take_first=True) - if series: - if "tom " in series: - series_name, series_info = series.split(" (tom ", 1) - series_info = series_info.replace(" ", "").replace(")", "") - # Check if book is not a bundle, i.e. chapter 1-3 - if "-" in series_info: - series_info = series_info.split("-", 1)[0] - if series_info.replace(".", "").isdigit() is True: - series_index = get_int_or_float(series_info) - return series_name, series_index - return None, None - - def _parse_tags(self) -> List[str]: - tags = self._parse_xpath_node(xpath=LubimyCzytac.TAGS, take_first=False) - if tags: - return [ - strip_accents(w.replace(", itd.", " itd.")) - for w in tags - if isinstance(w, str) - ] - return None - - def _parse_from_summary(self, attribute_name: str) -> Optional[str]: - value = None - summary_text = self._parse_xpath_node(xpath=LubimyCzytac.SUMMARY) - if summary_text: - data = json.loads(summary_text) - value = data.get(attribute_name) - return value.strip() if value is not None else value - - def _parse_rating(self) -> Optional[str]: - rating = self._parse_xpath_node(xpath=LubimyCzytac.RATING) - return round(float(rating.replace(",", ".")) / 2) if rating else rating - - def _parse_date(self, xpath="first_publish") -> Optional[datetime.datetime]: - options = { - "first_publish": LubimyCzytac.FIRST_PUBLISH_DATE, - "first_publish_pl": LubimyCzytac.FIRST_PUBLISH_DATE_PL, - } - date = self._parse_xpath_node(xpath=options.get(xpath)) - return parser.parse(date) if date else None - - def _parse_isbn(self) -> Optional[str]: - return self._parse_xpath_node(xpath=LubimyCzytac.ISBN) - - def _parse_description(self) -> str: - description = "" - description_node = self._parse_xpath_node( - xpath=LubimyCzytac.DESCRIPTION, strip_element=False - ) - if description_node is not None: - for source in self.root.xpath('//p[@class="source"]'): - source.getparent().remove(source) - description = tostring(description_node, method="html") - description = sanitize_comments_html(description) - - else: - description_node = self._parse_xpath_node(xpath=LubimyCzytac.META_TITLE) - if description_node is not None: - description = description_node - description = sanitize_comments_html(description) - description = self._add_extra_info_to_description(description=description) - return description - - def _add_extra_info_to_description(self, description: str) -> str: - pages = self._parse_from_summary(attribute_name="numberOfPages") - if pages: - description += LubimyCzytacParser.PAGES_TEMPLATE.format(pages) - - first_publish_date = self._parse_date() - if first_publish_date: - description += LubimyCzytacParser.PUBLISH_DATE_TEMPLATE.format( - first_publish_date.strftime("%d.%m.%Y") - ) - - first_publish_date_pl = self._parse_date(xpath="first_publish_pl") - if first_publish_date_pl: - description += LubimyCzytacParser.PUBLISH_DATE_PL_TEMPLATE.format( - first_publish_date_pl.strftime("%d.%m.%Y") - ) - translator = self._parse_xpath_node(xpath=LubimyCzytac.TRANSLATOR) - if translator: - description += LubimyCzytacParser.TRANSLATOR_TEMPLATE.format(translator) - - - return description diff --git a/root/app/calibre-web/cps/metadata_provider/scholar.py b/root/app/calibre-web/cps/metadata_provider/scholar.py deleted file mode 100644 index b3bfbb7..0000000 --- a/root/app/calibre-web/cps/metadata_provider/scholar.py +++ /dev/null @@ -1,83 +0,0 @@ -# -*- coding: utf-8 -*- - -# This file is part of the Calibre-Web (https://github.com/janeczku/calibre-web) -# Copyright (C) 2021 OzzieIsaacs -# -# This program is free software: you can redistribute it and/or modify -# it under the terms of the GNU General Public License as published by -# the Free Software Foundation, either version 3 of the License, or -# (at your option) any later version. -# -# This program is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -# GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License -# along with this program. If not, see . -import itertools -from typing import Dict, List, Optional -from urllib.parse import quote, unquote - -try: - from fake_useragent.errors import FakeUserAgentError -except (ImportError): - FakeUserAgentError = BaseException -try: - from scholarly import scholarly -except FakeUserAgentError: - raise ImportError("No module named 'scholarly'") - -from cps import logger -from cps.services.Metadata import MetaRecord, MetaSourceInfo, Metadata - -log = logger.create() - - -class scholar(Metadata): - __name__ = "Google Scholar" - __id__ = "googlescholar" - META_URL = "https://scholar.google.com/" - - def search( - self, query: str, generic_cover: str = "", locale: str = "en",**kwargs - ) -> Optional[List[MetaRecord]]: - val = list() - if self.active: - title_tokens = list(self.get_title_tokens(query, strip_joiners=False)) - if title_tokens: - tokens = [quote(t.encode("utf-8")) for t in title_tokens] - query = " ".join(tokens) - try: - scholarly.set_timeout(20) - scholarly.set_retries(2) - scholar_gen = itertools.islice(scholarly.search_pubs(query), 10) - except Exception as e: - log.warning(e) - return list() - for result in scholar_gen: - match = self._parse_search_result( - result=result, generic_cover="", locale=locale - ) - val.append(match) - return val - - def _parse_search_result( - self, result: Dict, generic_cover: str, locale: str - ) -> MetaRecord: - match = MetaRecord( - id=result.get("pub_url", result.get("eprint_url", "")), - title=result["bib"].get("title"), - authors=result["bib"].get("author", []), - url=result.get("pub_url", result.get("eprint_url", "")), - source=MetaSourceInfo( - id=self.__id__, description=self.__name__, link=scholar.META_URL - ), - ) - - match.cover = result.get("image", {}).get("original_url", generic_cover) - match.description = unquote(result["bib"].get("abstract", "")) - match.publisher = result["bib"].get("venue", "") - match.publishedDate = result["bib"].get("pub_year") + "-01-01" - match.identifiers = {"scholar": match.id} - return match diff --git a/root/app/calibre-web/cps/search_metadata.py b/root/app/calibre-web/cps/search_metadata.py index 9700c9c..2b94e91 100644 --- a/root/app/calibre-web/cps/search_metadata.py +++ b/root/app/calibre-web/cps/search_metadata.py @@ -23,7 +23,7 @@ import json import os import sys -from flask import Blueprint, request, url_for, make_response, jsonify +from flask import Blueprint, request, url_for, make_response, jsonify, copy_current_request_context from .cw_login import current_user from flask_babel import get_locale from sqlalchemy.exc import InvalidRequestError, OperationalError @@ -130,7 +130,7 @@ def metadata_search(): # ret = cl[0].search(query, static_cover, locale) with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor: meta = { - executor.submit(c.search, query, static_cover, locale, token=getattr(current_user,f'{c.__id__}_token',None)): c + executor.submit(copy_current_request_context(c.search), query, static_cover, locale): c for c in cl if active.get(c.__id__, True) } diff --git a/root/app/calibre-web/cps/templates/book_edit.html b/root/app/calibre-web/cps/templates/book_edit.html index 2a1cbb1..1ed07f6 100644 --- a/root/app/calibre-web/cps/templates/book_edit.html +++ b/root/app/calibre-web/cps/templates/book_edit.html @@ -243,7 +243,6 @@
    -
    {{_('Click the cover to load metadata to the form')}}
    From b0e7ba78942c26d206e7dffd4dcf26128329979b Mon Sep 17 00:00:00 2001 From: demitrix Date: Mon, 20 Jan 2025 23:12:21 +0000 Subject: [PATCH 05/42] Merge upsteam and correct rounding wrong page variable --- .../cps/metadata_provider/hardcover.py | 22 ------------------- .../app/calibre-web/cps/services/hardcover.py | 4 ++-- 2 files changed, 2 insertions(+), 24 deletions(-) diff --git a/root/app/calibre-web/cps/metadata_provider/hardcover.py b/root/app/calibre-web/cps/metadata_provider/hardcover.py index 5a85022..222d2b9 100644 --- a/root/app/calibre-web/cps/metadata_provider/hardcover.py +++ b/root/app/calibre-web/cps/metadata_provider/hardcover.py @@ -35,28 +35,6 @@ class Hardcover(Metadata): DESCRIPTION = "Hardcover Books" META_URL = "https://hardcover.app" BASE_URL = "https://api.hardcover.app/v1/graphql" - # SEARCH_QUERY = """{ - # books( - # where: {title: {_eq: "%s"}} - # limit: 10 - # order_by: {users_read_count: desc} - # ) { - # title - # book_series { - # series { - # name - # } - # position - # } - # cached_contributors - # id - # cached_image - # slug - # description - # release_date - # cached_tags - # } - # }""" SEARCH_QUERY = """query Search($query: String!) { search(query: $query, query_type: "Book", per_page: 50) { results diff --git a/root/app/calibre-web/cps/services/hardcover.py b/root/app/calibre-web/cps/services/hardcover.py index 040289f..eca2514 100644 --- a/root/app/calibre-web/cps/services/hardcover.py +++ b/root/app/calibre-web/cps/services/hardcover.py @@ -112,9 +112,9 @@ class HardcoverClient: book = self.add_book(ids, status=2) if book.get("status_id") is not 2: book = self.change_book_status(book, 2) - pages = round(book.get("edition",{}).get("pages",0)) + pages = book.get("edition",{}).get("pages",0) if pages: - pages_read = pages * (progress_percent / 100) + pages_read = round(pages * (progress_percent / 100)) read = next(iter(book.get("user_book_reads")),None) if not read: read = self.add_read(book, pages_read) From 671c088d56a9244726d014f8f9e8a3d2a824f86e Mon Sep 17 00:00:00 2001 From: demitrix Date: Tue, 21 Jan 2025 17:39:56 +0000 Subject: [PATCH 06/42] hardcover.py (metadata_provider) - Add option for environment variable HARDCOVER_TOKEN to enable metadata for all users - Fix broken edition links - General cleanup caliBlur.css/style.css - Fix metadata results for caliBlur get_meta.js - Fix identifiers not being invidually selectable book_edit.html - Add search editons link next to hardcover-id - Fix typos --- .../cps/metadata_provider/hardcover.py | 46 +++++++++---------- .../calibre-web/cps/static/css/caliBlur.css | 9 +++- root/app/calibre-web/cps/static/css/style.css | 1 - .../app/calibre-web/cps/static/js/get_meta.js | 28 +++++------ .../calibre-web/cps/templates/book_edit.html | 16 +++++-- 5 files changed, 56 insertions(+), 44 deletions(-) diff --git a/root/app/calibre-web/cps/metadata_provider/hardcover.py b/root/app/calibre-web/cps/metadata_provider/hardcover.py index 222d2b9..c94fbab 100644 --- a/root/app/calibre-web/cps/metadata_provider/hardcover.py +++ b/root/app/calibre-web/cps/metadata_provider/hardcover.py @@ -18,17 +18,16 @@ # Hardcover api document: https://Hardcover.gamespot.com/api/documentation from typing import Dict, List, Optional -from urllib.parse import quote import requests from cps import logger from cps.services.Metadata import MetaRecord, MetaSourceInfo, Metadata from ..cw_login import current_user +from os import getenv log = logger.create() - class Hardcover(Metadata): __name__ = "Hardcover" __id__ = "hardcover" @@ -98,33 +97,29 @@ class Hardcover(Metadata): def search( self, query: str, generic_cover: str = "", locale: str = "en" ) -> Optional[List[MetaRecord]]: - token = current_user.hardcover_token - if not token: - log.warning("Hardcover token not set for user") - return None val = list() if self.active: try: - if (token == ""): - raise Exception("Current user does not have Hardcover API token") - else: - edition_seach = query.split(":")[0] == "hardcover-id" - Hardcover.HEADERS["Authorization"] = "Bearer %s" % token - result = requests.post( - Hardcover.BASE_URL, - json={ - "query":Hardcover.SEARCH_QUERY if not edition_seach else Hardcover.EDITION_QUERY, - "variables":{"query":query if not edition_seach else query.split(":")[1]} - }, - headers=Hardcover.HEADERS, - ) - result.raise_for_status() + token = current_user.hardcover_token or getenv("HARDCOVER_TOKEN") + if not token: + self.set_status(False) + raise Exception("Hardcover token not set for user, and no global token provided.") + edition_seach = query.split(":")[0] == "hardcover-id" + Hardcover.HEADERS["Authorization"] = "Bearer %s" % token.replace("Bearer ","") + result = requests.post( + Hardcover.BASE_URL, + json={ + "query":Hardcover.SEARCH_QUERY if not edition_seach else Hardcover.EDITION_QUERY, + "variables":{"query":query if not edition_seach else query.split(":")[1]} + }, + headers=Hardcover.HEADERS, + ) + result.raise_for_status() except Exception as e: log.warning(e) return None if edition_seach: result = result.json()["data"]["books"][0] - log.debug(result) val = self._parse_edition_results(result=result, generic_cover=generic_cover, locale=locale) else: for result in result.json()["data"]["search"]["results"]["hits"]: @@ -151,7 +146,6 @@ class Hardcover(Metadata): ), series=series, ) - # TODO Add parse cover function to get better size match.cover = result["document"]["image"].get("url", generic_cover) match.description = result["document"].get("description","") @@ -183,7 +177,6 @@ class Hardcover(Metadata): ), series=result.get("book_series",[{}])[0].get("series",{}).get("name", ""), ) - # TODO Add parse cover function to get better size match.cover = (edition.get("image") or {}).get("url", generic_cover) match.description = result.get("description","") match.publisher = (edition.get("publisher") or {}).get("name","") @@ -197,6 +190,9 @@ class Hardcover(Metadata): "hardcover-edition": edition.get("id",""), "isbn": (edition.get("isbn_13",edition.get("isbn_10")) or "") } + isbn = edition.get("isbn_13",edition.get("isbn_10")) + if isbn: + match.identifiers["isbn"] = isbn match.format = Hardcover.FORMATS[edition.get("reading_format_id",0)] editions.append(match) return editions @@ -209,10 +205,10 @@ class Hardcover(Metadata): return url @staticmethod - def _parse_edition_url(edition: Dict, url: str) -> str: + def _parse_edition_url(result: Dict, edition: Dict, url: str) -> str: hardcover_edition = edition.get("id", "") if hardcover_edition: - return f"https://hardcover.app/books/jurassic-park/editions/{hardcover_edition}" + return f"https://hardcover.app/books/{result.get("slug", "")}/editions/{hardcover_edition}" return url @staticmethod diff --git a/root/app/calibre-web/cps/static/css/caliBlur.css b/root/app/calibre-web/cps/static/css/caliBlur.css index 7b3a149..3522a6d 100644 --- a/root/app/calibre-web/cps/static/css/caliBlur.css +++ b/root/app/calibre-web/cps/static/css/caliBlur.css @@ -2758,13 +2758,20 @@ input.pill + label:hover { margin: 0 } +#meta-info #book-list .media:nth-of-type(even) { + background: none; +} + #meta-info #book-list .media:nth-of-type(odd) { background: hsla(0, 0%, 100%, .02) } #meta-info #book-list .media { margin-top: 0; - padding: 20px 15px 5px + margin-bottom: 0; + padding: 20px 15px 5px; + box-shadow: none; + border-radius: 0; } #meta-info #book-list .media > .media-body > p > a { diff --git a/root/app/calibre-web/cps/static/css/style.css b/root/app/calibre-web/cps/static/css/style.css index e40589b..4f19862 100644 --- a/root/app/calibre-web/cps/static/css/style.css +++ b/root/app/calibre-web/cps/static/css/style.css @@ -554,7 +554,6 @@ input.pill:not(:checked) + label .glyphicon { #meta-info #book-list .media .media-body dt { font-weight: bold; - color: #333; display: flex; align-items: center; } diff --git a/root/app/calibre-web/cps/static/js/get_meta.js b/root/app/calibre-web/cps/static/js/get_meta.js index 819b395..da170a7 100644 --- a/root/app/calibre-web/cps/static/js/get_meta.js +++ b/root/app/calibre-web/cps/static/js/get_meta.js @@ -84,26 +84,26 @@ $(function () { $("#series_index").val(book.series_index); } if ( - updateItems.identifiers && typeof book.identifiers !== "undefined" ) { - populateIdentifiers(book.identifiers); + selectedIdentifiers = Object.keys(book.identifiers) + .filter((key) => updateItems[key]) + .reduce((result, key) => { + result[key] = book.identifiers[key]; + return result; + }, {}); + populateIdentifiers(selectedIdentifiers); } } - function populateIdentifiers(identifiers) { + function populateIdentifiers(identifiers){ for (const property in identifiers) { - if (identifiers[property].length !== 0) { - console.log(`${property}: ${identifiers[property]}`); - if ( - $('input[name="identifier-type-' + property + '"]').length - ) { - $('input[name="identifier-val-' + property + '"]').val( - identifiers[property] - ); - } else { - addIdentifier(property, identifiers[property]); - } + console.log(`${property}: ${identifiers[property]}`); + if ($('input[name="identifier-type-'+property+'"]').length) { + $('input[name="identifier-val-'+property+'"]').val(identifiers[property]) + } + else { + addIdentifier(property, identifiers[property]) } } } diff --git a/root/app/calibre-web/cps/templates/book_edit.html b/root/app/calibre-web/cps/templates/book_edit.html index 1ed07f6..26b3971 100644 --- a/root/app/calibre-web/cps/templates/book_edit.html +++ b/root/app/calibre-web/cps/templates/book_edit.html @@ -275,7 +275,7 @@
    - <% if(book.format !== "") { %> + <% if(book.format) { %>
    Format: <%= book.format %>
    <% } %>
    @@ -311,8 +311,12 @@ <% if (Object.keys(book.identifiers).length !== 0 ) { %> <% for (const key in book.identifiers) { %> <% if (book.identifiers[key] !== "") { %> -
    Identifier
    -
    <%= key %>:<%= book.identifiers[key] %>
    +
    Identifier
    +
    <%= key %>:<%= book.identifiers[key] %> + <% if (key === "hardcover-id" && !document.getElementById("keyword").value.includes("hardcover-id")) { %> + Editions + <% } %> +
    <% } %> <% } %> <% } %> @@ -353,6 +357,12 @@ el.nextElementSibling.classList.add("larger") } } + $(document).on('click','.meta_identifier a', + function (e) { + e.preventDefault() + document.getElementById("keyword").value = `hardcover-id:${e.target.dataset.hardcoverId}` + document.getElementById("do-search").click() + }) From 6685a26e6aabb81e265659917aeabb31e6770f62 Mon Sep 17 00:00:00 2001 From: demitrix Date: Tue, 21 Jan 2025 18:23:00 +0000 Subject: [PATCH 07/42] Missed change in hardcover.py for edition link --- root/app/calibre-web/cps/metadata_provider/hardcover.py | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/root/app/calibre-web/cps/metadata_provider/hardcover.py b/root/app/calibre-web/cps/metadata_provider/hardcover.py index c94fbab..dd39a8f 100644 --- a/root/app/calibre-web/cps/metadata_provider/hardcover.py +++ b/root/app/calibre-web/cps/metadata_provider/hardcover.py @@ -206,9 +206,10 @@ class Hardcover(Metadata): @staticmethod def _parse_edition_url(result: Dict, edition: Dict, url: str) -> str: - hardcover_edition = edition.get("id", "") - if hardcover_edition: - return f"https://hardcover.app/books/{result.get("slug", "")}/editions/{hardcover_edition}" + edition = edition.get("id", "") + slug = result.get("slug","") + if edition: + return f"https://hardcover.app/books/{slug}/editions/{edition}" return url @staticmethod From ab7e2c18796bb7bc40afbc61c67eb8dbef6e006f Mon Sep 17 00:00:00 2001 From: demitrix Date: Tue, 21 Jan 2025 19:02:08 +0000 Subject: [PATCH 08/42] Add call to user table migration. --- root/app/calibre-web/cps/ub.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/root/app/calibre-web/cps/ub.py b/root/app/calibre-web/cps/ub.py index f0ba832..b9ac78c 100644 --- a/root/app/calibre-web/cps/ub.py +++ b/root/app/calibre-web/cps/ub.py @@ -619,7 +619,7 @@ def migrate_Database(_session): add_missing_tables(engine, _session) migrate_registration_table(engine, _session) migrate_user_session_table(engine, _session) - + migrate_user_table(engine, _session) def clean_database(_session): # Remove expired remote login tokens From cff3d524040a982d11190d9c3c18f874f8b880bb Mon Sep 17 00:00:00 2001 From: demitrix Date: Tue, 21 Jan 2025 21:46:32 +0000 Subject: [PATCH 09/42] Removes requierment for Kobo Sync to be enabled to save Hardcover token Fixes edition language Fixes editions search for books with no series --- .../cps/metadata_provider/hardcover.py | 18 ++++++++++++++---- .../calibre-web/cps/templates/user_edit.html | 2 +- 2 files changed, 15 insertions(+), 5 deletions(-) diff --git a/root/app/calibre-web/cps/metadata_provider/hardcover.py b/root/app/calibre-web/cps/metadata_provider/hardcover.py index dd39a8f..e0da20a 100644 --- a/root/app/calibre-web/cps/metadata_provider/hardcover.py +++ b/root/app/calibre-web/cps/metadata_provider/hardcover.py @@ -22,7 +22,7 @@ from typing import Dict, List, Optional import requests from cps import logger from cps.services.Metadata import MetaRecord, MetaSourceInfo, Metadata - +from cps.isoLanguages import get_language_name from ..cw_login import current_user from os import getenv @@ -175,15 +175,15 @@ class Hardcover(Metadata): description=Hardcover.DESCRIPTION, link=Hardcover.META_URL, ), - series=result.get("book_series",[{}])[0].get("series",{}).get("name", ""), + series=(result.get("book_series") or [{}])[0].get("series",{}).get("name", ""), ) match.cover = (edition.get("image") or {}).get("url", generic_cover) match.description = result.get("description","") match.publisher = (edition.get("publisher") or {}).get("name","") match.publishedDate = edition.get("release_date", "") - match.series_index = result.get("book_series",[{}])[0].get("position", "") + match.series_index = (result.get("book_series") or [{}])[0].get("position", "") match.tags = self._parse_tags(result,[]) - match.languages = (edition.get("language") or {}).get("code3","") + match.languages = self._parse_languages(edition,locale) match.identifiers = { "hardcover-id": id, "hardcover-slug": result.get("slug", ""), @@ -227,3 +227,13 @@ class Hardcover(Metadata): except Exception as e: log.warning(e) return tags + + @staticmethod + def _parse_languages(edition: Dict, locale: str) -> List[str]: + language_iso = (edition.get("language") or {}).get("code3","") + languages = ( + [get_language_name(locale, language_iso)] + if language_iso + else [] + ) + return languages \ No newline at end of file diff --git a/root/app/calibre-web/cps/templates/user_edit.html b/root/app/calibre-web/cps/templates/user_edit.html index ed3b7b1..1fdc589 100644 --- a/root/app/calibre-web/cps/templates/user_edit.html +++ b/root/app/calibre-web/cps/templates/user_edit.html @@ -60,7 +60,7 @@ {% endfor %} {% endif %} - {% if kobo_support and hardcover_support and not new_user %} + {% if hardcover_support and not new_user %}
    From 686c67b29826651e553e35457388a5138a2b04d0 Mon Sep 17 00:00:00 2001 From: demitrix Date: Wed, 22 Jan 2025 01:29:54 +0000 Subject: [PATCH 10/42] Fixes missing argument for edtion url --- root/app/calibre-web/cps/metadata_provider/hardcover.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/root/app/calibre-web/cps/metadata_provider/hardcover.py b/root/app/calibre-web/cps/metadata_provider/hardcover.py index e0da20a..681f8ea 100644 --- a/root/app/calibre-web/cps/metadata_provider/hardcover.py +++ b/root/app/calibre-web/cps/metadata_provider/hardcover.py @@ -169,7 +169,7 @@ class Hardcover(Metadata): id=id, title=edition.get("title",""), authors=self._parse_edition_authors(edition,[]), - url=self._parse_edition_url(edition, ""), + url=self._parse_edition_url(result, edition, ""), source=MetaSourceInfo( id=self.__id__, description=Hardcover.DESCRIPTION, From 8ee03b2bf34202d42d5c2dc18c917551c8a05e71 Mon Sep 17 00:00:00 2001 From: demitrix Date: Tue, 28 Jan 2025 16:32:52 +0000 Subject: [PATCH 11/42] Fix unique Hardcover tokens preventing default Guest user during setup. --- root/app/calibre-web/cps/ub.py | 4 +++- root/app/calibre-web/cps/web.py | 2 +- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/root/app/calibre-web/cps/ub.py b/root/app/calibre-web/cps/ub.py index b9ac78c..a91e87c 100644 --- a/root/app/calibre-web/cps/ub.py +++ b/root/app/calibre-web/cps/ub.py @@ -257,7 +257,7 @@ class User(UserBase, Base): remote_auth_token = relationship('RemoteAuthToken', backref='user', lazy='dynamic') view_settings = Column(JSON, default={}) kobo_only_shelves_sync = Column(Integer, default=0) - hardcover_token = Column(String, unique=True, default="") + hardcover_token = Column(String, unique=True, default=None) if oauth_support: @@ -281,6 +281,7 @@ class OAuthProvider(Base): # anonymous user class Anonymous(AnonymousUserMixin, UserBase): def __init__(self): + self.hardcover_token = None self.kobo_only_shelves_sync = None self.view_settings = None self.allowed_column_value = None @@ -311,6 +312,7 @@ class Anonymous(AnonymousUserMixin, UserBase): self.allowed_column_value = data.allowed_column_value self.view_settings = data.view_settings self.kobo_only_shelves_sync = data.kobo_only_shelves_sync + self.hardcover_token = data.hardcover_token def role_admin(self): return False diff --git a/root/app/calibre-web/cps/web.py b/root/app/calibre-web/cps/web.py index 1c16518..02201c9 100644 --- a/root/app/calibre-web/cps/web.py +++ b/root/app/calibre-web/cps/web.py @@ -1526,7 +1526,7 @@ def change_profile(kobo_support, hardcover_support, local_oauth_check, oauth_sta current_user.kobo_only_shelves_sync = int(to_save.get("kobo_only_shelves_sync") == "on") or 0 if old_state == 0 and current_user.kobo_only_shelves_sync == 1: kobo_sync_status.update_on_sync_shelfs(current_user.id) - current_user.hardcover_token = to_save.get("hardcover_token","").replace("Bearer ","") + current_user.hardcover_token = to_save.get("hardcover_token","").replace("Bearer ","") or None except Exception as ex: flash(str(ex), category="error") From 1c9f73033618afb202fc7831ab1551815e6c4357 Mon Sep 17 00:00:00 2001 From: demitrix Date: Fri, 31 Jan 2025 15:34:42 +0000 Subject: [PATCH 12/42] Fix typo preventing title from being saved. --- root/app/calibre-web/cps/static/js/get_meta.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/root/app/calibre-web/cps/static/js/get_meta.js b/root/app/calibre-web/cps/static/js/get_meta.js index da170a7..0a8f566 100644 --- a/root/app/calibre-web/cps/static/js/get_meta.js +++ b/root/app/calibre-web/cps/static/js/get_meta.js @@ -58,7 +58,7 @@ $(function () { var ampSeparatedAuthors = (book.authors || []).join(" & "); $("#authors").val(ampSeparatedAuthors); } - if (updateItems.titles) { + if (updateItems.title) { $("#title").val(book.title); } $("#languages").val(uniqueLanguages.join(", ")); From 3e2c1ae19dca80709aac2301dd074705f294f837 Mon Sep 17 00:00:00 2001 From: demitrix Date: Wed, 5 Feb 2025 18:55:33 +0000 Subject: [PATCH 13/42] Better handling of read status sync to prevent multiple reads being created. --- .../app/calibre-web/cps/services/hardcover.py | 51 ++++++++++--------- 1 file changed, 27 insertions(+), 24 deletions(-) diff --git a/root/app/calibre-web/cps/services/hardcover.py b/root/app/calibre-web/cps/services/hardcover.py index eca2514..df545de 100644 --- a/root/app/calibre-web/cps/services/hardcover.py +++ b/root/app/calibre-web/cps/services/hardcover.py @@ -38,7 +38,7 @@ USER_BOOK_FRAGMENT = """ id pages } - user_book_reads(order_by: {started_at: desc}, limit: 1) { + user_book_reads(order_by: {started_at: desc}, where: {finished_at: {_is_null: true}}) { id started_at finished_at @@ -108,37 +108,40 @@ class HardcoverClient: def update_reading_progress(self, identifiers, progress_percent): ids = self.parse_identifiers(identifiers) book = self.get_user_book(ids) - if not book: + if not book: # Book doesn't exist, add it in Reading status book = self.add_book(ids, status=2) - if book.get("status_id") is not 2: + if book.get("status_id") != 2: # Book is either WTR or Read book = self.change_book_status(book, 2) pages = book.get("edition",{}).get("pages",0) if pages: pages_read = round(pages * (progress_percent / 100)) read = next(iter(book.get("user_book_reads")),None) if not read: - read = self.add_read(book, pages_read) - mutation = """ - mutation ($readId: Int!, $pages: Int, $editionId: Int, $startedAt: date, $finishedAt: date) { - update_user_book_read(id: $readId, object: { - progress_pages: $pages, - edition_id: $editionId, - started_at: $startedAt, - finished_at: $finishedAt - }) { - id + # read = self.add_read(book, pages_read) + # No read exists for some reason, return since we can't update anything. + return + else: + mutation = """ + mutation ($readId: Int!, $pages: Int, $editionId: Int, $startedAt: date, $finishedAt: date) { + update_user_book_read(id: $readId, object: { + progress_pages: $pages, + edition_id: $editionId, + started_at: $startedAt, + finished_at: $finishedAt + }) { + id + } + }""" + variables = { + "readId": int(read.get("id")), + "pages": pages_read, + "editionId": int(book.get("edition").get("id")), + "startedAt":read.get("started_at",datetime.now().strftime("%Y-%m-%d")), + "finishedAt": datetime.now().strftime("%Y-%m-%d") if progress_percent is 100 else None } - }""" - variables = { - "readId": int(read.get("id")), - "pages": pages_read, - "editionId": int(book.get("edition").get("id")), - "startedAt":read.get("started_at",datetime.now().strftime("%Y-%m-%d")), - "finishedAt": datetime.now().strftime("%Y-%m-%d") if progress_percent is 100 else None - } - if progress_percent is 100: - self.change_book_status(book, 3) - return self.execute(query=mutation, variables=variables) + if progress_percent is 100: + self.change_book_status(book, 3) + self.execute(query=mutation, variables=variables) return def change_book_status(self, book, status): From e77daddd2907d9901a38eacd5b8e7b03f3914982 Mon Sep 17 00:00:00 2001 From: demitrix Date: Thu, 13 Feb 2025 18:17:46 +0000 Subject: [PATCH 14/42] More checked for read status to prevent extra reads being created when a book is finished --- root/app/calibre-web/cps/services/hardcover.py | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/root/app/calibre-web/cps/services/hardcover.py b/root/app/calibre-web/cps/services/hardcover.py index df545de..7c59092 100644 --- a/root/app/calibre-web/cps/services/hardcover.py +++ b/root/app/calibre-web/cps/services/hardcover.py @@ -108,10 +108,15 @@ class HardcoverClient: def update_reading_progress(self, identifiers, progress_percent): ids = self.parse_identifiers(identifiers) book = self.get_user_book(ids) - if not book: # Book doesn't exist, add it in Reading status + # Book doesn't exist, add it in Reading status + if not book: book = self.add_book(ids, status=2) - if book.get("status_id") != 2: # Book is either WTR or Read + # Book is either WTR or Read, and we aren't finished reading + if book.get("status_id") != 2 and progress_percent != 100: book = self.change_book_status(book, 2) + # Book is already marked as read, and we are also done + if book.get("status_id") == 3 and progress_percent == 100: + return pages = book.get("edition",{}).get("pages",0) if pages: pages_read = round(pages * (progress_percent / 100)) @@ -220,16 +225,12 @@ class HardcoverClient: "query": query, "variables": variables or {} } - - response = requests.post(self.endpoint, json=payload, headers=self.headers) try: response.raise_for_status() except requests.exceptions.HTTPError as e: raise Exception(f"HTTP error occurred: {e}") - result = response.json() if "errors" in result: raise Exception(f"GraphQL error: {result['errors']}") - return result.get("data", {}) From dc186db9b69f7725ef9c8a109187c59a7386ef81 Mon Sep 17 00:00:00 2001 From: demitrix Date: Mon, 17 Feb 2025 16:11:31 +0000 Subject: [PATCH 15/42] Uses sudo to create directories avoiding temporary ownership change --- scripts/setup-cwa.sh | 12 ++++-------- 1 file changed, 4 insertions(+), 8 deletions(-) diff --git a/scripts/setup-cwa.sh b/scripts/setup-cwa.sh index ccb2f0c..98d7894 100644 --- a/scripts/setup-cwa.sh +++ b/scripts/setup-cwa.sh @@ -2,14 +2,10 @@ # Make required directories and files for metadata enforcement make_dirs () { - mkdir /app/calibre-web-automated/metadata_change_logs - chown -R abc:abc /app/calibre-web-automated/metadata_change_logs - mkdir /app/calibre-web-automated/metadata_temp - chown -R abc:abc /app/calibre-web-automated/metadata_temp - mkdir /cwa-book-ingest - chown abc:abc /cwa-book-ingest - mkdir /calibre-library - chown -R abc:abc /calibre-library + sudo -S -u abc mkdir -p /app/calibre-web-automated/metadata_change_logs + sudo -S -u abc mkdir -p /app/calibre-web-automated/metadata_temp + sudo -S -u abc mkdir -p /cwa-book-ingest + sudo -S -u abc mkdir -p /calibre-library } # Change ownership & permissions as required From c29c3e32b0ffe0a4d6419b8f9eb885089290d5a8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kacper=20Le=C5=9Bniara?= Date: Mon, 17 Feb 2025 22:25:31 +0000 Subject: [PATCH 16/42] fix: package correct kepubify for arm64 --- Dockerfile | 17 ++++++++++++----- 1 file changed, 12 insertions(+), 5 deletions(-) diff --git a/Dockerfile b/Dockerfile index 8207602..553bd24 100644 --- a/Dockerfile +++ b/Dockerfile @@ -28,6 +28,7 @@ ARG VERSION ARG CALIBREWEB_RELEASE=0.6.24 ARG LSCW_RELEASE=0.6.24-ls304 ARG UNIVERSAL_CALIBRE_RELEASE=7.16.0 +ARG KEPUBIFY_RELEASE=v4.0.4 LABEL build_version="Version:- ${VERSION}" LABEL build_date="${BUILD_DATE}" LABEL CW-Stock-version="${CALIBREWEB_RELEASE}" @@ -89,14 +90,20 @@ RUN \ requirements.txt -r \ optional-requirements.txt && \ # STEP 1.8 - Installs the latest release of kepubify - echo "***install kepubify" && \ - if [ -z ${KEPUBIFY_RELEASE+x} ]; then \ + echo "**** install kepubify ****" && \ + if [[ $KEPUBIFY_RELEASE == 'newest' ]]; then \ KEPUBIFY_RELEASE=$(curl -sX GET "https://api.github.com/repos/pgaskin/kepubify/releases/latest" \ | awk '/tag_name/{print $4;exit}' FS='[""]'); \ fi && \ - curl -o \ - /usr/bin/kepubify -L \ - https://github.com/pgaskin/kepubify/releases/download/${KEPUBIFY_RELEASE}/kepubify-linux-64bit && \ + if [ "$(uname -m)" == "x86_64" ]; then \ + curl -o \ + /usr/bin/kepubify -L \ + https://github.com/pgaskin/kepubify/releases/download/${KEPUBIFY_RELEASE}/kepubify-linux-64bit && \ + elif [ "$(uname -m)" == "aarch64" ]; then \ + curl -o \ + /usr/bin/kepubify -L \ + https://github.com/pgaskin/kepubify/releases/download/${KEPUBIFY_RELEASE}/kepubify-linux-arm64 && \ + fi && \ # STEP 2 - Install Calibre-Web Automated echo "~~~~ CWA Install - installing additional required packages ~~~~" && \ # STEP 2.1 - Install additional required packages From 5582df1e293c1882901a6b560bfbbf1ce43f1a5f Mon Sep 17 00:00:00 2001 From: Calychas Date: Mon, 17 Feb 2025 23:36:20 +0100 Subject: [PATCH 17/42] fix: incorrect bash --- Dockerfile | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Dockerfile b/Dockerfile index 553bd24..63c3b94 100644 --- a/Dockerfile +++ b/Dockerfile @@ -98,11 +98,11 @@ RUN \ if [ "$(uname -m)" == "x86_64" ]; then \ curl -o \ /usr/bin/kepubify -L \ - https://github.com/pgaskin/kepubify/releases/download/${KEPUBIFY_RELEASE}/kepubify-linux-64bit && \ + https://github.com/pgaskin/kepubify/releases/download/${KEPUBIFY_RELEASE}/kepubify-linux-64bit; \ elif [ "$(uname -m)" == "aarch64" ]; then \ curl -o \ /usr/bin/kepubify -L \ - https://github.com/pgaskin/kepubify/releases/download/${KEPUBIFY_RELEASE}/kepubify-linux-arm64 && \ + https://github.com/pgaskin/kepubify/releases/download/${KEPUBIFY_RELEASE}/kepubify-linux-arm64; \ fi && \ # STEP 2 - Install Calibre-Web Automated echo "~~~~ CWA Install - installing additional required packages ~~~~" && \ From c9d876a75f62eabe557f918bfc13737015d815ae Mon Sep 17 00:00:00 2001 From: Calychas Date: Mon, 17 Feb 2025 23:54:28 +0100 Subject: [PATCH 18/42] chore: port changes Dockerfile without calibre --- Dockerfile | 2 +- Dockerfile_calibre_not_included | 19 +++++++++++++------ 2 files changed, 14 insertions(+), 7 deletions(-) diff --git a/Dockerfile b/Dockerfile index 63c3b94..3127c3c 100644 --- a/Dockerfile +++ b/Dockerfile @@ -89,7 +89,7 @@ RUN \ pip install -U --no-cache-dir --find-links https://wheel-index.linuxserver.io/ubuntu/ -r \ requirements.txt -r \ optional-requirements.txt && \ - # STEP 1.8 - Installs the latest release of kepubify + # STEP 1.8 - Installs kepubify echo "**** install kepubify ****" && \ if [[ $KEPUBIFY_RELEASE == 'newest' ]]; then \ KEPUBIFY_RELEASE=$(curl -sX GET "https://api.github.com/repos/pgaskin/kepubify/releases/latest" \ diff --git a/Dockerfile_calibre_not_included b/Dockerfile_calibre_not_included index 23f4803..f66c62d 100644 --- a/Dockerfile_calibre_not_included +++ b/Dockerfile_calibre_not_included @@ -27,6 +27,7 @@ ARG BUILD_DATE ARG VERSION ARG CALIBREWEB_RELEASE=0.6.23 ARG LSCW_RELEASE=0.6.23-ls291 +ARG KEPUBIFY_RELEASE=v4.0.4 LABEL build_version="Version:- ${VERSION}" LABEL build_date="${BUILD_DATE}" LABEL CW-Stock-version="${CALIBREWEB_RELEASE}" @@ -87,15 +88,21 @@ RUN \ pip install -U --no-cache-dir --find-links https://wheel-index.linuxserver.io/ubuntu/ -r \ requirements.txt -r \ optional-requirements.txt && \ - # STEP 1.8 - Installs the latest release of kepubify - echo "***install kepubify" && \ - if [ -z ${KEPUBIFY_RELEASE+x} ]; then \ + # STEP 1.8 - Installs kepubify + echo "**** install kepubify ****" && \ + if [[ $KEPUBIFY_RELEASE == 'newest' ]]; then \ KEPUBIFY_RELEASE=$(curl -sX GET "https://api.github.com/repos/pgaskin/kepubify/releases/latest" \ | awk '/tag_name/{print $4;exit}' FS='[""]'); \ fi && \ - curl -o \ - /usr/bin/kepubify -L \ - https://github.com/pgaskin/kepubify/releases/download/${KEPUBIFY_RELEASE}/kepubify-linux-64bit && \ + if [ "$(uname -m)" == "x86_64" ]; then \ + curl -o \ + /usr/bin/kepubify -L \ + https://github.com/pgaskin/kepubify/releases/download/${KEPUBIFY_RELEASE}/kepubify-linux-64bit; \ + elif [ "$(uname -m)" == "aarch64" ]; then \ + curl -o \ + /usr/bin/kepubify -L \ + https://github.com/pgaskin/kepubify/releases/download/${KEPUBIFY_RELEASE}/kepubify-linux-arm64; \ + fi && \ # STEP 2 - Install Calibre-Web Automated echo "~~~~ CWA Install - installing additional required packages ~~~~" && \ # STEP 2.1 - Install additional required packages From c4150efa1548c220c1103e89901cd2a3e21c7a60 Mon Sep 17 00:00:00 2001 From: Brook <88465473+Turmaxx@users.noreply.github.com> Date: Tue, 18 Feb 2025 15:20:23 +0300 Subject: [PATCH 19/42] Update README.md updated port number on the quick start guide section of the README.md to the port number provided by default. --- README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index d49e5b3..e22986c 100644 --- a/README.md +++ b/README.md @@ -277,7 +277,7 @@ And just like that, Calibre-Web Automated should be up and running! **HOWEVER** ## _Calibre-Web Quick Start Guide_ -1. Open your browser and navigate to http://localhost:8084 or http://localhost:8084/opds for the OPDS catalog +1. Open your browser and navigate to http://localhost:8083 or http://localhost:8083/opds for the OPDS catalog 2. Log in with the default admin credentials (_below_) 3. Configure your Calibre-Web Automated instance via the Admin Page - A guide to what all of the stock CW Settings do can be found [here](https://github.com/janeczku/calibre-web/wiki/Configuration#basic-configuration) @@ -363,4 +363,4 @@ Check out [Post-Install Tasks Here](#post-install-tasks) when necessary. - CWA is really lucky to have a very passionate and active community of people that really help shape CWA into what it is today - If you have any ideas or want to contribute to the project, you're more than welcome to! We accept anyone regardless of skill level of expertise! -- If you've got a good idea or want to simply suggest improvements, simply get in touch with us on the Discord Server [here](https://discord.gg/EjgSeek94R)! \ No newline at end of file +- If you've got a good idea or want to simply suggest improvements, simply get in touch with us on the Discord Server [here](https://discord.gg/EjgSeek94R)! From 27742772714434fb9468ea5c1d212685a631b81b Mon Sep 17 00:00:00 2001 From: demitrix Date: Tue, 25 Feb 2025 15:59:12 +0000 Subject: [PATCH 20/42] Fixes typo that prevented series index from saving --- .../app/calibre-web/cps/static/js/get_meta.js | 444 +++++++++--------- 1 file changed, 217 insertions(+), 227 deletions(-) diff --git a/root/app/calibre-web/cps/static/js/get_meta.js b/root/app/calibre-web/cps/static/js/get_meta.js index 0a8f566..5aeea7d 100644 --- a/root/app/calibre-web/cps/static/js/get_meta.js +++ b/root/app/calibre-web/cps/static/js/get_meta.js @@ -17,248 +17,238 @@ /* global _, i18nMsg, tinymce, getPath */ $(function () { - var msg = i18nMsg; - var keyword = ""; + var msg = i18nMsg; + var keyword = ""; - var templates = { - bookResult: _.template($("#template-book-result").html()), - }; + var templates = { + bookResult: _.template($("#template-book-result").html()), + }; - function getUniqueValues(attribute_name, book) { - var presentArray = $.map( - $("#" + attribute_name) - .val() - .split(","), - $.trim + function getUniqueValues(attribute_name, book) { + var presentArray = $.map( + $("#" + attribute_name) + .val() + .split(","), + $.trim + ); + if (presentArray.length === 1 && presentArray[0] === "") { + presentArray = []; + } + $.each(book[attribute_name], function (i, el) { + if ($.inArray(el, presentArray) === -1) presentArray.push(el); + }); + return presentArray; + } + + function populateForm(book, idx) { + var updateItems = Object.fromEntries( + Array.from(document.querySelectorAll(`[data-meta-index="${idx}"]`)).map( + (value) => [value.dataset.metaValue, value.checked] + ) + ); + if (updateItems.description) { + tinymce.get("comments").setContent(book.description); + } + if (updateItems.tags) { + var uniqueTags = getUniqueValues("tags", book); + $("#tags").val(uniqueTags.join(", ")); + } + var uniqueLanguages = getUniqueValues("languages", book); + if (updateItems.authors) { + var ampSeparatedAuthors = (book.authors || []).join(" & "); + $("#authors").val(ampSeparatedAuthors); + } + if (updateItems.title) { + $("#title").val(book.title); + } + $("#languages").val(uniqueLanguages.join(", ")); + $("#rating").data("rating").setValue(Math.round(book.rating)); + + if (updateItems.cover && book.cover && $("#cover_url").length) { + $(".cover img").attr("src", book.cover); + $("#cover_url").val(book.cover); + } + if (updateItems.pubDate) { + $("#pubdate").val(book.publishedDate); + } + if (updateItems.publisher) { + $("#publisher").val(book.publisher); + } + if (updateItems.series && typeof book.series !== "undefined") { + $("#series").val(book.series); + } + if (updateItems.seriesIndex && typeof book.series_index !== "undefined") { + $("#series_index").val(book.series_index); + } + if (typeof book.identifiers !== "undefined") { + selectedIdentifiers = Object.keys(book.identifiers) + .filter((key) => updateItems[key]) + .reduce((result, key) => { + result[key] = book.identifiers[key]; + return result; + }, {}); + populateIdentifiers(selectedIdentifiers); + } + } + + function populateIdentifiers(identifiers) { + for (const property in identifiers) { + console.log(`${property}: ${identifiers[property]}`); + if ($('input[name="identifier-type-' + property + '"]').length) { + $('input[name="identifier-val-' + property + '"]').val( + identifiers[property] ); - if (presentArray.length === 1 && presentArray[0] === "") { - presentArray = []; - } - $.each(book[attribute_name], function (i, el) { - if ($.inArray(el, presentArray) === -1) presentArray.push(el); - }); - return presentArray; + } else { + addIdentifier(property, identifiers[property]); + } } + } - function populateForm(book, idx) { - var updateItems = Object.fromEntries( - Array.from( - document.querySelectorAll(`[data-meta-index="${idx}"]`) - ).map((value) => [value.dataset.metaValue, value.checked]) - ); - if (updateItems.description) { - tinymce.get("comments").setContent(book.description); - } - if (updateItems.tags) { - var uniqueTags = getUniqueValues("tags", book); - $("#tags").val(uniqueTags.join(", ")); - } - var uniqueLanguages = getUniqueValues("languages", book); - if (updateItems.authors) { - var ampSeparatedAuthors = (book.authors || []).join(" & "); - $("#authors").val(ampSeparatedAuthors); - } - if (updateItems.title) { - $("#title").val(book.title); - } - $("#languages").val(uniqueLanguages.join(", ")); - $("#rating").data("rating").setValue(Math.round(book.rating)); + function addIdentifier(name, value) { + var line = ""; + line += + ''; + line += + ''; + line += + '' + + _("Remove") + + ""; + line += ""; + $("#identifier-table").append(line); + } - if (updateItems.cover && book.cover && $("#cover_url").length) { - $(".cover img").attr("src", book.cover); - $("#cover_url").val(book.cover); - } - if (updateItems.pubDate) { - $("#pubdate").val(book.publishedDate); - } - if (updateItems.publisher) { - $("#publisher").val(book.publisher); - } - if (updateItems.series && typeof book.series !== "undefined") { - $("#series").val(book.series); - } - if ( - updateItems.series_index && - typeof book.series_index !== "undefined" - ) { - $("#series_index").val(book.series_index); - } - if ( - typeof book.identifiers !== "undefined" - ) { - selectedIdentifiers = Object.keys(book.identifiers) - .filter((key) => updateItems[key]) - .reduce((result, key) => { - result[key] = book.identifiers[key]; - return result; - }, {}); - populateIdentifiers(selectedIdentifiers); - } - } - - function populateIdentifiers(identifiers){ - for (const property in identifiers) { - console.log(`${property}: ${identifiers[property]}`); - if ($('input[name="identifier-type-'+property+'"]').length) { - $('input[name="identifier-val-'+property+'"]').val(identifiers[property]) - } - else { - addIdentifier(property, identifiers[property]) - } - } - } - - function addIdentifier(name, value) { - var line = ""; - line += - ''; - line += - ''; - line += - '' + - _("Remove") + - ""; - line += ""; - $("#identifier-table").append(line); - } - - function doSearch(keyword) { - if (keyword) { - $("#meta-info").text(msg.loading); - $.ajax({ - url: getPath() + "/metadata/search", - type: "POST", - data: { query: keyword }, - dataType: "json", - success: function success(data) { - if (data.length) { - $("#meta-info").html( - '
      ' - ); - data.forEach(function (book, idx) { - var $book = $( - templates.bookResult({ book: book, index: idx }) - ); - $book.find("button").on("click", function () { - populateForm(book, idx); - }); - $("#book-list").append($book); - }); - } else { - $("#meta-info").html( - '

      ' + - msg.no_result + - "!

      " + - $("#meta-info")[0].innerHTML - ); - } - }, - error: function error() { - $("#meta-info").html( - '

      ' + - msg.search_error + - "!

      " + - $("#meta-info")[0].innerHTML - ); - }, + function doSearch(keyword) { + if (keyword) { + $("#meta-info").text(msg.loading); + $.ajax({ + url: getPath() + "/metadata/search", + type: "POST", + data: { query: keyword }, + dataType: "json", + success: function success(data) { + if (data.length) { + $("#meta-info").html('
        '); + data.forEach(function (book, idx) { + var $book = $(templates.bookResult({ book: book, index: idx })); + $book.find("button").on("click", function () { + populateForm(book, idx); + }); + $("#book-list").append($book); }); - } + } else { + $("#meta-info").html( + '

        ' + + msg.no_result + + "!

        " + + $("#meta-info")[0].innerHTML + ); + } + }, + error: function error() { + $("#meta-info").html( + '

        ' + + msg.search_error + + "!

        " + + $("#meta-info")[0].innerHTML + ); + }, + }); } + } - function populate_provider() { - $("#metadata_provider").empty(); - $.ajax({ - url: getPath() + "/metadata/provider", - type: "get", - dataType: "json", - success: function success(data) { - data.forEach(function (provider) { - var checked = ""; - if (provider.active) { - checked = "checked"; - } - var $provider_button = - ''; - $("#metadata_provider").append($provider_button); - }); - }, + function populate_provider() { + $("#metadata_provider").empty(); + $.ajax({ + url: getPath() + "/metadata/provider", + type: "get", + dataType: "json", + success: function success(data) { + data.forEach(function (provider) { + var checked = ""; + if (provider.active) { + checked = "checked"; + } + var $provider_button = + ''; + $("#metadata_provider").append($provider_button); }); + }, + }); + } + + $(document).on("change", ".pill", function () { + var element = $(this); + var id = element.data("control"); + var initial = element.data("initial"); + var val = element.prop("checked"); + var params = { id: id, value: val }; + if (!initial) { + params["initial"] = initial; + params["query"] = keyword; } - - $(document).on("change", ".pill", function () { - var element = $(this); - var id = element.data("control"); - var initial = element.data("initial"); - var val = element.prop("checked"); - var params = { id: id, value: val }; - if (!initial) { - params["initial"] = initial; - params["query"] = keyword; - } - $.ajax({ - method: "post", - contentType: "application/json; charset=utf-8", - dataType: "json", - url: getPath() + "/metadata/provider/" + id, - data: JSON.stringify(params), - success: function success(data) { - element.data("initial", "true"); - data.forEach(function (book, idx) { - var $book = $( - templates.bookResult({ book: book, index: idx }) - ); - $book.find("button").on("click", function () { - populateForm(book, idx); - }); - $("#book-list").append($book); - }); - }, + $.ajax({ + method: "post", + contentType: "application/json; charset=utf-8", + dataType: "json", + url: getPath() + "/metadata/provider/" + id, + data: JSON.stringify(params), + success: function success(data) { + element.data("initial", "true"); + data.forEach(function (book, idx) { + var $book = $(templates.bookResult({ book: book, index: idx })); + $book.find("button").on("click", function () { + populateForm(book, idx); + }); + $("#book-list").append($book); }); + }, }); + }); - $("#meta-search").on("submit", function (e) { - e.preventDefault(); - keyword = $("#keyword").val(); - $(".pill").each(function () { - $(this).data("initial", $(this).prop("checked")); - }); - doSearch(keyword); + $("#meta-search").on("submit", function (e) { + e.preventDefault(); + keyword = $("#keyword").val(); + $(".pill").each(function () { + $(this).data("initial", $(this).prop("checked")); }); + doSearch(keyword); + }); - $("#get_meta").click(function () { - populate_provider(); - var bookTitle = $("#title").val(); - $("#keyword").val(bookTitle); - keyword = bookTitle; - doSearch(bookTitle); - }); - $("#metaModal").on("show.bs.modal", function (e) { - $(e.relatedTarget).one("focus", function (e) { - $(this).blur(); - }); + $("#get_meta").click(function () { + populate_provider(); + var bookTitle = $("#title").val(); + $("#keyword").val(bookTitle); + keyword = bookTitle; + doSearch(bookTitle); + }); + $("#metaModal").on("show.bs.modal", function (e) { + $(e.relatedTarget).one("focus", function (e) { + $(this).blur(); }); + }); }); From 4e0786ce24183be51e52e5a691c8223234ec0542 Mon Sep 17 00:00:00 2001 From: demitrix Date: Thu, 27 Feb 2025 15:35:47 +0000 Subject: [PATCH 21/42] Narrows scope of empty directory delete to ingest files parent folder --- scripts/ingest_processor.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/scripts/ingest_processor.py b/scripts/ingest_processor.py index 1e04e98..b66132a 100644 --- a/scripts/ingest_processor.py +++ b/scripts/ingest_processor.py @@ -168,7 +168,8 @@ class NewBookProcessor: def delete_current_file(self) -> None: """Deletes file just processed from ingest folder""" os.remove(self.filepath) # Removes processed file - subprocess.run(["find", f"{self.ingest_folder}", "-mindepth", "1", "-type", "d", "-empty", "-delete"]) # Removes any now empty folders in the ingest folder + if os.path.dirname(self.filepath) != self.ingest_folder: # File was in ingest_folder, no directories to delete + subprocess.run(["find", f"{os.path.dirname(self.filepath)}", "-type", "d", "-empty", "-delete"]) # Removes any now empty folders including parent directory def add_book_to_library(self, book_path:str) -> None: From be905a8c81b13e19e22fd7b0707572d97de4fb36 Mon Sep 17 00:00:00 2001 From: demitrix Date: Thu, 27 Feb 2025 16:22:52 +0000 Subject: [PATCH 22/42] Working version of first commit. --- scripts/ingest_processor.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/scripts/ingest_processor.py b/scripts/ingest_processor.py index b66132a..7f85b6b 100644 --- a/scripts/ingest_processor.py +++ b/scripts/ingest_processor.py @@ -168,7 +168,7 @@ class NewBookProcessor: def delete_current_file(self) -> None: """Deletes file just processed from ingest folder""" os.remove(self.filepath) # Removes processed file - if os.path.dirname(self.filepath) != self.ingest_folder: # File was in ingest_folder, no directories to delete + if not os.path.samefile(os.path.dirname(self.filepath),self.ingest_folder): # File not in ingest_folder, subdirectories to delete subprocess.run(["find", f"{os.path.dirname(self.filepath)}", "-type", "d", "-empty", "-delete"]) # Removes any now empty folders including parent directory From 51d4612af8ca164b38d9bdc11acfb9f94da7a993 Mon Sep 17 00:00:00 2001 From: Aymen Djellal Date: Thu, 20 Mar 2025 01:03:16 -0400 Subject: [PATCH 23/42] Always ignore .crdownload during ingestion This change updates the ingestion process to ignore files with the `.crdownload` extension. Since browsers like Chrome use `.crdownload` for files in progress, this prevents partially downloaded files from being processed, which could lead to issues. --- scripts/ingest_processor.py | 1 + 1 file changed, 1 insertion(+) diff --git a/scripts/ingest_processor.py b/scripts/ingest_processor.py index 1e04e98..189c7a3 100644 --- a/scripts/ingest_processor.py +++ b/scripts/ingest_processor.py @@ -44,6 +44,7 @@ class NewBookProcessor: self.auto_convert_on = self.cwa_settings['auto_convert'] self.target_format = self.cwa_settings['auto_convert_target_format'] self.ingest_ignored_formats = self.cwa_settings['auto_ingest_ignored_formats'] + self.ingest_ignored_formats.append(".crdownload") self.convert_ignored_formats = self.cwa_settings['auto_convert_ignored_formats'] self.is_kindle_epub_fixer = self.cwa_settings['kindle_epub_fixer'] From be41526c60d306dda00a4d510c179dbfdc1f69a5 Mon Sep 17 00:00:00 2001 From: demitrix Date: Thu, 27 Mar 2025 21:19:00 +0000 Subject: [PATCH 24/42] Finally fix Hardcover sync being required to add user hardcover token --- root/app/calibre-web/cps/web.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/root/app/calibre-web/cps/web.py b/root/app/calibre-web/cps/web.py index 02201c9..c4a555e 100644 --- a/root/app/calibre-web/cps/web.py +++ b/root/app/calibre-web/cps/web.py @@ -1571,7 +1571,7 @@ def profile(): languages = calibre_db.speaking_language() translations = get_available_locale() kobo_support = feature_support['kobo'] and config.config_kobo_sync - hardcover_support = feature_support['hardcover'] and config.config_hardcover_sync + hardcover_support = feature_support['hardcover'] if feature_support['oauth'] and config.config_login_type == 2: oauth_status = get_oauth_status() local_oauth_check = oauth_check From 397dffa02286c2a119e5e78aee0ff29dd3b367a7 Mon Sep 17 00:00:00 2001 From: demitrix Date: Mon, 31 Mar 2025 16:53:59 +0000 Subject: [PATCH 25/42] Add Global Hardcover Token --- root/app/calibre-web/cps/admin.py | 4 ++++ root/app/calibre-web/cps/config_sql.py | 2 ++ .../app/calibre-web/cps/metadata_provider/hardcover.py | 4 ++-- root/app/calibre-web/cps/templates/config_edit.html | 10 ++++++++++ 4 files changed, 18 insertions(+), 2 deletions(-) diff --git a/root/app/calibre-web/cps/admin.py b/root/app/calibre-web/cps/admin.py index 41f853f..63fb9cc 100644 --- a/root/app/calibre-web/cps/admin.py +++ b/root/app/calibre-web/cps/admin.py @@ -1870,6 +1870,10 @@ def _configuration_update_helper(): services.goodreads_support.connect(config.config_goodreads_api_key, config.config_use_goodreads) + # Hardcover configuration + _config_checkbox(to_save, "config_use_hardcover") + _config_string(to_save, "config_hardcover_token") + _config_int(to_save, "config_updatechannel") # Reverse proxy login configuration diff --git a/root/app/calibre-web/cps/config_sql.py b/root/app/calibre-web/cps/config_sql.py index d0164a4..641efad 100644 --- a/root/app/calibre-web/cps/config_sql.py +++ b/root/app/calibre-web/cps/config_sql.py @@ -118,6 +118,8 @@ class _Settings(_Base): config_use_goodreads = Column(Boolean, default=False) config_goodreads_api_key = Column(String) + config_hardcover_token = Column(String) + config_register_email = Column(Boolean, default=False) config_login_type = Column(Integer, default=0) diff --git a/root/app/calibre-web/cps/metadata_provider/hardcover.py b/root/app/calibre-web/cps/metadata_provider/hardcover.py index 681f8ea..54f539a 100644 --- a/root/app/calibre-web/cps/metadata_provider/hardcover.py +++ b/root/app/calibre-web/cps/metadata_provider/hardcover.py @@ -20,7 +20,7 @@ from typing import Dict, List, Optional import requests -from cps import logger +from cps import logger, config from cps.services.Metadata import MetaRecord, MetaSourceInfo, Metadata from cps.isoLanguages import get_language_name from ..cw_login import current_user @@ -100,7 +100,7 @@ class Hardcover(Metadata): val = list() if self.active: try: - token = current_user.hardcover_token or getenv("HARDCOVER_TOKEN") + token = current_user.hardcover_token or config.config_hardcover_token or getenv("HARDCOVER_TOKEN") if not token: self.set_status(False) raise Exception("Hardcover token not set for user, and no global token provided.") diff --git a/root/app/calibre-web/cps/templates/config_edit.html b/root/app/calibre-web/cps/templates/config_edit.html index 5d93f17..a376d3a 100644 --- a/root/app/calibre-web/cps/templates/config_edit.html +++ b/root/app/calibre-web/cps/templates/config_edit.html @@ -167,6 +167,16 @@
        {% endif %} +
        + + +
        +
        +
        + + +
        +
        From 8f2f4aa46f7902dcb5f45bae75525455d6434de3 Mon Sep 17 00:00:00 2001 From: demitrix Date: Mon, 31 Mar 2025 20:10:17 +0000 Subject: [PATCH 26/42] Default to all metadata items being checked --- .../calibre-web/cps/templates/book_edit.html | 20 +++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/root/app/calibre-web/cps/templates/book_edit.html b/root/app/calibre-web/cps/templates/book_edit.html index 26b3971..41eb952 100644 --- a/root/app/calibre-web/cps/templates/book_edit.html +++ b/root/app/calibre-web/cps/templates/book_edit.html @@ -271,7 +271,7 @@ alt="Cover" >
        - +
        @@ -280,38 +280,38 @@ <% } %>
        -
        Title:
        +
        Title:
        <%= book.title %>
        -
        Author:
        +
        Author:
        <%= book.authors.join(" & ") %>
        <% if (book.publisher) { %> -
        Publisher:
        +
        Publisher:
        <%= book.publisher %>
        <% } %> <% if (book.publishedDate) { %> -
        Published Date:
        +
        Published Date:
        <%= book.publishedDate %>
        <% } %> <% if (book.series) { %> -
        Series:
        +
        Series:
        <%= book.series %>
        <% } %> <% if (book.series_index) { %> -
        Series Index:
        +
        Series Index:
        <%= book.series_index %>
        <% } %> <% if (book.description) { %> -
        Description:
        +
        Description:
        <%= book.description %>
        <% } %> <% if (book.tags.length !== 0) { %> -
        Tags:
        +
        Tags:
        <%= book.tags.join(", ") %>
        <% } %> <% if (Object.keys(book.identifiers).length !== 0 ) { %> <% for (const key in book.identifiers) { %> <% if (book.identifiers[key] !== "") { %> -
        Identifier
        +
        Identifier
        <%= key %>:<%= book.identifiers[key] %> <% if (key === "hardcover-id" && !document.getElementById("keyword").value.includes("hardcover-id")) { %> Editions From 49418757f13e264a32ea99990fa24bf0f00748e6 Mon Sep 17 00:00:00 2001 From: Nota Inutilis <9675966+NotaInutilis@users.noreply.github.com> Date: Thu, 8 May 2025 00:53:32 +0200 Subject: [PATCH 27/42] Fixing port 8084 instead of 8083 in the readme Tested both, 8083 actually works! --- README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index d49e5b3..e22986c 100644 --- a/README.md +++ b/README.md @@ -277,7 +277,7 @@ And just like that, Calibre-Web Automated should be up and running! **HOWEVER** ## _Calibre-Web Quick Start Guide_ -1. Open your browser and navigate to http://localhost:8084 or http://localhost:8084/opds for the OPDS catalog +1. Open your browser and navigate to http://localhost:8083 or http://localhost:8083/opds for the OPDS catalog 2. Log in with the default admin credentials (_below_) 3. Configure your Calibre-Web Automated instance via the Admin Page - A guide to what all of the stock CW Settings do can be found [here](https://github.com/janeczku/calibre-web/wiki/Configuration#basic-configuration) @@ -363,4 +363,4 @@ Check out [Post-Install Tasks Here](#post-install-tasks) when necessary. - CWA is really lucky to have a very passionate and active community of people that really help shape CWA into what it is today - If you have any ideas or want to contribute to the project, you're more than welcome to! We accept anyone regardless of skill level of expertise! -- If you've got a good idea or want to simply suggest improvements, simply get in touch with us on the Discord Server [here](https://discord.gg/EjgSeek94R)! \ No newline at end of file +- If you've got a good idea or want to simply suggest improvements, simply get in touch with us on the Discord Server [here](https://discord.gg/EjgSeek94R)! From 503f47c6de4bb0ca6b2713549c808d94b8ad974d Mon Sep 17 00:00:00 2001 From: Dee Abson Date: Thu, 8 May 2025 18:06:37 -0600 Subject: [PATCH 28/42] Fix: Kepub conversion not being passed the full path of the source file. --- scripts/convert_library.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/scripts/convert_library.py b/scripts/convert_library.py index 0d65c87..cf3883b 100644 --- a/scripts/convert_library.py +++ b/scripts/convert_library.py @@ -163,7 +163,7 @@ class LibraryConverter: continue if self.target_format == "kepub": - convert_successful, target_filepath = self.convert_to_kepub(filename, file_extension) + convert_successful, target_filepath = self.convert_to_kepub(file, file_extension) if not convert_successful: print_and_log(f"[convert-library]: ({self.current_book}/{len(self.to_convert)}) Conversion of {os.path.basename(file)} was unsuccessful. Moving to next book...") self.current_book += 1 From 922ebcf88c313e5bca7c8b280958c51b304855d8 Mon Sep 17 00:00:00 2001 From: Aymen Djellal Date: Tue, 13 May 2025 13:58:03 -0400 Subject: [PATCH 29/42] Update ingest_processor.py --- scripts/ingest_processor.py | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/scripts/ingest_processor.py b/scripts/ingest_processor.py index 189c7a3..746a327 100644 --- a/scripts/ingest_processor.py +++ b/scripts/ingest_processor.py @@ -44,7 +44,12 @@ class NewBookProcessor: self.auto_convert_on = self.cwa_settings['auto_convert'] self.target_format = self.cwa_settings['auto_convert_target_format'] self.ingest_ignored_formats = self.cwa_settings['auto_ingest_ignored_formats'] - self.ingest_ignored_formats.append(".crdownload") + + # Ignore temporary files during download + self.ingest_ignored_formats.append(".crdownload") # Chromium based + self.ingest_ignored_formats.append(".download") # Safari + self.ingest_ignored_formats.append(".part") #Firefox and tools (ie curl) + self.convert_ignored_formats = self.cwa_settings['auto_convert_ignored_formats'] self.is_kindle_epub_fixer = self.cwa_settings['kindle_epub_fixer'] From ddb98dbbabbd223440ff2e8c8adaf59bba641824 Mon Sep 17 00:00:00 2001 From: angelicadvocate Date: Wed, 14 May 2025 12:20:41 -0500 Subject: [PATCH 30/42] changes and updates are listed in angelicadvocate-notes-README.md the feature added is a user profile picture updater --- Dockerfile | 8 +- angelicadvocate-notes-README.md | 34 +++++ .../user-profile-data/CWA-profile-updater.js | 21 +++ .../user-profile-data/user_profiles.json | 3 + root/app/calibre-web/cps/templates/admin.html | 1 + .../app/calibre-web/cps/templates/layout.html | 1 + .../cps/templates/profile_pictures.html | 120 ++++++++++++++++++ root/app/calibre-web/cps/web.py | 58 +++++++++ 8 files changed, 245 insertions(+), 1 deletion(-) create mode 100644 angelicadvocate-notes-README.md create mode 100644 root/app/calibre-web/cps/static/user-profile-data/CWA-profile-updater.js create mode 100644 root/app/calibre-web/cps/static/user-profile-data/user_profiles.json create mode 100644 root/app/calibre-web/cps/templates/profile_pictures.html diff --git a/Dockerfile b/Dockerfile index 3127c3c..3b73230 100644 --- a/Dockerfile +++ b/Dockerfile @@ -209,4 +209,10 @@ COPY --from=unrar /usr/bin/unrar-ubuntu /usr/bin/unrar EXPOSE 8083 VOLUME /config VOLUME /cwa-book-ingest -VOLUME /calibre-library \ No newline at end of file +VOLUME /calibre-library + +######################################################################### +#add permission for editing the json from the webui for profile pictures + +RUN chmod -R 777 /app/calibre-web/cps/static/user-profile-data +########################################################################## \ No newline at end of file diff --git a/angelicadvocate-notes-README.md b/angelicadvocate-notes-README.md new file mode 100644 index 0000000..edfd682 --- /dev/null +++ b/angelicadvocate-notes-README.md @@ -0,0 +1,34 @@ +### Summary of Changes: + +1. **Script Integration in `layout.html`** + Added a script to `layout.html` (located at `root/app/calibre-web/cps/`) that: + - Retrieves the user's profile name from the existing HTML. + - Replaces the default image in the dark theme with a custom user profile image. + + **Current Behavior:** + The script requires images to be converted to base64 to fit the current HTML structure. However, I am working on implementing a user-friendly process for this in the UX.Ideally, users will have a separate field to upload an image, which will then be automatically converted to base64. + + For now, both usernames and base64 images are stored in a JSON file located beside the script at `root/app/calibre-web/cps/static/`. This feature is currently supported only in the "Caliblur! Dark Theme." + +2. **Admin Profile Picture Management Page** + A new page has been added for admins to manage profile pictures. The page is accessible via a button in the admin panel (`admin.html`), and the corresponding HTML page is `profile_pictures.html` located at `root/app/calibre-web/cps/`. + + **Key Features:** + - The page checks for admin status before allowing access. + - Two text fields are provided to input the username and base64 image string, which will be stored in the JSON file. + - For now, only admins have access to this feature to reduce the chances of simultaneous writes to the JSON file. + - In the future, I might consider moving to a database for better scalability. + +3. **Permissions for JSON File** + Permissions for the JSON file were set in the Dockerfile, which is located at the very bottom. + +4. **New Admin Button** + I added a button to the admin panel to access the profile picture management page. Look for the following line in `admin.html`: + {{ _('Manage Profile Pictures') }} + +5. **Using the Tool** + Admins can click the button in the admin panel to access the new interface. From there: + - They can add a username and base64 image string. + - If an image for a user already exists, adding the same username and new base64 string will overwrite the old data. + - After applying the image, users may need to click the refresh button to see the updated profile picture. + diff --git a/root/app/calibre-web/cps/static/user-profile-data/CWA-profile-updater.js b/root/app/calibre-web/cps/static/user-profile-data/CWA-profile-updater.js new file mode 100644 index 0000000..c547b98 --- /dev/null +++ b/root/app/calibre-web/cps/static/user-profile-data/CWA-profile-updater.js @@ -0,0 +1,21 @@ +fetch('/static/user-profile-data/user_profiles.json') + .then(response => response.json()) + .then(usernameToImage => { + var usernameElement = document.querySelector('#top_user .hidden-sm'); + if (usernameElement) { + var username = usernameElement.textContent.trim(); + + if (usernameToImage[username]) { + var style = document.createElement('style'); + style.innerHTML = ` + .profileDrop > span:before { + background-image: url(${usernameToImage[username]}) !important; + } + body.me > div.container-fluid > div.row-fluid > div.col-sm-10:before { + background-image: url(${usernameToImage[username]}) !important; + } + `; + document.head.appendChild(style); + } + } + }); diff --git a/root/app/calibre-web/cps/static/user-profile-data/user_profiles.json b/root/app/calibre-web/cps/static/user-profile-data/user_profiles.json new file mode 100644 index 0000000..527aa45 --- /dev/null +++ b/root/app/calibre-web/cps/static/user-profile-data/user_profiles.json @@ -0,0 +1,3 @@ +{ +"hermes": "data:image/png;base64,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" +} diff --git a/root/app/calibre-web/cps/templates/admin.html b/root/app/calibre-web/cps/templates/admin.html index bf3d490..957862b 100644 --- a/root/app/calibre-web/cps/templates/admin.html +++ b/root/app/calibre-web/cps/templates/admin.html @@ -51,6 +51,7 @@ {{_('Edit Users')}} {% endif %} {{_('Add New User')}} + {{ _('Manage Profile Pictures') }} {% if (config.config_login_type == 1) %}
        {{_('Import LDAP Users')}}
        {% endif %} diff --git a/root/app/calibre-web/cps/templates/layout.html b/root/app/calibre-web/cps/templates/layout.html index bf9c7da..10a93d3 100644 --- a/root/app/calibre-web/cps/templates/layout.html +++ b/root/app/calibre-web/cps/templates/layout.html @@ -327,5 +327,6 @@ {% endif %} {% block js %}{% endblock %} + diff --git a/root/app/calibre-web/cps/templates/profile_pictures.html b/root/app/calibre-web/cps/templates/profile_pictures.html new file mode 100644 index 0000000..b15962b --- /dev/null +++ b/root/app/calibre-web/cps/templates/profile_pictures.html @@ -0,0 +1,120 @@ + + + + + + {{ title }} + + + + +

        {{ title }}

        + +
        +

        This is the admin page for managing profile pictures. This feature is currently in development.

        +

        To upload a profile picture, please use the following form. Note: The image data must be in Base64 format.

        +

        You can convert an image to Base64 using various online tools. If you use a website such as www.base64-image.de

        +

        then make sure you use the version that starts with the line "data:image/png;base64," not the url version.

        +

        To display the image as a round shape, it must already be in PNG format with a round frame applied.

        +

        It is recommended to use images no larger than 100x100px to avoid using excessive storage space.

        +
        + +
        +
        + + +
        + + +
        + +
        + + +
        + + +
        +
        + +
        + Back to Admin Page +
        + + diff --git a/root/app/calibre-web/cps/web.py b/root/app/calibre-web/cps/web.py index 558d768..dc6927c 100644 --- a/root/app/calibre-web/cps/web.py +++ b/root/app/calibre-web/cps/web.py @@ -1693,3 +1693,61 @@ def show_book(book_id): flash(_("Oops! Selected book is unavailable. File does not exist or is not accessible"), category="error") return redirect(url_for("web.index")) + +# ################################### Profile Pictures ################################################### + +@web.route("/me/cwa/profilepictures", methods=["GET", "POST"]) +@user_login_required +def profile_pictures(): + log.debug("Accessed /me/cwa/profilepictures route.") + + # Check if the user is an admin + if not current_user.role_admin(): + flash(_("You must be an admin to access this page."), category="error") + log.warning(f"Unauthorized access attempt by user: {current_user.name}") + return redirect(url_for('web.profile')) + + if request.method == "POST": + log.debug("POST request received on profile_pictures page.") + + # Get the form data (username and image data) + username = request.form.get("username") + image_data = request.form.get("image_data") + + log.debug(f"Form data received - Username: {username}, Image Data Length: {len(image_data) if image_data else 'None'}") + + # Validate form fields + if not username or not image_data: + flash(_("Both username and image data are required."), category="error") + log.warning("Form submission missing username or image_data.") + return redirect(url_for('web.profile_pictures')) + + try: + # Path to the JSON file + json_path = "/app/calibre-web/cps/static/user-profile-data/user_profiles.json" + log.debug(f"Opening JSON file at: {json_path}") + + # Read the existing data from the JSON file and update it + with open(json_path, "r+") as file: + user_data = json.load(file) + user_data[username] = image_data # Add new or update existing entry + file.seek(0) # Move to the start of the file for writing + json.dump(user_data, file, indent=4) # Write back the updated data + file.truncate() # Ensure there is no leftover content + + # Success feedback and logging + flash(_("Profile picture updated successfully."), category="success") + log.info(f"Profile picture updated for user: {username}") + + except Exception as e: + # Error handling in case of an issue + flash(f"Error: {str(e)}", category="error") + log.error(f"Exception while updating profile picture JSON: {str(e)}") + + return redirect(url_for('web.profile_pictures')) + + # Handle the GET request and render the page + log.debug("Rendering GET view for profile_pictures page.") + return render_title_template("profile_pictures.html", + title=_("Profile Pictures Management"), + page="profilepictures") From 72c7df598584fd8cc04d1406765677479a48b477 Mon Sep 17 00:00:00 2001 From: crocodilestick <105450872+crocodilestick@users.noreply.github.com> Date: Wed, 14 May 2025 20:29:29 +0200 Subject: [PATCH 31/42] Updated setup-cwa.sh for the current s6 services --- scripts/setup-cwa.sh | 10 ++++------ 1 file changed, 4 insertions(+), 6 deletions(-) diff --git a/scripts/setup-cwa.sh b/scripts/setup-cwa.sh index ccb2f0c..fc7ee3b 100644 --- a/scripts/setup-cwa.sh +++ b/scripts/setup-cwa.sh @@ -14,15 +14,13 @@ make_dirs () { # Change ownership & permissions as required change_script_permissions () { - chmod +x /app/calibre-web-automated/scripts/check-cwa-services.sh - chmod +x /etc/s6-overlay/s6-rc.d/cwa-ingest-service/run - chmod +x /etc/s6-overlay/s6-rc.d/cwa-init-remove-locks/run - chmod +x /etc/s6-overlay/s6-rc.d/metadata-change-detector/run - chmod +x /etc/s6-overlay/s6-rc.d/cwa-set-perms/run chmod +x /etc/s6-overlay/s6-rc.d/cwa-auto-library/run chmod +x /etc/s6-overlay/s6-rc.d/cwa-auto-zipper/run - chmod +x /etc/s6-overlay/s6-rc.d/cwa-set-binary-paths/run + chmod +x /etc/s6-overlay/s6-rc.d/cwa-ingest-service/run + chmod +x /etc/s6-overlay/s6-rc.d/cwa-init/run + chmod +x /etc/s6-overlay/s6-rc.d/metadata-change-detector/run chmod +x /etc/s6-overlay/s6-rc.d/universal-calibre-setup/run + chmod +x /app/calibre-web-automated/scripts/check-cwa-services.sh chmod 775 /app/calibre-web/cps/editbooks.py chmod 775 /app/calibre-web/cps/admin.py } From e7098980929eeb3e8c0c7067fb1cfa64c9d1f19f Mon Sep 17 00:00:00 2001 From: angelicadvocate Date: Thu, 15 May 2025 11:14:33 -0500 Subject: [PATCH 32/42] - Removed previous changes to the Dockerfile. - Added a check in `/cwa-init/run` to verify if the JSON file exists, and create it if it doesn't. - Moved the JSON file into the `config` directory to avoid extra volume binds. - Began integrating the **Caliblur** theme into the profile pictures page for a more cohesive UI across the application. - Fixed several bugs introduced in the initial draft of `profile_pictures.html`, including issues with page scrolling. --- Dockerfile | 6 - angelicadvocate-notes-README.md | 39 +-- .../user-profile-data/CWA-profile-updater.js | 2 +- .../user-profile-data/user_profiles.json | 3 - .../cps/templates/profile_pictures.html | 232 ++++++++++-------- root/app/calibre-web/cps/web.py | 16 +- root/etc/s6-overlay/s6-rc.d/cwa-init/run | 11 + 7 files changed, 165 insertions(+), 144 deletions(-) delete mode 100644 root/app/calibre-web/cps/static/user-profile-data/user_profiles.json diff --git a/Dockerfile b/Dockerfile index 3b73230..1e1e5f9 100644 --- a/Dockerfile +++ b/Dockerfile @@ -210,9 +210,3 @@ EXPOSE 8083 VOLUME /config VOLUME /cwa-book-ingest VOLUME /calibre-library - -######################################################################### -#add permission for editing the json from the webui for profile pictures - -RUN chmod -R 777 /app/calibre-web/cps/static/user-profile-data -########################################################################## \ No newline at end of file diff --git a/angelicadvocate-notes-README.md b/angelicadvocate-notes-README.md index edfd682..6c0282b 100644 --- a/angelicadvocate-notes-README.md +++ b/angelicadvocate-notes-README.md @@ -1,34 +1,7 @@ -### Summary of Changes: - -1. **Script Integration in `layout.html`** - Added a script to `layout.html` (located at `root/app/calibre-web/cps/`) that: - - Retrieves the user's profile name from the existing HTML. - - Replaces the default image in the dark theme with a custom user profile image. - - **Current Behavior:** - The script requires images to be converted to base64 to fit the current HTML structure. However, I am working on implementing a user-friendly process for this in the UX.Ideally, users will have a separate field to upload an image, which will then be automatically converted to base64. - - For now, both usernames and base64 images are stored in a JSON file located beside the script at `root/app/calibre-web/cps/static/`. This feature is currently supported only in the "Caliblur! Dark Theme." - -2. **Admin Profile Picture Management Page** - A new page has been added for admins to manage profile pictures. The page is accessible via a button in the admin panel (`admin.html`), and the corresponding HTML page is `profile_pictures.html` located at `root/app/calibre-web/cps/`. - - **Key Features:** - - The page checks for admin status before allowing access. - - Two text fields are provided to input the username and base64 image string, which will be stored in the JSON file. - - For now, only admins have access to this feature to reduce the chances of simultaneous writes to the JSON file. - - In the future, I might consider moving to a database for better scalability. - -3. **Permissions for JSON File** - Permissions for the JSON file were set in the Dockerfile, which is located at the very bottom. - -4. **New Admin Button** - I added a button to the admin panel to access the profile picture management page. Look for the following line in `admin.html`: - {{ _('Manage Profile Pictures') }} - -5. **Using the Tool** - Admins can click the button in the admin panel to access the new interface. From there: - - They can add a username and base64 image string. - - If an image for a user already exists, adding the same username and new base64 string will overwrite the old data. - - After applying the image, users may need to click the refresh button to see the updated profile picture. +## Update Summary +- Removed previous changes to the Dockerfile. +- Added a check in `/cwa-init/run` to verify if the JSON file exists, and create it if it doesn't. +- Moved the JSON file into the `config` directory to avoid extra volume binds. +- Began integrating the **Caliblur** theme into the profile pictures page for a more cohesive UI across the application. +- Fixed several bugs introduced in the initial draft of `profile_pictures.html`, including issues with page scrolling. diff --git a/root/app/calibre-web/cps/static/user-profile-data/CWA-profile-updater.js b/root/app/calibre-web/cps/static/user-profile-data/CWA-profile-updater.js index c547b98..dd49c12 100644 --- a/root/app/calibre-web/cps/static/user-profile-data/CWA-profile-updater.js +++ b/root/app/calibre-web/cps/static/user-profile-data/CWA-profile-updater.js @@ -1,4 +1,4 @@ -fetch('/static/user-profile-data/user_profiles.json') +fetch('/user_profiles.json') .then(response => response.json()) .then(usernameToImage => { var usernameElement = document.querySelector('#top_user .hidden-sm'); diff --git a/root/app/calibre-web/cps/static/user-profile-data/user_profiles.json b/root/app/calibre-web/cps/static/user-profile-data/user_profiles.json deleted file mode 100644 index 527aa45..0000000 --- a/root/app/calibre-web/cps/static/user-profile-data/user_profiles.json +++ /dev/null @@ -1,3 +0,0 @@ -{ -"hermes": "data:image/png;base64,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" -} diff --git a/root/app/calibre-web/cps/templates/profile_pictures.html b/root/app/calibre-web/cps/templates/profile_pictures.html index b15962b..85230e9 100644 --- a/root/app/calibre-web/cps/templates/profile_pictures.html +++ b/root/app/calibre-web/cps/templates/profile_pictures.html @@ -1,120 +1,154 @@ - - - - - {{ title }} - + + + {{instance}} | {{title}} + + + + + + + + + + + + + + {% if g.current_theme == 1 %} + + + + {% endif %} + + + - + -

        {{ title }}

        - -
        -

        This is the admin page for managing profile pictures. This feature is currently in development.

        -

        To upload a profile picture, please use the following form. Note: The image data must be in Base64 format.

        -

        You can convert an image to Base64 using various online tools. If you use a website such as www.base64-image.de

        -

        then make sure you use the version that starts with the line "data:image/png;base64," not the url version.

        -

        To display the image as a round shape, it must already be in PNG format with a round frame applied.

        -

        It is recommended to use images no larger than 100x100px to avoid using excessive storage space.

        -
        - -
        -
        - - -
        - - -
        - -
        - - -
        - - -
        +
        +

        {{ title }}

        -
        - Back to Admin Page -
        - +
        +

        This is the admin page for managing profile pictures. This feature is currently in development.

        + +

        + To upload a profile picture, please use the following form. Note: The image data must be in Base64 format. + You can convert an image to Base64 using various online tools. If you use a website such as + www.base64-image.de, + then make sure you use the version that starts with the line "data:image/png;base64," not the URL version. + To display the image as a round shape, it must already be in PNG format with a round frame applied. + It is recommended to use images no larger than 100x100px to avoid using excessive storage space. +

        + +
        +
        + + +
        + + + Enter the exact username for the profile picture assignment. +
        + +
        + + + Paste the full Base64 encoded PNG image data here. +
        + + +
        +
        + +
        + Back to Admin Page +
        +
        + + diff --git a/root/app/calibre-web/cps/web.py b/root/app/calibre-web/cps/web.py index dc6927c..d48d55d 100644 --- a/root/app/calibre-web/cps/web.py +++ b/root/app/calibre-web/cps/web.py @@ -1696,6 +1696,18 @@ def show_book(book_id): # ################################### Profile Pictures ################################################### +@web.route("/user_profiles.json") +@user_login_required +def user_profiles_json(): + try: + json_path = "/config/user_profiles.json" + with open(json_path, "r") as file: + data = json.load(file) + return jsonify(data) + except Exception as e: + log.error(f"Error reading user_profiles.json: {str(e)}") + return jsonify({}), 500 + @web.route("/me/cwa/profilepictures", methods=["GET", "POST"]) @user_login_required def profile_pictures(): @@ -1724,7 +1736,7 @@ def profile_pictures(): try: # Path to the JSON file - json_path = "/app/calibre-web/cps/static/user-profile-data/user_profiles.json" + json_path = "/config/user_profiles.json" log.debug(f"Opening JSON file at: {json_path}") # Read the existing data from the JSON file and update it @@ -1749,5 +1761,5 @@ def profile_pictures(): # Handle the GET request and render the page log.debug("Rendering GET view for profile_pictures page.") return render_title_template("profile_pictures.html", - title=_("Profile Pictures Management"), + title=_("Profile Picture Management"), page="profilepictures") diff --git a/root/etc/s6-overlay/s6-rc.d/cwa-init/run b/root/etc/s6-overlay/s6-rc.d/cwa-init/run index 1355bd5..30ea014 100755 --- a/root/etc/s6-overlay/s6-rc.d/cwa-init/run +++ b/root/etc/s6-overlay/s6-rc.d/cwa-init/run @@ -73,6 +73,17 @@ fi echo "[cwa-init] CWA-init complete! Service exiting now..." +#------------------------------------------------------------------------------------------------------------------------ +# Create blank json file for profile pictures if one doesn't exist +#------------------------------------------------------------------------------------------------------------------------ + +if [ ! -f /config/user_profiles.json ]; then + echo "[cwa-init] No existing user_profiles.json found! Creating blank one..." + echo -e "{\n}" > /config/user_profiles.json +else + echo "[cwa-init] Existing user_profiles.json found!" +fi + #------------------------------------------------------------------------------------------------------------------------ # Set required permissions #------------------------------------------------------------------------------------------------------------------------ From 90331a8f814642c7dbac5aac3496394ed09346f9 Mon Sep 17 00:00:00 2001 From: crocodilestick <105450872+crocodilestick@users.noreply.github.com> Date: Fri, 16 May 2025 17:04:06 +0200 Subject: [PATCH 33/42] Added the following PRs from CW: #3390 - Resolves a 403 response when accessing /ajax/updateThumbnails from a session authenticated by reverse proxy #3387 - Adds lazy loading to Cover image rendering, makes the UI feel a lot snappier --- angelicadvocate-notes-README.md | 7 ------ root/app/calibre-web/cps/admin.py | 2 +- root/app/calibre-web/cps/templates/image.html | 22 +++++++++++++++++++ 3 files changed, 23 insertions(+), 8 deletions(-) delete mode 100644 angelicadvocate-notes-README.md create mode 100755 root/app/calibre-web/cps/templates/image.html diff --git a/angelicadvocate-notes-README.md b/angelicadvocate-notes-README.md deleted file mode 100644 index 6c0282b..0000000 --- a/angelicadvocate-notes-README.md +++ /dev/null @@ -1,7 +0,0 @@ -## Update Summary - -- Removed previous changes to the Dockerfile. -- Added a check in `/cwa-init/run` to verify if the JSON file exists, and create it if it doesn't. -- Moved the JSON file into the `config` directory to avoid extra volume binds. -- Began integrating the **Caliblur** theme into the profile pictures page for a more cohesive UI across the application. -- Fixed several bugs introduced in the initial draft of `profile_pictures.html`, including issues with page scrolling. diff --git a/root/app/calibre-web/cps/admin.py b/root/app/calibre-web/cps/admin.py index 63fb9cc..daece72 100644 --- a/root/app/calibre-web/cps/admin.py +++ b/root/app/calibre-web/cps/admin.py @@ -190,8 +190,8 @@ def reconnect(): @admi.route("/ajax/updateThumbnails", methods=['POST']) -@admin_required @user_login_required +@admin_required def update_thumbnails(): content = config.get_scheduled_task_settings() if content['schedule_generate_book_covers']: diff --git a/root/app/calibre-web/cps/templates/image.html b/root/app/calibre-web/cps/templates/image.html new file mode 100755 index 0000000..62820b7 --- /dev/null +++ b/root/app/calibre-web/cps/templates/image.html @@ -0,0 +1,22 @@ +{% macro book_cover(book, alt=None) -%} + {%- set image_title = book.title if book.title else book.name -%} + {%- set image_alt = alt if alt else image_title -%} + {% set srcset = book|get_cover_srcset %} + {{ image_alt }} +{%- endmacro %} + +{% macro series(series, alt=None) -%} + {%- set image_alt = alt if alt else image_title -%} + {% set srcset = series|get_series_srcset %} + {{ title }} +{%- endmacro %} From 0bc8b8bde0f70f8d3360011387dc709c9da737ab Mon Sep 17 00:00:00 2001 From: crocodilestick <105450872+crocodilestick@users.noreply.github.com> Date: Fri, 16 May 2025 17:31:22 +0200 Subject: [PATCH 34/42] Added the following CW PRs: #3355 - Shows the number of items in each shelf in the Web UI #3352 - Kobo sync's logic is incorrect, and looks like it pretty much always has been. This is seen on initial sync of a freshly reset device against CW configured to sync all shelves. With 1500+ books to sync, CW syncs only about 250 or so before saying it's done. That's two full batches of 100, followed by a partial batch. The problem is in the way the query performs paging. On the first pass it discovers all the books that need to be synced. On the second pass it does pretty well. Third pass, it does badly. All this is because of the way it currently detects which books have been modified since last sync. As it goes through the sync, this query result set gets progressively smaller, incorrectly. Attempt to repair the logic, and seems to now work perfectly, working a lot better now for both initial sync and maintenance sync --- root/app/calibre-web/cps/kobo.py | 29 ++++++++++--------- .../app/calibre-web/cps/templates/layout.html | 2 +- 2 files changed, 16 insertions(+), 15 deletions(-) diff --git a/root/app/calibre-web/cps/kobo.py b/root/app/calibre-web/cps/kobo.py index ff188ad..d37a1d2 100644 --- a/root/app/calibre-web/cps/kobo.py +++ b/root/app/calibre-web/cps/kobo.py @@ -141,6 +141,7 @@ def HandleSyncRequest(): if not current_user.role_download(): log.info("Users need download permissions for syncing library to Kobo reader") return abort(403) + sync_token = SyncToken.SyncToken.from_headers(request.headers) log.info("Kobo library sync request received") log.debug("SyncToken: {}".format(sync_token)) @@ -167,6 +168,8 @@ def HandleSyncRequest(): only_kobo_shelves = current_user.kobo_only_shelves_sync + log.debug("Kobo Sync: books last modified: {}".format(sync_token.books_last_modified)) + if only_kobo_shelves: changed_entries = calibre_db.session.query(db.Books, ub.ArchivedBook.last_modified, @@ -177,11 +180,14 @@ def HandleSyncRequest(): ub.ArchivedBook.user_id == current_user.id)) .filter(db.Books.id.notin_(calibre_db.session.query(ub.KoboSyncedBooks.book_id) .filter(ub.KoboSyncedBooks.user_id == current_user.id))) - .filter(ub.BookShelf.date_added > sync_token.books_last_modified) + .filter(or_( + ub.BookShelf.date_added > sync_token.books_last_modified, + db.Books.last_modified > sync_token.books_last_modified, + )) .filter(db.Data.format.in_(KOBO_FORMATS)) .filter(calibre_db.common_filters(allow_show_archived=True)) + .order_by(db.Books.last_modified) .order_by(db.Books.id) - .order_by(ub.ArchivedBook.last_modified) .join(ub.BookShelf, db.Books.id == ub.BookShelf.book_id) .join(ub.Shelf) .filter(ub.Shelf.user_id == current_user.id) @@ -200,10 +206,11 @@ def HandleSyncRequest(): .filter(db.Data.format.in_(KOBO_FORMATS)) .order_by(db.Books.last_modified) .order_by(db.Books.id)) + log.debug("Kobo Sync: changed entries: {}".format(changed_entries.count())) reading_states_in_new_entitlements = [] books = changed_entries.limit(SYNC_ITEM_LIMIT) - log.debug("Books to Sync: {}".format(len(books.all()))) + log.debug("Kobo Sync: selected to sync: {}".format(len(books.all()))) for book in books: formats = [data.format for data in book.Books.data] if 'KEPUB' not in formats and config.config_kepubifypath and 'EPUB' in formats: @@ -235,12 +242,6 @@ def HandleSyncRequest(): new_books_last_modified = max( book.Books.last_modified.replace(tzinfo=None), new_books_last_modified ) - try: - new_books_last_modified = max( - new_books_last_modified, book.date_added - ) - except AttributeError: - pass new_books_last_created = max(ts_created, new_books_last_created) kobo_sync_status.add_synced_books(book.Books.id) @@ -257,20 +258,19 @@ def HandleSyncRequest(): book_count = changed_entries.count() # last entry: cont_sync = bool(book_count) - log.debug("Remaining books to Sync: {}".format(book_count)) + log.debug("Kobo Sync: remaining books to sync: {}".format(book_count)) # generate reading state data changed_reading_states = ub.session.query(ub.KoboReadingState) + log.debug("Kobo Sync: rstate last modified: {}".format(sync_token.reading_state_last_modified)) if only_kobo_shelves: changed_reading_states = changed_reading_states.join(ub.BookShelf, ub.KoboReadingState.book_id == ub.BookShelf.book_id)\ .join(ub.Shelf)\ .filter(current_user.id == ub.Shelf.user_id)\ .filter(ub.Shelf.kobo_sync, - or_( - ub.KoboReadingState.last_modified > sync_token.reading_state_last_modified, - func.datetime(ub.BookShelf.date_added) > sync_token.books_last_modified - )).distinct() + ub.KoboReadingState.last_modified > sync_token.reading_state_last_modified)\ + .distinct() else: changed_reading_states = changed_reading_states.filter( ub.KoboReadingState.last_modified > sync_token.reading_state_last_modified) @@ -279,6 +279,7 @@ def HandleSyncRequest(): and_(ub.KoboReadingState.user_id == current_user.id, ub.KoboReadingState.book_id.notin_(reading_states_in_new_entitlements)))\ .order_by(ub.KoboReadingState.last_modified) + log.debug("Kobo Sync: changed states: {}".format(changed_reading_states.count())) cont_sync |= bool(changed_reading_states.count() > SYNC_ITEM_LIMIT) for kobo_reading_state in changed_reading_states.limit(SYNC_ITEM_LIMIT).all(): book = calibre_db.session.query(db.Books).filter(db.Books.id == kobo_reading_state.book_id).one_or_none() diff --git a/root/app/calibre-web/cps/templates/layout.html b/root/app/calibre-web/cps/templates/layout.html index 10a93d3..f25b5c4 100644 --- a/root/app/calibre-web/cps/templates/layout.html +++ b/root/app/calibre-web/cps/templates/layout.html @@ -254,7 +254,7 @@ {% if current_user.is_authenticated or g.allow_anonymous %} {% for shelf in g.shelves_access %} -
      • {{shelf.name|shortentitle(40)}}{% if shelf.is_public == 1 %} {{_('(Public)')}}{% endif %}
        • +
      • {{shelf.name|shortentitle(40)}}{% if shelf.is_public == 1 %} {{_('(Public)')}}{% endif %} ({{shelf.books.all()|length}})
        • {% endfor %} {% if not current_user.is_anonymous %} From 42d6db390e4344a1b8e77f1120485d17bd0bddef Mon Sep 17 00:00:00 2001 From: crocodilestick <105450872+crocodilestick@users.noreply.github.com> Date: Fri, 16 May 2025 17:55:33 +0200 Subject: [PATCH 35/42] Set HOME env to /config to allow the use of Calibre Plugins like DeDRM (copy your Calibre "plugins" folder to /config (closes Issue #243) --- Dockerfile | 3 +++ 1 file changed, 3 insertions(+) diff --git a/Dockerfile b/Dockerfile index 1e1e5f9..13d3d1e 100644 --- a/Dockerfile +++ b/Dockerfile @@ -3,6 +3,9 @@ FROM ghcr.io/linuxserver/unrar:latest AS unrar FROM ghcr.io/linuxserver/baseimage-ubuntu:jammy +# Sets HOME ENV to /config to allow plugins to be installed +ENV HOME /config + # Set the default shell for the following RUN instructions to bash instead of sh SHELL ["/bin/bash", "-c"] From e025a5a3d2a65ae62f68afb652d3db9ea4d0a829 Mon Sep 17 00:00:00 2001 From: angelicadvocate Date: Fri, 16 May 2025 17:22:17 -0500 Subject: [PATCH 36/42] Various bugfixes and improvements. See angelicadvocate-README.md for details. --- .gitattributes | 8 ++++++ angelicadvocate-README.md | 26 +++++++++++++++++++ .../app/calibre-web/cps/services/hardcover.py | 4 +-- .../s6-rc.d/metadata-change-detector/run | 3 +++ scripts/ingest_processor.py | 17 ++++++++++++ 5 files changed, 56 insertions(+), 2 deletions(-) create mode 100644 .gitattributes create mode 100644 angelicadvocate-README.md diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000..24913b1 --- /dev/null +++ b/.gitattributes @@ -0,0 +1,8 @@ +# Enforce LF for all shell scripts and related files +*.sh text eol=lf +*.bash text eol=lf +*.env text eol=lf +*.conf text eol=lf +Dockerfile text eol=lf +*.yml text eol=lf +**/run text eol=lf \ No newline at end of file diff --git a/angelicadvocate-README.md b/angelicadvocate-README.md new file mode 100644 index 0000000..75cb348 --- /dev/null +++ b/angelicadvocate-README.md @@ -0,0 +1,26 @@ +# Development Notes + +## Syntax Fixes +- **File:** `hardcover.py` (lines 145 and 147) + Changed `is` to `==` when comparing literal values. + The original code was using `is` for value comparison, which is meant for identity checks. + Using `==` ensures proper value equality checks and avoids `SyntaxWarning` messages in logs. + +## Ingest Filter Fixes +- **File:** `ingest_processor.py` + Fixed logic for ignoring unwanted files with extensions like `.crdownload`, `.download`, and `.part`. + See section: `# Make sure it's a list, if it's a string convert it to a single-item list`. + +## Line Ending Normalization +- Added a `.gitattributes` file to enforce LF line endings for shell scripts and related files. + This helps prevent inconsistent line endings across environments during versioning, pulls, and merges. + +## Directory Handling +- **File:** `metadata-change-detector/run` + Added logic to create the `$WATCH_FOLDER` directory if it doesn't exist. + This prevents the script from entering a continuous loop due to a missing folder. + +## File Name Truncation +- **File:** `ingest_processor.py` + Implemented filename truncation to prevent issues with excessively long file names. + This resolves errors when processing files that exceed filesystem limits or break internal logic. diff --git a/root/app/calibre-web/cps/services/hardcover.py b/root/app/calibre-web/cps/services/hardcover.py index 7c59092..4cc0df6 100644 --- a/root/app/calibre-web/cps/services/hardcover.py +++ b/root/app/calibre-web/cps/services/hardcover.py @@ -142,9 +142,9 @@ class HardcoverClient: "pages": pages_read, "editionId": int(book.get("edition").get("id")), "startedAt":read.get("started_at",datetime.now().strftime("%Y-%m-%d")), - "finishedAt": datetime.now().strftime("%Y-%m-%d") if progress_percent is 100 else None + "finishedAt": datetime.now().strftime("%Y-%m-%d") if progress_percent == 100 else None } - if progress_percent is 100: + if progress_percent == 100: self.change_book_status(book, 3) self.execute(query=mutation, variables=variables) return diff --git a/root/etc/s6-overlay/s6-rc.d/metadata-change-detector/run b/root/etc/s6-overlay/s6-rc.d/metadata-change-detector/run index 5df5596..b8e6ef3 100644 --- a/root/etc/s6-overlay/s6-rc.d/metadata-change-detector/run +++ b/root/etc/s6-overlay/s6-rc.d/metadata-change-detector/run @@ -6,6 +6,9 @@ echo "========== STARTING METADATA CHANGE DETECTOR ===========" WATCH_FOLDER="/app/calibre-web-automated/metadata_change_logs" echo "[metadata-change-detector] Watching folder: $WATCH_FOLDER" +# Create the folder if it doesn't exist +mkdir -p "$WATCH_FOLDER" + # Monitor the folder for new files s6-setuidgid abc inotifywait -m -e close_write -e moved_to --exclude '^.*\.(swp)$' "$WATCH_FOLDER" | while read -r directory events filename; do diff --git a/scripts/ingest_processor.py b/scripts/ingest_processor.py index c00b236..4ed9766 100644 --- a/scripts/ingest_processor.py +++ b/scripts/ingest_processor.py @@ -44,6 +44,10 @@ class NewBookProcessor: self.auto_convert_on = self.cwa_settings['auto_convert'] self.target_format = self.cwa_settings['auto_convert_target_format'] self.ingest_ignored_formats = self.cwa_settings['auto_ingest_ignored_formats'] + + # Make sure it's a list, if it's a string convert it to a single-item list + if isinstance(self.ingest_ignored_formats, str): + self.ingest_ignored_formats = [self.ingest_ignored_formats] # Ignore temporary files during download self.ingest_ignored_formats.append(".crdownload") # Chromium based @@ -233,6 +237,19 @@ class NewBookProcessor: def main(filepath=sys.argv[1]): """Checks if filepath is a directory. If it is, main will be ran on every file in the given directory Inotifywait won't detect files inside folders if the folder was moved rather than copied""" + ############################################################################################## + # Truncates the filename if it is too long + MAX_LENGTH = 150 + filename = os.path.basename(filepath) + name, ext = os.path.splitext(filename) + allowed_len = MAX_LENGTH - len(ext) + + if len(name) > allowed_len: + new_name = name[:allowed_len] + ext + new_path = os.path.join(os.path.dirname(filepath), new_name) + os.rename(filepath, new_path) + filepath = new_path + ############################################################################################### if os.path.isdir(filepath) and Path(filepath).exists(): # print(os.listdir(filepath)) for filename in os.listdir(filepath): From bc1a1af00582789b83ba701050f2edff427d2dce Mon Sep 17 00:00:00 2001 From: angelicadvocate Date: Fri, 16 May 2025 18:26:02 -0500 Subject: [PATCH 37/42] Improve file renaming logic in ingest_processor.py Avoids concatenating the original filename with the path and extension in a way that could exceed filesystem limits. Resolves edge cases where the filename could still be too long even after truncation. --- scripts/ingest_processor.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/scripts/ingest_processor.py b/scripts/ingest_processor.py index 4ed9766..4f3df5c 100644 --- a/scripts/ingest_processor.py +++ b/scripts/ingest_processor.py @@ -185,9 +185,9 @@ class NewBookProcessor: def add_book_to_library(self, book_path:str) -> None: if self.target_format == "epub" and self.is_kindle_epub_fixer: self.run_kindle_epub_fixer(book_path, dest=self.tmp_conversion_dir) - fixed_epub_path = str(self.empty_tmp_con_dir) + str(os.path.basename(book_path)) + fixed_epub_path = Path(self.tmp_conversion_dir) / os.path.basename(book_path) if Path(fixed_epub_path).exists(): - book_path = self.empty_tmp_con_dir + os.path.basename(book_path) + book_path = str(fixed_epub_path) print("[ingest-processor]: Importing new book to CWA...") import_path = Path(book_path) From c2821d660fa0f3d02c92623528e87ab13810e9cf Mon Sep 17 00:00:00 2001 From: angelicadvocate Date: Fri, 16 May 2025 18:32:36 -0500 Subject: [PATCH 38/42] updated angelicadvocate-README.md --- angelicadvocate-README.md | 3 +++ 1 file changed, 3 insertions(+) diff --git a/angelicadvocate-README.md b/angelicadvocate-README.md index 75cb348..1fd90ec 100644 --- a/angelicadvocate-README.md +++ b/angelicadvocate-README.md @@ -24,3 +24,6 @@ - **File:** `ingest_processor.py` Implemented filename truncation to prevent issues with excessively long file names. This resolves errors when processing files that exceed filesystem limits or break internal logic. + Improve file renaming logic in ingest_processor.py + Avoids concatenating the original filename with the path and extension in a way that could exceed filesystem limits. + Resolves edge cases where the filename could still be too long even after truncation. \ No newline at end of file From 00af9128527598f718efbe2448398a0c64113f24 Mon Sep 17 00:00:00 2001 From: angelicadvocate Date: Sat, 17 May 2025 11:05:21 -0500 Subject: [PATCH 39/42] removed personal readme from the repository for cleaner codebase --- angelicadvocate-README.md | 29 ----------------------------- 1 file changed, 29 deletions(-) delete mode 100644 angelicadvocate-README.md diff --git a/angelicadvocate-README.md b/angelicadvocate-README.md deleted file mode 100644 index 1fd90ec..0000000 --- a/angelicadvocate-README.md +++ /dev/null @@ -1,29 +0,0 @@ -# Development Notes - -## Syntax Fixes -- **File:** `hardcover.py` (lines 145 and 147) - Changed `is` to `==` when comparing literal values. - The original code was using `is` for value comparison, which is meant for identity checks. - Using `==` ensures proper value equality checks and avoids `SyntaxWarning` messages in logs. - -## Ingest Filter Fixes -- **File:** `ingest_processor.py` - Fixed logic for ignoring unwanted files with extensions like `.crdownload`, `.download`, and `.part`. - See section: `# Make sure it's a list, if it's a string convert it to a single-item list`. - -## Line Ending Normalization -- Added a `.gitattributes` file to enforce LF line endings for shell scripts and related files. - This helps prevent inconsistent line endings across environments during versioning, pulls, and merges. - -## Directory Handling -- **File:** `metadata-change-detector/run` - Added logic to create the `$WATCH_FOLDER` directory if it doesn't exist. - This prevents the script from entering a continuous loop due to a missing folder. - -## File Name Truncation -- **File:** `ingest_processor.py` - Implemented filename truncation to prevent issues with excessively long file names. - This resolves errors when processing files that exceed filesystem limits or break internal logic. - Improve file renaming logic in ingest_processor.py - Avoids concatenating the original filename with the path and extension in a way that could exceed filesystem limits. - Resolves edge cases where the filename could still be too long even after truncation. \ No newline at end of file From 68cc3a160bd5e6dc1e2b22564ada7d28404a3a84 Mon Sep 17 00:00:00 2001 From: crocodilestick <105450872+crocodilestick@users.noreply.github.com> Date: Mon, 19 May 2025 13:35:06 +0200 Subject: [PATCH 40/42] Setting the HOME ENV to /config i the last commit prevented the image from building, investigating other solutions --- Dockerfile | 3 +++ 1 file changed, 3 insertions(+) diff --git a/Dockerfile b/Dockerfile index 1e1e5f9..13d3d1e 100644 --- a/Dockerfile +++ b/Dockerfile @@ -3,6 +3,9 @@ FROM ghcr.io/linuxserver/unrar:latest AS unrar FROM ghcr.io/linuxserver/baseimage-ubuntu:jammy +# Sets HOME ENV to /config to allow plugins to be installed +ENV HOME /config + # Set the default shell for the following RUN instructions to bash instead of sh SHELL ["/bin/bash", "-c"] From 61dd9cb42868930e395936b82697de2e2a2f2eae Mon Sep 17 00:00:00 2001 From: crocodilestick <105450872+crocodilestick@users.noreply.github.com> Date: Mon, 19 May 2025 13:37:02 +0200 Subject: [PATCH 41/42] Setting the HOME ENV to /config i the last commit prevented the image from building, investigating other solutions --- Dockerfile | 3 --- 1 file changed, 3 deletions(-) diff --git a/Dockerfile b/Dockerfile index 13d3d1e..1e1e5f9 100644 --- a/Dockerfile +++ b/Dockerfile @@ -3,9 +3,6 @@ FROM ghcr.io/linuxserver/unrar:latest AS unrar FROM ghcr.io/linuxserver/baseimage-ubuntu:jammy -# Sets HOME ENV to /config to allow plugins to be installed -ENV HOME /config - # Set the default shell for the following RUN instructions to bash instead of sh SHELL ["/bin/bash", "-c"] From 4c09e735a9cfb46c58234a417c74a9bcbf5f1658 Mon Sep 17 00:00:00 2001 From: crocodilestick <105450872+crocodilestick@users.noreply.github.com> Date: Mon, 19 May 2025 13:59:24 +0200 Subject: [PATCH 42/42] Reverted integration of PR #263 due to permissions issues --- scripts/setup-cwa.sh | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) diff --git a/scripts/setup-cwa.sh b/scripts/setup-cwa.sh index 59850e6..fc7ee3b 100644 --- a/scripts/setup-cwa.sh +++ b/scripts/setup-cwa.sh @@ -2,10 +2,14 @@ # Make required directories and files for metadata enforcement make_dirs () { - sudo -S -u abc mkdir -p /app/calibre-web-automated/metadata_change_logs - sudo -S -u abc mkdir -p /app/calibre-web-automated/metadata_temp - sudo -S -u abc mkdir -p /cwa-book-ingest - sudo -S -u abc mkdir -p /calibre-library + mkdir /app/calibre-web-automated/metadata_change_logs + chown -R abc:abc /app/calibre-web-automated/metadata_change_logs + mkdir /app/calibre-web-automated/metadata_temp + chown -R abc:abc /app/calibre-web-automated/metadata_temp + mkdir /cwa-book-ingest + chown abc:abc /cwa-book-ingest + mkdir /calibre-library + chown -R abc:abc /calibre-library } # Change ownership & permissions as required