def validateConfiguration(host,
                          entId,
                          key,
                          prefix="Bearer",
                          maxAttempt=Globals.MAX_RETRY):
    configuration = esperclient.Configuration()
    configuration.host = host
    configuration.api_key["Authorization"] = key
    configuration.api_key_prefix["Authorization"] = prefix

    api_instance = esperclient.EnterpriseApi(
        esperclient.ApiClient(configuration))
    enterprise_id = entId

    try:
        api_response = None
        for attempt in range(maxAttempt):
            try:
                api_response = api_instance.get_enterprise(enterprise_id)
                break
            except Exception as e:
                if attempt == maxAttempt - 1:
                    ApiToolLog().LogError(e)
                    raise e
                time.sleep(Globals.RETRY_SLEEP)
        if hasattr(api_response, "id"):
            return True
    except ApiException as e:
        print("Exception when calling EnterpriseApi->get_enterprise: %s\n" % e)
        ApiToolLog().LogError(e)
    return False
Пример #2
0
def main():
    """Launches Main App"""
    sys.excepthook = ApiToolLog().excepthook
    try:
        Globals.app = MyApp(0)
        Globals.app.MainLoop()
    except Exception as e:
        ApiToolLog().LogError(e)
def toggleKioskMode(
    frame,
    deviceid,
    appToUse,
    isKiosk,
    timeout=Globals.COMMAND_TIMEOUT,
    maxAttempt=Globals.MAX_RETRY,
):
    """Toggles Kiosk Mode On/Off"""
    api_instance = getCommandsApiInstance()
    if isKiosk:
        command_args = esperclient.V0CommandArgs(package_name=appToUse)
    else:
        command_args = {}
    command = esperclient.V0CommandRequest(
        enterprise=Globals.enterprise_id,
        command_type="DEVICE",
        device_type=Globals.CMD_DEVICE_TYPE,
        devices=[deviceid],
        command="SET_KIOSK_APP",
        command_args=command_args,
    )
    api_response = None
    for attempt in range(maxAttempt):
        try:
            api_response = api_instance.create_command(Globals.enterprise_id,
                                                       command)
            break
        except Exception as e:
            if hasattr(e, "body") and "invalid device id" in e.body:
                logBadResponse("create command api", api_response, None)
                return None
            if attempt == maxAttempt - 1:
                ApiToolLog().LogError(e)
                raise e
            time.sleep(Globals.RETRY_SLEEP)
    response = None
    for attempt in range(maxAttempt):
        try:
            response = api_instance.get_command_request_status(
                Globals.enterprise_id, api_response.id)
            break
        except Exception as e:
            if attempt == maxAttempt - 1:
                ApiToolLog().LogError(e)
                raise e
            time.sleep(Globals.RETRY_SLEEP)
    status = response.results[0].state
    ignoreQueued = False if Globals.REACH_QUEUED_ONLY else True
    status = waitForCommandToFinish(frame,
                                    api_response.id,
                                    ignoreQueue=ignoreQueued,
                                    timeout=timeout)
    return status
Пример #4
0
def logPlaceDone(func):
    try:
        if Globals.RECORD_PLACE:
            place = "Finshed "
            currThread = threading.current_thread()
            if func.__name__ and func.__doc__:
                place += str(func.__name__ + "\t:\t" + func.__doc__ + "\t:\t" +
                             currThread.name)
            elif func.__name__:
                place += str(func.__name__ + "\t:\t" + currThread.name)
            ApiToolLog().LogPlace(place)
    except Exception as e:
        ApiToolLog().LogError(e)
def getAllDevices(groupToUse, maxAttempt=Globals.MAX_RETRY):
    """ Make a API call to get all Devices belonging to the Enterprise """
    if not groupToUse:
        return None
    try:
        api_instance = esperclient.DeviceApi(
            esperclient.ApiClient(Globals.configuration))
        api_response = None
        if type(groupToUse) == list:
            for group in groupToUse:
                for attempt in range(maxAttempt):
                    try:
                        response = api_instance.get_all_devices(
                            Globals.enterprise_id,
                            group=group,
                            limit=Globals.limit,
                            offset=Globals.offset,
                        )
                        break
                    except Exception as e:
                        if attempt == maxAttempt - 1:
                            ApiToolLog().LogError(e)
                            raise e
                        time.sleep(Globals.RETRY_SLEEP)
                if not api_response:
                    api_response = response
                else:
                    api_response.results = api_response.results + response.results
        else:
            for attempt in range(maxAttempt):
                try:
                    api_response = api_instance.get_all_devices(
                        Globals.enterprise_id,
                        group=groupToUse,
                        limit=Globals.limit,
                        offset=Globals.offset,
                    )
                    break
                except Exception as e:
                    if attempt == maxAttempt - 1:
                        ApiToolLog().LogError(e)
                        raise e
                    time.sleep(Globals.RETRY_SLEEP)
        postEventToFrame(wxThread.myEVT_LOG,
                         "---> Device API Request Finished")
        return api_response
    except ApiException as e:
        raise Exception(
            "Exception when calling DeviceApi->get_all_devices: %s\n" % e)
def getInstallDevices(version_id,
                      application_id,
                      maxAttempt=Globals.MAX_RETRY):
    api_instance = esperclient.ApplicationApi(
        esperclient.ApiClient(Globals.configuration))
    enterprise_id = Globals.enterprise_id
    for attempt in range(maxAttempt):
        try:
            # List install devices
            api_response = api_instance.get_install_devices(
                version_id,
                application_id,
                enterprise_id,
                limit=Globals.limit,
                offset=Globals.offset,
            )
            return api_response
        except ApiException as e:
            if attempt == maxAttempt - 1:
                ApiToolLog().LogError(e)
                print(
                    "Exception when calling ApplicationApi->get_install_devices: %s\n"
                    % e)
                raise e
            time.sleep(1)
def getAppVersions(application_id,
                   version_code="",
                   build_number="",
                   maxAttempt=Globals.MAX_RETRY):
    api_instance = esperclient.ApplicationApi(
        esperclient.ApiClient(Globals.configuration))
    enterprise_id = Globals.enterprise_id
    for attempt in range(maxAttempt):
        try:
            api_response = api_instance.get_app_versions(
                application_id,
                enterprise_id,
                version_code=version_code,
                build_number=build_number,
                limit=Globals.limit,
                offset=Globals.offset,
            )
            return api_response
        except Exception as e:
            if attempt == maxAttempt - 1:
                ApiToolLog().LogError(e)
                print(
                    "Exception when calling ApplicationApi->get_app_versions: %s\n"
                    % e)
                raise e
            time.sleep(1)
def postEsperCommand(command_data, useV0=True):
    json_resp = None
    resp = None
    try:
        headers = getHeader()
        url = ""
        if useV0:
            url = "https://%s-api.esper.cloud/api/v0/enterprise/%s/command/" % (
                Globals.configuration.host.split("-api")[0].replace(
                    "https://", ""),
                Globals.enterprise_id,
            )
        else:
            url = "https://%s-api.esper.cloud/api/enterprise/%s/command/" % (
                Globals.configuration.host.split("-api")[0].replace(
                    "https://", ""),
                Globals.enterprise_id,
            )
        resp = performPostRequestWithRetry(url,
                                           headers=headers,
                                           json=command_data)
        json_resp = resp.json()
        logBadResponse(url, resp, json_resp)
    except Exception as e:
        ApiToolLog().LogError(e)
    return resp, json_resp
Пример #9
0
    def uploadMissingApk(self, app, template, newTemplate, config, entId):
        try:
            postEventToFrame(
                wxThread.myEVT_LOG,
                "Attempting to download %s to upload to endpoint" %
                app["packageName"],
            )
            file = "%s.apk" % app["applicationName"]
            deleteFile(file)
            download(app["downloadUrl"], file)
            res = uploadApplicationForHost(config, entId, file)
            if type(res) != InlineResponse201:
                deleteFile(file)
                raise Exception("Upload failed!")
            deleteFile(file)

            if template["template"]["application"]["startOnBoot"] == app[
                    "packageName"]:
                newTemplate["application"]["appMode"] = template["template"][
                    "application"]["appMode"]
                newTemplate["application"]["startOnBoot"] = template[
                    "template"]["application"]["startOnBoot"]
        except Exception as e:
            print(e)
            ApiToolLog().LogError(e)
            postEventToFrame(
                wxThread.myEVT_LOG,
                "To Enterprise is missing app, %s, not adding to template" %
                app["applicationName"],
            )
            self.missingApps += str(app["applicationName"]) + ", "
def getAllApplicationsForHost(config,
                              enterprise_id,
                              maxAttempt=Globals.MAX_RETRY):
    """ Make a API call to get all Applications belonging to the Enterprise """
    try:
        api_instance = esperclient.ApplicationApi(
            esperclient.ApiClient(config))
        api_response = None
        for attempt in range(maxAttempt):
            try:
                api_response = api_instance.get_all_applications(
                    enterprise_id,
                    limit=Globals.limit,
                    offset=0,
                    is_hidden=False,
                )
                break
            except Exception as e:
                if attempt == maxAttempt - 1:
                    ApiToolLog().LogError(e)
                    raise e
                time.sleep(Globals.RETRY_SLEEP)
        return api_response
    except Exception as e:
        raise Exception(
            "Exception when calling ApplicationApi->get_all_applications: %s\n"
            % e)
Пример #11
0
def downloadFileFromUrl(url,
                        fileName,
                        filepath="",
                        redirects=True,
                        chunk_size=1024):
    if not filepath:
        filepath = str(os.path.join(Path.home(), "Downloads"))
    fullPath = os.path.join(filepath, fileName)
    num = 1
    while os.path.exists(fullPath):
        parts = fileName.split(".")
        parts.insert(1, (" (%s)" % num))
        parts[len(parts) - 1] = ".%s" % parts[len(parts) - 1]
        tmpFileName = "".join(parts)
        fullPath = os.path.join(filepath, tmpFileName)
        num += 1
    parentPath = os.path.abspath(os.path.join(fullPath, os.pardir))
    if not os.path.exists(parentPath):
        os.makedirs(parentPath)
    try:
        r = requests.get(url, stream=True, allow_redirects=redirects)
        with open(fullPath, "wb") as file:
            for chunk in r.iter_content(chunk_size=chunk_size):
                if chunk:
                    file.write(chunk)
        return fullPath
    except Exception as e:
        print(e)
        ApiToolLog().LogError(e)
    return None
def getAllApplications(maxAttempt=Globals.MAX_RETRY):
    """ Make a API call to get all Applications belonging to the Enterprise """
    try:
        api_instance = esperclient.ApplicationApi(
            esperclient.ApiClient(Globals.configuration))
        api_response = None
        for attempt in range(maxAttempt):
            try:
                api_response = api_instance.get_all_applications(
                    Globals.enterprise_id,
                    limit=Globals.limit,
                    offset=Globals.offset,
                    is_hidden=False,
                )
                break
            except Exception as e:
                if attempt == maxAttempt - 1:
                    ApiToolLog().LogError(e)
                    raise e
                time.sleep(Globals.RETRY_SLEEP)
        postEventToFrame(wxThread.myEVT_LOG, "---> App API Request Finished")
        return api_response
    except ApiException as e:
        raise Exception(
            "Exception when calling ApplicationApi->get_all_applications: %s\n"
            % e)
Пример #13
0
 def updateCheck(self):
     icon = wx.ICON_INFORMATION
     msg = ""
     json = None
     try:
         json = checkForUpdate()
     except Exception as e:
         print(e)
         ApiToolLog().LogError(e)
     if json:
         tagVersion = json["tag_name"].replace("v", "")
         if float(tagVersion) > float(Globals.VERSION.replace("v", "")):
             downloadURL = ""
             name = ""
             assets = json["assets"]
             for asset in assets:
                 name = asset["name"]
                 if "win" in name.lower() and self.WINDOWS:
                     downloadURL = asset["browser_download_url"]
                     break
                 elif "mac" in name.lower() and not self.WINDOWS:
                     downloadURL = asset["browser_download_url"]
                     break
             if downloadURL:
                 result = None
                 try:
                     result = downloadFileFromUrl(downloadURL, name)
                 except Exception as e:
                     print(e)
                     ApiToolLog().LogError(e)
                 if result:
                     msg = (
                         "Download Succeeded! File should be located at:\n\n%s\nPlease open the executable from the download!"
                         % result)
                 else:
                     icon = wx.ICON_ERROR
                     msg = "An error occured while downloading the update. Please try again later."
         else:
             msg = "You are up-to-date!"
     else:
         icon = wx.ICON_ERROR
         msg = (
             "An error occured while downloading the update. Please try again later."
         )
     wx.MessageBox(msg, style=icon)
     self.isCheckingForUpdates = False
def setAppState(device_id,
                pkg_name,
                appVer=None,
                state="HIDE",
                maxAttempt=Globals.MAX_RETRY):
    pkgName = pkg_name
    if not appVer:
        _, app = getdeviceapps(device_id,
                               createAppList=False,
                               useEnterprise=Globals.USE_ENTERPRISE_APP)
        if app["results"] and "application" in app["results"][0]:
            app = list(
                filter(
                    lambda x: x["application"]["package_name"] == pkg_name,
                    app["results"],
                ))
        else:
            app = list(
                filter(
                    lambda x: x["package_name"] == pkg_name,
                    app["results"],
                ))
        if app:
            app = app[0]
        if "application" in app:
            appVer = app["application"]["version"]["version_code"]
        elif "version_code" in app:
            appVer = app["version_code"]
    if pkgName and appVer:
        args = V0CommandArgs(
            app_state=state,
            app_version=appVer,
            package_name=pkgName,
        )
        args.version_code = appVer
        request = esperclient.V0CommandRequest(
            enterprise=Globals.enterprise_id,
            command_type="DEVICE",
            device_type=Globals.CMD_DEVICE_TYPE,
            devices=[device_id],
            command="SET_APP_STATE",
            command_args=args,
        )
        api_instance = getCommandsApiInstance()
        for attempt in range(maxAttempt):
            try:
                api_response = api_instance.create_command(
                    Globals.enterprise_id, request)
                break
            except Exception as e:
                if attempt == maxAttempt - 1:
                    ApiToolLog().LogError(e)
                    raise e
                time.sleep(1)
        ignoreQueued = False if Globals.REACH_QUEUED_ONLY else True
        return waitForCommandToFinish(Globals.frame,
                                      api_response.id,
                                      ignoreQueue=ignoreQueued)
Пример #15
0
def deleteFile(file):
    try:
        if os.path.exists(file):
            os.remove(file)
            return True
    except Exception as e:
        print(e)
        ApiToolLog().LogError(e)
    return False
def getTokenInfo(maxAttempt=Globals.MAX_RETRY):
    api_instance = esperclient.TokenApi(
        esperclient.ApiClient(Globals.configuration))
    try:
        api_response = None
        for attempt in range(maxAttempt):
            try:
                api_response = api_instance.get_token_info()
                break
            except Exception as e:
                if attempt == maxAttempt - 1:
                    ApiToolLog().LogError(e)
                    raise e
                time.sleep(Globals.RETRY_SLEEP)
        return api_response
    except ApiException as e:
        print("Exception when calling TokenApi->get_token_info: %s\n" % e)
        ApiToolLog().LogError(e)
Пример #17
0
def postEventToFrame(eventType, eventValue=None):
    """ Post an Event to the Main Thread """
    if eventType:
        try:
            evt = wxThread.CustomEvent(eventType, -1, eventValue)
            if Globals.frame:
                wx.PostEvent(Globals.frame, evt)
        except Exception as e:
            ApiToolLog().LogError(e)
def setdevicename(
    frame,
    deviceid,
    devicename,
    ignoreQueue,
    timeout=Globals.COMMAND_TIMEOUT,
    maxAttempt=Globals.MAX_RETRY,
):
    """Pushes New Name To Name"""
    api_instance = getCommandsApiInstance()
    args = esperclient.V0CommandArgs(device_alias_name=devicename)
    command = esperclient.V0CommandRequest(
        command_type="DEVICE",
        devices=[deviceid],
        command="UPDATE_DEVICE_CONFIG",
        command_args=args,
        device_type=Globals.CMD_DEVICE_TYPE,
    )
    api_response = None
    for attempt in range(maxAttempt):
        try:
            api_response = api_instance.create_command(Globals.enterprise_id,
                                                       command)
            break
        except Exception as e:
            if attempt == maxAttempt - 1:
                ApiToolLog().LogError(e)
                raise e
            time.sleep(Globals.RETRY_SLEEP)
    response = None
    for attempt in range(maxAttempt):
        try:
            response = api_instance.get_command_request_status(
                Globals.enterprise_id, api_response.id)
            break
        except Exception as e:
            if attempt == maxAttempt - 1:
                ApiToolLog().LogError(e)
                raise e
            time.sleep(Globals.RETRY_SLEEP)
    status = response.results[0].state
    status = waitForCommandToFinish(frame, api_response.id, ignoreQueue,
                                    timeout)
    return status
def getDeviceById(deviceToUse, maxAttempt=Globals.MAX_RETRY):
    """ Make a API call to get a Device belonging to the Enterprise by its Id """
    try:
        api_instance = esperclient.DeviceApi(
            esperclient.ApiClient(Globals.configuration))
        api_response_list = []
        api_response = None
        if type(deviceToUse) == list:
            for device in deviceToUse:
                for attempt in range(maxAttempt):
                    try:
                        api_response = api_instance.get_device_by_id(
                            Globals.enterprise_id, device_id=device)
                        break
                    except Exception as e:
                        if attempt == maxAttempt - 1:
                            ApiToolLog().LogError(e)
                            raise e
                        time.sleep(Globals.RETRY_SLEEP)
                if api_response:
                    api_response_list.append(api_response)
        else:
            for attempt in range(maxAttempt):
                try:
                    api_response = api_instance.get_device_by_id(
                        Globals.enterprise_id, device_id=deviceToUse)
                    break
                except Exception as e:
                    if attempt == maxAttempt - 1:
                        ApiToolLog().LogError(e)
                        raise e
                    time.sleep(Globals.RETRY_SLEEP)
        if api_response and api_response_list:
            api_response.results = api_response_list
        elif api_response:
            api_response.results = [api_response]
        postEventToFrame(wxThread.myEVT_LOG,
                         "---> Device API Request Finished")
        return api_response
    except ApiException as e:
        print("Exception when calling DeviceApi->get_device_by_id: %s\n" % e)
        ApiToolLog().LogError(e)
def setAppStateForAllAppsListed(state, maxAttempt=Globals.MAX_RETRY):
    api_instance = esperclient.DeviceApi(
        esperclient.ApiClient(Globals.configuration))
    api_response = None
    for attempt in range(maxAttempt):
        try:
            api_response = api_instance.get_all_devices(
                Globals.enterprise_id,
                limit=Globals.limit,
                offset=Globals.offset,
            )
            break
        except Exception as e:
            if attempt == maxAttempt - 1:
                postEventToFrame(
                    wxThread.myEVT_LOG,
                    "---> ERROR: Failed to get devices ids to modify tags and aliases",
                )
                print(e)
                ApiToolLog().LogError(e)
                return
            time.sleep(Globals.RETRY_SLEEP)

    deviceIdentifers = Globals.frame.gridPanel.getDeviceIdentifersFromGrid()
    if api_response:
        tempRes = []
        for device in api_response.results:
            for deviceIds in deviceIdentifers:
                if (device.device_name in deviceIds
                        or device.hardware_info["serialNumber"] in deviceIds):
                    tempRes.append(device)
        if tempRes:
            api_response.results = tempRes
        threads = []
        for device in api_response.results:
            if (device.device_name in deviceIdentifers or
                    device.hardware_info["serialNumber"] in deviceIdentifers):
                t = wxThread.GUIThread(
                    Globals.frame,
                    setAllAppsState,
                    args=(Globals.frame, device, state),
                    name="setAllAppsState",
                )
                threads.append(t)
                t.start()
                limitActiveThreads(threads)
        t = wxThread.GUIThread(
            Globals.frame,
            waitTillThreadsFinish,
            args=(tuple(threads), state, -1, 4),
            name="waitTillThreadsFinish%s" % state,
        )
        t.start()
Пример #21
0
def download(url, file_name, overwrite=True):
    try:
        if os.path.exists(file_name) and overwrite:
            os.remove(file_name)
    except Exception as e:
        print(e)
        ApiToolLog().LogError(e)
    # open in binary mode
    with open(file_name, "wb") as file:
        # get request
        response = requests.get(url)
        # write to file
        file.write(response.content)
def fetchGroupName(groupURL):
    headers = getHeader()
    resp = performGetRequestWithRetry(groupURL, headers=headers)
    try:
        if resp.status_code < 300:
            json_resp = resp.json()
            logBadResponse(groupURL, resp, json_resp)

            if "name" in json_resp:
                return json_resp["name"]
    except Exception as e:
        ApiToolLog().LogError(e)
        logBadResponse(groupURL, resp, None)
    return None
def clearAppData(frame, device):
    json_resp = None
    try:
        appToUse = frame.sidePanel.appChoice.GetClientData(
            frame.sidePanel.appChoice.GetSelection())
        _, apps = getdeviceapps(device.id,
                                createAppList=False,
                                useEnterprise=Globals.USE_ENTERPRISE_APP)
        cmdArgs = {}
        for app in apps["results"]:
            if app["package_name"] == appToUse:
                cmdArgs["package_name"] = app["package_name"]
                cmdArgs["application_name"] = app["app_name"]
                cmdArgs["version_code"] = app["version_code"]
                cmdArgs["version_name"] = app["version_name"]
                if app["app_type"] == "GOOGLE":
                    cmdArgs["is_g_play"] = True
                else:
                    cmdArgs["is_g_play"] = False
                break

        if cmdArgs:
            reqData = {
                "command_type": "DEVICE",
                "command_args": cmdArgs,
                "devices": [device.id],
                "groups": [],
                "device_type": Globals.CMD_DEVICE_TYPE,
                "command": "CLEAR_APP_DATA",
            }
            resp, json_resp = postEsperCommand(reqData)
            logBadResponse(resp.request.url, resp, json_resp)
            if resp.status_code > 300:
                postEventToFrame(wxThread.myEVT_ON_FAILED, device)
            if resp.status_code < 300:
                frame.Logging(
                    "---> Clear %s App Data Command has been sent to %s" %
                    (cmdArgs["application_name"], device.device_name))
        else:
            frame.Logging(
                "ERROR: Failed to send Clear %s App Data Command to %s" %
                (frame.sidePanel.appChoice.GetValue(), device.device_name))
    except Exception as e:
        ApiToolLog().LogError(e)
        frame.Logging("ERROR: Failed to send Clear App Data Command to %s" %
                      (device.device_name))
        postEventToFrame(wxThread.myEVT_ON_FAILED, device)
    return json_resp
Пример #24
0
def performDeleteRequestWithRetry(url,
                                  headers=None,
                                  json=None,
                                  data=None,
                                  maxRetry=Globals.MAX_RETRY):
    resp = None
    for attempt in range(maxRetry):
        try:
            resp = requests.delete(url, headers=headers, data=data, json=json)
            if resp.status_code < 300:
                break
        except Exception as e:
            if attempt == maxRetry - 1:
                ApiToolLog().LogError(e)
            time.sleep(Globals.RETRY_SLEEP)
    return resp
def getDeviceApplicationById(device_id, application_id):
    try:
        headers = getHeader()
        url = "https://%s-api.esper.cloud/api/enterprise/%s/device/%s/app/%s" % (
            Globals.configuration.host.split("-api")[0].replace(
                "https://", ""),
            Globals.enterprise_id,
            device_id,
            application_id,
        )
        resp = performGetRequestWithRetry(url, headers=headers)
        json_resp = resp.json()
        logBadResponse(url, resp, json_resp)
    except Exception as e:
        ApiToolLog().LogError(e)
    return resp, json_resp
def processDevices(chunk, number_of_devices, action, isUpdate=False):
    """ Try to obtain more device info for a given device """
    deviceList = {}
    for device in chunk:
        try:
            number_of_devices = number_of_devices + 1
            deviceInfo = {}
            deviceInfo.update({"num": number_of_devices})
            deviceInfo = populateDeviceInfoDictionary(device, deviceInfo)

            deviceList[number_of_devices] = [device, deviceInfo]
            # if deviceInfo not in Globals.GRID_DEVICE_INFO_LIST:
            #    Globals.GRID_DEVICE_INFO_LIST.append(deviceInfo)
        except Exception as e:
            print(e)
            ApiToolLog().LogError(e)
    return (action, deviceList)
def fillInDeviceInfoDict(chunk, number_of_devices, maxGauge):
    deviceList = {}
    for device in chunk:
        try:
            deviceInfo = {}
            deviceInfo = populateDeviceInfoDictionary(device, deviceInfo)

            deviceList[number_of_devices] = [device, deviceInfo]
            number_of_devices += 1
            Globals.deviceInfo_lock.acquire()
            value = int(Globals.frame.gauge.GetValue() + 1 / maxGauge * 100)
            Globals.frame.setGaugeValue(value)
            Globals.deviceInfo_lock.release()
        except Exception as e:
            print(e)
            ApiToolLog().LogError(e)
    return deviceList
def executeCommandOnDevice(
    frame,
    command_args,
    schedule=None,
    schedule_type="IMMEDIATE",
    command_type="UPDATE_DEVICE_CONFIG",
    maxAttempt=Globals.MAX_RETRY,
):
    """ Execute a Command on a Device """
    statusList = []
    for deviceToUse in frame.sidePanel.selectedDevicesList:
        request = esperclient.V0CommandRequest(
            enterprise=Globals.enterprise_id,
            command_type="DEVICE",
            device_type=Globals.CMD_DEVICE_TYPE,
            devices=[deviceToUse],
            command=command_type,
            command_args=command_args,
            schedule="IMMEDIATE"
            if command_type != "UPDATE_LATEST_DPC" else "WINDOW",
            schedule_args=schedule,
        )
        api_instance = getCommandsApiInstance()
        api_response = None
        for attempt in range(maxAttempt):
            try:
                api_response = api_instance.create_command(
                    Globals.enterprise_id, request)
                break
            except Exception as e:
                if attempt == maxAttempt - 1:
                    ApiToolLog().LogError(e)
                    raise e
                time.sleep(Globals.RETRY_SLEEP)
        ignoreQueued = False if Globals.REACH_QUEUED_ONLY else True
        last_status = waitForCommandToFinish(frame,
                                             api_response.id,
                                             ignoreQueue=ignoreQueued)
        if hasattr(last_status, "state"):
            entry = {"Device": deviceToUse, "status": last_status.state}
            if hasattr(last_status, "reason"):
                entry["Reason"] = last_status.reason
            statusList.append(entry)
        else:
            statusList.append({"Device": deviceToUse, "Status": last_status})
    return statusList
def changeAliasForDevice(device, aliasDic, frame, maxGaugeAction):
    numNewName = 0
    succeeded = 0
    logString = ""
    # Alias modification
    if (device.device_name in aliasDic.keys()
            or device.hardware_info["serialNumber"] in aliasDic.keys()):
        newName = None
        if device.device_name in aliasDic:
            newName = aliasDic[device.device_name]
        else:
            newName = aliasDic[device.hardware_info["serialNumber"]]
        logString = str("--->" + str(device.device_name) + " : " +
                        str(newName) + "--->")
        if not newName and not device.alias_name:
            return
        if newName != str(device.alias_name):
            numNewName += 1
            status = ""
            try:
                ignoreQueued = False if Globals.REACH_QUEUED_ONLY else True
                status = apiCalls.setdevicename(frame, device.id, newName,
                                                ignoreQueued)
            except Exception as e:
                ApiToolLog().LogError(e)
            if "Success" in str(status):
                logString = logString + " <success>"
                succeeded += 1
            elif "Queued" in str(status):
                logString = logString + " <Queued> Make sure device is online."
                postEventToFrame(wxThread.myEVT_ON_FAILED, (device, "Queued"))
            else:
                logString = logString + " <failed>"
                postEventToFrame(wxThread.myEVT_ON_FAILED, device)
        else:
            logString = logString + " (Alias Name already set)"
        if "Success" in logString or "Queued" in logString:
            postEventToFrame(wxThread.myEVT_UPDATE_GRID_CONTENT,
                             (device, "alias"))
        postEventToFrame(
            wxThread.myEVT_UPDATE_GAUGE,
            int(frame.gauge.GetValue() + 1 / maxGaugeAction * 100),
        )
        postEventToFrame(wxThread.myEVT_LOG, logString)
    return (numNewName, succeeded)
def getAppVersion(version_id, application_id, maxAttempt=Globals.MAX_RETRY):
    api_instance = esperclient.ApplicationApi(
        esperclient.ApiClient(Globals.configuration))
    enterprise_id = Globals.enterprise_id
    for attempt in range(maxAttempt):
        try:
            # Get app version information
            api_response = api_instance.get_app_version(
                version_id, application_id, enterprise_id)
            return api_response
        except ApiException as e:
            if attempt == maxAttempt - 1:
                ApiToolLog().LogError(e)
                print(
                    "Exception when calling ApplicationApi->get_app_version: %s\n"
                    % e)
                raise e
            time.sleep(1)