async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool: """Set up config entry.""" if CONF_TOKEN not in entry.data: raise ConfigEntryAuthFailed implementation = ( await config_entry_oauth2_flow.async_get_config_entry_implementation( hass, entry)) session = config_entry_oauth2_flow.OAuth2Session(hass, entry, implementation) neato_session = api.ConfigEntryAuth(hass, entry, session) hass.data[NEATO_DOMAIN][entry.entry_id] = neato_session hub = NeatoHub(hass, Account(neato_session)) try: await hass.async_add_executor_job(hub.update_robots) except NeatoException as ex: _LOGGER.debug("Failed to connect to Neato API") raise ConfigEntryNotReady from ex hass.data[NEATO_LOGIN] = hub hass.config_entries.async_setup_platforms(entry, PLATFORMS) return True
def login(email, password, vendor): if (vendor == "Neato"): v = Neato() elif (vendor == "Vorwerk"): v = Vorwerk() try: account = Account(email, password, v) if (account is None): # failed login pyotherside.send("loginrequired") r_json = { "vendor": vendor, "token": account.access_token, "robots": [] } for robot in account.robots: r_json["robots"].append({ "name": robot.name, "serial": robot.serial, "secret": robot.secret }) with open(CACHE_FILE, "w") as write_file: json.dump(r_json, write_file) init() except requests.exceptions.HTTPError as e: # Whoops it wasn't a 200 pyotherside.send("loginrequired")
def init(): if not os.path.exists(CACHE_DIR): pyotherside.send("loginrequired") os.makedirs(CACHE_DIR) return if not os.path.exists(CACHE_FILE): pyotherside.send("loginrequired") return with open(CACHE_FILE, "r") as read_file: global account global robots global vendor robots = json.load(read_file) if (robots["vendor"] == "Neato"): vendor = Neato() elif (robots["vendor"] == "Vorwerk"): vendor = Vorwerk() account = Account(robots["token"], None, vendor) for r in robots["robots"]: pyotherside.send("rfound", r["name"]) pyotherside.send("loginsuccessful")
def onStart(self): # List all robots associated with account botvacSession = PasswordSession(email=Parameters['Username'], password=Parameters['Password'], vendor=Neato()) botvacAccount = Account(botvacSession).robots botvacDevice = next((botvac for botvac in botvacAccount if botvac.name == Parameters["Mode3"]), None) if botvacDevice is None: Domoticz.Log("No robot found") else: self.DEVICE_NAME = botvacDevice.name self.DEVICE_SERIAL = botvacDevice.serial self.API_SECRET = botvacDevice.secret if Parameters["Mode4"] == "Debug": Domoticz.Debugging(1) DumpConfigToLog() #if (self.iconName not in Images): Domoticz.Image('icons.zip').Create() #iconID = Images[self.iconName].ID # Check if images are in database if self.iconName not in Images: Domoticz.Image("icons.zip").Create() try: iconID = Images[self.iconName].ID except: iconID = 0 Domoticz.Debug("Image created. ID: " + str(iconID)) if self.statusUnit not in Devices: Domoticz.Device(Name='Status', Unit=self.statusUnit, Type=17, Switchtype=17, Image=iconID, Used=1).Create() if self.controlUnit not in Devices: Domoticz.Device(Name='Control', Unit=self.controlUnit, TypeName='Selector Switch', Image=iconID, Options=self.controlOptions, Used=1).Create() if self.scheduleUnit not in Devices: Domoticz.Device(Name='Schedule', Unit=self.scheduleUnit, TypeName='Switch', Image=iconID, Used=1).Create() self.botvacGetValues() Domoticz.Heartbeat(self.heartbeatsInterval) Domoticz.Debug("onStart called")
def setup_platform(hass, config, add_devices, discovery_info=None): """Setup the Neato platform.""" from pybotvac import Account try: auth = Account(config[CONF_USERNAME], config[CONF_PASSWORD]) except HTTPError: _LOGGER.error("Unable to connect to Neato API") return False dev = [] for robot in auth.robots: for type_name in SWITCH_TYPES: dev.append(NeatoConnectedSwitch(robot, type_name)) add_devices(dev)
def try_login(username, password, vendor): """Try logging in to device and return any errors.""" this_vendor = None if vendor == "vorwerk": this_vendor = Vorwerk() else: # Neato this_vendor = Neato() try: Account(username, password, this_vendor) except NeatoLoginException: return "invalid_credentials" except NeatoRobotException: return "unexpected_error" return None
def init(): if not os.path.exists(CACHE_DIR): pyotherside.send("loginrequired") os.makedirs(CACHE_DIR) return if not os.path.exists(CACHE_FILE): pyotherside.send("loginrequired") return with open(CACHE_FILE, "r") as read_file: global account global robots robots = json.load(read_file) account = Account(robots["token"]) for r in robots["robots"]: pyotherside.send("rfound", r["name"]) pyotherside.send("loginsuccessful")
async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool: """Set up config entry.""" if CONF_TOKEN not in entry.data: raise ConfigEntryAuthFailed implementation = ( await config_entry_oauth2_flow.async_get_config_entry_implementation( hass, entry)) session = config_entry_oauth2_flow.OAuth2Session(hass, entry, implementation) try: await session.async_ensure_token_valid() except aiohttp.ClientResponseError as ex: _LOGGER.debug("API error: %s (%s)", ex.code, ex.message) if ex.code in (401, 403): raise ConfigEntryAuthFailed( "Token not valid, trigger renewal") from ex raise ConfigEntryNotReady from ex neato_session = api.ConfigEntryAuth(hass, entry, implementation) hass.data[NEATO_DOMAIN][entry.entry_id] = neato_session hub = NeatoHub(hass, Account(neato_session)) await hub.async_update_entry_unique_id(entry) try: await hass.async_add_executor_job(hub.update_robots) except NeatoException as ex: _LOGGER.debug("Failed to connect to Neato API") raise ConfigEntryNotReady from ex hass.data[NEATO_LOGIN] = hub hass.config_entries.async_setup_platforms(entry, PLATFORMS) return True
async def async_setup_entry(hass: HomeAssistantType, entry: ConfigEntry) -> bool: """Set up config entry.""" if CONF_TOKEN not in entry.data: # Init reauth flow hass.async_create_task( hass.config_entries.flow.async_init( NEATO_DOMAIN, context={CONF_SOURCE: SOURCE_REAUTH}, )) return False implementation = ( await config_entry_oauth2_flow.async_get_config_entry_implementation( hass, entry)) session = config_entry_oauth2_flow.OAuth2Session(hass, entry, implementation) neato_session = api.ConfigEntryAuth(hass, entry, session) hass.data[NEATO_DOMAIN][entry.entry_id] = neato_session hub = NeatoHub(hass, Account(neato_session)) try: await hass.async_add_executor_job(hub.update_robots) except NeatoException as ex: _LOGGER.debug("Failed to connect to Neato API") raise ConfigEntryNotReady from ex hass.data[NEATO_LOGIN] = hub for component in PLATFORMS: hass.async_create_task( hass.config_entries.async_forward_entry_setup(entry, component)) return True
def updateAccount(self): self.connected = False email = self.pluginPrefs.get('email', '') password = self.pluginPrefs.get('password', '') if email and password: try: self.account = Account(email, password) robots = self.account.robots self.connected = True self.logger.info(u'Neato account updated') if len(robots) > 0: self.logger.info(u'Robots found:') for robot in self.account.robots: self.logger.info(u' {} ({})'.format( robot.name, robot.serial)) else: self.logger.error(u'No robots found') except: self.logger.error( u'Error accessing Neato account - check plugin config and internet connection' ) else: # plugin is not configured self.logger.error(u'No account credentials - check plugin config')
def setupThing(info): # Setup for the account if info.thing.thingClassId == accountThingClassId: logger.log("SetupThing for account:", info.thing.name) pluginStorage().beginGroup(info.thing.id) token = json.loads(pluginStorage().value("token")) logger.log("setup", token) pluginStorage().endGroup() try: oAuthSession = OAuthSession(token=token) # Login went well, finish the setup info.finish(nymea.ThingErrorNoError) except Exception as e: # Login error logger.warn("Error setting up neato account:", str(e)) info.finish(nymea.ThingErrorAuthenticationFailure, str(e)) return # Mark the account as logged-in and connected info.thing.setStateValue(accountLoggedInStateTypeId, True) info.thing.setStateValue(accountConnectedStateTypeId, True) # Create an account session on the session to get info about the login account = Account(oAuthSession) accountsMap[info.thing] = account # List all robots associated with account logger.log("account created. Robots:", account.robots) thingDescriptors = [] for robot in account.robots: logger.log("Found new robot:", robot.serial) # Check if this robot is already added in nymea found = False for thing in myThings(): logger.log("Comparing to existing robot:", thing.name) if thing.thingClassId == robotThingClassId and thing.paramValue( robotThingSerialParamTypeId) == robot.serial: logger.log("Already have this robot in the system") # Yep, already here... skip it found = True break if found: continue logger.log("Adding new robot to the system with parent", info.thing.id) thingDescriptor = nymea.ThingDescriptor(robotThingClassId, robot.name, parentId=info.thing.id) thingDescriptor.params = [ nymea.Param(robotThingSerialParamTypeId, robot.serial), nymea.Param(robotThingSecretParamTypeId, robot.secret) ] thingDescriptors.append(thingDescriptor) # And let nymea know about all the users robots autoThingsAppeared(thingDescriptors) # If no poll timer is set up yet, start it now logger.log("Creating polltimer") global pollTimer if pollTimer is None: pollTimer = threading.Timer(5, pollService) pollTimer.start() return # Setup for the robots if info.thing.thingClassId == robotThingClassId: logger.log("SetupThing for robot:", info.thing.name) serial = info.thing.paramValue(robotThingSerialParamTypeId) secret = info.thing.paramValue(robotThingSecretParamTypeId) try: robot = Robot(serial, secret, info.thing.name) thingsAndRobots[info.thing] = robot refreshRobot(info.thing) except Exception as e: logger.warn("Error setting up robot:", e) info.finish(nymea.ThingErrorHardwareFailure, str(e)) return info.thing.setStateValue(robotConnectedStateTypeId, True) # set up polling for robot status info.finish(nymea.ThingErrorNoError) return
def setupThing(info): # Setup for the account if info.thing.thingClassId == accountThingClassId: pluginStorage().beginGroup(info.thing.id) token = json.loads(pluginStorage().value("token")) logger.log("setup", token) pluginStorage().endGroup() try: oAuthSession = OAuthSession(token=token) # Login went well, finish the setup info.finish(nymea.ThingErrorNoError) except: # Login error info.finish(nymea.ThingErrorAuthenticationFailure, "Login error") return # Mark the account as logged-in and connected info.thing.setStateValue(accountLoggedInStateTypeId, True) info.thing.setStateValue(accountConnectedStateTypeId, True) # Create an account session on the session to get info about the login account = Account(oAuthSession) # List all robots associated with account logger.log("account created. Robots:", account.robots) logger.log("Persistent maps: ", account.persistent_maps) mapDict = account.persistent_maps mapKeys = mapDict.keys() logger.log("Keys: ", mapKeys) mapValues = mapDict.values() logger.log("Values: ", mapValues) thingDescriptors = [] for robot in account.robots: logger.log(robot) # Check if this robot is already added in nymea found = False for thing in myThings(): if thing.paramValue( robotThingSerialParamTypeId) == robot.serial: # Yep, already here... skip it found = True continue if found: continue thingDescriptor = nymea.ThingDescriptor(robotThingClassId, robot.name) logger.log("MapID for Serial: ", robot.serial, mapDict[robot.serial]) mapInfo = mapDict[robot.serial] logger.log("Type mapInfo: ", type(mapInfo)) logger.log("Contents mapInfo: ", mapInfo) mapInfo2 = mapInfo[0] logger.log("MapInfo2 type: ", type(mapInfo2), " MapInfo2 contents: ", mapInfo2) mapId = mapInfo2['id'] logger.log("MapId type: ", type(mapId), " MapId contents: ", mapId) mapName = mapInfo2['name'] logger.log("MapName type: ", type(mapName), " MapName contents: ", mapName) mapIDshort = mapId thingDescriptor.params = [ nymea.Param(robotThingSerialParamTypeId, robot.serial), nymea.Param(robotThingSecretParamTypeId, robot.secret), nymea.Param(robotThingMapIdParamTypeId, mapIDshort) ] thingDescriptors.append(thingDescriptor) # And let nymea know about all the users robots autoThingsAppeared(thingDescriptors) # return # If no poll timer is set up yet, start it now logger.log("Creating polltimer") global pollTimer pollTimer = threading.Timer(5, pollService) pollTimer.start() return # Setup for the robots if info.thing.thingClassId == robotThingClassId: serial = info.thing.paramValue(robotThingSerialParamTypeId) secret = info.thing.paramValue(robotThingSecretParamTypeId) robot = Robot(serial, secret, info.thing.name) thingsAndRobots[info.thing] = robot logger.log(robot.get_robot_state()) # set up polling for robot status info.finish(nymea.ThingErrorNoError) return
# account = Account(session) ########################## # Authenticate via OAuth2 ########################## session = OAuthSession( client_id=client_id, client_secret=client_secret, redirect_uri=redirect_uri, vendor=vendor, ) authorization_url = session.get_authorization_url() print("Visit: " + authorization_url) authorization_response = input("Enter the full callback URL: ") token = session.fetch_token(authorization_response) account = Account(session) ########################## # Authenticate via One Time Password ########################## # session = PasswordlessSession(client_id=client_id, vendor=vendor) # session.send_email_otp(email) # code = input("Enter the code: ") # session.fetch_token_passwordless(email, code) # account = Account(session) print("Robots:") for robot in account.robots: print(robot) print()
try: input = raw_input except NameError: pass login = str(input('Your neato account login/email: ')) passwd = str(input('Your neato account password: '******'---------------------------------------------------------------------------------------------------------' ) # List all robots associated with account for robot in account.robots: print('Robot: {}'.format(robot.name)) print( '---------------------------------------------------------------------------------------------------------' ) myRobot = str( input('Please type the name of the robot you want to configure (None): ') or 'None') if myRobot != 'None':
import sys from pybotvac import Account if sys.version_info[0] < 3: input = raw_input email = input('Enter email\n') password = input('Enter password\n') account = Account(email, password) print("Robots:") for robot in account.robots: print(robot) print() print("State:\n", robot.state) print() print("Schedule enabled:", robot.schedule_enabled) print("Disabling schedule") robot.schedule_enabled = False print("Schedule enabled:", robot.schedule_enabled) print("Enabling schedule") robot.schedule_enabled = True print("Schedule enabled:", robot.schedule_enabled)
import sys from pybotvac import Account, Vorwerk if sys.version_info[0] < 3: input = raw_input email = input('Enter email\n') password = input('Enter password\n') vendor = Vorwerk() account = Account(email, password, vendor) print("Robots:") for robot in account.robots: print(robot) print() print("State:\n", robot.state) print() print("Schedule enabled:", robot.schedule_enabled) print("Disabling schedule") robot.schedule_enabled = False print("Schedule enabled:", robot.schedule_enabled) print("Enabling schedule") robot.schedule_enabled = True