def targets(workspace_id, list_id): ''' For GET requets, return all targets of the given list. For POST requests, add a target to the given list. ''' if not validate_workspace(workspace_id): return 'workspace does not exist', 404 targetlist = List.query.filter_by(id=list_id, workspace_id=workspace_id).first() if targetlist is None: return 'list does not exist', 404 # request is a GET if request.method == 'GET': targets = Person.query.filter_by(list_id=list_id) schema = PersonSchema(many=True, strict=True) all_targets = schema.dump(targets) return jsonify(all_targets) # request is a POST if request.method == 'POST': first_name = request.form.get('first_name') last_name = request.form.get('last_name') email = request.form.get('email') person = Person(first_name=first_name, last_name=last_name, email=email) targetlist.targets.append(person) update_workspace_ts(Workspace.query.filter_by(id=workspace_id).first()) db.session.commit() return 'added person', 201
def campaign_modules(workspace_id): ''' For GET requests, return possible campaign modules in the given workspace. ''' if not validate_workspace(workspace_id): return 'workspace does not exist', 404 page_names = Page.query.with_entities( Page.name).filter((Page.workspace_id == workspace_id) | (Page.workspace_id == 1)).all() list_names = List.query.with_entities( List.name).filter((List.workspace_id == workspace_id) | (List.workspace_id == 1)).all() email_names = Email.query.with_entities( Email.name).filter((Email.workspace_id == workspace_id) | (Email.workspace_id == 1)).all() profile_names = Profile.query.with_entities( Profile.name).filter((Profile.workspace_id == workspace_id) | (Profile.workspace_id == 1)).all() domain_names = Domain.query.with_entities(Domain.domain).all() server_names = Server.query.with_entities(Server.alias).all() all_info = { "pages": [item for sublist in page_names for item in sublist], # make list of lists a flat list "lists": [item for sublist in list_names for item in sublist], "emails": [item for sublist in email_names for item in sublist], "profiles": [item for sublist in profile_names for item in sublist], "domains": [item for sublist in domain_names for item in sublist], "servers": [item for sublist in server_names for item in sublist], } return jsonify(all_info), 200
def email(workspace_id, email_id): ''' For GET requests, return the given email. For DELETE requests, delete the given email. For PUT requests, update the given email. ''' if not validate_workspace(workspace_id): return 'workspace does not exist', 404 email = Email.query.filter_by(id=email_id, workspace_id=workspace_id).first() if email is None: return 'email does not exist', 404 #request is a GET if request.method == 'GET': schema = EmailSchema(strict=True) email_data = schema.dump(email) return jsonify(email_data) # request is a DELETE elif request.method == 'DELETE': db.session.delete(email) update_workspace_ts(Workspace.query.filter_by(id=workspace_id).first()) db.session.commit() return 'deleted', 204 # request is a PUT elif request.method == 'PUT': name = request.form.get('Name') subject = request.form.get('Subject') html = request.form.get('HTML').encode() track = request.form.get('Track') same_email = Email.query.filter_by(name=name).first() if same_email is not None and str(same_email.id) != email_id: print(same_email.name, same_email.id) return json.dumps({'success': False}), 200, { 'ContentType': 'application/json' } track_bool = convert_to_bool(track) if type(track_bool) != bool: return 'Track must be either true or false', 400 email.name = name email.subject = subject email.html = html email.track = track_bool update_workspace_ts(Workspace.query.filter_by(id=workspace_id).first()) db.session.commit() return json.dumps({'success': True}), 200, { 'ContentType': 'application/json' }
def targetlist(workspace_id, list_id): ''' For GET requests, return the given list. For PUT requests, udpate the given list. For DELETE requests, delete the given list. ''' if not validate_workspace(workspace_id): return 'workspace does not exist', 404 targetlist = List.query.filter_by(id=list_id, workspace_id=workspace_id).first() if targetlist is None: return 'list does not exist', 404 # request is a GET if request.method == 'GET': schema = ListSchema(strict=True) list_data = schema.dump(targetlist) return jsonify(list_data) # request is a DELETE elif request.method == 'DELETE': db.session.delete(targetlist) update_workspace_ts( Workspace.query.filter_lby(id=workspace_id).first()) db.session.commit() return '', 204 # request is a PUT (update attributes of the List) elif request.method == 'PUT': req_json = request.get_json() name = req_json['name'] targets = req_json['targets'] same_list = List.query.filter_by(name=name).first() if same_list is not None and str(same_list.id) != list_id: return json.dumps({'success': False}), 200, { 'ContentType': 'application/json' } targetlist.targets = [] for target in targets: person = Person(first_name=target['first_name'], last_name=target['last_name'], email=target['email']) targetlist.targets.append(person) targetlist.name = name update_workspace_ts(Workspace.query.filter_by(id=workspace_id).first()) db.session.commit() schema = ListSchema(strict=True) list_data = schema.dump(targetlist) return jsonify(list_data[0]), 201
def cast(workspace_id, campaign_id): ''' For GET requests, kick off the given campaign. ''' if not validate_workspace(workspace_id): return json.dumps({ 'success': False, 'reasonCode': 1 }), 200, { 'ContentType': 'application/json' } campaign = Campaign.query.filter_by(id=campaign_id, workspace_id=workspace_id).first() if campaign is None: return json.dumps({ 'success': False, 'reasonCode': 2 }), 200, { 'ContentType': 'application/json' } if campaign.status != 'Inactive': return json.dumps({ 'success': False, 'reasonCode': 3 }), 200, { 'ContentType': 'application/json' } if campaign.server.check_status() != 'Online': return json.dumps({ 'success': False, 'reasonCode': 4 }), 200, { 'ContentType': 'application/json' } schema = WorkerCampaignSchema(strict=True) campaign_data = schema.dump(campaign) campaign.prep_tracking() campaign.cast(campaign_data) return json.dumps({'success': True}), 200, { 'ContentType': 'application/json' }
def page(workspace_id, page_id): ''' For GET requests, return the given page. For DELETE requests, delete the given page. For PUT requests, update the given page. ''' if not validate_workspace(workspace_id): return 'workspace does not exist', 404 page = Page.query.filter_by(id=page_id, workspace_id=workspace_id).first() if page is None: return 'page does not exist', 404 #request is a GET if request.method == 'GET': page.find_form_fields() schema = PageSchema(strict=True) page_data = schema.dump(page) return jsonify(page_data) # request is a DELETE elif request.method == 'DELETE': db.session.delete(page) update_workspace_ts(Workspace.query.filter_by(id=workspace_id).first()) db.session.commit() return 'deleted', 204 # request is a PUT elif request.method == 'PUT': name = request.form.get('Name') html = request.form.get('HTML').encode() url = request.form.get('URL') same_page = Page.query.filter_by(name=name).first() if same_page is not None and str(same_page.id) != page_id: return json.dumps({'success': False}), 200, { 'ContentType': 'application/json' } page.name = name page.html = html page.url = url update_workspace_ts(Workspace.query.filter_by(id=workspace_id).first()) db.session.commit() return json.dumps({'success': True}), 200, { 'ContentType': 'application/json' }
def campaign_results(workspace_id, campaign_id): ''' For GET requests, return results for the given campaign. ''' if not validate_workspace(workspace_id): return 'workspace does not exist', 404 campaign = Campaign.query.filter_by(id=campaign_id, workspace_id=workspace_id).first() if campaign is None: return 'campaign does not exist', 404 schema = ResultSchema(many=True, strict=True) results = schema.dump(campaign.results) return jsonify(results[0])
def profiles(workspace_id): ''' For GET requests, return all profiles. For POST requests, add a new profile. ''' if not validate_workspace(workspace_id): return 'workspace does not exist', 404 if request.method == 'GET': all_profiles = Profile.query.filter_by( workspace_id=workspace_id).order_by( Profile.updated_at.desc()).all() schema = ProfileSchema(many=True, strict=True) profiles = schema.dump(all_profiles) return jsonify(profiles[0]) # request is a POST else: name = request.form.get('Name') from_address = request.form.get('From_Address') host = request.form.get('SMTP_Host') port = request.form.get('SMTP_Port') username = request.form.get('Username') password = request.form.get('Password') tls = request.form.get('TLS') ssl = request.form.get('SSL') profile = Profile.query.filter_by(name=name).first() ssl_bool = convert_to_bool(ssl) tls_bool = convert_to_bool(tls) if profile is not None: return json.dumps({'success': False}), 200, { 'ContentType': 'application/json' } elif type(ssl_bool) != bool or type(tls_bool) != bool: return 'ssl/tls must be either true or false', 400 profile = Profile(name=name, from_address=from_address, smtp_host=host, smtp_port=port, \ username=username, password=password, tls=tls_bool, ssl=ssl_bool, workspace_id=workspace_id) db.session.add(profile) update_workspace_ts(Workspace.query.filter_by(id=workspace_id).first()) db.session.commit() schema = ProfileSchema(strict=True) profile_data = schema.dump(profile) return jsonify(profile_data[0]), 201
def workspace_results(workspace_id): ''' For GET requests, return results for all campaigns in the given workspace. ''' if not validate_workspace(workspace_id): return 'workspace does not exist', 404 workspace_results = Result.query.join(Campaign).join(Workspace).filter( Workspace.id == workspace_id).all() campaigns = Campaign.query.filter_by(workspace_id=workspace_id).all() schema = ResultCampaignSchema(many=True, strict=True) c_results = schema.dump(campaigns) schema = ResultSchema(many=True, strict=True) results = schema.dump(workspace_results) return jsonify(c_results[0], results[0])
def targetlists(workspace_id): ''' For GET requests, return all target lists associated with the given workspace. For POST requests, add a new list to the given workspace. ''' if not validate_workspace(workspace_id): return 'workspace does not exist', 404 # request is a GET if request.method == 'GET': workspace_lists = List.query.filter_by(workspace_id=workspace_id).all() schema = ListSchema(many=True, strict=True) list_data = schema.dump(workspace_lists) return jsonify(list_data[0]) # request is a POST elif request.method == 'POST': req_json = request.get_json() print(req_json) name = req_json['name'] targets = req_json['targets'] list_name = List.query.filter_by(workspace_id=workspace_id, name=name).first() if list_name is not None: return json.dumps({'success': False}), 200, { 'ContentType': 'application/json' } new_list = List(name=name, workspace_id=workspace_id) for target in targets: person = Person(first_name=target['first_name'], last_name=target['last_name'], email=target['email']) new_list.targets.append(person) db.session.add(new_list) update_workspace_ts(Workspace.query.filter_by(id=workspace_id).first()) db.session.commit() schema = ListSchema(strict=True) list_data = schema.dump(new_list) return jsonify(list_data[0]), 201
def target(workspace_id, list_id, target_id): ''' For DELETE requests, delete the given target from the given list. ''' if not validate_workspace(workspace_id): return 'workspace does not exist', 404 targetlist = List.query.filter_by(id=list_id, workspace_id=workspace_id).first() if targetlist is None: return 'list does not exist', 404 target = Person.query.filter_by(id=target_id, list_id=list_id).first() if target is None: return 'target does not exist' db.session.delete(target) update_workspace_ts(Workspace.query.filter_by(id=workspace_id).first()) db.session.commit() return 'deleted', 204
def emails(workspace_id): ''' For GET requests, return all emails for the given workspace. For POST requests, add a new email to the given workspace. ''' if not validate_workspace(workspace_id): return 'workspace does not exist', 404 # request is a GET if request.method == 'GET': all_emails = Email.query.filter_by(workspace_id=workspace_id).order_by( Email.updated_at.desc()).all() schema = EmailSchema(many=True, strict=True) email_data = schema.dump(all_emails) return jsonify(email_data[0]) # request is a POST elif request.method == 'POST': name = request.form.get('Name') html = request.form.get('HTML').encode() subject = request.form.get('Subject') track = request.form.get('Track') track_bool = convert_to_bool(track) if type(track_bool) != bool: return 'Track must be either true or false', 400 email = Email(name=name, html=html, subject=subject, workspace_id=workspace_id, track=track_bool) db.session.add(email) update_workspace_ts(Workspace.query.filter_by(id=workspace_id).first()) db.session.commit() schema = EmailSchema(strict=True) email_data = schema.dump(email) return jsonify(email_data[0]), 200
def pages(workspace_id): ''' For GET requests, return all pages for the given workspace. For POST requests, add a new pages to the given workspace. ''' if not validate_workspace(workspace_id): return 'workspace does not exist', 404 # request is a GET if request.method == 'GET': all_pages = Page.query.filter_by(workspace_id=workspace_id).order_by( Page.updated_at.desc()).all() schema = PageSchema(many=True, strict=True) page_data = schema.dump(all_pages) return jsonify(page_data[0]) # request is a POST elif request.method == 'POST': name = request.form.get('Name') html = request.form.get('HTML').encode() url = request.form.get('URL') page = Page.query.filter_by(name=name).first() if page is not None: return json.dumps({'success': False}), 200, { 'ContentType': 'application/json' } page = Page(name=name, html=html, workspace_id=workspace_id, url=url) db.session.add(page) update_workspace_ts(Workspace.query.filter_by(id=workspace_id).first()) db.session.commit() schema = PageSchema(strict=True) page_data = schema.dump(page) return jsonify(page_data[0]), 201
def kill(workspace_id, campaign_id): ''' For GET requests, kill the given campaign. ''' if not validate_workspace(workspace_id): return 'workspace does not exist', 404 campaign = Campaign.query.filter_by(id=campaign_id, workspace_id=workspace_id).first() if campaign is None: return 'campaign does not exist', 404 if campaign.status != 'Active': return 'campaign is not active', 400 if campaign.server.check_status() != 'Online': campaign.status = 'Complete' db.session.commit() return 'could not stop campaign: %s. - campaign changed to completed' % campaign.server.status, 400 campaign.kill() return 'campaign killed', 200
def campaign(workspace_id, campaign_id): ''' For GET requests, return the given campaign. For DELETE requests, delete the given campaign. For PUT requests, update the given campaign. ''' if not validate_workspace(workspace_id): return 'workspace does not exist', 404 campaign = Campaign.query.filter_by(id=campaign_id, workspace_id=workspace_id).first() if campaign is None: return 'campaign does not exist', 404 # request is a GET if request.method == 'GET': schema = CampaignSchema(strict=True) campaign_data = schema.dump(campaign) return jsonify(campaign_data) # request is a DELETE elif request.method == 'DELETE': if campaign.status == 'Active': kill(workspace_id, campaign_id) db.session.delete(campaign) update_workspace_ts(Workspace.query.filter_by(id=workspace_id).first()) db.session.commit() return 'campaign deleted', 204 # request is a PUT elif request.method == 'PUT': name = request.form.get('Name') email_name = request.form.get('Email_Name') profile_name = request.form.get('Profile_Name') list_name = request.form.get('List_Name') domain_name = request.form.get('Domain_Name') server_alias = request.form.get('Server_Alias') port = request.form.get('Port') ssl = request.form.get('SSL') redirect_url = request.form.get('Redirect_URL') same_campaign = Campaign.query.filter_by(name=name).first() if same_campaign is not None and str(same_campaign.id) != campaign_id: return json.dumps({'success': False}), 200, { 'ContentType': 'application/json' } ssl_bool = convert_to_bool(ssl) if type(ssl_bool) != bool: return 'ssl must be either true or false', 400 email = Email.query.filter_by(name=email_name, workspace_id=workspace_id).first() profile = Profile.query.filter_by(name=profile_name, workspace_id=workspace_id).first() targetlist = List.query.filter_by(name=list_name, workspace_id=workspace_id).first() domain = Domain.query.filter_by(domain=domain_name).first() server = Server.query.filter_by(alias=server_alias).first() # make sure all given modules exist before continuing makeup = validate_campaign_makeup(email, page, profile, targetlist, domain, server) if makeup: return makeup campaign.name = name campaign.email_id = email.id campaign.profile_id = profile.id campaign.list_id = targetlist.id campaign.domain_id = domain.id campaign.server_id = server.id campaign.port = port campaign.ssl = ssl_bool campaign.redirect_url = redirect_url update_workspace_ts(Workspace.query.filter_by(id=workspace_id).first()) db.session.commit() return 'campaign updated'
def profile(workspace_id, profile_id): ''' For GET requests, return the profile with the given name. For POST requests, use the given profile to send a test email. For DELETE requests, delete the given profile. ''' if not validate_workspace(workspace_id): return 'workspace does not exist', 404 profile = Profile.query.filter_by(id=profile_id, workspace_id=workspace_id).first() if profile is None: return 'profile does not exist', 404 # request is a GET if request.method == 'GET': schema = ProfileSchema(strict=True) profile_data = schema.dump(profile) return jsonify(profile_data) # request is a DELETE elif request.method == 'DELETE': db.session.delete(profile) update_workspace_ts(Workspace.query.filter_by(id=workspace_id).first()) db.session.commit() return 'profile deleted', 204 # request is a POST elif request.method == 'POST': address = request.form.get('Address') if not validate_email_format(address): return 'Enter a valid email address', 400 success = profile.send_test_mail(address) return json.dumps({'success': success}), 200, { 'ContentType': 'application/json' } # request is a PUT elif request.method == 'PUT': name = request.form.get('Name') from_address = request.form.get('From_Address') host = request.form.get('SMTP_Host') port = request.form.get('SMTP_Port') username = request.form.get('Username') password = request.form.get('Password') tls = request.form.get('TLS') ssl = request.form.get('SSL') same_profile = Profile.query.filter_by(name=name).first() if same_profile is not None and str(same_profile.id) != profile_id: return json.dumps({'success': False}), 200, { 'ContentType': 'application/json' } ssl_bool = convert_to_bool(ssl) tls_bool = convert_to_bool(tls) if type(ssl_bool) != bool or type(tls_bool) != bool: return 'ssl/tls must be either true or false', 400 profile.name = name profile.from_address = from_address profile.smtp_host = host profile.smtp_port = port profile.username = username profile.password = password profile.tls = tls_bool profile.ssl = ssl_bool profile.workspace_id = workspace_id update_workspace_ts(Workspace.query.filter_by(id=workspace_id).first()) db.session.commit() schema = ProfileSchema(strict=True) profile_data = schema.dump(profile) return jsonify(profile_data[0]), 200
def campaigns(workspace_id): ''' For GET requests, return all campaigns for the given workspace. For POST requests, all a campaign to the given workspace. ''' if not validate_workspace(workspace_id): return 'workspace does not exist', 404 # request is a GET if request.method == 'GET': all_campaigns = Campaign.query.filter_by( workspace_id=workspace_id).order_by( Campaign.updated_at.desc()).all() # sort the pages associated with the campaign by index for campaign in all_campaigns: campaign.pages.sort(key=lambda camp: camp.index) schema = CampaignSchema(many=True, strict=True) campaign_data = schema.dump(all_campaigns) return jsonify(campaign_data[0]) # request is a POST elif request.method == 'POST': name = request.form.get('Name') email_name = request.form.get('Email_Name') page_names = request.form.getlist( 'Page_Names[]' ) # page names is a list of page names # page names is a list of page names profile_name = request.form.get('Profile_Name') list_name = request.form.get('List_Name') domain_name = request.form.get('Domain_Name') server_alias = request.form.get('Server_Alias') port = request.form.get('Port') ssl = request.form.get('SSL') redirect_url = request.form.get('Redirect_URL') ssl_bool = convert_to_bool(ssl) if type(ssl_bool) != bool: return 'ssl must be either true or false', 400 pages = [] for page_name in page_names: page = Page.query.with_entities( Page).filter((Page.name == page_name) & ((Page.workspace_id == 2) | (Page.workspace_id == 1))).first() pages.append(page) email = Email.query.with_entities(Email).filter( (Email.name == email_name) & ((Email.workspace_id == 2) | (Email.workspace_id == 1))).first() profile = Profile.query.with_entities( Profile).filter((Profile.name == profile_name) & ((Profile.workspace_id == 2) | (Profile.workspace_id == 1))).first() targetlist = List.query.with_entities(List).filter( (List.name == list_name) & ((List.workspace_id == 2) | (List.workspace_id == 1))).first() domain = Domain.query.filter_by(domain=domain_name).first() server = Server.query.filter_by(alias=server_alias).first() # make sure all given modules exist before continuing makeup = validate_campaign_makeup(email, pages, profile, targetlist, domain, server) if makeup: return makeup campaign = Campaign(name=name, workspace_id=workspace_id, email_id=email.id, profile_id=profile.id, \ list_id=targetlist.id, domain_id=domain.id, server_id=server.id, port=port, ssl=ssl_bool, redirect_url=redirect_url) #for page in pages: #print(campaign.id) db.session.add(campaign) update_workspace_ts(Workspace.query.filter_by(id=workspace_id).first()) db.session.commit() for idx, page in enumerate(pages): page_association = Campaignpages(campaign_id=campaign.id, page_id=page.id, index=idx) db.session.add(page_association) db.session.commit() return json.dumps({ 'success': True, 'id': campaign.id }), 200, { 'ContentType': 'application/json' }