我们从Python开源项目中，提取了以下48个代码示例，用于说明如何使用htmlentitydefs.name2codepoint.get()。
def getChoice(choices, **opts): if Cmd.ArgumentsRemaining(): choice = Cmd.Current().strip().lower() if choice: if choice in opts.get(CHOICE_ALIASES, []): choice = opts[CHOICE_ALIASES][choice] if choice not in choices: choice = choice.replace(u'_', u'').replace(u'-', u'') if choice in opts.get(CHOICE_ALIASES, []): choice = opts[CHOICE_ALIASES][choice] if choice in choices: Cmd.Advance() return choice if not opts.get(MAP_CHOICE, False) else choices[choice] if opts.get(DEFAULT_CHOICE, NO_DEFAULT) != NO_DEFAULT: return opts[DEFAULT_CHOICE] invalidChoiceExit(choices, False) elif opts.get(DEFAULT_CHOICE, NO_DEFAULT) != NO_DEFAULT: return opts[DEFAULT_CHOICE] missingChoiceExit(choices)
def buildGAPIObject(api): GM.Globals[GM.CURRENT_API_USER] = None _, httpObj, service, cred_family = getAPIversionHttpService(api) credentials = getClientCredentials(cred_family) try: API_Scopes = set(list(service._rootDesc[u'auth'][u'oauth2'][u'scopes'])) except KeyError: API_Scopes = set(API.VAULT_SCOPES) if api == API.VAULT else set() GM.Globals[GM.CURRENT_API_SCOPES] = list(API_Scopes.intersection(credentials.scopes)) if not GM.Globals[GM.CURRENT_API_SCOPES]: systemErrorExit(NO_SCOPES_FOR_API_RC, Msg.NO_SCOPES_FOR_API.format(service._rootDesc[u'title'])) try: service._http = credentials.authorize(httpObj) except httplib2.ServerNotFoundError as e: systemErrorExit(NETWORK_ERROR_RC, str(e)) except oauth2client.client.AccessTokenRefreshError as e: return handleOAuthTokenError(str(e), False) if not GC.Values[GC.DOMAIN]: GC.Values[GC.DOMAIN] = credentials.id_token.get(u'hd', u'UNKNOWN').lower() if not GC.Values[GC.CUSTOMER_ID]: GC.Values[GC.CUSTOMER_ID] = GC.MY_CUSTOMER GM.Globals[GM.ADMIN] = credentials.id_token.get(u'email', u'UNKNOWN').lower() GM.Globals[GM.OAUTH2_CLIENT_ID] = credentials.client_id return service
def initGDataObject(gdataObj, api): if hasattr(sys, u'_MEIPASS') and not GM.Globals[GM.CACERTS_TXT]: GM.Globals[GM.CACERTS_TXT] = os.path.join(sys._MEIPASS, u'httplib2', u'cacerts.txt') os.environ['REQUESTS_CA_BUNDLE'] = GM.Globals[GM.CACERTS_TXT] os.environ['DEFAULT_CA_BUNDLE_PATH'] = GM.Globals[GM.CACERTS_TXT] _, _, api_version, cred_family = API.getVersion(api) disc_file, discovery = readDiscoveryFile(api_version) GM.Globals[GM.CURRENT_API_USER] = None credentials = getClientCredentials(cred_family) try: GM.Globals[GM.CURRENT_API_SCOPES] = list(set(list(discovery[u'auth'][u'oauth2'][u'scopes'])).intersection(credentials.scopes)) except KeyError: invalidDiscoveryJsonExit(disc_file) if not GM.Globals[GM.CURRENT_API_SCOPES]: systemErrorExit(NO_SCOPES_FOR_API_RC, Msg.NO_SCOPES_FOR_API.format(discovery.get(u'title', api_version))) getGDataOAuthToken(gdataObj, credentials) if GC.Values[GC.DEBUG_LEVEL] > 0: gdataObj.debug = True return gdataObj
def splitEmailAddressOrUID(emailAddressOrUID): normalizedEmailAddressOrUID = normalizeEmailAddressOrUID(emailAddressOrUID) atLoc = normalizedEmailAddressOrUID.find(u'@') if atLoc > 0: return (normalizedEmailAddressOrUID, normalizedEmailAddressOrUID[:atLoc], normalizedEmailAddressOrUID[atLoc+1:]) try: cd = buildGAPIObject(API.DIRECTORY) result = callGAPI(cd.users(), u'get', throw_reasons=GAPI.USER_GET_THROW_REASONS, userKey=normalizedEmailAddressOrUID, fields=u'primaryEmail') if u'primaryEmail' in result: normalizedEmailAddressOrUID = result[u'primaryEmail'].lower() atLoc = normalizedEmailAddressOrUID.find(u'@') return (normalizedEmailAddressOrUID, normalizedEmailAddressOrUID[:atLoc], normalizedEmailAddressOrUID[atLoc+1:]) except (GAPI.userNotFound, GAPI.domainNotFound, GAPI.domainCannotUseApis, GAPI.forbidden, GAPI.badRequest, GAPI.backendError, GAPI.systemError): pass return (normalizedEmailAddressOrUID, normalizedEmailAddressOrUID, GC.Values[GC.DOMAIN]) # Convert Org Unit Id to Org Unit Path
def convertOrgUnitIDtoPath(orgUnitId, cd): if GM.Globals[GM.MAP_ORGUNIT_ID_TO_NAME] is None: GM.Globals[GM.MAP_ORGUNIT_ID_TO_NAME] = {} orgUnitPath = None else: orgUnitPath = GM.Globals[GM.MAP_ORGUNIT_ID_TO_NAME].get(orgUnitId) if not orgUnitPath: if cd is None: cd = buildGAPIObject(API.DIRECTORY) try: orgUnitPath = callGAPI(cd.orgunits(), u'get', throw_reasons=[GAPI.INVALID_ORGUNIT, GAPI.ORGUNIT_NOT_FOUND, GAPI.BACKEND_ERROR, GAPI.BAD_REQUEST, GAPI.INVALID_CUSTOMER_ID, GAPI.LOGIN_REQUIRED], customerId=GC.Values[GC.CUSTOMER_ID], orgUnitPath=orgUnitId, fields=u'orgUnitPath')[u'orgUnitPath'] except (GAPI.invalidOrgunit, GAPI.orgunitNotFound, GAPI.backendError, GAPI.badRequest, GAPI.invalidCustomerId, GAPI.loginRequired): orgUnitPath = orgUnitId GM.Globals[GM.MAP_ORGUNIT_ID_TO_NAME][orgUnitId] = orgUnitPath return orgUnitPath
def doInfoResoldCustomer(): res = buildGAPIObject(API.RESELLER) customerId = getString(Cmd.OB_CUSTOMER_ID) checkForExtraneousArguments() try: customerInfo = callGAPI(res.customers(), u'get', throw_reasons=[GAPI.BAD_REQUEST, GAPI.RESOURCE_NOT_FOUND, GAPI.FORBIDDEN], customerId=customerId) printKeyValueList([u'Customer ID', customerInfo[u'customerId']]) printKeyValueList([u'Customer Domain', customerInfo[u'customerDomain']]) printKeyValueList([u'Customer Domain Verified', customerInfo[u'customerDomainVerified']]) _showCustomerAddressPhoneNumber(customerInfo) printKeyValueList([u'Customer Alternate Email', customerInfo[u'alternateEmail']]) printKeyValueList([u'Customer Admin Console URL', customerInfo[u'resourceUiUrl']]) except (GAPI.badRequest, GAPI.resourceNotFound, GAPI.forbidden) as e: entityActionFailedWarning([Ent.CUSTOMER_ID, customerId], str(e))
def doInfoDomainAlias(): cd = buildGAPIObject(API.DIRECTORY) domainAliasName = getString(Cmd.OB_DOMAIN_ALIAS) checkForExtraneousArguments() try: result = callGAPI(cd.domainAliases(), u'get', throw_reasons=[GAPI.DOMAIN_ALIAS_NOT_FOUND, GAPI.BAD_REQUEST, GAPI.NOT_FOUND, GAPI.FORBIDDEN], customer=GC.Values[GC.CUSTOMER_ID], domainAliasName=domainAliasName) aliasSkipObjects = [u'domainAliasName',] _showDomainAlias(result, aliasSkipObjects) except GAPI.domainAliasNotFound: entityActionFailedWarning([Ent.DOMAIN_ALIAS, domainAliasName], Msg.DOES_NOT_EXIST) except (GAPI.badRequest, GAPI.notFound, GAPI.forbidden): accessErrorExit(cd) # gam print domainaliases [todrive [<ToDriveAttributes>]]
def doInfoCustomer(): cd = buildGAPIObject(API.DIRECTORY) checkForExtraneousArguments() try: customerInfo = callGAPI(cd.customers(), u'get', throw_reasons=[GAPI.BAD_REQUEST, GAPI.RESOURCE_NOT_FOUND, GAPI.FORBIDDEN], customerKey=GC.Values[GC.CUSTOMER_ID]) printKeyValueList([u'Customer ID', customerInfo[u'id']]) printKeyValueList([u'Primary Domain', customerInfo[u'customerDomain']]) printKeyValueList([u'Customer Creation Time', formatLocalTime(customerInfo[u'customerCreationTime'])]) verified = callGAPI(cd.domains(), u'get', customer=customerInfo[u'id'], domainName=customerInfo[u'customerDomain'], fields=u'verified')[u'verified'] printKeyValueList([u'Primary Domain Verified', verified]) printKeyValueList([u'Default Language', customerInfo[u'language']]) _showCustomerAddressPhoneNumber(customerInfo) printKeyValueList([u'Admin Secondary Email', customerInfo[u'alternateEmail']]) _showCustomerLicenseInfo(customerInfo[u'id']) except (GAPI.badRequest, GAPI.resourceNotFound, GAPI.forbidden): accessErrorExit(cd) # gam update customer [primary <DomainName>] [adminsecondaryemail|alternateemail <EmailAddress>] [language <LanguageCode] [phone|phonenumber <String>] # [contact|contactname <String>] [name|organizationname <String>] # [address1|addressline1 <String>] [address2|addressline2 <String>] [address3|addressline3 <String>] # [locality <String>] [region <String>] [postalcode <String>] [country|countrycode <String>]
def _showMailboxExportRequestStatus(request, i, count, showFilter=False, showDates=False, showFiles=False): printEntity([Ent.REQUEST_ID, request[u'requestId']], i, count) Ind.Increment() printEntity([Ent.USER, request[u'userEmailAddress']]) printKeyValueList([u'Status', request[u'status']]) printKeyValueList([u'Request Date', request[u'requestDate']]) printKeyValueList([u'Requested By', request[u'adminEmailAddress']]) printKeyValueList([u'Requested Parts', request[u'packageContent']]) if showFilter: printKeyValueList([u'Request Filter', request.get(u'searchQuery', u'None')]) printKeyValueList([u'Include Deleted', request[u'includeDeleted']]) if showDates: printKeyValueList([u'Begin', request.get(u'beginDate', u'Account creation date')]) printKeyValueList([u'End', request.get(u'endDate', u'Export request date')]) if showFiles: _showFileURLs(request) Ind.Decrement() # gam audit export request <EmailAddress> [begin <DateTime>] [end <DateTime>] [search <QueryGmail>] [headersonly] [includedeleted]
def doInfoMobileDevices(): entityList, cd = getMobileDeviceEntity() parameters = _initMobileFieldsParameters() while Cmd.ArgumentsRemaining(): myarg = getArgument() _getMobileFieldsArguments(myarg, parameters) fields = u','.join(set(parameters[u'fieldsList'])) if parameters[u'fieldsList'] else None i = 0 count = len(entityList) for resourceId in entityList: i += 1 try: info = callGAPI(cd.mobiledevices(), u'get', throw_reasons=[GAPI.INTERNAL_ERROR, GAPI.RESOURCE_ID_NOT_FOUND, GAPI.BAD_REQUEST, GAPI.RESOURCE_NOT_FOUND, GAPI.FORBIDDEN], customerId=GC.Values[GC.CUSTOMER_ID], resourceId=resourceId, projection=parameters[u'projection'], fields=fields) printEntity([Ent.MOBILE_DEVICE, resourceId], i, count) Ind.Increment() showJSON(None, info, timeObjects=MOBILE_TIME_OBJECTS) Ind.Decrement() except GAPI.internalError: entityActionFailedWarning([Ent.MOBILE_DEVICE, resourceId], Msg.DOES_NOT_EXIST, i, count) except (GAPI.resourceIdNotFound, GAPI.badRequest, GAPI.resourceNotFound, GAPI.forbidden) as e: entityActionFailedWarning([Ent.MOBILE_DEVICE, resourceId], str(e), i, count)
def _showBuilding(building, delimiter=u',', i=0, count=0): if u'buildingName' in building: printEntity([Ent.BUILDING, building[u'buildingName']], i, count) Ind.Increment() printKeyValueList([u'buildingId', u'id:{0}'.format(building[u'buildingId'])]) else: printEntity([Ent.BUILDING_ID, u'id:{0}'.format(building[u'buildingId'])], i, count) Ind.Increment() if u'description' in building: printKeyValueList([u'description', building[u'description']]) if u'floorNames' in building: printKeyValueList([u'floorNames', delimiter.join(building[u'floorNames'])]) if u'coordinates' in building: printKeyValueList([u'coordinates', None]) Ind.Increment() printKeyValueList([u'latitude', building[u'coordinates'].get(u'latitude', 0)]) printKeyValueList([u'longitude', building[u'coordinates'].get(u'longitude', 0)]) Ind.Decrement() Ind.Decrement() # gam info building <BuildingID>
def _infoCalendarACLs(cal, entityType, calId, j, jcount, ruleIds, kcount): Ind.Increment() k = 0 for ruleId in ruleIds: k += 1 ruleId = normalizeRuleId(ruleId) try: result = callGAPI(cal.acl(), u'get', throw_reasons=[GAPI.NOT_FOUND, GAPI.INVALID, GAPI.INVALID_SCOPE_VALUE, GAPI.FORBIDDEN], calendarId=calId, ruleId=ruleId, fields=u'id,role') printEntity([entityType, calId, Ent.CALENDAR_ACL, formatACLScopeRole(result[u'id'], result[u'role'])], k, kcount) except (GAPI.notFound, GAPI.invalid) as e: if not checkCalendarExists(cal, calId): entityUnknownWarning(entityType, calId, j, jcount) break else: entityActionFailedWarning([entityType, calId, Ent.CALENDAR_ACL, formatACLScopeRole(ruleId, None)], str(e), k, kcount) except (GAPI.invalidScopeValue, GAPI.forbidden) as e: entityActionFailedWarning([entityType, calId, Ent.CALENDAR_ACL, formatACLScopeRole(ruleId, None)], str(e), k, kcount) Ind.Decrement()
def _getCalendarListEventsProperty(myarg, attributes, kwargs): attrName, attribute = attributes.get(myarg, (None, None)) if not attrName: return False attrType = attribute[GC.VAR_TYPE] if attrType == GC.TYPE_BOOLEAN: kwargs[attrName] = True elif attrType == GC.TYPE_STRING: kwargs[attrName] = getString(Cmd.OB_STRING) elif attrType == GC.TYPE_CHOICE: kwargs[attrName] = getChoice(attribute[u'choices'], mapChoice=True) elif attrType == GC.TYPE_DATETIME: kwargs[attrName] = getTimeOrDeltaFromNow() else: # GC.TYPE_INTEGER kwargs[attrName] = getInteger() return True
def doInfoVaultHold(): v = buildGAPIObject(API.VAULT) holdName = getString(Cmd.OB_HOLD_ITEM) cd = matterId = None while Cmd.ArgumentsRemaining(): myarg = getArgument() if myarg == u'matter': matterId, matterNameId = getMatterItem(v) holdId, holdName, holdNameId = convertHoldNameToID(v, holdName, matterId, matterNameId) elif myarg == u'shownames': cd = buildGAPIObject(API.DIRECTORY) else: unknownArgumentExit() if matterId is None: missingArgumentExit(Cmd.OB_MATTER_ITEM) try: hold = callGAPI(v.matters().holds(), u'get', throw_reasons=[GAPI.NOT_FOUND, GAPI.BAD_REQUEST, GAPI.FORBIDDEN], matterId=matterId, holdId=holdId) entityActionPerformed([Ent.VAULT_MATTER, matterNameId, Ent.VAULT_HOLD, formatHoldNameId(hold[u'name'], hold[u'holdId'])]) _showVaultHold(hold, cd) except (GAPI.notFound, GAPI.badRequest, GAPI.forbidden) as e: entityActionFailedWarning([Ent.VAULT_MATTER, matterNameId, Ent.VAULT_HOLD, holdNameId], str(e))
def FieldsToSite(fields): import atom import gdata.apps.sites def GetField(fieldName): return fields.get(fieldName) def GetSiteField(fieldName, fieldClass): value = fields.get(fieldName) if value: return fieldClass(text=value) return None site_entry = gdata.apps.sites.SiteEntry(sourceSite=GetField(SITE_SOURCELINK)) site_entry.siteName = GetSiteField(SITE_SITE, gdata.apps.sites.SiteName) site_entry.title = GetSiteField(SITE_NAME, atom.Title) site_entry.summary = GetSiteField(SITE_SUMMARY, atom.Summary) site_entry.theme = GetSiteField(SITE_THEME, gdata.apps.sites.Theme) value = GetField(SITE_CATEGORIES) if value: for category in value: site_entry.category.append(atom.Category(term=category, scheme=gdata.apps.sites.TAG_KIND_TERM)) return site_entry
def _processTags(tagReplacements, message): while True: match = RT_PATTERN.search(message) if not match: break if tagReplacements.get(match.group(1)): message = RT_OPEN_PATTERN.sub(u'', message, count=1) message = RT_CLOSE_PATTERN.sub(u'', message, count=1) else: message = RT_STRIP_PATTERN.sub(u'', message, count=1) while True: match = RT_TAG_REPLACE_PATTERN.search(message) if not match: break message = re.sub(match.group(0), tagReplacements.get(match.group(1), u''), message) return message # Substitute for #user#, #email#, #usernamne#
def sendCreateUserNotification(notify, body, i=0, count=0): def _makeSubstitutions(field): notify[field] = _substituteForUser(notify[field], body[u'primaryEmail'], userName) notify[field] = notify[field].replace(u'#domain#', domain) notify[field] = notify[field].replace(u'#givenname#', body[u'name'][u'givenName']) notify[field] = notify[field].replace(u'#familyname#', body[u'name'][u'familyName']) notify[field] = notify[field].replace(u'#password#', notify[u'password']) userName, domain = splitEmailAddress(body[u'primaryEmail']) if not notify.get(u'subject'): notify[u'subject'] = Msg.CREATE_USER_NOTIFY_SUBJECT _makeSubstitutions(u'subject') if not notify.get(u'message'): notify[u'message'] = Msg.CREATE_USER_NOTIFY_MESSAGE _makeSubstitutions(u'message') send_email(notify[u'subject'], notify[u'message'], notify[u'emailAddress'], i, count) # gam create user <EmailAddress> <UserAttributes> [notify <EmailAddress>] [subject <String>] [message <String>|(file <FileName> [charset <CharSet>])]
def getPrinterScopeListsForRole(cp, printerId, i, count, role): try: result = callGCP(cp.printers(), u'get', throw_messages=[GCP.UNKNOWN_PRINTER], printerid=printerId) try: jcount = len(result[u'printers'][0][u'access']) except KeyError: jcount = 0 scopeList = [] if jcount > 0: for acl in result[u'printers'][0][u'access']: if acl.get(u'role') == role: scopeList.append(acl[u'scope'].lower()) return scopeList except GCP.unknownPrinter as e: entityActionFailedWarning([Ent.PRINTER, printerId], str(e), i, count) return None # gam printer|printers <PrinterIDEntity> sync user|manager|owner <PrinterACLScopeEntity> [notify]
def _showBackupCodes(user, codes, i, count): Act.Set(Act.SHOW) jcount = 0 for code in codes: if code.get(u'verificationCode'): jcount += 1 entityPerformActionNumItems([Ent.USER, user], jcount, Ent.BACKUP_VERIFICATION_CODES, i, count) if jcount == 0: setSysExitRC(NO_ENTITIES_FOUND) return Ind.Increment() j = 0 for code in codes: j += 1 printKeyValueList([u'{0:2}'.format(j), code.get(u'verificationCode')]) Ind.Decrement() # gam <UserTypeEntity> update backupcodes|verificationcodes
def infoCalendars(users): calendarEntity = getCalendarEntity() checkForExtraneousArguments() i, count, users = getEntityArgument(users) for user in users: i += 1 user, cal, calIds, jcount = _validateUserGetCalendarIds(user, i, count, calendarEntity) if jcount == 0: continue Ind.Increment() j = 0 for calId in calIds: j += 1 calId = normalizeCalendarId(calId, user) _processCalendarList(user, calId, j, jcount, cal, u'get', calendarId=calId) Ind.Decrement() # <CalendarSettings> ::== # [description <String>] [location <String>] [summary <String>] [timezone <String>]
def _getCalendarSettings(summaryRequired=False): body = {} while Cmd.ArgumentsRemaining(): myarg = getArgument() if myarg == u'description': body[u'description'] = getString(Cmd.OB_STRING, minLen=0).replace(u'\\n', u'\n') elif myarg == u'location': body[u'location'] = getString(Cmd.OB_STRING, minLen=0) elif myarg == u'summary': body[u'summary'] = getString(Cmd.OB_STRING) elif myarg == u'timezone': body[u'timeZone'] = getString(Cmd.OB_STRING) else: unknownArgumentExit() if summaryRequired and not body.get(u'summary', None): missingArgumentExit(u'summary <String>') return body # gam <UserTypeEntity> create calendars <CalendarSettings>
def doDriveSearch(drive, user, i, count, query=None, parentQuery=False, orderBy=None, teamDriveOnly=False, **kwargs): if GC.Values[GC.SHOW_GETTINGS]: printGettingAllEntityItemsForWhom(Ent.DRIVE_FILE_OR_FOLDER, user, i, count, query=query) try: files = callGAPIpages(drive.files(), u'list', VX_PAGES_FILES, page_message=getPageMessageForWhom(noNL=True), throw_reasons=GAPI.DRIVE_USER_THROW_REASONS+[GAPI.INVALID_QUERY, GAPI.INVALID, GAPI.FILE_NOT_FOUND, GAPI.TEAMDRIVE_NOT_FOUND], q=query, orderBy=orderBy, fields=u'nextPageToken,files(id,teamDriveId)', pageSize=GC.Values[GC.DRIVE_MAX_RESULTS], **kwargs) if files or not parentQuery: return [f_file[u'id'] for f_file in files if not teamDriveOnly or f_file.get(u'teamDriveId')] entityActionFailedWarning([Ent.USER, user, Ent.DRIVE_FILE, None], invalidQuery(query), i, count) except (GAPI.invalidQuery, GAPI.invalid): entityActionFailedWarning([Ent.USER, user, Ent.DRIVE_FILE, None], invalidQuery(query), i, count) except GAPI.fileNotFound: printGotEntityItemsForWhom(0) except GAPI.teamDriveNotFound as e: entityActionFailedWarning([Ent.USER, user, Ent.TEAMDRIVE_ID, kwargs[u'teamDriveId']], str(e), i, count) except (GAPI.serviceNotAvailable, GAPI.authError, GAPI.domainPolicy) as e: userSvcNotApplicableOrDriveDisabled(user, str(e), i, count) return None
def _getDriveFileNameFromId(drive, fileId, combineTitleId=True): try: result = callGAPI(drive.files(), u'get', throw_reasons=GAPI.DRIVE_ACCESS_THROW_REASONS, fileId=fileId, fields=VX_FILENAME_MIMETYPE_TEAMDRIVEID, supportsTeamDrives=True) if result: fileName = result[VX_FILENAME] if (result[u'mimeType'] == MIMETYPE_GA_FOLDER) and (result[VX_FILENAME] == TEAM_DRIVE) and result.get(u'teamDriveId'): fileName = _getTeamDriveNameFromId(drive, result[u'teamDriveId']) if combineTitleId: fileName += u'('+fileId+u')' return (fileName, _getEntityMimeType(result)) except (GAPI.fileNotFound, GAPI.forbidden, GAPI.internalError, GAPI.insufficientFilePermissions, GAPI.internalError, GAPI.serviceNotAvailable, GAPI.authError, GAPI.domainPolicy): pass return (fileId, Ent.DRIVE_FILE_OR_FOLDER_ID)
def _validateUserGetTeamDriveFileIDs(user, i, count, fileIdEntity, drive=None, entityType=None): if fileIdEntity[u'dict']: cleanFileIDsList(fileIdEntity, fileIdEntity[u'dict'][user]) if not drive: user, drive = buildGAPIServiceObject(API.DRIVE3, user) if not drive: return (user, None, 0) else: user = convertUIDtoEmailAddress(user) if fileIdEntity.get(u'teamdrivename') and not _convertTeamDriveNameToId(drive, user, i, count, fileIdEntity): return (user, None, 0) if fileIdEntity[u'teamdrivefilequery']: fileIdEntity[u'list'] = doDriveSearch(drive, user, i, count, query=fileIdEntity[u'teamdrivefilequery'], teamDriveOnly=True, **fileIdEntity[u'teamdrive']) if fileIdEntity[u'list'] is None or not fileIdEntity[u'list']: setSysExitRC(NO_ENTITIES_FOUND) return (user, None, 0) fileIdEntity[u'teamdrive'].pop(u'teamDriveId', None) fileIdEntity[u'teamdrive'].pop(u'corpora', None) l = len(fileIdEntity[u'list']) if l == 0: setSysExitRC(NO_ENTITIES_FOUND) if entityType: entityPerformActionNumItems([Ent.USER, user], l, entityType, i, count) return (user, drive, l)
def _showTeamDriveThemes(users): checkForExtraneousArguments() i, count, users = getEntityArgument(users) for user in users: i += 1 user, drive = buildGAPIServiceObject(API.DRIVE3, user) if not drive: continue try: themes = callGAPIitems(drive.about(), u'get', u'teamDriveThemes', throw_reasons=GAPI.DRIVE_USER_THROW_REASONS, fields=u'teamDriveThemes') jcount = len(themes) entityPerformActionNumItems([Ent.USER, user], jcount, Ent.TEAMDRIVE_THEME, i, count) _showTeamDriveThemeSettings(themes) except (GAPI.serviceNotAvailable, GAPI.authError, GAPI.domainPolicy) as e: userSvcNotApplicableOrDriveDisabled(user, str(e), i, count) # gam <UserTypeEntity> show teamdrivethemes
def _setShowProfile(users, function, **kwargs): cd = buildGAPIObject(API.DIRECTORY) checkForExtraneousArguments() i, count, users = getEntityArgument(users) for user in users: i += 1 user = normalizeEmailAddressOrUID(user) try: result = callGAPI(cd.users(), function, throw_reasons=[GAPI.USER_NOT_FOUND, GAPI.FORBIDDEN], userKey=user, fields=u'includeInGlobalAddressList', **kwargs) printEntity([Ent.USER, user, Ent.PROFILE_SHARING_ENABLED, result.get(u'includeInGlobalAddressList', u'Unknown')], i, count) except (GAPI.userNotFound, GAPI.forbidden): entityUnknownWarning(Ent.USER, user, i, count) # gam <UserTypeEntity> profile share|shared|unshare|unshared
def deleteTokens(users): cd = buildGAPIObject(API.DIRECTORY) checkArgumentPresent(u'clientid', required=True) clientId = commonClientIds(getString(Cmd.OB_CLIENT_ID)) checkForExtraneousArguments() i, count, users = getEntityArgument(users) for user in users: i += 1 user = normalizeEmailAddressOrUID(user) try: callGAPI(cd.tokens(), u'get', throw_reasons=[GAPI.USER_NOT_FOUND, GAPI.DOMAIN_NOT_FOUND, GAPI.DOMAIN_CANNOT_USE_APIS, GAPI.FORBIDDEN, GAPI.NOT_FOUND, GAPI.RESOURCE_NOT_FOUND], userKey=user, clientId=clientId, fields=u'') callGAPI(cd.tokens(), u'delete', throw_reasons=[GAPI.USER_NOT_FOUND, GAPI.DOMAIN_NOT_FOUND, GAPI.DOMAIN_CANNOT_USE_APIS, GAPI.FORBIDDEN, GAPI.NOT_FOUND, GAPI.RESOURCE_NOT_FOUND], userKey=user, clientId=clientId) entityActionPerformed([Ent.USER, user, Ent.ACCESS_TOKEN, clientId], i, count) except (GAPI.notFound, GAPI.resourceNotFound) as e: entityActionFailedWarning([Ent.USER, user, Ent.ACCESS_TOKEN, clientId], str(e), i, count) except (GAPI.userNotFound, GAPI.domainNotFound, GAPI.domainCannotUseApis, GAPI.forbidden): entityUnknownWarning(Ent.USER, user, i, count)
def _checkDelegator(cd, delegatorEmail, i, count, jcount): try: result = callGAPI(cd.users(), u'get', throw_reasons=GAPI.USER_GET_THROW_REASONS, userKey=delegatorEmail, fields=u'suspended,changePasswordAtNextLogin') if result[u'suspended']: entityNumEntitiesActionFailedWarning(Ent.DELEGATOR, delegatorEmail, Ent.DELEGATE, jcount, Ent.TypeMessage(Ent.DELEGATOR, Msg.IS_SUSPENDED_NO_DELEGATION), i, count) setSysExitRC(USER_SUSPENDED_ERROR_RC) elif result[u'changePasswordAtNextLogin']: entityNumEntitiesActionFailedWarning(Ent.DELEGATOR, delegatorEmail, Ent.DELEGATE, jcount, Ent.TypeMessage(Ent.DELEGATOR, Msg.IS_REQD_TO_CHG_PWD_NO_DELEGATION), i, count) setSysExitRC(USER_REQUIRED_TO_CHANGE_PASSWORD_ERROR_RC) else: return True except (GAPI.userNotFound, GAPI.domainNotFound, GAPI.domainCannotUseApis, GAPI.forbidden, GAPI.badRequest, GAPI.backendError, GAPI.systemError) as e: entityNumEntitiesActionFailedWarning(Ent.DELEGATOR, delegatorEmail, Ent.DELEGATE, jcount, Ent.TypeMessage(Ent.DELEGATOR, str(e)), i, count) return False
def _checkDelegate(cd, delegatorEmail, delegateEmail, j, jcount): try: result = callGAPI(cd.users(), u'get', throw_reasons=GAPI.USER_GET_THROW_REASONS, userKey=delegateEmail, fields=u'suspended,changePasswordAtNextLogin') if result[u'suspended']: entityActionFailedWarning([Ent.DELEGATOR, delegatorEmail, Ent.DELEGATE, delegateEmail], Ent.TypeMessage(Ent.DELEGATE, Msg.IS_SUSPENDED_NO_DELEGATION), j, jcount) setSysExitRC(USER_SUSPENDED_ERROR_RC) elif result[u'changePasswordAtNextLogin']: entityActionFailedWarning([Ent.DELEGATOR, delegatorEmail, Ent.DELEGATE, delegateEmail], Ent.TypeMessage(Ent.DELEGATE, Msg.IS_REQD_TO_CHG_PWD_NO_DELEGATION), j, jcount) setSysExitRC(USER_REQUIRED_TO_CHANGE_PASSWORD_ERROR_RC) else: entityActionFailedWarning([Ent.DELEGATOR, delegatorEmail, Ent.DELEGATE, delegateEmail], Msg.GOOGLE_DELEGATION_ERROR, j, jcount) setSysExitRC(GOOGLE_API_ERROR_RC) except (GAPI.userNotFound, GAPI.domainNotFound, GAPI.domainCannotUseApis, GAPI.forbidden, GAPI.badRequest, GAPI.backendError, GAPI.systemError) as e: entityActionFailedWarning([Ent.DELEGATOR, delegatorEmail, Ent.DELEGATE, delegateEmail], Ent.TypeMessage(Ent.DELEGATE, str(e)), j, jcount)
def _processForwardingAddress(user, i, count, emailAddress, j, jcount, gmail, function, **kwargs): userDefined = True try: result = callGAPI(gmail.users().settings().forwardingAddresses(), function, throw_reasons=GAPI.GMAIL_THROW_REASONS+[GAPI.NOT_FOUND, GAPI.ALREADY_EXISTS, GAPI.DUPLICATE], userId=u'me', **kwargs) if function == u'get': _showForwardingAddress(j, count, result) else: entityActionPerformed([Ent.USER, user, Ent.FORWARDING_ADDRESS, emailAddress], j, jcount) except (GAPI.notFound, GAPI.alreadyExists, GAPI.duplicate) as e: entityActionFailedWarning([Ent.USER, user, Ent.FORWARDING_ADDRESS, emailAddress], str(e), j, jcount) except (GAPI.serviceNotAvailable, GAPI.badRequest): entityServiceNotApplicableWarning(Ent.USER, user, i, count) userDefined = False return userDefined # gam <UserTypeEntity> create|add forwardingaddresses <EmailAddressEntity>
def _processSendAs(user, i, count, entityType, emailAddress, j, jcount, gmail, function, formatSig, **kwargs): userDefined = True try: result = callGAPI(gmail.users().settings().sendAs(), function, throw_reasons=GAPI.GMAIL_THROW_REASONS+[GAPI.NOT_FOUND, GAPI.ALREADY_EXISTS, GAPI.DUPLICATE, GAPI.CANNOT_DELETE_PRIMARY_SENDAS, GAPI.INVALID_ARGUMENT], userId=u'me', **kwargs) if function == u'get': _showSendAs(result, j, jcount, formatSig) else: entityActionPerformed([Ent.USER, user, entityType, emailAddress], j, jcount) except (GAPI.notFound, GAPI.alreadyExists, GAPI.duplicate, GAPI.cannotDeletePrimarySendAs, GAPI.invalidArgument) as e: entityActionFailedWarning([Ent.USER, user, entityType, emailAddress], str(e), j, jcount) except (GAPI.serviceNotAvailable, GAPI.badRequest): entityServiceNotApplicableWarning(Ent.USER, user, i, count) userDefined = False return userDefined
def adjustRedirectedSTDFilesIfNotMultiprocessing(): def adjustRedirectedSTDFile(stdtype): rdFd = GM.Globals[stdtype].get(GM.REDIRECT_FD) rdMultiFd = GM.Globals[stdtype].get(GM.REDIRECT_MULTI_FD) if rdFd and rdMultiFd and rdFd != rdMultiFd: try: rdFd.write(rdMultiFd.getvalue()) rdMultiFd.close() GM.Globals[stdtype][GM.REDIRECT_MULTI_FD] = rdFd if (stdtype == GM.STDOUT) and (GM.Globals.get(GM.SAVED_STDOUT) is not None): sys.stdout = rdFd except IOError as e: systemErrorExit(FILE_ERROR_RC, e) adjustRedirectedSTDFile(GM.STDOUT) if GM.Globals[GM.STDERR].get(GM.REDIRECT_NAME) != u'stdout': adjustRedirectedSTDFile(GM.STDERR) else: GM.Globals[GM.STDERR][GM.REDIRECT_MULTI_FD] = GM.Globals[GM.STDOUT][GM.REDIRECT_MULTI_FD]
def decodeHtmlentities(string): string = entitiesfix(string) entity_re = re.compile("&(#?)(\d{1,5}|\w{1,8});") def substitute_entity(match): from htmlentitydefs import name2codepoint as n2cp ent = match.group(2) if match.group(1) == "#": return unichr(int(ent)).encode('utf-8') else: cp = n2cp.get(ent) if cp: return unichr(cp).encode('utf-8') else: return match.group() return entity_re.subn(substitute_entity, string)[0]
def check_output(*popenargs, **kwargs): r"""Run command with arguments and return its output as a byte string. Backported from Python 2.7 as it's implemented as pure python on stdlib. >>> check_output(['/usr/bin/python', '--version']) Python 2.6.2 Added extra KeyboardInterrupt handling """ try: process = subprocess.Popen(stdout=subprocess.PIPE, *popenargs, **kwargs) output, unused_err = process.communicate() retcode = process.poll() if retcode: cmd = kwargs.get("args") if cmd is None: cmd = popenargs[0] error = subprocess.CalledProcessError(retcode, cmd) error.output = output raise error return output except KeyboardInterrupt: process.terminate() raise
def getOrgUnitId(cd=None): if cd is None: cd = buildGAPIObject(API.DIRECTORY) orgUnit = getOrgUnitItem() if orgUnit[:3] == u'id:': return (orgUnit, orgUnit) try: result = callGAPI(cd.orgunits(), u'get', throw_reasons=[GAPI.INVALID_ORGUNIT, GAPI.ORGUNIT_NOT_FOUND, GAPI.BACKEND_ERROR, GAPI.BAD_REQUEST, GAPI.INVALID_CUSTOMER_ID, GAPI.LOGIN_REQUIRED], customerId=GC.Values[GC.CUSTOMER_ID], orgUnitPath=makeOrgUnitPathRelative(orgUnit), fields=u'orgUnitId') return (orgUnit, result[u'orgUnitId']) except (GAPI.invalidOrgunit, GAPI.orgunitNotFound, GAPI.backendError): entityDoesNotExistExit(Ent.ORGANIZATIONAL_UNIT, orgUnit) except (GAPI.badRequest, GAPI.invalidCustomerId, GAPI.loginRequired): accessErrorExit(cd)
def checkOrgUnitPathExists(cd, orgUnitPath, i=0, count=0, showError=False): if orgUnitPath == u'/': return (True, orgUnitPath) try: return (True, callGAPI(cd.orgunits(), u'get', throw_reasons=[GAPI.INVALID_ORGUNIT, GAPI.ORGUNIT_NOT_FOUND, GAPI.BACKEND_ERROR, GAPI.BAD_REQUEST, GAPI.INVALID_CUSTOMER_ID, GAPI.LOGIN_REQUIRED], customerId=GC.Values[GC.CUSTOMER_ID], orgUnitPath=makeOrgUnitPathRelative(orgUnitPath), fields=u'orgUnitPath')[u'orgUnitPath']) except (GAPI.invalidOrgunit, GAPI.orgunitNotFound, GAPI.backendError): pass except (GAPI.badRequest, GAPI.invalidCustomerId, GAPI.loginRequired): errMsg = accessErrorMessage(cd) if errMsg: systemErrorExit(INVALID_DOMAIN_RC, errMsg) if showError: entityActionFailedWarning([Ent.ORGANIZATIONAL_UNIT, orgUnitPath], Msg.DOES_NOT_EXIST, i, count) return (False, orgUnitPath)
def writeStdout(data): try: GM.Globals[GM.STDOUT].get(GM.REDIRECT_MULTI_FD, sys.stdout).write(data) except IOError as e: systemErrorExit(FILE_ERROR_RC, e)
def flushStdout(): try: GM.Globals[GM.STDOUT].get(GM.REDIRECT_MULTI_FD, sys.stdout).flush() except IOError as e: systemErrorExit(FILE_ERROR_RC, e)
