def confirm_email(token):
s = URLSafeTimedSerializer(app.config['SECRET_KEY'])
email = s.loads(token, salt='email-confirm', max_age=3600)
UserService.confirm_customer(email, token)
form = forms.CustomerLogin()
return render_template("login.html", conf=True, form=form)
def admin_campaigns(customer_id):
vf = AdminViewFuncs(customer_id)
if vf.ValidView():
account_form = forms.AccountForm()
if request.method == 'POST' and account_form.validate_on_submit():
UserService.update_id(facebook_id=account_form.facebook_id.data,
google_id=account_form.google_id.data,
twitter_id=account_form.twitter_id.data,
customer_id=customer_id)
page = AdminViewModel(session['permissions'],
'campaigns',
admin=session['admin'],
user=customer_id,
view="campaigns")
return render_template('layouts/admin_layout.html',
view="campaigns",
owner=session['owner_logged_in'],
admin=session['admin_logged_in'],
manager=session['manager_logged_in'],
page=page,
customer_id=customer_id,
account_form=account_form)
else:
return 'You do not have permission to view this client.'
def login_post(service: UserService):
username = request.json.get('username')
password = request.json.get('password')
user = service.find_one_by(username=username)
if user is None:
raise UserLoginFailed()
service.verify_password(user, password)
response = jsonify(user.to_dict())
set_new_tokens(response, username)
return response
def customer_login():
if 'logged_in' in session and session.get('logged_in') == True:
return redirect(url_for("home"))
else:
form = forms.CustomerLogin()
if ViewFuncs.ValidSubmission(form=form, method=request.method):
loginResult, action = UserService.customer_login(
form.email.data, form.password.data)
return UserService.routeLogin(loginResult, action, form=form)
elif request.method == 'GET':
session['logged_in'] = False
return render_template('login.html', form=form)
def get_user_service():
global user_service
if user_service:
return user_service
else:
user_service = UserService()
return user_service
def temperature():
user_id = session["user_id"]
devices = UserService().get_by_user_id_and_type(user_id=user_id,
device_type="temperature")
return render_template("temperature.html",
user_id=user_id,
devices=devices)
def configure_services(binder):
user_validator = UserValidator()
user_service = UserService(user_validator)
binder.bind(UserService, to=user_service, scope=singleton)
area_validator = AreaValidator()
area_service = AreaService(area_validator)
binder.bind(AreaService, to=area_service, scope=singleton)
socket_server = SocketIO(cors_allowed_origins='*')
binder.bind(SocketIO, to=socket_server, scope=singleton)
notification_service = NotificationService(socket_server)
binder.bind(NotificationService, to=notification_service, scope=singleton)
area_service.emitter.on(AreaServiceEvents.AREA_ADDED, notification_service.notify_area_add)
area_service.emitter.on(AreaServiceEvents.AREA_UPDATED, notification_service.notify_area_update)
area_service.emitter.on(AreaServiceEvents.AREA_DELETED, notification_service.notify_area_delete)
def notification_service_on_authentication_try_link(sid: str, username: str):
user = user_service.find_one_by(username=username)
if not user:
notification_service.notify_authenticate_error(sid)
return
notification_service.authenticate_link_notify(sid, user)
notification_service.emitter.on(NotificationServiceEvents.AUTHENTICATE_TRY_LINK,
notification_service_on_authentication_try_link)
def meta(self):
query = 'SELECT tactic_id, title, description, image, category FROM tactics WHERE tactic_id = ?'
tup = (self.tag_id, )
data, cursor = db.execute(query, True, tup)
data = cursor.fetchall()
columns = ['tactic_id', 'title', 'description', 'image', 'category']
data = UserService.parseCursor(data, columns)
return data
def register_post(service: UserService):
username = request.json.get('username')
password = request.json.get('password')
first_name = request.json.get('first_name')
last_name = request.json.get('last_name')
user = service.add(username, password, first_name, last_name)
return jsonify(user.to_dict())
def get(self) -> dict:
query = f"""exec fetch_notifications @customer_id = {self.customer_id}"""
data, cursor = db.execute(query, True, ())
data = cursor.fetchall()
columns = [
'message_string', 'task_title', 'insight_body', 'message_from'
]
return_data = UserService.parseCursor(data, columns)
return return_data
def get_tests(self):
query = """SELECT * FROM get_tests(?)"""
data, cursor = db.execute(query, True, (self.customer_id,))
data = cursor.fetchall()
columns = [
'views', 'conversion', 'variant', 'best_worst_binary', 'hypothesis'
]
return_data = UserService.parseCursor(data, columns)
return return_data
class RatingService:
def __init__(self):
self.database = database
self.product = ProductService()
self.user = UserService()
def addRating(self, user_id, rating, product_id):
if self.productAndUserExist(user_id, product_id):
logger.info(
"Adding rating for user: {}, product: {}, rating: {}".format(
user_id, product_id, rating))
saved_record = self.database.addRating(user_id, rating, product_id)
return saved_record
else:
logger.error("Product/User does not exist.")
return None
def productAndUserExist(self, user_id, product_id):
product = self.database.getProduct(product_id)
user = self.database.getUser(user_id)
if product is not None and user is not None:
return True
else:
return False
def getRatingsDetailsForProduct(self, params):
response = {}
product_id = params['productId']
response['averageRating'] = self.database.getAverageRating(product_id)
response['totalRatings'] = self.database.getRatingsCount(product_id)
response['productDetails'] = self.product.getProductById(product_id)
if 'userId' in params:
response['userDetails'] = self.user.getUserById(params['userId'])
response[
'loggedInUserRating'] = self.database.getProductRatingForUser(
product_id, params['userId'])
if response['loggedInUserRating'] is None:
response['loggedInUserRating'] = 0
ratings = self.database.getRatings(product_id)
response['ratingsBreakdown'] = self.computeRatingsBreakdown(ratings)
return response
def removeRating(self, params):
return self.database.removeRating(params['userId'],
params['productId'])
@staticmethod
def computeRatingsBreakdown(ratings):
c = Counter(ratings)
ratings_percentages = dict(
(i, round(c[i] / len(ratings) * 100, 1)) for i in ratings)
for i in range(1, 5):
if i not in ratings_percentages:
ratings_percentages[i] = 0
return ratings_percentages
def get(self):
print('invoked')
query = "exec get_tactics @customer_id = ?"
data, cursor = db.execute(query, True, (self.customer_id, ))
data = cursor.fetchall()
columns = ['title', 'description', 'tactic_id']
returned = UserService.parseCursor(data, columns)
return returned
def setup_authentication(app):
login_manager = LoginManager()
login_manager.setup_app(app)
login_manager.login_view = '/login'
user_service = UserService()
@login_manager.user_loader
def load_user(userId):
user = user_service.get_user(user_id=userId)
return user
def new():
form = forms.CreateCustomer()
if ViewFuncs.ValidSubmission(form=form, method=request.method):
result = UserService.CreateCustomer(form.email.data,
form.password.data,
form=form,
app=app)
if result:
# return redirect(url_for('"splash", next_step="begin"'))
login = UserService.customer_login(form.email.data,
form.password.data)
if login:
return redirect(url_for('begin'))
else:
error = "something went wrong."
return render_template('new.html', form=form, error=error)
elif request.method == 'GET':
session['logged_in'] = False
return render_template('new.html', form=form)
def add_secondary_user():
req = request.get_json()
UserService.CreateSecondaryUser(req.get('first_name'),
req.get('last_name'), req.get('email'),
req.get('password'), session['user'])
email = EmailService()
email.send_email_reset(req.get('email'), reset=False)
return 'hi'
def register_user():
payload = request.get_json()
user = UserService.register_user(email=payload['username'],
password=payload['password'])
if not user:
return 'Email already used', status.HTTP_409_CONFLICT
else:
return jsonify(user), status.HTTP_200_OK
def success():
# get plan id
email = session['email'] if session['logged_in'] else request.args.get(
'email')
customer_id = session['stripe_id'] if session[
'logged_in'] else request.args.get('stripe_id')
payments = PaymentsService(session['email'],
customer_id=session['stripe_id'])
gchat = GoogleChatService()
plans = payments.get_plan()
for plan in plans:
gchat.new_customer(email=session['email'], customer_type=plan)
# update db with plan id
UserService.update_plan(session['user'], plan)
UserService.init_profile_after_purchase(UserService.now(), session['user'])
# redirect to home
return redirect(url_for('home', view='campaigns'))
def audience():
form = forms.Audience()
service = IntakeService(session['user'], 'audience',
session['onboarding_complete'])
if 'view_id' not in request.args:
view_id = service.get_persona()
return redirect(url_for('audience', view_id=view_id, splash=False))
if ViewFuncs.ValidSubmission(form=form, method=request.method):
if request.form['submit_button'] != 'skip':
service.audience(form.data, request.args.get('view_id'))
else:
service.skip(40)
if request.form['submit_button'] == '+ save and add another audience':
next_id = service.get_persona()
return redirect(url_for('audience', view_id=next_id, splash=False))
else:
if not session['onboarding_complete']:
ts = time.time()
st = datetime.datetime.fromtimestamp(ts).strftime(
'%Y-%m-%d %H:%M:%S')
UserService.init_profile(st, session['user'])
google = GoogleChatService()
google.onboarding_complete(email=session['email'])
session['onboarding_complete'] = True
intro = True
else:
intro = False
return redirect(url_for('home', view='campaigns', intro=intro))
return ViewFuncs.view_page(
user=session['user'],
user_name=session['user_name'],
form=form,
view_page='audience',
next_page='product',
coming_home=request.args.get('home'),
splash=request.args.get('splash'),
onboarding_complete=session['onboarding_complete'])
def user_resource():
if request.method == 'GET':
user_id = flask_jwt.current_identity.id
user = UserService.get_user_by_id(user_id=user_id)
if not user:
return 'User does not exist', status.HTTP_404_NOT_FOUND
else:
return jsonify(user), status.HTTP_200_OK
if request.method == 'PUT':
payload = request.get_json()
user_id = flask_jwt.current_identity.id
user = UserService.update_user(user_id, payload['age'], payload['bio'],
payload['firstName'],
payload['lastName'],
payload['interests'])
if not user:
return 'User does not exist', status.HTTP_404_NOT_FOUND
else:
return jsonify(user), status.HTTP_200_OK
def is_time_period_available(user_id, user_given_start_date, user_given_end_date):
def time_periods_overlap(ftpsd, ftped, stpsd, stped):
return stpsd <= ftpsd <= stped or stpsd <= ftped <= stped \
or stpsd <= ftpsd <= stped or stpsd <= ftped <= stped
if user_given_end_date <= user_given_start_date:
return False
busytimes = UserService.get_user_busy_times(user_id)
return list(
filter((lambda busytime: time_periods_overlap(
user_given_start_date, user_given_end_date, busytime.start, busytime.end)), busytimes)
) == []
def GetData(self):
if self.table == 'audience':
params = ('persona_name', 'audience_id', self.table, self.user)
elif self.table == 'product_list':
params = ('name', 'p_id', self.table, self.user)
query = "SELECT %s, %s FROM %s WHERE customer_id = %s" % params
data, cursor = db.execute(query, True, ())
data = cursor.fetchall()
column_list = ['name', 'id']
data = UserService.parseCursor(data, column_list)
return data
def __init__(self, id, user_name, title=None): stage_1 = ['competitors', 'company', 'audience', 'product', 'product_2', 'salescycle'] stage_2 = ['goals'] stage_3 = ['history', 'platforms', 'past'] stage_4 = ['creative'] custom = ['salescycle', 'history', 'platforms'] self.id = id self.title = title self.name = user_name if self.title in stage_1: self.stage = 1 elif self.title in stage_2: self.stage = 2 elif self.title in stage_3: self.stage = 3 elif self.title in stage_4: self.stage = 4 else: self.stage = 0 def get_copy(self): query = """ SELECT * FROM dbo.everything as e WHERE e.page_title = '%s' and ( NOT EXISTS (select * from should_show(e.relevant_tags, %s)) OR e.relevant_tags IS null ) ORDER BY e.order_on_page """ % (self.title, self.id) data, cursor = db.execute(query, True, ()) data = data.fetchall() cursor.close() return data columns = ['q_id', 'page_id', 'page_title', 'page_h1', 'page_p', 'label', 'why_asking_binary', 'why_label', 'what_binary', 'what_label', 'required_binary', 'label_p', 'horizontal_separator_binary', 'container_binary', 'answer_type', 'placeholder', 'a_format', 'html_name', 'route', 'tiles_name_h6', 'tiles_name_p', 'icon_file_path', 'sub_name', 'relevant_tags', 'order_on_page', 'q_group'] if self.title not in custom: self.questions = UserService.parseCursor(get_copy(self), columns) else: self.questions = None
def get_customers(self, conditional=None):
query = """
SELECT * FROM customer_list
"""
if conditional != None:
query += conditional
data, cursor = db.execute(query, True, ())
data = cursor.fetchall()
cursor.close()
columns = [
'name', 'email', 'company_name', 'customer_id', 'mgr', 'admin_id'
]
if len(data) > 0:
return_data = UserService.parseCursor(data, columns)
else:
null_list = [('no customers assigned yet', '', '', '', '', '')]
return_data = UserService.parseCursor(null_list, columns)
return return_data
class UserController(BaseController):
def __init__(self, app):
super().__init__(app)
self.user_service = UserService()
self.app = app
def routes_setup(self):
self.app.add_url_rule('/users', 'users_index', self.index, methods=['GET'])
def index(self):
return self.response_success({"msg": self.user_service.r})
def get_by_id(self):
post_count = self.user_service.get_by_id(1)
return jsonify({"posts": post_count})
def events_by_availability_filter_builder(user_id):
def time_periods_overlap(ftpsd, ftped, stpsd, stped):
return stpsd <= ftpsd <= stped or stpsd <= ftped <= stped \
or stpsd <= ftpsd <= stped or stpsd <= ftped <= stped
busytimes = UserService.get_user_busy_times(user_id)
if not busytimes:
return lambda busytime: True
return lambda event: reduce(
(lambda x, y: x and y),
map(
(lambda busytime: not time_periods_overlap(
event.busytime.start, event.busytime.end, busytime.start, busytime.end)),
busytimes
)
)
def post(self, user_id, device_id=None):
request_data = request.json
user = UserService().get_by_id(resource_id=user_id)
if device_id:
device = self.resource_service.update(device_id, request_data)
else:
device = self.resource_service.create(request_data)
user.update(add_to_set__devices=device, upsert=True)
user.save()
return response_handler.success(response_data=device.to_json())
def get_google(self, user='******'):
query = """SELECT * FROM customer_ads_display(?)"""
data, cursor = db.execute(query, True, (self.customer_id,))
data = cursor.fetchall()
columns = [
'agg_ctr',
'agg_cost',
'best_ctr',
'worst_ctr',
'best_headline_1',
'best_headline_2',
'best_description',
'worst_headline_1',
'worst_headline_2',
'worst_description'
]
return_data = UserService.parseCursor(data, columns)
return return_data
def events_by_interests_filter_builder(user_id):
def intersection(list1, list2):
return [element for element in list1 if element in list2]
def interests_in_event(event):
event_interests = [
interest.label for user in event.users
for interest in user.interests
]
event_interests = list(set(event_interests)) # Removing duplicates
return event_interests
user_interests = [
interest.label
for interest in UserService.get_user_by_id(user_id).interests
]
return lambda event: intersection(interests_in_event(event),
user_interests) is not []
def begin():
form = forms.Profile()
service = IntakeService(session['user'], 'begin',
session['onboarding_complete'])
if ViewFuncs.ValidSubmission(form=form, method=request.method):
if request.form['submit_button'] != 'skip':
service.begin(form.data)
if session['onboarding_complete'] == False:
payments = PaymentsService(session['email'])
stripe_id = payments.create_customer()
session['stripe_id'] = stripe_id
UserService.UpdateStripeId(session['email'],
session['stripe_id'])
gchat = GoogleChatService()
gchat.onboarding_started(email=session['email'])
stripe_info = PaymentsService(session['email'],
customer_id=session['stripe_id'])
stripe_info.modify(company_name=form.company_name.data)
else:
service.skip(10)
if session['onboarding_complete'] == True:
return redirect(url_for('home', view='profile'))
else:
return redirect(url_for('competitors'))
return ViewFuncs.view_page(
user=session['user'],
user_name=session['user_name'],
form=form,
view_page='profile',
next_page='competitors',
coming_home=request.args.get('home'),
splash=request.args.get('splash'),
onboarding_complete=session['onboarding_complete'],
onboarding=True if session['onboarding_complete'] == False else False)
