Merge pull request 'fix-featured-image' (#27) from fix-featured-image into master

Reviewed-on: #27

import_export_canalblog.py

@@ -55,7 +55,7 @@ def remove(index, number, args, basic, logger, ssl_wordpress):
 
 def download(name_thread, max_thread, url, logger, parser, directory, html, img, ssl_canalblog, revert, tmp):
     exportWp = WPExport(name="Thread-{0}".format(int(name_thread) + 1), url=url, logger=logger, parser=parser, directory=directory, ssl_canalblog=ssl_canalblog)    
-    if not revert:
+    if revert is False:
         exportWp.getUrlPage(name_thread, max_thread)
     for i in ["article", "page"]:
         for j in ["publications", "principal"]:
@@ -170,6 +170,8 @@ if __name__ == '__main__':
     import_parser.add_argument("--no-create", help="No create post", dest="create", default="store_false", action="store_true")
     import_parser.add_argument("--no-update", help="No update post", dest="update", default="store_false", action="store_true")
     import_parser.add_argument("--no-image", help="No image add or update", dest="image", default="store_false", action="store_true")
+    import_parser.add_argument("--no-menu", help="No menu add or update", dest="menu", default="store_false", action="store_true")
+
     import_parser.add_argument("--author", dest="author", help="Define author", default="")
 
 
@@ -264,8 +266,9 @@ if __name__ == '__main__':
             for i in wordpress:
                 importWp.setUrl(i)
                 importWp.fromFile(files=args.file.split(","))
-                menuWp = WPMenu(name="Thread-1", basic=basic, wordpress=args.wordpress, logger=logger, parser=args.parser, ssl_canalblog=ssl_canalblog, ssl_wordpress=ssl_wordpress)    
-                menuWp.fromFile("{0}".format(args.file.split(",")[0]))
+                if args.menu is False:
+                    menuWp = WPMenu(name="Thread-1", basic=basic, wordpress=args.wordpress, logger=logger, parser=args.parser, ssl_canalblog=ssl_canalblog, ssl_wordpress=ssl_wordpress)    
+                    menuWp.fromFile("{0}".format(args.file.split(",")[0]))
         if len(args.directory) > 0:
             try:
                 with futures.ThreadPoolExecutor(max_workers=int(args.parallel)) as ex:
@@ -276,9 +279,10 @@ if __name__ == '__main__':
                     ex.submit(importDirectory, i, int(args.parallel), args.directory, logger, args.parser, args.wordpress, basic, args.serial, ssl_wordpress, args.create, args.update, args.image, args.revert, args.author)
                     for i in range(0, int(args.parallel))
                     ]
-                    wait(wait_for, return_when=ALL_COMPLETED)
-                    menuWp = WPMenu(name="Thread-1", basic=basic, wordpress=args.wordpress, logger=logger, parser=args.parser, ssl_canalblog=ssl_canalblog, ssl_wordpress=ssl_wordpress)    
-                    menuWp.fromFile("{0}/index.html".format(args.directory))
+                    if args.menu is False:
+                        wait(wait_for, return_when=ALL_COMPLETED)
+                        menuWp = WPMenu(name="Thread-1", basic=basic, wordpress=args.wordpress, logger=logger, parser=args.parser, ssl_canalblog=ssl_canalblog, ssl_wordpress=ssl_wordpress)    
+                        menuWp.fromFile("{0}/index.html".format(args.directory))
             except Exception as err:
                 logger.error("Threading error : {0}".format(err))
         if len(args.canalblog) > 0:
@@ -291,9 +295,10 @@ if __name__ == '__main__':
                     ex.submit(importUrl, i, int(args.parallel), args.canalblog, logger, args.parser, args.wordpress, basic, args.serial, ssl_wordpress, ssl_canalblog, args.create, args.update, args.image, args.revert, args.tmp, args.author)
                     for i in range(0, int(args.parallel))
                     ]
-                    wait(wait_for, return_when=ALL_COMPLETED)
-                    menuWp = WPMenu(name="Thread-1", basic=basic, wordpress=args.wordpress, logger=logger, parser=args.parser, ssl_canalblog=ssl_canalblog, ssl_wordpress=ssl_wordpress)    
-                    menuWp.fromUrl(args.canalblog)
+                    if args.menu is False:
+                        wait(wait_for, return_when=ALL_COMPLETED)
+                        menuWp = WPMenu(name="Thread-1", basic=basic, wordpress=args.wordpress, logger=logger, parser=args.parser, ssl_canalblog=ssl_canalblog, ssl_wordpress=ssl_wordpress)    
+                        menuWp.fromUrl(args.canalblog)
 
 
 

lib/WPExport.py

@@ -58,14 +58,26 @@ class WPExport:
     # Download HTML
 
     def downloadHTML(self, first, second):
-        self._downloadPage(webpage[first][second], self._dir)
+        try:
+            with open("{0}/{1}.json".format(self._tmp, self._name)) as file:
+                webpage = json.loads(file.read())
+                self._downloadPage(webpage[first][second], self._dir)
+        except Exception as ex:
+            self._logger.error("{0} : Read file json from tmp : {1}".format(self._name, ex))
 
     # Download Image
     
     def downloadImg(self, first, second):
-        page_src = self._getImg(webpage[first][second])
-        o = urlparse(self._url)
-        self._downloadPage(page_src, "{0}/{1}/{2}".format(self._dir, o.path, "img"))
+        try:
+            with open("{0}/{1}.json".format(self._tmp, self._name)) as file:
+                webpage = json.loads(file.read())
+                page_src = self._getImg(webpage[first][second])
+                o = urlparse(self._url)
+                self._downloadPage(page_src, "{0}/{1}/{2}".format(self._dir, o.path, "img"))
+        except Exception as ex:
+            self._logger.error("{0} : Read file json from tmp : {1}".format(self._name, ex))
+
+
 
 
      # Get URL

lib/WPImport.py

@@ -141,7 +141,7 @@ class WPimport:
 
     def _getInfoAlbum(self, link):
         if self._ssl_canalblog:
-            link = link.replace("http", "https")
+            link = link.replace("http", "https").replace("httpss", "https")
         self._logger.info("{0} : Info album : {1}".format(self._name, link))
         link_o = urlparse(link)
         if len(link_o.netloc) > 0:
@@ -162,14 +162,17 @@ class WPimport:
             if os.path.exists("{0}/..{1}".format(self._directory, link_o)):
                 page_img = open("{0}/..{1}".format(self._directory, link_o), "r")
         soup = BeautifulSoup(page_img, self._parser)
-        paragraph = soup.find("div", class_="albumbody").find("p")
-        self._logger.info("{0} get paragraph : {1}".format(self._name, paragraph))
-        split_paragraph = str(paragraph).split("<br>")
-        self._logger.info("{0} length paragraph splitted : {1}".format(self._name, len(split_paragraph)))
-        if len(split_paragraph) == 1:
-            split_paragraph = str(paragraph).split("<br/>")
-        self._logger.info("{0} get paragraph splitted : {1}".format(self._name, split_paragraph))
-        author = split_paragraph[1].split(":")[1].replace(" ", "").lower()
+        paragraphs = soup.find("div", class_="albumbody").find_all("p")
+        for paragraph in paragraphs:
+            self._logger.info("{0} get paragraph : {1}".format(self._name, paragraph))
+            split_paragraph = str(paragraph).split("<br>")
+            self._logger.info("{0} length paragraph splitted : {1}".format(self._name, len(split_paragraph)))
+            if len(split_paragraph) == 1:
+                split_paragraph = str(paragraph).split("<br/>")
+            self._logger.info("{0} get paragraph splitted : {1}".format(self._name, split_paragraph))
+            if len(split_paragraph) > 1:
+                if len(split_paragraph[1].split(":")) > 1:
+                    author = split_paragraph[1].split(":")[1].replace(" ", "").lower()
         return author
 
 
@@ -302,7 +305,7 @@ class WPimport:
                                                 exit(1)
                                             except Exception as err:
                                                 self._logger.error("{0} : Exception error for update page : {1}".format(self._name, err))
-                        if page.status_code == 400:
+                        elif page.status_code == 400:
                             self._logger.error("{0} : Connection for update post unauthorized : {1}".format(self._name, page.status_code))
                             self._logger.debug("{0} : {1}".format(self._name, page.content))
                             break
@@ -414,6 +417,67 @@ class WPimport:
                 subdirectory = self._getDirectories(sub, "{0}/{1}".format(item, i))
         return subdirectory
 
+
+    def _linkFeaturedMedia(self, img_src, h2, result):
+        try:
+            page = self._request.get(img_src)
+            if page.status_code == 200:
+                name_img = img_src.replace("_q", "")
+                name_img = name_img.split("/")[len(name_img.split("/"))-1]
+                params = {"search": name_img}
+                try:
+                    page = self._request.get("{1}://{0}/wp-json/wp/v2/media".format(self._wordpress, self._protocol), auth=self._basic, params=params)                    
+                    if page.status_code == 200:
+                        res = page.json()
+                        if len(res) > 0:
+                            id_media = res[0]["id"]
+                            data = {"featured_media": id_media}
+                            try:
+                                r = self._request.post("{2}://{0}/wp-json/wp/v2/posts/{1}".format(self._wordpress, result[0]["id"], self._protocol), auth=self._basic, headers=self._headers_json, data=json.dumps(data))
+                                if r.status_code == 200:
+                                    self._logger.info("{0} : Add media featured : {1}".format(self._name, r.json()["title"]["raw"]))
+                                else:
+                                    self._logger.error("{0} : Connection error with status code for featured media : {1}".format(self._name, r.status_code))
+                                    self._logger.debug("{0} : {1}".format(self._name, r.content))
+                            except ConnectionError as err:
+                                self._logger.error("{0} : Connection error for post media featured : {1}".format(self._name, err))
+                                exit(1)
+                            except Exception as err:
+                                self._logger.error("{0} : Exception error for post media featured : {1}".format(self._name, err))
+                        else:
+                            self._logger.info("{0} : No media found for {1}".format(self._name, h2))
+                            try:
+                                page = self._request.get(img_src.replace("_q", ""))
+                                if page.status_code == 200:
+                                    self._logger.info("{0} : Get image for media featured : {1}".format(self._name, img_src.replace("_q", "")))
+                                    media = self._addOrUpdateMedia(img_src.replace("_q", ""), page)
+                                    if media["id"] != "":
+                                        self._linkFeaturedMedia(img_src.replace("_q", ""), h2)
+                                    else:
+                                        self._logger.error("{0} : Connection error with status code for get image for featured media : {1}".format(self._name, page.status_code))
+                                        self._logger.debug("{0} : {1}".format(self._name, page.content))
+                            except ConnectionError as err:
+                                self._logger.error("{0} : Connection error for get to image for featured media : {1}".format(self._name, err))
+                                exit(1)
+                            except Exception as err:
+                                self._logger.error("{0} : Exception error for get to image media featured : {1}".format(self._name, err))
+                    else:
+                        self._logger.error("{0} : Connection error with status code for search featured media: {1}".format(self._name, page.status_code))
+                        self._logger.debug("{0} : {1}".format(self._name, page.content))
+                except ConnectionError as err:
+                    self._logger.error("{0} : Connection error search featured media : {1}".format(self._name, err))
+                    exit(1)
+                except Exception as err:
+                    self._logger.error("{0} : Exception error search featured media : {1}".format(self._name, err))
+            else:
+                self._logger.error("{0} : Connection error for get featured media with status code : {1}".format(self._name, page.status_code))
+                self._logger.debug("{0} : {1}".format(self._name, page.content))
+        except ConnectionError as err:
+            self._logger.error("{0} : Connection error for get featured media : {1}".format(self._name, err))
+            exit(1)
+        except Exception as err:
+            self._logger.error("{0} : Exception error for get featured media : {1}".format(self._name, err))
+
     ## Add or update featured media
 
     def _addOrUpdateFeaturedMedia(self, soup):
@@ -426,54 +490,11 @@ class WPimport:
                 if page.status_code == 200:
                     result = page.json()
                     if len(result) > 0:
-                        if h2 == result[0]["title"]:
+                        if h2 == self._replaceCaracter(result[0]["title"]):
                             img = i.find_all("img")
                             if len(img) > 0:
                                 img_src = img[0].get("src")
-                                try:
-                                    page = self._request.get(img_src)
-                                    if page.status_code == 200:
-                                        name_img = img_src.replace("_q", "")
-                                        name_img = name_img.split("/")[len(name_img.split("/"))-1]
-                                        params = {"search": name_img}
-                                        try:
-                                            page = self._request.get("{1}://{0}/wp-json/wp/v2/media".format(self._wordpress, self._protocol), auth=self._basic, params=params)
-                                        
-                                            if page.status_code == 200:
-                                                res = page.json()
-                                                if len(res) > 0:
-                                                    id_media = res[0]["id"]
-                                                    data = {"featured_media": id_media}
-                                                    try:
-                                                        r = self._request.post("{2}://{0}/wp-json/wp/v2/posts/{1}".format(self._wordpress, result[0]["id"], self._protocol), auth=self._basic, headers=self._headers_json, data=json.dumps(data))
-                                                        if r.status_code == 200:
-                                                            self._logger.info("{0} : Add media featured : {1}".format(self._name, r.json()["title"]["raw"]))
-                                                        else:
-                                                            self._logger.error("{0} : Connection error with status code for featured media : {1}".format(self._name, r.status_code))
-                                                            self._logger.debug("{0} : {1}".format(self._name, r.content))
-                                                    except ConnectionError as err:
-                                                        self._logger.error("{0} : Connection error for post media featured : {1}".format(self._name, err))
-                                                        exit(1)
-                                                    except Exception as err:
-                                                        self._logger.error("{0} : Exception error for post media featured : {1}".format(self._name, err))
-                                                else:
-                                                    self._logger.info("{0} : No media found for {1}".format(self._name, h2))
-                                            else:
-                                                self._logger.error("{0} : Connection error with status code for search featured media: {1}".format(self._name, page.status_code))
-                                                self._logger.debug("{0} : {1}".format(self._name, page.content))
-                                        except ConnectionError as err:
-                                            self._logger.error("{0} : Connection error search featured media : {1}".format(self._name, err))
-                                            exit(1)
-                                        except Exception as err:
-                                            self._logger.error("{0} : Exception error search featured media : {1}".format(self._name, err))
-                                    else:
-                                        self._logger.error("{0} : Connection error for get featured media with status code : {1}".format(self._name, page.status_code))
-                                        self._logger.debug("{0} : {1}".format(self._name, page.content))
-                                except ConnectionError as err:
-                                    self._logger.error("{0} : Connection error for get featured media : {1}".format(self._name, err))
-                                    exit(1)
-                                except Exception as err:
-                                    self._logger.error("{0} : Exception error for get featured media : {1}".format(self._name, err))
+                                self._linkFeaturedMedia(img_src, h2, result)    
                 else:
                     self._logger.error("{0} : Connection error with status code for featured media : {1}".format(self._name, page.status_code))
                     self._logger.debug("{0} : {1}".format(self._name, page.content))
@@ -817,7 +838,7 @@ class WPimport:
                                         listelement[i].append(k["id"])
                             else:
                                 break
-                        if page.status_code == 400:
+                        elif page.status_code == 400:
                             self._logger.error("{0} : {1} not found due status code : {2}".format(self._name, i, page.status_code))
                             self._logger.debug("{0} : {1}".format(self._name, page.content))
                             break
@@ -867,12 +888,15 @@ class WPimport:
             bodyhtml = bodyhtml.replace(i["old_href"], o.path)
             bodyhtml = bodyhtml.replace(i["old_src"], o.path)
         hour = articledate[0].text
-        time = dateheader[0].text.split(" ")
+        time = ""
+        if len(dateheader) > 0:
+            time = dateheader[0].text.split(" ")
         self._logger.debug("{0} : Title post : |{1}|".format(self._name, title))
         title = self._removeSpace(title)
         self._logger.debug("{0} : Rendered Title post : |{1}|".format(self._name, title))
-
-        data = {"title":title, "content":bodyhtml, "status":"publish", "date": "{0}-{1}-{2}T{3}:00".format(time[2],month[time[1]],time[0], hour), "tags": listelement["tags"], "categories": listelement["categories"]}
+        data = {"title":title, "content":bodyhtml, "status":"publish", "tags": listelement["tags"], "categories": listelement["categories"]}
+        if len(dateheader) > 0:
+            data = {"title":title, "content":bodyhtml, "status":"publish", "date": "{0}-{1}-{2}T{3}:00".format(time[2],month[time[1]],time[0], hour), "tags": listelement["tags"], "categories": listelement["categories"]}
         self._logger.debug("{0} : Data for post : |{1}| : {2}" .format(self._name, title, data))
 
         data["author"] = self._getAuthor(author)