def register(): if request.method == "POST": email = request.form['email'] # checks if email exists in database user = User.query.filter_by(email=email).first() if not user: email_db = '' else: email_db = user.email if email != email_db: try: # validate email using hunter hunter = PyHunter('fce98eff8d99f93fe14df75bf06d0713d73f406a') hunter.email_verifier(email) # gets additional information for a user using clearbit clearbit.key = 'sk_074ad5265e753838e4bc9993b1a1473f' person = clearbit.Person.find(email=email, stream=True) bio = None if person is not None and person['bio'] is not None: bio = person['bio'] role = None if person is not None and person['employment']['role'] is not None: role = person['employment']['role'] location = None if person is not None and person['location'] is not None: location = person['location'] # inserts new user into database new_user = User(public_id=str(uuid.uuid4()), first_name=request.form['first_name'], last_name=request.form['last_name'], email=email, password=request.form['password'], bio=bio, role=role, location=location) db.session.add(new_user) db.session.commit() return render_template('login.html') except: return render_template('invalid.html') else: return render_template('userexists.html') return render_template('register.html')
def create(self, validated_data): user = User( email=validated_data['email'], first_name=validated_data['first_name'], last_name=validated_data['last_name'] ) user.set_password(validated_data['password']) user.is_active = True hunter = PyHunter(settings.HUNTER_API_KEY) hunter.email_verifier(user.email) pp = pprint.PrettyPrinter(indent=4) pp.pprint(hunter.email_verifier(user.email)) user.save() return user
def create(self, request, *args, **kwargs): #check email by EmailHunter #if it's failed, send status 400 hunter = PyHunter(EMAIL_HUNTER_API_KEY) verify = hunter.email_verifier(request.data['email']) if verify.get('result', {}) == 'undelivarable': return Response(status=status.HTTP_400_BAD_REQUEST) #enrich account by first name and last name using clearbit clearbit.key = CLEARBIT_APY_KEY res = clearbit.Enrichment.find(email=request.data['email']) try: request.data['first_name'] = res['person']['name'].get( 'givenName', '') request.data['last_name'] = res['person']['name'].get( 'familyName', '') except (TypeError, KeyError): #if enrichment is failed, set fields as empty strings request.data['first_name'] = request.data['last_name'] = '' #serialize data from request serializer = self.get_serializer(data=request.data) serializer.is_valid(raise_exception=True) #and create a user self.perform_create(serializer) #define headers and respond to client headers = self.get_success_headers(serializer.data) return Response(serializer.data, status=status.HTTP_201_CREATED, headers=headers)
def verify_email(email): hunter = PyHunter(os.environ.get('HUNTER_API_KEY')) try: quality_score = hunter.email_verifier(email) except HunterApiError: return 0 return quality_score.get('score', 0)
def validate_email(self, email): hunter_key = 'HUNTER_API_KEY' hunter = PyHunter(hunter_key) if hunter.email_verifier(email)['status'] not in ['valid','webmail']: raise serializers.ValidationError('Invalid email address') return email
def check_email_function(user_id): user = User.objects.get(pk=user_id) hunter = PyHunter(settings.PYHUNTER_TOKEN) res = hunter.email_verifier(user.email) # check result parameters here if res['score'] > 10: user.is_active = True user.save()
def check_email(email): # Check the deliverability of a given email adress by emailhunter.co hunter = PyHunter(settings.EMAILHUNTER_API_KEY) hunter_result = hunter.email_verifier(email) if hunter_result and 'result' in hunter_result: return hunter_result['result'] else: return 'unchecked'
def register(usr): hunter = PyHunter(config("HUNTER_KEY")) mail = hunter.email_verifier(usr["email"])["webmail"] if mail: user = models.User() user.first_name = usr["first_name"] user.last_name = usr["last_name"] user.email = usr["email"] user.password = md5(usr["password"].encode()).hexdigest() user.save()
def validate_email(self, value): """ Check if email exists """ if not settings.DEBUG_SIGNUP: hunter = PyHunter(settings.HUNTER_API_KEY) verification = hunter.email_verifier(value) if verification['result'] == 'undeliverable': raise ValidationError('Email address does not exist') return value
def validate_email(value): # Use emailhunter.co for verifying email existence on signup py_hunter = PyHunter(settings.HUNTER_API_KEY) if settings.HUNTER_ENABLED and settings.HUNTER_API_KEY: if py_hunter.email_verifier(value).get( 'result') != 'undeliverable': return value raise serializers.ValidationError( 'An issue with email verification occures') return value
def validate_email(self, email): hunter = PyHunter(HUNTERIO_KEY) try: payload = hunter.email_verifier(email) except Exception: return result = payload.get('result') if result == 'undeliverable': raise serializers.ValidationError( 'The email address is not valid.')
def _mail_verification(mail): """Mail validation via hunter site""" try: hunter = PyHunter(my_hunter_api_key) user_data = hunter.email_verifier(mail) # On risky & deliverable continue if user_data['result'] == 'undeliverable': raise Exception('Mail not approved') return user_data except Exception as e: logging.warning(e) return {e}
def emailVerifier(email): print("email trouvé: ", email) if email == None: return False else: hunter = PyHunter('a890302fd13f718af83604989dbd3213772a0d07') statut = hunter.email_verifier(email)['result'] print("statut: ", statut) if statut == 'undeliverable': return False else: return True
def verifylist(): for x in EMAILS: list = EMAILS hk = API_KEYS["hunter"] hunter = PyHunter(hk) h = hunter.email_verifier(x) if h["result"] == "undeliverable": Style.Colors.RB(x + " EMAIL RETURNED AN UNDELIVERABLE!") continue break else: Style.Colors.GB(x + " " + h["result"]) continue break
def check_email_hunter(email): try: # we could also use hunter.email_finder for get email list from domain and check is it include our email or not, # but I see that we don't get all emails using this function and I decide dont't use it verified = False hunter = PyHunter(settings.HUNTERIO_API_KEY) result = hunter.email_verifier(email) if isinstance(result, dict) and result.get( 'webmail', False) and not result.get('block', True): verified = True except (ConnectionError, Timeout, HTTPError) as ex: logger.error(f'Email hunter connection error {ex}') return verified
def registration(): email = request.form['email'] first_name = request.form['first_name'] last_name = request.form['last_name'] password = request.form['password'] #checking for existing user user = User.query.filter_by(email=email).first() if user: return {'success': False, 'msg': 'User already exists! Please Log in!'} try: #HUNTER hunter = PyHunter('8a225ea7e524328c62224526b273d48266a41d65') hunter.email_verifier(email) #CLEARBIT clearbit.key = 'sk_9910ef6078230afe0cf6460e59da8bf4' user = clearbit.Person.find(email=email, stream=True) '''if user != None: user['some_parametar_for_get_data']''' new_user = User(public_id=str(uuid.uuid4()), email=email, first_name=first_name, last_name=last_name, password=generate_password_hash(password)) db.session.add(new_user) db.session.commit() return {'success': True, 'msg': 'Successfully registered!'} except: return { 'success': False, 'msg': 'Registration failed, please try again!' }
def email_verify(email): """ Check is email valid and is it deliverable :param email: email to check :return: True if email valid :raise ValidationError if email invalid or undeliverable """ hunter = PyHunter(settings.HUNTER_API_KEY) try: response = hunter.email_verifier(email) if response['result'] == 'undeliverable': raise serializers.ValidationError except exceptions.HTTPError: raise serializers.ValidationError return True
def post(self, request, format=None): hunterAPI = '5aa57f6c3b4600d3a881a0d2b38e9311e5b91640' email = request.data.get('email') hunter = PyHunter(hunterAPI) verify_email = hunter.email_verifier(email) #Checks if the email is deliverable or not through hunterAPI if(verify_email.get('result')=='undeliverable'): return Response({'status': 'Incorrect data', 'message': 'E-mail not deliverable'}, status=status.HTTP_400_BAD_REQUEST) else: if not request.data._mutable: request.data._mutable = True serializer = self.serializer_class(data=request.data) if serializer.is_valid(): serializer.save() return Response(serializer.data, status=status.HTTP_201_CREATED) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request, *args, **kwargs): email = request.data['email'] hunter = PyHunter(settings.EMAILHUNTER_KEY) clearbit.key = settings.CLEARBIT_KEY valid = hunter.email_verifier(email) content = dict( valid=valid['result'], ) person = clearbit.Person.find(email=email, stream=True) if person is not None: content.update(dict( company=person['employment']['name'], role=person['employment']['role'], city=person['geo']['city'], country=person['geo']['country'], bio=person['bio'], )) return Response(content)
def validate_email(self, email): """ Validate the email field. :param email: The email. :return: The email after validation """ if email is None: raise serializers.ValidationError( 'Users must have an email address.') # Verify email using hunter.io hunter = PyHunter(settings.HUNTER_API_KEY) result = hunter.email_verifier(email) if result['status'] == 'invalid': raise serializers.ValidationError( 'Users must have an valid email address.') return email
def create(self, request, *args, **kwargs): serializer = self.get_serializer(data=request.data) serializer.is_valid(raise_exception=True) email = serializer.validated_data['email'] # verify the deliverability of an email address hunter = PyHunter(settings.EMAIL_HUNTER_API_KEY) verify = hunter.email_verifier(email) if not verify['gibberish'] and not verify['block']: user = self.perform_create(serializer) headers = self.get_success_headers(serializer.data) return Response(self.get_response_data(user), status=status.HTTP_201_CREATED, headers=headers) return Response( { 'You use an automatically generated email address ' 'or your email is blocked' }, status=status.HTTP_400_BAD_REQUEST)
def create(self, request, *args, **kwargs): serializer = self.get_serializer(data=request.data) serializer.is_valid(raise_exception=True) # emailhunter.co for verifying email existence on signup user_email = serializer.data['email'] hunter = PyHunter(settings.HUNTER_KEY) if hunter.email_verifier(user_email)['result'] == 'undeliverable': logger.warning( 'New user with invalid email was registered. Email: %s' % user_email) # I let the user with the undeliverable email to register because we have to implement bot for this task, # otherwise we would have here: # return Response( # {'message': 'New user with invalid email tried to register. Email: %s' % user_email}, # status=status.HTTP_400_BAD_REQUEST) else: try: clearbit.key = settings.CLEARBIT_KEY person = clearbit.Person.find(email=user_email, stream=True) except: person = None if person: full_name = person['name']['fullName'] country = person['geo']['country'] else: full_name = None country = None user = self.perform_create(serializer) user_profile = UserProfile(user=user, full_name=full_name, country=country) user_profile.save() headers = self.get_success_headers(serializer.data) logger.info('New user with email %s has been registered' % user_email) return Response(self.get_response_data(user), status=status.HTTP_201_CREATED, headers=headers)
hk = API_KEYS["hunter"] menu.sub_3() ek = input() while ek != '0': if ek == '1': if not hk: Style.Colors.RB("MISSING HUNTER API KEY. CANNOT COMPLETE THIS MODULE") Style.RST() break else: Style.Colors.C("ENTER AN EMAIL ADDRESS TO VERIFY") Style.RST() email = input() x = email hunter = PyHunter(hk) h = hunter.email_verifier(x) if h["result"] == "undeliverable": Style.Colors.RB(x + "EMAIL RETURNED AN UNDELIVERABLE! \n\n" + h["result"]) else: Style.Colors.GB(x + h["result"]) Style.RST() break if xkey == '4': print('ENTER HOSTNAME TO SCAN AND GATHER DATA ON') host = input() shkey = API_KEYS["shodan_key"] if not shkey: Style.Colors.RB('\nMISSING SHODAN API KEY, RETURNING TO MAIN MENU') Style.RST() else:
def Search(Query_List, Task_ID, Type, Limit=10): try: Data_to_Cache = [] Directory = General.Make_Directory(Plugin_Name.lower()) logger = logging.getLogger() logger.setLevel(logging.INFO) Log_File = General.Logging(Directory, Plugin_Name.lower()) handler = logging.FileHandler(os.path.join(Directory, Log_File), "w") handler.setLevel(logging.DEBUG) formatter = logging.Formatter("%(levelname)s - %(message)s") handler.setFormatter(formatter) logger.addHandler(handler) Shodan_API_Key = Load_Configuration() API_Session = PyHunter(Shodan_API_Key) Cached_Data_Object = General.Cache(Directory, Plugin_Name) Cached_Data = Cached_Data_Object.Get_Cache() Query_List = General.Convert_to_List(Query_List) Limit = General.Get_Limit(Limit) for Query in Query_List: try: if Type == "Domain": if Common.Regex_Handler(Query, Type="Domain"): Local_Plugin_Name = Plugin_Name + "-Domain" API_Response = API_Session.domain_search(Query) JSON_Object = Common.JSON_Handler(API_Response) JSON_Output_Response = JSON_Object.Dump_JSON() if API_Response["domain"] and API_Response['emails']: Main_File = General.Main_File_Create( Directory, Local_Plugin_Name, JSON_Output_Response, Query, The_File_Extensions["Main"]) Output_Connections = General.Connections( Query, Local_Plugin_Name, Domain, "Account", Task_ID, Plugin_Name.lower()) Current_Step = 0 for Hunter_Item in API_Response["emails"]: Current_Email_Address = Hunter_Item["value"] Current_Hunter_Item_Host = f"https://{Domain}/verify/{Current_Email_Address}" Current_Hunter_Item_Responses = Common.Request_Handler( Current_Hunter_Item_Host, Filter=True, Host=f"https://{Domain}") Filtered_Response = Current_Hunter_Item_Responses[ "Filtered"] Title = "Hunter | " + Current_Email_Address if Current_Email_Address not in Cached_Data and Current_Email_Address not in Data_to_Cache and Current_Step < int( Limit): Output_file = General.Create_Query_Results_Output_File( Directory, Query, Local_Plugin_Name, Filtered_Response, Current_Hunter_Item_Host, The_File_Extensions["Query"]) if Output_file: Output_Connections.Output( [Main_File, Output_file], Current_Hunter_Item_Host, Title, Plugin_Name.lower()) Data_to_Cache.append( Current_Email_Address) else: logging.warning( f"{Common.Date()} - {__name__.strip('plugins.')} - Failed to create output file. File may already exist." ) Current_Step += 1 elif Type == "Email": if Common.Regex_Handler(Query, Type="Email"): Local_Plugin_Name = Plugin_Name + "-Email" API_Response = API_Session.email_verifier(Query) JSON_Object = Common.JSON_Handler(API_Response) JSON_Output_Response = JSON_Object.Dump_JSON() if API_Response["email"] and API_Response['sources']: Main_File = General.Main_File_Create( Directory, Local_Plugin_Name, JSON_Output_Response, Query, The_File_Extensions["Main"]) Output_Connections = General.Connections( Query, Local_Plugin_Name, Domain, "Account Source", Task_ID, Plugin_Name.lower()) Current_Step = 0 for Hunter_Item in API_Response["sources"]: Current_Hunter_Item_Host = Hunter_Item["uri"] Current_Hunter_Item_Domain = Hunter_Item[ "domain"] if 'http://' in Current_Hunter_Item_Host: Current_Hunter_Item_Responses = Common.Request_Handler( Current_Hunter_Item_Host, Filter=True, Host= f"http://{Current_Hunter_Item_Domain}") Filtered_Response = Current_Hunter_Item_Responses[ "Filtered"] elif 'https://' in Current_Hunter_Item_Host: Current_Hunter_Item_Responses = Common.Request_Handler( Current_Hunter_Item_Host, Filter=True, Host= f"https://{Current_Hunter_Item_Domain}" ) Filtered_Response = Current_Hunter_Item_Responses[ "Filtered"] else: Filtered_Response = Common.Request_Handler( Current_Hunter_Item_Host) Title = "Hunter | " + Current_Hunter_Item_Host if Current_Hunter_Item_Host not in Cached_Data and Current_Hunter_Item_Host not in Data_to_Cache and Current_Step < int( Limit): Output_file = General.Create_Query_Results_Output_File( Directory, Query, Local_Plugin_Name, Filtered_Response, Current_Hunter_Item_Host, The_File_Extensions["Query"]) if Output_file: Output_Connections.Output( [Main_File, Output_file], Current_Hunter_Item_Host, Title, Plugin_Name.lower()) Data_to_Cache.append( Current_Hunter_Item_Host) else: logging.warning( f"{Common.Date()} - {__name__.strip('plugins.')} - Failed to create output file. File may already exist." ) Current_Step += 1 except Exception as e: logging.warning( f"{Common.Date()} - {__name__.strip('plugins.')} - Failed to complete task - {str(e)}" ) Cached_Data_Object.Write_Cache(Data_to_Cache) except Exception as e: logging.warning( f"{Common.Date()} - {__name__.strip('plugins.')} - {str(e)}")
def verify_email(user): hunter = PyHunter(settings.HUNTER_KEY) response = hunter.email_verifier(user.email) if response['regexp'] and response['smtp_check']: user.verified_email = True user.save(update_fields=['verified_email'])
def main(): linkedin_username = os.getenv("LINKEDIN_USER") linkedin_passkey = os.getenv("LINKEDIN_PASS") hunter_apikey = os.getenv("HUNTER_API") chromedriver_dir = os.getenv("CHROMEDRIVER") listing_url = input( "Welcome to Recruit_Link! Please enter a job listing's LinkedIn url:\n" ) name, title, profile, company, company_website, job_title = \ find_contact(listing_url, linkedin_username, linkedin_passkey, chromedriver_dir) company_website = company_website.replace("bit.ly", f"{company}.com").replace( "/careers", "") print(f"Now searching for: {name.strip()}, {title.strip()}\n") email_message = f"Hi {name.split()[0]},\n" \ f"\n" \ f"I hope this email finds you well. I just recently saw a posting for a {job_title} position at {company}" \ f" and would love to learn more. My experience with Python, SQL, SKILLS HERE feels like a great fit for " \ f"the role.\n" \ f"\n" \ f"Could you tell me more about the data science team and what it's like to work for the company? " \ f"I believe you would have great insight as a {title.strip()} for {company}.\n" \ f"\n" \ f"I appreciate any information you could provide, looking forward to hearing from you!\n" \ f"\n" \ f"Thank you,\n" \ f"\n" linkedin_message = f"Hi {name.split()[0]}, I recently saw a {job_title} position at {company} and I wanted " \ f"to learn more about your company! My experience with Python, SQL, FILL feels like a great fit " \ f"for the role. Would love any more information you have, thanks!" name = name.lower() company_email = company_website.replace("https://www.", "@")\ .replace("http://www.", "@")\ .replace("http:", "@")\ .replace("https:", "@")\ .replace("jobs.", "")\ .replace(r"\.com.*$", ".com")\ .replace("/", "") patterns = [ "finitiallast", "finitial.last", "firstlast", "first.last", "first", "last", "firstlinitial", "first.linitial", "first_linitial", "finitial_last" ] patterns = [ pattern.replace("first", name.split()[0]).replace( "last", name.split()[-1]).replace( "finitial", name.split()[0][0]).replace( "linitial", name.split()[-1][0]) + company_email for pattern in patterns ] hunter = PyHunter(hunter_apikey) # Hunter API Key here hunter_email, confidence_score = hunter.email_finder(company_website, full_name=name) if hunter_email: emails = [hunter_email] + patterns else: emails = patterns for email in emails: print(f"Checking {email}...") try: verification = hunter.email_verifier(email) except: continue if verification['result'] == 'deliverable': print("Success, found the following email:\n") print(email) pyperclip.copy(email_message) print("Message pasted to clipboard.") exit() elif email == emails[-1]: print(f"Email search failed, try to contact on LinkedIn:\n" f"{profile}") pyperclip.copy(linkedin_message) print("Message pasted to clipboard.") exit() else: continue
def check_email(email): hunter = PyHunter(os.getenv("HUNTER_API")) result = hunter.email_verifier(email) return result['webmail']
url = x print(url) results = hunter.domain_search(url) printed = json.dumps(results) fopen.write(printed) fopen.close() elif (args.fns): company1 = input("Enter company of interest..") name = input("Enter person of interest") results = hunter.email_finder(company=company1, full_name=name, raw=True) print(results) elif (args.v): validatepls = input("File with Email addresses to validate..") outfile = input("Location of output text file..") fopen = open(outfile, 'w') with open(validatepls) as f: for i in f: x = i.rstrip('\n') print(x) emailname = x print(emailname) validated = hunter.email_verifier(emailname) printed = json.dumps(validated) fopen.write(emailname) fopen.write('\n') fopen.write(printed) fopen.close() elif (args.c): number_left = hunter.account_information() print(number_left)
def post(self, request, *args, **kwargs): username = request.data.get("username", "") password = request.data.get("password", "") email = request.data.get("email", "") first_name = request.data.get("first_name", "") last_name = request.data.get("last_name", "") if not username and not password and not email: return Response(data={ "message": "username, password and email is required to register a user" }, status=status.HTTP_400_BAD_REQUEST) try: validate_email(email) except ValidationError as e: return Response( data={"message": "please provide proper email address"}, status=status.HTTP_400_BAD_REQUEST) try: validate_password( password, password_validators=[MinimumLengthValidator(min_length=6)]) except ValidationError as e: return Response( data={"message": "password length should be 6 or longer"}, status=status.HTTP_400_BAD_REQUEST) try: hunter = PyHunter(EMAILHUNTER_API_KEY) email_verifier = hunter.email_verifier(email) if (not email_verifier or email_verifier['result'] == 'undeliverable'): return Response(data={ "message": "email address: {} is not deliverable".format(email) }, status=status.HTTP_400_BAD_REQUEST) except Exception as e: return Response(data={"message": e.args[0]}, status=status.HTTP_500_INTERNAL_SERVER_ERROR) try: new_user = User.objects.create_user(username=username, password=password, email=email, first_name=first_name, last_name=last_name) except IntegrityError as e: if 'UNIQUE constraint' in e.args[0]: return Response(data={ "message": "username {} already exists".format(username) }, status=status.HTTP_409_CONFLICT) try: clearbit.key = CLEARBIT_API_KEY profile_data_clearbit = clearbit.Enrichment.find(email=email, stream=True) except Exception as e: return Response(data={"message": e.args[0]}, status=status.HTTP_500_INTERNAL_SERVER_ERROR) if profile_data_clearbit and 'person' in profile_data_clearbit: new_user.profile.bio = profile_data_clearbit['person']['bio'] new_user.profile.site = profile_data_clearbit['person']['site'] new_user.profile.location = profile_data_clearbit['person'][ 'location'] new_user.profile.timezone = profile_data_clearbit['person'][ 'timeZone'] new_user.profile.utc_offset = profile_data_clearbit['person'][ 'utcOffset'] new_user.profile.company_name = profile_data_clearbit['person'][ 'employment']['name'] new_user.profile.company_role = profile_data_clearbit['person'][ 'employment']['role'] new_user.profile.facebook_handle = profile_data_clearbit['person'][ 'facebook']['handle'] new_user.profile.twitter_handle = profile_data_clearbit['person'][ 'twitter']['handle'] new_user.profile.github_handle = profile_data_clearbit['person'][ 'github']['handle'] new_user.profile.linkedin_handle = profile_data_clearbit['person'][ 'linkedin']['handle'] new_user.profile.googleplus_handle = profile_data_clearbit[ 'person']['googleplus']['handle'] new_user.save() return Response(data=UserSerializer(new_user).data, status=status.HTTP_201_CREATED)
categories = [] data = [] # NanData = ['noEmail']*12 + [[]] # verify2 = hunter.email_verifier('*****@*****.**') # len=13 # To populate the dataframe we are just going to iterate through the dictionary # If sources are empty, then pass,else iterate through sources hunterInfo = pd.DataFrame(columns=['result','score', 'Email','regexp','gibberish', 'disposable','webmail','mx_records','smtp_server', 'smtp_check','accept_all','block','sources']) total= len(temp_list) counter = 0 for email in temp_list: counter += 1 print('{}/{}'.format(counter,total)) print('Verifying {}...'.format(email)) verify_dict = hunter.email_verifier(email) for items in verify_dict.items(): # print(items) # print(type(items[0])) # categories.append(items[0]) data.append(items[1]) hunterInfo.loc[len(hunterInfo)] = data data = [] ''' for emails in email_list: verify_dict=email_verifier(emails) source = verify_dict['sources'] if not source: 'no source'