Add IronPPT & Version Check Support

Author: irondarrius

.vscode/launch.json

@@ -10,6 +10,18 @@
             "request": "launch",
             "program": "${file}",
             "console": "integratedTerminal"
+        },
+        {
+            "name": "check-apidocs",
+            "type": "debugpy",
+            "request": "launch",
+            "program": "${workspaceFolder}/check-apidocs.py",
+            "console": "integratedTerminal",
+            "args": [
+                "--product-code=ironpdfnodejs",
+                "--latest-version",
+                "--docs-exists"
+            ]
         }
     ]
 }

__pycache__/apidocs.cpython-312.pyc

@@ -0,0 +1,117 @@
+import requests, json, re
+import os
+
+NUGET_ENDPOINT_FORMAT = "https://api-v2v3search-0.nuget.org/query?q=packageid:{}"
+MAVEN_ENDPOINT_FORMAT = "https://search.maven.org/solrsearch/select?q=g:{groupId}+AND+a:{artifactId}&core=gav&rows=1000&wt=json"
+NPM_ENDPOINT_FORMAT = "https://registry.npmjs.org/{package_name}"
+PYPI_ENDPOINT_FORMAT = "https://pypi.org/pypi/{package_name}/json"
+PRODUCTS_CATALOG = os.path.join(os.path.dirname(os.path.abspath(__file__)), "iron-products.json")
+APIDOCS_STORAGE_PATH = os.path.join(os.path.dirname(os.path.abspath(__file__)), "object-reference")
+APIDOCS_DESTINATION_PATH_TEMPLATE = APIDOCS_STORAGE_PATH + os.path.sep + "{}" + os.path.sep + "{}"
+
+def get_apidoc_path(info:dict, version_string:str) -> str:
+    destination_path = APIDOCS_DESTINATION_PATH_TEMPLATE.format(info["code"], version_string)
+    return destination_path
+
+def apidoc_already_exists(info:dict, version_string:str) -> bool:
+    destination_path = get_apidoc_path(info, version_string)
+    return os.path.exists(destination_path)
+
+def get_maven_package_versions(group_id:str, artifact_id:str) -> dict:
+    response = requests.get(url=MAVEN_ENDPOINT_FORMAT.format(groupId = group_id, artifactId = artifact_id))
+    data = response.json()
+    versions = data["response"]["docs"];
+    return versions;
+
+def get_pip_package_versions(package_name:str) -> dict:
+    response = requests.get(url=PYPI_ENDPOINT_FORMAT.format(package_name = package_name))
+    data = response.json()
+    versions = data["releases"];
+    return versions;
+
+
+def get_npm_package_versions(package_name:str) -> dict:
+    response = requests.get(url=NPM_ENDPOINT_FORMAT.format(package_name = package_name))
+    data = response.json()
+    versions = data["versions"];
+    return versions;
+
+def get_nuget_package_versions(package:str) -> dict:
+    response = requests.get(url=NUGET_ENDPOINT_FORMAT.format(package))
+    data = response.json()
+    versions = data["data"][0]["versions"];
+    return versions;
+
+def query_product_info(product_code:str, product_name:str=None) -> dict|None:
+    selected_product=None
+    package_versions=None
+    latest_version=None
+    with open(PRODUCTS_CATALOG, 'r') as file:
+        products = json.load(file)
+
+
+        for product in products["libraries"]:
+            if product["code"] == product_code or (product_name is not None and product["name"] == product_name):
+                selected_product = product
+                break
+        
+        if selected_product is not None:
+            if selected_product["packageType"] == "nuget":
+                package_versions = get_nuget_package_versions(selected_product["packageName"])
+            elif product["packageType"] == "maven":
+                package_versions = get_maven_package_versions(selected_product["groupId"], selected_product["artifactId"])
+            elif product["packageType"] == "pip":
+                package_versions = get_pip_package_versions(selected_product["packageName"])
+            elif product["packageType"] == "npm":
+                package_versions = get_npm_package_versions(selected_product["packageName"])
+            
+            if len(package_versions) > 0:
+                if selected_product["packageType"] == "pip" or selected_product["packageType"] == "npm":
+                    versions = list(package_versions.keys())
+                    latest_version = package_versions[versions[-1]]
+                    if selected_product["packageType"] == "pip":
+                        latest_version = latest_version[0]
+                    if "version" not in latest_version.keys():
+                        latest_version["version"] = versions[-1]
+                    product_versions = []
+                    for version in versions:
+                        package_version = package_versions[version]
+                        if selected_product["packageType"] == "pip":
+                            package_version = package_version[0]
+                            package_version["version"] = version
+                        product_versions.append(package_version)
+                    package_versions = product_versions
+                elif selected_product["packageType"] == "maven":
+                    latest_version = package_versions[0]
+                else:
+                    latest_version = package_versions[-1]
+
+    return {"product": selected_product, "available_versions": package_versions, "latest_version": latest_version}
+
+def get_product_version(product_data:dict, version:str = "", get_latest_version:bool = True) -> str:
+    version="N/A"
+    if get_latest_version:
+        if product_data["product"]["packageType"] == "maven":
+            version = product_data["latest_version"]["v"]
+        else:
+            version = product_data["latest_version"]["version"]
+    elif version != "":
+        for product in product_data['available_versions']:
+            if product_data["product"]["packageType"] == "maven":
+                version = product["v"]
+            else:
+                version = product["version"]
+    return version
+
+def check_if_product_and_version_exists(product_data:dict, product_version:str)-> bool:
+    exists = False
+    for product in product_data["available_versions"]:
+        version = ""
+        if product_data["product"]["packageType"] == "maven":
+            version = product["v"]
+        else:
+            version = product["version"]
+        if version == product_version:
+            exists = apidoc_already_exists(product_data["product"], product_version)
+            break
+    return exists

__pycache__/statuslogger.cpython-312.pyc

@@ -0,0 +1,48 @@
+import shutil, subprocess, sys, os, getopt, re, json
+from apidocs import *
+from statuslogger import *
+
+
+def main(arguments):
+    product_code = None
+    product_name = None
+    version = None
+    get_latest_version = False
+    check_if_exists = False
+
+    opts, args = getopt.getopt(arguments, "p:n:v:Va", ["product-code=", "product-name=", "version=", "latest-version", "docs-exists"])
+    for opt, arg in opts:
+        if opt in ("-p", "--product-code"):
+            product_code = arg
+        elif opt in ("-n", "--product-name"):
+            product_name = arg
+        elif opt in ("-v", "--version"):
+            version = arg
+        elif opt in ("-V", "--latest-version"):
+            get_latest_version = True
+        elif opt in ("-a", "--docs-exists"):
+            check_if_exists = True
+    
+    if product_code is None and product_name is None:
+        StatusLogger.error("Please specify product code or product name (-p , --product-code|-n, --product-name)")
+        exit(1)
+    else:
+        product_data = query_product_info(product_code, product_name)
+        if product_data['product'] is None:
+            StatusLogger.error("Specified product does not exist")
+            exit(1)
+        else:
+            output = ""
+            name = product_data["product"]["name"]
+            output += f"Name: {name}\n"
+            product_version = get_product_version(product_data, version, get_latest_version)
+            output += f"Version: {product_version}\n"
+            if check_if_exists:
+                docs_exists = check_if_product_and_version_exists(product_data, product_version)
+                output += f"API Docs Built: {str(docs_exists)}\n"
+                if docs_exists:
+                    docs_path = get_apidoc_path(product_data["product"], product_version)
+                    output += f"API Docs Path: {docs_path}"
+            print(output)
+if __name__ == "__main__":
+    main(sys.argv[1:])

apidocs.py

@@ -21,13 +21,16 @@
     {
       "name": "IronPDF for Python",
       "code": "ironpdfpython",
+      "packageName": "IronPdf",
       "packageType": "pip",
+      "packageUrl": "https://pypi.org/project/IronPdf/",
       "domain": "ironpdf.com",
       "path": "/python"
     },
     {
       "name": "IronPDF for Node.js",
       "code": "ironpdfnodejs",
+      "packageName": "@ironsoftware/ironpdf",
       "packageType": "npm",
       "domain": "ironpdf.com",
       "path": "/nodejs"
@@ -59,6 +62,15 @@
       "domain": "ironsoftware.com",
       "path": "/csharp/word"
     },
+    {
+      "name": "IronPPT",
+      "code": "ironppt",
+      "packageType": "nuget",
+      "packageName": "IronPPT",
+      "packageUrl": "https://www.nuget.org/packages/IronPPT/",
+      "domain": "ironsoftware.com",
+      "path": "/csharp/ppt"
+    },
     {
       "name": "IronZIP",
       "code": "ironzip",
@@ -77,6 +89,15 @@
       "domain": "ironsoftware.com",
       "path": "/csharp/excel"
     },
+    {
+      "name": "IronXL for Python",
+      "code": "ironxlpython",
+      "packageType": "pip",
+      "packageName": "IronXL",
+      "packageUrl": "https://pypi.org/project/IronXL/",
+      "domain": "ironsoftware.com",
+      "path": "/python/excel"
+    },
     {
       "name": "IronPrint",
       "code": "ironprint",