codexctl 0.1.0__py3-none-any.whl

codexctl/server.py

@@ -0,0 +1,172 @@
+from http.server import HTTPServer, SimpleHTTPRequestHandler
+import xml.etree.ElementTree as ET
+import os
+import hashlib
+import binascii
+
+response_ok = """<?xml version='1.0' encoding='UTF-8'?>
+<response protocol="3.0" server="prod">
+	<daystart elapsed_seconds="42548" elapsed_days="5179"/>
+	<app status="ok" appid="{98DA7DF2-4E3E-4744-9DE6-EC931886ABAB}">
+		<event status="ok"/>
+		<ping status="ok"/>
+	</app>
+</response>
+"""
+
+response_template = """<?xml version="1.0" encoding="UTF-8"?>
+ <response protocol="3.0" server="prod">
+	<daystart elapsed_seconds="37145" elapsed_days="5179"/>
+	<app status="ok" appid="{{98DA7DF2-4E3E-4744-9DE6-EC931886ABAB}}">
+		<event status="ok"/>
+		<updatecheck status="ok">
+			<urls>
+				<url codebase="{codebase_url}"/>
+			</urls>
+			<manifest version="{version}">
+				<packages>
+					<package required="true" hash="{update_sha1}" name="{update_name}" size="{update_size}"/>
+				</packages>
+				<actions>
+					<action successsaction="default" sha256="{update_sha256}" event="postinstall" DisablePayloadBackoff="true"/>
+				</actions>
+			</manifest>
+		</updatecheck>
+		<ping status="ok"/>
+	</app>
+</response>
+"""
+
+
+def getupdateinfo(platform, version, update_name):
+    full_path = os.path.join("updates", update_name)
+
+    update_size = str(os.path.getsize(full_path))
+
+    BUF_SIZE = 8192
+
+    sha1 = hashlib.sha1()
+    sha256 = hashlib.sha256()
+    with open(full_path, "rb") as f:
+        while True:
+            data = f.read(BUF_SIZE)
+            if not data:
+                break
+            sha1.update(data)
+            sha256.update(data)
+    update_sha1 = binascii.b2a_base64(sha1.digest(), newline=False).decode()
+    update_sha256 = binascii.b2a_base64(sha256.digest(), newline=False).decode()
+    return (update_sha1, update_sha256, update_size)
+
+
+def get_available_version(version):
+    available_versions = scanUpdates()
+
+    for device, ids in available_versions.items():
+        if version in ids:
+            available_version = {device: ids}
+
+            return available_version
+
+
+def scanUpdates():
+    files = os.listdir("updates")
+    versions = {}
+
+    for f in files:
+        p = f.split("_")
+        if len(p) != 2:
+            continue
+        t = p[1].split(".")
+        if len(t) != 2:
+            continue
+
+        z = t[0].split("-")
+
+        version = p[0]
+        # print(version)
+        product = z[0]
+
+        if product not in versions or versions[product][0] < version:
+            versions[product] = (version, f)
+
+    return versions
+
+
+class MySimpleHTTPRequestHandler(SimpleHTTPRequestHandler):
+    def do_POST(self):
+        length = int(self.headers.get("Content-Length"))
+        body = self.rfile.read(length).decode("utf-8")
+        # print(body)
+        print("Updating...")
+        xml = ET.fromstring(body)
+        updatecheck_node = xml.find("app/updatecheck")
+
+        # check for update
+        if updatecheck_node is not None:
+            version = xml.attrib["version"]
+            platform = xml.find("os").attrib["platform"]
+            print("requested: ", version)
+            print("platform: ", platform)
+
+            version, update_name = available_versions[platform]
+
+            update_sha1, update_sha256, update_size = getupdateinfo(
+                platform, version, update_name
+            )
+            params = {
+                "version": version,
+                "update_name": f"updates/{update_name}",
+                "update_sha1": update_sha1,
+                "update_sha256": update_sha256,
+                "update_size": update_size,
+                "codebase_url": host_url,
+            }
+
+            response = response_template.format(**params)
+            # print("Response:")
+            # print(response)
+            self.send_response(200)
+            self.end_headers()
+            self.wfile.write(response.encode())
+            return
+
+        event_node = xml.find("app/event")
+        event_type = int(event_node.attrib["eventtype"])
+        event_result = int(event_node.attrib["eventresult"])
+
+        # post install status
+        if event_result != 0:
+            print("Update downloaded, please wait for device to install...")
+            if "errorcode" in event_node.attrib:
+                print("With errorcode:", event_node.attrib["errorcode"])
+            return
+
+        # update done
+        if event_type == 14:
+            print("OK Response:")
+            print(response_ok)
+            self.send_response(200)
+            self.end_headers()
+            self.wfile.write(response_ok.encode())
+            return
+
+
+def startUpdate(versionsGiven, host, port=8080):
+    global available_versions
+    global host_url  # I am aware globals are generally bad practice, but this is a quick and dirty solution
+
+    host_url = f"http://{host}:{port}/"
+    available_versions = versionsGiven
+
+    if not available_versions:
+        raise FileNotFoundError("Could not find any update files")
+
+    handler = MySimpleHTTPRequestHandler
+    print(f"Starting fake updater at {host}:{port}")
+    try:
+        httpd = HTTPServer((host, port), handler)
+    except OSError:
+        print("Error: Could not start fake updater. Is the port already in use?")
+        return
+    httpd.serve_forever()

codexctl/sync.py

@@ -0,0 +1,218 @@
+import requests
+import os
+import glob
+
+import logging
+
+
+class RmWebInterfaceAPI:  # TODO: Add docstrings
+    def __init__(self, BASE="http://10.11.99.1/", logger=None):
+        self.logger = logger
+
+        if self.logger is None:
+            self.logger = logging
+
+        self.BASE = BASE
+        self.NAME_ATTRIBUTE = "VissibleName"
+        self.ID_ATTRIBUTE = "ID"
+
+        self.logger.debug(f"Base is: {BASE}")
+
+    def __POST(self, endpoint, data={}, fileUpload=False):
+        try:
+            logging.debug(
+                f"Sending POST request to {self.BASE + endpoint} with data {data}"
+            )
+
+            if fileUpload:
+                result = requests.post(self.BASE + endpoint, files=data)
+            else:
+                result = requests.post(self.BASE + endpoint, data=data)
+
+            if result.status_code == 408:
+                self.logger.error("Request timed out!")
+
+            logging.debug(f"Result headers: {result.headers}")
+            if "application/json" in result.headers["Content-Type"]:
+                return result.json()
+            return result.content
+
+        except Exception:
+            return None
+
+    def __get_documents_recursive(
+        self, folderId="", currentLocation="", currentDocuments=[]
+    ):
+        data = self.__POST(f"documents/{folderId}")
+
+        for item in data:
+            self.logger.debug(f"Checking item: {item}")
+
+            if "fileType" in item:
+                item["location"] = currentLocation
+                currentDocuments.append(item)
+            else:
+                self.logger.debug(
+                    f"Getting documents over {item[self.ID_ATTRIBUTE]}, current location is {currentLocation}/{item[self.NAME_ATTRIBUTE]}"
+                )
+                self.__get_documents_recursive(
+                    item[self.ID_ATTRIBUTE],
+                    f"{currentLocation}/{item[self.NAME_ATTRIBUTE]}",
+                    currentDocuments,
+                )
+
+        return currentDocuments
+
+    def __get_folder_id(self, folderName, _from=""):
+        results = self.__POST(f"documents/{_from}")
+
+        if results is None:
+            return None
+
+        results.reverse()  # We only want folders
+
+        for data in results:
+            self.logger.debug(f"Folder: {data}")
+
+            if "fileType" in data:
+                return None
+
+            if data[self.NAME_ATTRIBUTE].strip() == folderName.strip():
+                return data[self.ID_ATTRIBUTE]
+
+            self.logger.debug(
+                f"Getting folders over {folderName}, {data[self.ID_ATTRIBUTE]}"
+            )
+
+            recursiveResults = self.__get_folder_id(folderName, data[self.ID_ATTRIBUTE])
+            if recursiveResults is None:
+                continue
+            else:
+                return recursiveResults
+
+    def __get_docs(self, folderName="", recursive=True):
+        folderId = ""
+
+        if folderName:
+            folderId = self.__get_folder_id(folderName)
+
+            if folderId is None:
+                return {}
+
+        if recursive:
+            self.logger.debug(f"Calling recursive function on {folderName}")
+            return self.__get_documents_recursive(
+                folderId=folderId, currentLocation=folderName
+            )
+
+        data = self.__POST(f"documents/{folderId}")
+
+        for item in data:
+            item["location"] = ""
+
+        return [item for item in data if "fileType" in item]
+
+    def download(self, document, location="", overwrite=False):
+        filename = document[self.NAME_ATTRIBUTE]
+        if "/" in filename:
+            filename = filename.replace("/", "_")
+
+        self.logger.debug(f"Downloading {filename}, location {location}")
+
+        if not os.path.exists(location):
+            self.logger.debug("Download folder does not exist, creating it")
+            os.makedirs(location)
+
+        try:
+            fileLocation = f"{location}/{filename}.pdf"
+
+            if os.path.isfile(fileLocation) and overwrite is False:
+                self.logger.debug("Not overwriting file")
+                return True
+
+            binaryData = self.__POST(
+                f"download/{document[self.ID_ATTRIBUTE]}/placeholder"
+            )
+
+            if isinstance(binaryData, dict):
+                print(f"Error trying to download {filename}: {binaryData}")
+                return False
+
+            with open(fileLocation, "wb") as outFile:
+                outFile.write(binaryData)
+
+            return True
+
+        except Exception as error:
+            print(f"Error trying to download {filename}: {error}")
+            return False
+
+    def upload(self, input_paths, remoteFolder):
+        folderId = ""
+        if remoteFolder:
+            folderId = self.__get_folder_id(remoteFolder)
+
+            if folderId is None:
+                raise SystemExit(f"Error: Folder {remoteFolder} does not exist!")
+
+        self.__POST(f"documents/{folderId}")  # Setting up for upload...
+
+        errors, documents = [], []
+
+        for document in input_paths:  # This needs improvement...
+            if os.path.isdir(document):
+                for file in glob.glob(f"{document}/*"):
+                    if not file.endswith(".pdf"):
+                        self.logger.error(f"Error: {document} is not a pdf!")
+                    else:
+                        documents.append(file)
+            elif os.path.isfile(document):
+                if not document.endswith(".pdf"):
+                    errors.append(document)
+                    self.logger.error(f"Error: {document} is not a pdf!")
+                else:
+                    documents.append(document)
+            else:
+                errors.append(document)
+                self.logger.error(f"Error: {document} is not a file or directory!")
+
+        for document in documents:
+            self.logger.debug(
+                f"Uploading {document} to {remoteFolder if remoteFolder else 'root'}"
+            )
+            with open(document, "rb") as inFile:
+                response = self.__POST("upload", data={"file": inFile}, fileUpload=True)
+
+                if response is None:
+                    self.logger.error(
+                        f"Error: Unknown error while uploading {document}!"
+                    )
+                    errors.append(document)
+                elif response == {"status": "Upload successful"}:
+                    self.logger.debug(f"Uploaded {document} successfully!")
+
+        if len(errors) > 0:
+            print("The following files failed to upload: " + ",".join(errors))
+
+        print(f"Done! {len(documents)-len(errors)} files were uploaded.")
+
+    def sync(self, localFolder, remoteFolder="", overwrite=False, recursive=True):
+        count = 0
+
+        if not os.path.exists(localFolder):
+            self.logger.debug("Local folder does not exist, creating it")
+            os.mkdir(localFolder)
+
+        documents = self.__get_docs(remoteFolder, recursive)
+
+        if documents == {}:
+            print("No documents were found!")
+
+        else:
+            for doc in documents:
+                self.logger.debug(f"Processing {doc}")
+                count += 1
+                self.download(
+                    doc, f"{localFolder}/{doc['location']}", overwrite=overwrite
+                )
+            print(f"Done! {count} files were exported.")