def admin_dashboard():
current_user = get_current_user()
users = User.query.filter_by(is_registered=True).order_by(User.name).all()
messages = get_all_messages()
event_types = ['home', 'register', 'feed', 'profile', 'send_message', 'about', 'logout']
daily_events = {t: get_daily_events(t) for t in event_types}
return render_template("admin_dashboard.html", users=users, current_user=current_user, messages=messages, daily_events=daily_events)
def feed(show_intro, filter):
user = get_current_user()
if not user:
return redirect(url_for('index'))
# get feed companies
feed_companies_query = feed_companies_query_template.format(user.id)
companies_results = db.engine.execute(feed_companies_query)
# get feed friends
feed_friends_query = feed_friends_query_template.format(user.id)
friends_results = db.engine.execute(feed_friends_query)
# populate dicts with resulting companies and friends
companies = get_companies_and_friends_feed_info_from_query_results(companies_results, friends_results)
# split into 4 vertical columns
companies_vertical = prepare_companies_for_feed(companies, filter)
# pick ahri index
ahri_column = random.randint(1, 4)
ahri_row = random.randint(1, len(companies_vertical[0]) / 2 + 1)
# count how many are still scraping
feed_companies_pending_query = feed_companies_pending_query_template.format(user.id)
pending_result = db.engine.execute(feed_companies_pending_query)
for row in pending_result:
pending_count = row[0]
# fetch vetted companies
exclude_inlist = ",".join([str(id) for id in companies])
feed_vetted_companies_query = feed_vetted_companies_query_template.format(user.id, exclude_inlist)
vetted_companies_results = db.engine.execute(feed_vetted_companies_query)
vetted_companies = get_companies_and_friends_feed_info_from_query_results(vetted_companies_results, [])
# split into 4 vertical columns
vetted_companies_vertical = prepare_companies_for_feed(vetted_companies)
# log event
log_event(user.id, 'feed', {'ip': request.remote_addr, 'companies_count': len(companies)})
# print page
return render_template('feed.html', companies_vertical=companies_vertical, vetted_companies_vertical=vetted_companies_vertical, pending_count=pending_count, current_user=user, show_intro=show_intro, ahri_column=ahri_column, ahri_row=ahri_row)
def admin_add_article_form():
current_user = get_current_user()
article_fields = [
"title",
"subtitle",
"url",
"author_name",
"image_url",
"content",
"mins_to_read",
"order_id",
"is_visible"
]
ArticleForm = model_form(Article, article_fields)
article = Article(current_user.id)
form = ArticleForm(request.form, obj=article)
if form.validate_on_submit():
form.populate_obj(article)
db.session.add(article)
db.session.commit()
print 'Inserted article ' + str(article.title) + ' <--'
return redirect(url_for('articles'))
elif form.is_submitted():
flash(form.errors)
return render_template("admin_add_article_form.html", fields=article_fields, form=form)
def view_campaign(campaign_id):
user = get_current_user()
if not user:
return redirect(url_for('index'))
campaign = Campaign.query.get(campaign_id)
if not campaign:
return 'No such campaign id' # TODO better
if campaign.user_id != user.id:
return 'This is not your campaign' # TODO better
return render_template('view_campaign.html', campaign=campaign)
def kuenne_multiaccount():
user = get_current_user()
if not user.is_admin and user.id != 4973:
return 'Not Kuenne'
if user.linkedin_tokens_json:
linkedin_tokens = json.loads(user.linkedin_tokens_json)
else:
linkedin_tokens = dict()
app_indexes = [str(app_idx) for app_idx in range(len(LINKEDIN_API_AND_SECRET_KEYS))]
return render_template('kuenne_multiaccount.html', linkedin_tokens=linkedin_tokens, app_indexes=app_indexes, current_user=user)
def remove_favorite(company_id):
current_user = get_current_user()
if not current_user:
return 'BLA' # TODO better response
company = Company.query.get(company_id)
if not company:
return 'BLAA' # TODO better
current_user.favorites.remove(company)
db.session.commit()
resp = json.dumps({'status': 'ok', 'company_id': company_id})
print 'remove favorite response = ' + str(resp)
return resp # TODO better response
def kuenne_login_callback():
user = get_current_user()
if not user.is_admin and user.id != 4973:
return 'Not Kuenne'
app_idx = session.get('kuenne_linkedin_app_idx')
if user.linkedin_tokens_json:
linkedin_tokens = json.loads(user.linkedin_tokens_json)
else:
linkedin_tokens = dict()
linkedin_tokens[app_idx] = session['kuenne_linkedin_token']
user.linkedin_tokens_json = json.dumps(linkedin_tokens)
db.session.commit()
return redirect(url_for('kuenne_multiaccount'))
def send_feedback():
current_user = get_current_user()
user_id = None
if current_user:
user_id = current_user.id
data = json.loads(request.data)
url = data.get('url')
text = data.get('text')
feedback = Feedback(user_id, url, text)
db.session.add(feedback)
db.session.commit()
resp = json.dumps({'status': 'ok'})
print 'feedback response = ' + str(resp)
return resp # TODO better response
def new_campaign():
user = get_current_user()
if not user:
return redirect(url_for('index'))
CampaignForm = model_form(Campaign, CAMPAIGN_FIELDS)
campaign = Campaign(user.id)
form = CampaignForm(request.form, obj=campaign)
if form.validate_on_submit():
form.populate_obj(campaign)
db.session.add(campaign)
db.session.commit()
print 'Created new campaign: ' + str(campaign.name)
return redirect(url_for('list_campaigns'))
return render_template("new_campaign.html", form=form)
def edit_campaign(campaign_id):
user = get_current_user()
if not user:
return redirect(url_for('index'))
CampaignForm = model_form(Campaign, CAMPAIGN_FIELDS)
campaign = Campaign.query.get(campaign_id)
if not campaign:
return 'No such campaign id' # TODO better
if campaign.user_id != user.id:
return 'This is not your campaign' # TODO better
form = CampaignForm(request.form, obj=campaign)
if form.validate_on_submit():
form.populate_obj(campaign)
db.session.commit()
print 'Edited campaign id ' + str(campaign.id)
return redirect(url_for('view_campaign', campaign_id=campaign_id))
elif form.is_submitted():
flash(form.errors)
return render_template("edit_campaign.html", form=form, campaign=campaign)
def send_linkedin_message(friend_id):
current_user = get_current_user()
if not current_user:
return 'Not logged in...' # TODO better error
data = json.loads(request.data)
subject = data.get('subject')
body = data.get('body')
body += "\n\n-------------------------\nSent from StartupLinx\nwww.startuplinx.co\nConnecting Students with Startups"
recipient = User.query.get(friend_id)
if not recipient:
return 'ERROR: Recipient not found' # TODO return real error
message = json.dumps({
"recipients": {
"values": [
{
"person": {
"_path": "/people/" + str(recipient.linkedin_id)
}
}
]
},
"subject": subject,
"body": body
})
print current_user.name.encode('utf8') + ' sending linkedin message to ' + recipient.name.encode('utf8') + ':'
response = post_linkedin_message(message)
print '...Sent! response data = ' + str(response.data)
# TODO better error handling
log_event(current_user.id, 'send_message', {
'ip': request.remote_addr,
'recipient_id': recipient.id,
'recipient_name': recipient.name,
'subject': subject,
'body': body,
'linkedin_response': response.data
})
print 'Logged event'
resp = json.dumps({'status': 'ok'})
if 'errorCode' in response.data or 'error' in response.data:
resp = json.dumps({'status': 'error'})
print 'send message resp = ' + str(resp)
return resp
def profile(company_id):
user = get_current_user()
if not user:
return redirect(url_for('index'))
# avoid SQL injections
company_id = int(company_id)
# get company
profile_company_query = profile_company_query_template.format(company_id)
company_result = db.engine.execute(profile_company_query).fetchone()
# get friends
if user.is_admin and session.get('admin_mode'):
# if admin mode is on, show all employees
profile_friends_query = profile_all_employees_query_template.format(company_id)
else:
# otherwise, just user's friends
profile_friends_query = profile_friends_query_template.format(user.id, company_id)
friends_results = db.engine.execute(profile_friends_query)
# populate dict with resulting company and friends
company = get_company_and_friends_profile_info_from_query_results(company_result, friends_results)
if not company:
return 'ERROR -- no company found'
log_event(user.id, 'profile', {'ip': request.remote_addr, 'company_id': company['id'], 'company_name': company['name']})
return render_template('profile.html', company=company, current_user=user)
def admin():
current_user = get_current_user()
users = User.query.filter_by(is_registered=True).order_by(User.name).all()
return render_template('admin.html', users=users, current_user=current_user)
def list_campaigns():
user = get_current_user()
if not user:
return redirect(url_for('index'))
campaigns = Campaign.query.filter_by(user_id=user.id).order_by(desc(Campaign.created)).all()
return render_template('list_campaigns.html', campaigns=campaigns, current_user=user)
def kuenne(is_csv):
user = get_current_user()
if not user.is_admin and user.id != 4973:
return 'Not Kuenne'
# first apply any changes to the website url / other form fields
for field, value in request.form.iteritems():
if field.startswith('website_') and value:
print field + ' -> ' + str(value)
company_id = int(field.split('_')[1])
company = Company.query.get(company_id)
print ' setting company_id ' + str(company_id) + ' (' + company.name.encode('utf8') + ') to ' + str(value)
company.website_url = value
db.session.commit()
# then fetch all the CEOs and founders that are connected to Kuenne
kuenne_query = kuenne_ceos_and_founders_query_template.format(11522) # 11522
results = db.engine.execute(kuenne_query)
# split in groups
groups = OrderedDict({
'good': [],
'meh': [],
'bad': []
})
ceos = dict()
for result in results:
job = get_job_from_result(result)
# add job to group
group = kuenne_get_job_group(job)
job['group'] = group
groups[group].append(job)
# add job to ceo's jobs and potentially fill in fields
user_id = job['user_id']
email_domains = json.loads(job['email_domains_json']) if job['email_domains_json'] else []
if user_id in ceos:
ceos[user_id]['jobs'].append(job)
ceos[user_id]['email_domains'] = [job['stripped_website_url']] + ceos[user_id]['email_domains'] + email_domains
else:
ceos[user_id] = {
'id': user_id,
'first_name': job['first_name'],
'last_name': job['last_name'],
'email': job['email'],
'group': 'bad',
'jobs': [job],
'email_domains': [job['stripped_website_url']] + email_domains,
'main_email_domains': []
}
if group == 'good':
ceos[user_id]['group'] = 'good'
# see if that's the position where s/he is CEO and fill the fields
is_ceo = False
is_founder = False
if job['title'].lower().find('founder') != -1:
is_founder = True
if job['title'].lower().find('ceo') != -1 or job['title'].lower().find('executive') != -1 or job['title'].lower().find('chief') != -1:
is_ceo = True
if is_ceo or is_founder:
ceos[user_id]['main_email_domains'] = [job['stripped_website_url']] + ceos[user_id]['main_email_domains'] + email_domains
if is_ceo and is_founder:
title = 'founder and CEO'
elif is_ceo:
title = 'CEO'
else:
title = 'founder'
ceos[user_id]['title'] = title
ceos[user_id]['company'] = job['company_name']
# find the good ones by user_id
good_ids = []
for job in groups['good']:
good_ids.append(job['user_id'])
# split in groups again, this time intelligently
new_groups = OrderedDict({
'good': [],
'meh': [],
'okay': [],
'bad': []
})
new_group_colors = {
'good': 'green',
'meh': 'gray',
'okay': 'brown',
'bad': 'red'
}
for group, jobs in groups.iteritems():
if group == 'good':
new_groups[group] = jobs
else:
for job in jobs:
if job['user_id'] in good_ids:
new_groups['okay'].append(job)
else:
new_groups[group].append(job)
if is_csv:
# generate CSV file for download
attributes = ['first_name', 'last_name', 'company', 'title', 'email']
lines = []
lines.append(','.join(attributes))
for id, ceo in ceos.iteritems():
if ceo['email']:
# use default email
line = ','.join(ceo[attr] for attr in attributes)
lines.append(line)
else:
# generate emails from domains and name
top_3_domains = get_top_3_domains(ceo['main_email_domains'])
emails = permute_emails(ceo['first_name'], ceo['last_name'], top_3_domains)
for email in emails:
ceo['email'] = email
line = ','.join(ceo[attr] for attr in attributes)
lines.append(line)
ceo['email'] = None
csv = '\n\r'.join(lines)
response = make_response(csv)
response.headers["Content-Disposition"] = "attachment; filename=ceos.csv"
return response
else:
return render_template('kuenne.html', current_user=user, groups=new_groups, group_colors=new_group_colors, ceos=ceos)
