def register():
"""
{
"email": "*****@*****.**",
"lat": 51.1234,
"lon": 21.0101,
"hours": [12, 14, 20]
}
"""
json_data = request.get_json()
if not json_data:
return bad_request('No input data provided')
try:
data = new_sub_schema.load(json_data)
except ValidationError as e:
return jsonify(e.messages), 422
else:
current_app.logger.info('Subscription data: %s' % data)
# sprawdzić czy email już istnieje
old_sub = Subscription.query.filter_by(email=data.get('email')).first()
if old_sub is not None:
current_app.logger.info("Email taken")
return error_response(
422, "Email '%s' already registered!" % data.get('email'))
hours = data.pop('hours')
sub = Subscription(**data)
sub.update_hours(hours)
db.session.add(sub)
db.session.commit()
current_app.logger.info("Subscription saved")
return jsonify({'message': 'Subscription saved!'}), 200
def cancel_subscription():
user = User(current_user)
party = user.party
subscriptions = Subscription.search([('party', '=', party.id),
('is_online', '=', True),
('state', '=', 'running')])
invoices = Invoice.search([('party', '=', party.id),
('state', '=', 'posted')])
cancel_form = CancelEnrollForm()
if len(subscriptions) == 0 and len(invoices) == 0:
return redirect(url_for('course.index'))
if len(subscriptions) > 0 or len(invoices) > 0:
if cancel_form.validate_on_submit():
if len(subscriptions) > 0:
for subscription in subscriptions:
Subscription.draft([subscription])
Subscription.cancel([subscription])
if len(invoices) > 0:
for invoice in invoices:
Invoice.cancel([invoice])
return redirect(url_for('course.index'))
return render_template('course/cancel_enroll.html',
user=user,
cancel_form=cancel_form,
invoices=invoices,
subscriptions=subscriptions)
def post(self, topic_id):
username = self.current_user
s = yield gen.maybe_future(
Subscription.get_by_user_topic(username, topic_id))
if s:
raise exceptions.TopicAlreadySubscribed()
else:
yield gen.maybe_future(Subscription.create(username, topic_id))
def _make_sub(email, lat, lon, hours):
sub = Subscription(email=email, lat=lat, lon=lon)
sub.hours = [SubscriptionHour(hour=h) for h in hours]
database.session.add(sub)
database.session.commit()
return sub
def compute_metric2() -> Metric2:
now = arrow.now()
_24h_ago = now.shift(days=-1)
nb_referred_user_paid = 0
for user in User.filter(User.referral_id.isnot(None)):
if user.is_paid():
nb_referred_user_paid += 1
return Metric2.create(
date=now,
# user stats
nb_user=User.count(),
nb_activated_user=User.filter_by(activated=True).count(),
# subscription stats
nb_premium=Subscription.filter(
Subscription.cancelled.is_(False)).count(),
nb_cancelled_premium=Subscription.filter(
Subscription.cancelled.is_(True)).count(),
# todo: filter by expires_date > now
nb_apple_premium=AppleSubscription.count(),
nb_manual_premium=ManualSubscription.filter(
ManualSubscription.end_at > now,
ManualSubscription.is_giveaway.is_(False),
).count(),
nb_coinbase_premium=CoinbaseSubscription.filter(
CoinbaseSubscription.end_at > now).count(),
# referral stats
nb_referred_user=User.filter(User.referral_id.isnot(None)).count(),
nb_referred_user_paid=nb_referred_user_paid,
nb_alias=Alias.count(),
# email log stats
nb_forward_last_24h=EmailLog.filter(
EmailLog.created_at > _24h_ago).filter_by(bounced=False,
is_spam=False,
is_reply=False,
blocked=False).count(),
nb_bounced_last_24h=EmailLog.filter(
EmailLog.created_at > _24h_ago).filter_by(bounced=True).count(),
nb_total_bounced_last_24h=Bounce.filter(
Bounce.created_at > _24h_ago).count(),
nb_reply_last_24h=EmailLog.filter(
EmailLog.created_at > _24h_ago).filter_by(is_reply=True).count(),
nb_block_last_24h=EmailLog.filter(
EmailLog.created_at > _24h_ago).filter_by(blocked=True).count(),
# other stats
nb_verified_custom_domain=CustomDomain.filter_by(
verified=True).count(),
nb_subdomain=CustomDomain.filter_by(is_sl_subdomain=True).count(),
nb_directory=Directory.count(),
nb_deleted_directory=DeletedDirectory.count(),
nb_deleted_subdomain=DeletedSubdomain.count(),
nb_app=Client.count(),
commit=True,
)
def add_position(update: Update, context: CallbackContext):
callback_query: CallbackQuery = update.callback_query
_, suffix = callback_query.data.strip().split('.')
position = Position.query.filter_by(id=suffix).first()
city_id: str = context.user_data['city_id']
city = City.query.get(city_id)
message: Message = callback_query.message
subscription = Subscription(
chat_id=message.chat_id,
city_id=city_id,
position_id=position.id,
)
subscription.soft_add()
db.session.commit()
callback_query.answer(
callback_query=callback_query.id,
text=f"Дякую, я запам'ятав твій вибір",
cache_time=60,
)
message.reply_text(
text=
(f"Опитування завершено 🎉 \n"
f"Тепер я буду тебе сповіщувати про "
f"нові вакансії у категорії *{position.name}* у місті *{city.name}*."
f"\n\n"
f"За мить, ти отримаєш перелік вакансій за обраними параметрами 😉"),
parse_mode='Markdown',
reply_markup=get_keyboard_menu(update),
)
stat = Stat(chat_id=message.chat_id, action=Action.subscribed.value)
db.session.add(stat)
db.session.commit()
vacancies = parser.update_new_vacancies(city, position)
if not vacancies:
message.reply_text(
text=
f"🤷♀️ На жаль, у місті *{city.name}* немає вакансій в категорії *{position.name}*",
parse_mode='Markdown',
)
# send only 10 vacancies for preventing spamming
vacancies = vacancies[:10]
sender.send_vacancies(vacancies, message.chat_id)
return ConversationHandler.END
def save_credit_card_response(billing_agreement_response, payment_id):
""" Function to save credit card response """
try:
payment_token = payment_id
plans = Subscription.get_all()
if 'id' in billing_agreement_response:
pdobj = PaymentDetail(
amount=plans.subscription_price,
subscription_id=plans.id,
payment_status='Success',
payment_date=func.now(),
billing_aggrement_id=billing_agreement_response.id,
payment_token=payment_token,
payment_mode='credit_card')
db.session.add(pdobj)
db.session.commit()
pobj = Payment(user_id=current_user.id,
payment_detail_id=pdobj.id,
created_at=func.now(),
updated_at=func.now())
db.session.add(pobj)
current_user.payment_status = True
db.session.commit()
return True
except Exception as err:
errorlog.error('Credit Card response Error', details=str(err))
return render_template('error.html', message="Error!")
def subscribe():
if request.is_json:
json = request.get_json(force=True)
if (json is None or json.get("subscription", None) is None
or json.get("subscription").get("endpoint", None) is None
or json.get("subscription").get("keys", None) is None or
json.get("subscription").get("keys").get("auth", None) is None
or json.get("subscription").get("keys").get("p256dh",
None) is None):
return make_response("Body not of subscription format", 400)
existing_sub = Subscription.query.filter_by(sub_json=str(json)).first()
if existing_sub:
log.info("Subscription already stored, renewing!")
existing_sub.sub_json = str(json)
existing_sub.expires = int(time.time()) + 24 * 3600
else:
sub = Subscription(sub_json=str(json))
log.info("Added new subscription: %s", sub.sub_json)
db.session.add(sub)
db.session.commit()
else:
return make_response("Body not JSON", 400)
return make_response("OK", 200)
def notify_premium_end():
"""sent to user who has canceled their subscription and who has their subscription ending soon"""
for sub in Subscription.filter_by(cancelled=True).all():
if (arrow.now().shift(days=3).date() > sub.next_bill_date >=
arrow.now().shift(days=2).date()):
user = sub.user
if user.lifetime:
continue
LOG.d(f"Send subscription ending soon email to user {user}")
send_email(
user.email,
f"Your subscription will end soon",
render(
"transactional/subscription-end.txt",
user=user,
next_bill_date=sub.next_bill_date.strftime("%Y-%m-%d"),
),
render(
"transactional/subscription-end.html",
user=user,
next_bill_date=sub.next_bill_date.strftime("%Y-%m-%d"),
),
retries=3,
)
def toggle_subscriptions():
req_data = request.get_json()
subreddit_name = req_data['subreddit']
subreddit = Subreddit.query.filter(Subreddit.name == subreddit_name).first()
subscription = Subscription.query.get((current_user.id, subreddit.id))
new_type = 'ADD'
try:
if request.method == 'DELETE':
db.session.delete(subscription)
new_type = 'REMOVE'
else:
if subscription:
raise IntegrityError('Entry already exists',
subscription, 'user_routes')
new_sub = Subscription(
user_id=current_user.id,
subreddit_id=subreddit.id
)
db.session.add(new_sub)
db.session.commit()
except IntegrityError:
return {"errors": "There was a problem processing your request."}
return {"subscription": subreddit_name, "type": new_type}
def setUp(self):
'''
Set up method that will run before every Test
'''
self.new_subscriber = Subscription(1234, 'Python Must Be Crazy',
'A thrilling new Python Series')
def seed_subscriptions(user_list, subreddit_list):
subscription_list = [
Subscription(
user_id=user_list[0].id,
subreddit_id=subreddit_list[0].id,
),
Subscription(
user_id=user_list[0].id,
subreddit_id=subreddit_list[3].id,
),
Subscription(
user_id=user_list[0].id,
subreddit_id=subreddit_list[6].id,
),
Subscription(
user_id=user_list[0].id,
subreddit_id=subreddit_list[2].id,
),
Subscription(
user_id=user_list[0].id,
subreddit_id=subreddit_list[5].id,
),
Subscription(
user_id=user_list[1].id,
subreddit_id=subreddit_list[3].id,
),
Subscription(
user_id=user_list[1].id,
subreddit_id=subreddit_list[6].id,
),
Subscription(
user_id=user_list[2].id,
subreddit_id=subreddit_list[5].id,
),
Subscription(
user_id=user_list[3].id,
subreddit_id=subreddit_list[6].id,
),
Subscription(
user_id=user_list[5].id,
subreddit_id=subreddit_list[6].id,
),
]
db.session.add_all(subscription_list)
db.session.commit()
return subscription_list
def get(self):
username = self.current_user
subs = yield gen.maybe_future(Subscription.list_by_user(username))
result = {
'total': len(subs),
'topics': [(yield gen.maybe_future(s.to_dict())) for s in subs],
}
raise gen.Return(result)
def delete(self, topic_id):
username = self.current_user
s = yield gen.maybe_future(
Subscription.get_by_user_topic(username, topic_id))
if s:
yield gen.maybe_future(s.delete())
else:
raise exceptions.TopicHasNotBeenSubscribed()
def subscribe(id):
user = User.query.get_or_404(id)
subscription = Subscription(user_id=user.id, subscriber_id=current_user.id)
db.session.add(subscription)
db.session.commit()
return json.dumps({'success': True})
async def add_entry(request):
data = await request.json()
data['data']['offset'] = datetime.today() - timedelta(hours=24)
sub = Subscription(data['data'])
try:
sub.m.save()
return web.json_response(status=200, data={'ok': True})
except:
return web.json_response(status=500, data={'ok': False})
def _topic_info(username, topic):
is_subed = False
if username is not None:
exists = Subscription.get_by_user_topic(username, topic.id)
if exists:
is_subed = True
info = topic.to_dict()
info.update({'is_subscribed': is_subed})
return info
def create_subscription(issue_autocard=True, pull_request_autocard=True):
"""Create a subscription."""
db.session.add(
Subscription(
board_id=default_board_id,
repo_id=default_repo_id,
issue_autocard=issue_autocard,
pull_request_autocard=pull_request_autocard
)
)
def subscribe(id):
collection = Collection.query.get(id)
if collection is None:
return abort(404)
db.session.add(Subscription(user=current_user, collection=collection))
db.session.commit()
next = request.args.get("next")
return (abort(400) if not is_safe_url(next) else redirect(
next or url_for("auth.subscription", id=id)))
def subscriptions_add():
if current_user.subscr_left > 0:
newsubscr = Subscription(user_id = current_user.id)
user = User.query.filter(User.id==current_user.id).first()
user.subscr_left = current_user.subscr_left - 1
db.session.add(user)
db.session.add(newsubscr)
db.session.commit()
flash("Subscription {sub} added, you have {numsubscr} subscriptions left".format(sub=newsubscr.id, numsubscr=user.subscr_left), 'success')
else:
flash("You have no subscriptions left, upgrade your plan to get more", 'warning')
return redirect(url_for('subscriptions.subscriptions'))
def subscription_render(code):
subscriptions = Subscription.search([('subscription_code','=',code)])
if len(subscriptions)>=1:
if current_user.is_authenticated:
user = User(current_user)
return render_template('digital_certificate.html',
subscriptions=subscriptions,
user=user,
)
return render_template('digital_certificate.html',
subscriptions=subscriptions,)
else:
return redirect(url_for('main.welcome'))
def subscriptions():
""" Function to get all subscriptions """
try:
if current_user.user_type != 'admin':
flash('You are not allowed to access this page', 'danger')
return redirect(url_for('userbp.dashboard'))
plans = Subscription.all_subscriptions()
if plans:
all_plans = plans
else:
all_plans = []
return render_template('payment/subscriptions.html', plans=all_plans)
except Exception as err:
errorlog.error('Subscription list Error', details=str(err))
return render_template('error.html', message="Error!")
def index():
"""
View root page function that returns the index page and its data
"""
title = 'Home'
page = request.args.get('page', 1, type=int)
posts = Post.query.order_by(Post.date_posted.desc()).paginate(page=page,
per_page=4)
form = SubscribeForm()
if form.validate_on_submit():
email = Subscription(email=form.email.data)
db.session.add(email)
db.session.commit()
return render_template('index.html', title=title, posts=posts, form=form)
def subscription():
form = SubscriptionForm()
if form.validate_on_submit():
sub = Subscription(name=form.name.data,
cost=form.cost.data,
currency=form.currency.data,
billing_date=form.billing_date.data,
active=True)
db.session.add(sub)
db.session.commit()
flash(f'Added \'{form.name.data}\' to subscriptions')
return redirect(url_for('index'))
return render_template('subscription.html', form=form, action='Create')
def record_subscription(user_id, plan_type='Basic'):
exists = User.query.get(user_id).subscription.all()
if exists:
logging.info('User already have a subscription !')
return 0
else:
s = Subscription(
plan_type=plan_type,
user_id=user_id,
max_results=subscription_plans()[plan_type]['max_results'],
monthly_price_eur=subscription_plans()[plan_type]
['monthly_price_eur'],
unlimited=subscription_plans()[plan_type]['unlimited'])
db.session.add(s)
db.session.commit()
logging.info("User's subscription correctly set!")
return s.id
def execute():
""" Function to execute plan after redirecting from paypal site after
customer agreement """
try:
configure_paypal()
payment_token = request.args.get('token', '')
billing_agreement_response = BillingAgreement.execute(payment_token)
plans = Subscription.get_all()
action = url_for('userbp.dashboard')
billing_action = url_for('paymentbp.billing')
if 'id' in billing_agreement_response:
pdobj = PaymentDetail(
amount=plans.subscription_price,
subscription_id=plans.id,
payment_status='Success',
payment_date=func.now(),
billing_aggrement_id=billing_agreement_response.id,
payment_token=payment_token,
payment_mode='paypal')
db.session.add(pdobj)
db.session.commit()
user_id = current_user.id
if 'app_user_id' in session:
user_id = session['app_user_id']
session.pop('app_user_id')
action = url_for('userbp.dashboard', userid=user_id)
billing_action = url_for('paymentbp.billing', userid=user_id)
pobj = Payment(user_id=user_id,
payment_detail_id=pdobj.id,
created_at=func.now(),
updated_at=func.now())
db.session.add(pobj)
get_user = User.by_id(int(user_id))
get_user.payment_status = True
db.session.commit()
flash(PLAN_EXECUTED, 'success')
return redirect(action)
else:
flash(PLAN_EXECUTED_ERROR, 'danger')
return redirect(billing_action)
except Exception as err:
errorlog.error('Subscribe Error', details=str(err))
return render_template('error.html', message="Error!")
def billing():
""" Function to integrate the billing page """
try:
plan = Subscription.get_all(True)
get_uid = request.args.get('userid', default=None, type=int)
paypalaction = url_for('paymentbp.subscribe_paypal',
payment_id=plan.subscription_id)
if get_uid is not None:
if current_user.user_type == 'admin':
uid = get_uid
usr_detail = User.by_id(uid)
paypalaction = url_for('paymentbp.subscribe_paypal',
payment_id=plan.subscription_id,
userid=get_uid)
if usr_detail.payment_status:
flash(ALREADY_SUBSCRIBED, 'danger')
return redirect(url_for('userbp.dashboard'))
else:
if current_user.payment_status:
flash(ALREADY_SUBSCRIBED, 'danger')
return redirect(url_for('userbp.dashboard'))
else:
if current_user.payment_status:
flash(ALREADY_SUBSCRIBED, 'danger')
return redirect(url_for('userbp.dashboard'))
credit_card_form = payment_form.credit_card()
credit_card_form.payment_token.data = plan.subscription_id
if credit_card_form.validate_on_submit():
res = subscribe(credit_card_form.payment_token.data,
credit_card_form)
if res is True:
flash(PLAN_SUBSCRIBED, 'success')
return redirect(url_for('userbp.dashboard'))
return render_template('payment/billing.html',
action='billing',
paypalaction=paypalaction,
plan=plan,
ccform=credit_card_form)
except Exception as err:
errorlog.error('Billing Error', details=str(err))
return render_template('error.html', message="Error!")
def get(self, topic_id):
topic = yield gen.maybe_future(Topic.get(topic_id))
if not topic:
raise HTTPError(404)
admin = yield gen.maybe_future(User.get(topic.admin_id))
is_subscribed = False
if self.current_user:
is_subscribed = yield gen.maybe_future(
Subscription.get_by_user_topic(self.current_user, topic.id))
self.render(
'topic.html',
title=topic.name,
keywords=topic.name + ', 2L',
description=topic.description,
topic_id=topic_id,
admin=admin.username,
avatar=topic.avatar,
rules=topic.rules,
is_subscribed=int(bool(is_subscribed)),
)
def activate_plan():
""" Function to activate plan """
try:
if current_user.user_type != 'admin':
flash('You are not allowed to access this page', 'danger')
return redirect(url_for('userbp.dashboard'))
configure_paypal()
pid = request.args.get('id', '')
billing_plan = BillingPlan.find(pid)
if billing_plan.activate():
subplan = Subscription.by_planid(pid)
subplan.status = True
db.session.commit()
else:
errorlog.error('Plan activate Error',
details=str(billing_plan.error))
return redirect(url_for('paymentbp.subscriptions'))
except Exception as err:
errorlog.error('Plan activate Error', details=str(err))
return render_template('error.html', message="Error!")
def manage_subscription(token):
subscription = Subscription.verify_change_subscription_token(token)
if not subscription:
return error_response(404, "Token not recognized")
else:
current_app.logger.info('Manage: %s' % subscription)
# usunięcie subskrypcji
if request.method == 'DELETE':
db.session.delete(subscription)
db.session.commit()
current_app.logger.info('Subscription deleted')
return jsonify({'message': 'Subscription deleted'}), 200
# aktualizacja subskrypcji
elif request.method == "PUT":
json_data = request.get_json()
if not json_data:
return bad_request('No input data provided')
try:
data = edit_sub_schema.load(json_data)
except ValidationError as e:
return jsonify(e.messages), 422
else:
current_app.logger.info('Update subscription data: %s' % data)
subscription.update_hours(data.pop('hours'))
for key, value in data.items():
subscription.__setattr__(key, value)
db.session.add(subscription)
db.session.commit()
current_app.logger.info('Subscription updated')
return jsonify({'message': 'Subscription updated'}), 200
# pobierz dane subskrypcji
elif request.method == "GET":
result = new_sub_schema.dump(subscription)
return result, 200
def my_account():
""" Function to view my account having info abount subscription and payment history """
try:
get_uid = request.args.get('userid', default=None, type=int)
uid = current_user.id
if get_uid is not None and current_user.user_type == 'admin':
uid = get_uid
userinfo = User.by_id(uid)
trans_list = None
billing_agreement = None
account_detail = None
if userinfo.payment_status == 1:
account_detail = Payment.byuser_id(userinfo.id)
get_date = datetime.strptime(str(
userinfo.created_at), '%Y-%m-%d %H:%M:%S') - timedelta(days=1)
start_date, end_date = get_date.strftime('%Y-%m-%d'), \
datetime.now().strftime("%Y-%m-%d")
account_detail = Payment.byuser_id(userinfo.id)
configure_paypal()
billing_agreement = BillingAgreement.find(
account_detail.PaymentDetail.billing_aggrement_id)
transactions = billing_agreement.search_transactions(
start_date, end_date)
trans_list = transactions.agreement_transaction_list
if trans_list is None:
trans_list = []
credit_card_form = payment_form.credit_card()
plan = Subscription.get_all(True)
credit_card_form.payment_token.data = plan.subscription_id
return render_template('payment/my_account.html',
account_detail=account_detail,
transactions=trans_list,
agreement=billing_agreement,
userinfo=userinfo,
plan=plan,
ccform=credit_card_form)
except Exception as err:
errorlog.error('My Account Error', details=str(err))
return render_template('error.html', message="Error!")
def get_feed(url, and_subscribe=None):
"""
- download a RSS url
- make a Feed entry for it
- populate corresponding Episodes
kwargs
and_subscribe: if not None, the specified userid gets subscribed to it.
"""
feedp = feedparser.parse(url)
feed = Feed(url, feedp)
db.session.add(feed)
db.session.flush()
for entry in feedp['entries']:
title = entry['title']
enclosure = find_enclosure(entry)
episode = Episode(feed.id, title, enclosure)
db.session.add(episode)
if and_subscribe is not None:
userid = and_subscribe
sub = Subscription(feed.id, userid)
db.session.add(sub)
db.session.commit()
def paddle():
LOG.debug(
f"paddle callback {request.form.get('alert_name')} {request.form}")
# make sure the request comes from Paddle
if not paddle_utils.verify_incoming_request(dict(request.form)):
LOG.exception("request not coming from paddle. Request data:%s",
dict(request.form))
return "KO", 400
if (request.form.get("alert_name") == "subscription_created"
): # new user subscribes
# the passthrough is json encoded, e.g.
# request.form.get("passthrough") = '{"user_id": 88 }'
passthrough = json.loads(request.form.get("passthrough"))
user_id = passthrough.get("user_id")
user = User.get(user_id)
subscription_plan_id = int(
request.form.get("subscription_plan_id"))
if subscription_plan_id in PADDLE_MONTHLY_PRODUCT_IDS:
plan = PlanEnum.monthly
elif subscription_plan_id in PADDLE_YEARLY_PRODUCT_IDS:
plan = PlanEnum.yearly
else:
LOG.exception(
"Unknown subscription_plan_id %s %s",
subscription_plan_id,
request.form,
)
return "No such subscription", 400
sub = Subscription.get_by(user_id=user.id)
if not sub:
LOG.d(f"create a new Subscription for user {user}")
Subscription.create(
user_id=user.id,
cancel_url=request.form.get("cancel_url"),
update_url=request.form.get("update_url"),
subscription_id=request.form.get("subscription_id"),
event_time=arrow.now(),
next_bill_date=arrow.get(
request.form.get("next_bill_date"),
"YYYY-MM-DD").date(),
plan=plan,
)
else:
LOG.d(f"Update an existing Subscription for user {user}")
sub.cancel_url = request.form.get("cancel_url")
sub.update_url = request.form.get("update_url")
sub.subscription_id = request.form.get("subscription_id")
sub.event_time = arrow.now()
sub.next_bill_date = arrow.get(
request.form.get("next_bill_date"), "YYYY-MM-DD").date()
sub.plan = plan
# make sure to set the new plan as not-cancelled
# in case user cancels a plan and subscribes a new plan
sub.cancelled = False
LOG.debug("User %s upgrades!", user)
db.session.commit()
elif request.form.get(
"alert_name") == "subscription_payment_succeeded":
subscription_id = request.form.get("subscription_id")
LOG.debug("Update subscription %s", subscription_id)
sub: Subscription = Subscription.get_by(
subscription_id=subscription_id)
# when user subscribes, the "subscription_payment_succeeded" can arrive BEFORE "subscription_created"
# at that time, subscription object does not exist yet
if sub:
sub.event_time = arrow.now()
sub.next_bill_date = arrow.get(
request.form.get("next_bill_date"), "YYYY-MM-DD").date()
db.session.commit()
elif request.form.get("alert_name") == "subscription_cancelled":
subscription_id = request.form.get("subscription_id")
sub: Subscription = Subscription.get_by(
subscription_id=subscription_id)
if sub:
# cancellation_effective_date should be the same as next_bill_date
LOG.warning(
"Cancel subscription %s %s on %s, next bill date %s",
subscription_id,
sub.user,
request.form.get("cancellation_effective_date"),
sub.next_bill_date,
)
sub.event_time = arrow.now()
sub.cancelled = True
db.session.commit()
user = sub.user
send_email(
user.email,
"SimpleLogin - what can we do to improve the product?",
render(
"transactional/subscription-cancel.txt",
end_date=request.form.get(
"cancellation_effective_date"),
),
)
else:
return "No such subscription", 400
elif request.form.get("alert_name") == "subscription_updated":
subscription_id = request.form.get("subscription_id")
sub: Subscription = Subscription.get_by(
subscription_id=subscription_id)
if sub:
LOG.debug(
"Update subscription %s %s on %s, next bill date %s",
subscription_id,
sub.user,
request.form.get("cancellation_effective_date"),
sub.next_bill_date,
)
if (int(request.form.get("subscription_plan_id")) ==
PADDLE_MONTHLY_PRODUCT_ID):
plan = PlanEnum.monthly
else:
plan = PlanEnum.yearly
sub.cancel_url = request.form.get("cancel_url")
sub.update_url = request.form.get("update_url")
sub.event_time = arrow.now()
sub.next_bill_date = arrow.get(
request.form.get("next_bill_date"), "YYYY-MM-DD").date()
sub.plan = plan
# make sure to set the new plan as not-cancelled
sub.cancelled = False
db.session.commit()
else:
return "No such subscription", 400
return "OK"
def fake_data():
LOG.d("create fake data")
# Remove db if exist
if os.path.exists("db.sqlite"):
LOG.d("remove existing db file")
os.remove("db.sqlite")
# Create all tables
db.create_all()
# Create a user
user = User.create(
email="*****@*****.**",
name="John Wick",
password="******",
activated=True,
is_admin=True,
enable_otp=False,
otp_secret="base32secret3232",
intro_shown=True,
fido_uuid=None,
)
user.include_sender_in_reverse_alias = None
user.trial_end = None
db.session.commit()
# add a profile picture
file_path = "profile_pic.svg"
s3.upload_from_bytesio(
file_path,
open(os.path.join(ROOT_DIR, "static", "default-icon.svg"), "rb"),
content_type="image/svg",
)
file = File.create(user_id=user.id, path=file_path, commit=True)
user.profile_picture_id = file.id
db.session.commit()
# create a bounced email
alias = Alias.create_new_random(user)
db.session.commit()
bounce_email_file_path = "bounce.eml"
s3.upload_email_from_bytesio(
bounce_email_file_path,
open(os.path.join(ROOT_DIR, "local_data", "email_tests", "2.eml"),
"rb"),
"download.eml",
)
refused_email = RefusedEmail.create(
path=bounce_email_file_path,
full_report_path=bounce_email_file_path,
user_id=user.id,
commit=True,
)
contact = Contact.create(
user_id=user.id,
alias_id=alias.id,
website_email="*****@*****.**",
reply_email="*****@*****.**",
commit=True,
)
EmailLog.create(
user_id=user.id,
contact_id=contact.id,
refused_email_id=refused_email.id,
bounced=True,
commit=True,
)
LifetimeCoupon.create(code="coupon", nb_used=10, commit=True)
# Create a subscription for user
Subscription.create(
user_id=user.id,
cancel_url="https://checkout.paddle.com/subscription/cancel?user=1234",
update_url="https://checkout.paddle.com/subscription/update?user=1234",
subscription_id="123",
event_time=arrow.now(),
next_bill_date=arrow.now().shift(days=10).date(),
plan=PlanEnum.monthly,
commit=True,
)
CoinbaseSubscription.create(user_id=user.id,
end_at=arrow.now().shift(days=10),
commit=True)
api_key = ApiKey.create(user_id=user.id, name="Chrome")
api_key.code = "code"
api_key = ApiKey.create(user_id=user.id, name="Firefox")
api_key.code = "codeFF"
pgp_public_key = open(get_abs_path("local_data/public-pgp.asc")).read()
m1 = Mailbox.create(
user_id=user.id,
email="*****@*****.**",
verified=True,
pgp_public_key=pgp_public_key,
)
m1.pgp_finger_print = load_public_key(pgp_public_key)
db.session.commit()
for i in range(3):
if i % 2 == 0:
a = Alias.create(email=f"e{i}@{FIRST_ALIAS_DOMAIN}",
user_id=user.id,
mailbox_id=m1.id)
else:
a = Alias.create(
email=f"e{i}@{FIRST_ALIAS_DOMAIN}",
user_id=user.id,
mailbox_id=user.default_mailbox_id,
)
db.session.commit()
if i % 5 == 0:
if i % 2 == 0:
AliasMailbox.create(alias_id=a.id,
mailbox_id=user.default_mailbox_id)
else:
AliasMailbox.create(alias_id=a.id, mailbox_id=m1.id)
db.session.commit()
# some aliases don't have any activity
# if i % 3 != 0:
# contact = Contact.create(
# user_id=user.id,
# alias_id=a.id,
# website_email=f"contact{i}@example.com",
# reply_email=f"rep{i}@sl.local",
# )
# db.session.commit()
# for _ in range(3):
# EmailLog.create(user_id=user.id, contact_id=contact.id)
# db.session.commit()
# have some disabled alias
if i % 5 == 0:
a.enabled = False
db.session.commit()
CustomDomain.create(user_id=user.id, domain="ab.cd", verified=True)
CustomDomain.create(user_id=user.id,
domain="very-long-domain.com.net.org",
verified=True)
db.session.commit()
Directory.create(user_id=user.id, name="abcd")
Directory.create(user_id=user.id, name="xyzt")
db.session.commit()
# Create a client
client1 = Client.create_new(name="Demo", user_id=user.id)
client1.oauth_client_id = "client-id"
client1.oauth_client_secret = "client-secret"
client1.published = True
db.session.commit()
RedirectUri.create(client_id=client1.id, uri="https://ab.com")
client2 = Client.create_new(name="Demo 2", user_id=user.id)
client2.oauth_client_id = "client-id2"
client2.oauth_client_secret = "client-secret2"
client2.published = True
db.session.commit()
ClientUser.create(user_id=user.id, client_id=client1.id, name="Fake Name")
referral = Referral.create(user_id=user.id,
code="REFCODE",
name="First referral")
db.session.commit()
for i in range(6):
Notification.create(user_id=user.id,
message=f"""Hey hey <b>{i}</b> """ * 10)
db.session.commit()
User.create(
email="*****@*****.**",
password="******",
activated=True,
referral_id=referral.id,
)
db.session.commit()
def fake_data():
LOG.d("create fake data")
# Remove db if exist
if os.path.exists("db.sqlite"):
LOG.d("remove existing db file")
os.remove("db.sqlite")
# Create all tables
db.create_all()
# Create a user
user = User.create(
email="*****@*****.**",
name="John Wick",
password="******",
activated=True,
is_admin=True,
enable_otp=False,
otp_secret="base32secret3232",
intro_shown=True,
fido_uuid=None,
)
db.session.commit()
user.trial_end = None
LifetimeCoupon.create(code="coupon", nb_used=10)
db.session.commit()
# Create a subscription for user
Subscription.create(
user_id=user.id,
cancel_url="https://checkout.paddle.com/subscription/cancel?user=1234",
update_url="https://checkout.paddle.com/subscription/update?user=1234",
subscription_id="123",
event_time=arrow.now(),
next_bill_date=arrow.now().shift(days=10).date(),
plan=PlanEnum.monthly,
)
db.session.commit()
api_key = ApiKey.create(user_id=user.id, name="Chrome")
api_key.code = "code"
api_key = ApiKey.create(user_id=user.id, name="Firefox")
api_key.code = "codeFF"
m1 = Mailbox.create(
user_id=user.id,
email="*****@*****.**",
verified=True,
pgp_finger_print="fake fingerprint",
)
db.session.commit()
for i in range(3):
if i % 2 == 0:
a = Alias.create(email=f"e{i}@{FIRST_ALIAS_DOMAIN}",
user_id=user.id,
mailbox_id=m1.id)
else:
a = Alias.create(
email=f"e{i}@{FIRST_ALIAS_DOMAIN}",
user_id=user.id,
mailbox_id=user.default_mailbox_id,
)
db.session.commit()
if i % 5 == 0:
if i % 2 == 0:
AliasMailbox.create(alias_id=a.id,
mailbox_id=user.default_mailbox_id)
else:
AliasMailbox.create(alias_id=a.id, mailbox_id=m1.id)
db.session.commit()
# some aliases don't have any activity
# if i % 3 != 0:
# contact = Contact.create(
# user_id=user.id,
# alias_id=a.id,
# website_email=f"contact{i}@example.com",
# reply_email=f"rep{i}@sl.local",
# )
# db.session.commit()
# for _ in range(3):
# EmailLog.create(user_id=user.id, contact_id=contact.id)
# db.session.commit()
# have some disabled alias
if i % 5 == 0:
a.enabled = False
db.session.commit()
CustomDomain.create(user_id=user.id, domain="ab.cd", verified=True)
CustomDomain.create(user_id=user.id,
domain="very-long-domain.com.net.org",
verified=True)
db.session.commit()
Directory.create(user_id=user.id, name="abcd")
Directory.create(user_id=user.id, name="xyzt")
db.session.commit()
# Create a client
client1 = Client.create_new(name="Demo", user_id=user.id)
client1.oauth_client_id = "client-id"
client1.oauth_client_secret = "client-secret"
client1.published = True
db.session.commit()
RedirectUri.create(client_id=client1.id, uri="https://ab.com")
client2 = Client.create_new(name="Demo 2", user_id=user.id)
client2.oauth_client_id = "client-id2"
client2.oauth_client_secret = "client-secret2"
client2.published = True
db.session.commit()
ClientUser.create(user_id=user.id, client_id=client1.id, name="Fake Name")
referral = Referral.create(user_id=user.id,
code="REFCODE",
name="First referral")
db.session.commit()
for i in range(6):
Notification.create(user_id=user.id,
message=f"""Hey hey <b>{i}</b> """ * 10)
db.session.commit()
User.create(
email="*****@*****.**",
name="Winston",
password="******",
activated=True,
referral_id=referral.id,
)
db.session.commit()
