Monitoring Source Code Project

auth = dmda.DomoAuth(
    domo_instance=os.environ["DOMO_INSTANCE"],
    access_token=os.environ["DOMO_ACCESS_TOKEN"],
)
auth

---

source

DocumentSources

 DocumentSources (auth:mbison.client.core.DomoAuth,
                  documents:List[__main__.DocumentSource]=<factory>,
                  log_dt:datetime.datetime=datetime.datetime(2024, 7, 30,
                  2, 0, 13, 827619))

class SourceCode_Enum:
    """captures metadata about where source came from"""
    CODE_ENGINE = "Code Engine"
    ENTERPRISE_APP = "Enterprise App"


@dataclass
class DocumentSource:
    environment: SourceCode_Enum
    id: str
    name: str
    design_id: str
    design_name: str
    log_dt: dt.datetime
    code: str
    version: str
    last_modified_dt: dt.datetime
    domo_instance: str
    owner: str

    def __eq__(self, other):
        if not self.__class__.__name__ == other.__class__.__name__:
            return False

        return self.id == other.id and self.environment == other.environment

    @classmethod
    def from_codeengine_package_version(
        cls, dce_package: dmce.DomoCodeEngine_Package, log_dt: dt.datetime = None
    ):

        log_dt = log_dt or dt.datetime.now()

        dce_current_version = dce_package.get_current_version()

        # from pprint import pprint
        # pprint({"version": dce_current_version,
        #        "owner" : dce_package.owner})

        owner = None
        try:
            owner = dmdu.DomoUser.get_by_id(
                auth=dce_package.auth, user_id=dce_package.owner
            )

        except dmdu.User_API_Exception as e:
            print(e)

        return cls(
            environment=SourceCode_Enum.CODE_ENGINE,
            id=dce_package.id,
            name=dce_package.name,
            design_id=dce_package.id,
            design_name=dce_package.name,
            log_dt=log_dt,
            code=dce_current_version.code,
            version=dce_current_version.version,
            last_modified_dt=dce_package.updated_on_dt,
            domo_instance=dce_package.auth.domo_instance,
            owner=owner,
        )

    @classmethod
    def from_source_file(
        cls,
        file_path,
        design_id,
        design_name,
        domo_instance: str,
        owner: dmdu.DomoUser,
        log_dt: dt.datetime = None,
        version: str = None,
        last_modified_dt: dt.datetime = None,
    ):

        with open(file_path, "r") as f:
            code = f.read()

        log_dt = log_dt or dt.datetime.now()

        return cls(
            id=file_path,
            name=os.path.split(file_path)[-1],
            design_id=design_id,
            design_name=design_name,
            log_dt=log_dt,
            code=code,
            version=version,
            last_modified_dt=last_modified_dt,
            domo_instance=domo_instance,
            owner=owner,
            environment=SourceCode_Enum.ENTERPRISE_APP,
        )

        # custom_app, design_version, appdb_collection):
        # document["ID"] = custom_app["id"]
        # document["Name"] = custom_app["name"]
        # document["Published Date"] = custom_app["updatedDate"]


@dataclass
class DocumentSources:
    auth: dmda.DomoAuth
    documents: List[DocumentSource] = field(default_factory=lambda: [])

    log_dt: dt.datetime = dt.datetime.now()

    def get_codeengine(self):
        domo_codenegine_packages = dmce.DomoCodeEngine_Packages(
            auth=self.auth
        ).get_packages()

        documents = [
            DocumentSource.from_codeengine_package_version(
                dce_package=dce_package, log_dt=self.log_dt
            )
            for dce_package in domo_codenegine_packages
        ]

        [self.add_document(document) for document in documents]

        return self.documents

    @staticmethod
    def _download_custom_app_sourcecode(app, download_folder, debug_api: bool = False):
            zip_name = "_package.zip"
            _download_folder = f"{download_folder}/{app.name}/{app.current_version}"

            try:
                res = app.get_source_code(download_folder=_download_folder, file_name=zip_name, debug_api = debug_api)
                
                zip_file_path=os.path.join(
                        _download_folder, zip_name
                    )
                
                path_ls = dmut.download_zip(
                    output_folder=_download_folder,
                    zip_file_path=zip_file_path,
                )

                res.response = path_ls

                return res
            
            except dmap.App_API_Exception as e:
                print(e)
                return False


    def get_custom_apps(self, download_folder="./EXPORT", debug_api : bool = False):
        domo_apps = dmap.DomoEnterpriseApps(auth=self.auth).get_apps()

        return [self._download_custom_app_sourcecode(app = app, download_folder = download_folder, debug_api = debug_api) for app in domo_apps]            


    def add_document(self, document: DocumentSource):
        if document in self.documents:
            return False

        self.documents.append(document)
        return True

---

source

DocumentSource

 DocumentSource (environment:__main__.SourceCode_Enum, id:str, name:str,
                 design_id:str, design_name:str, log_dt:datetime.datetime,
                 code:str, version:str,
                 last_modified_dt:datetime.datetime, domo_instance:str,
                 owner:str)

---

source

SourceCode_Enum

 SourceCode_Enum ()

captures metadata about where source came from

document_sources = DocumentSources(auth= auth)

res_ls = document_sources.get_custom_apps(download_folder= '../../TEST/' ,debug_api = False)
[res for res in res_ls if res ][0:5]

document_sources = DocumentSources(auth= auth)

document_sources.get_codeengine()

document_sources.documents[0]

document_sources.documents[0].__dict__