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()