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 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 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 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 _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 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 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 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 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 post(self):
log(log.INFO, "POST subscription start")
args = self.post_args.parse_args()
log(log.DEBUG, "subs args: %s", args)
status = check_token(args)
if status["status"] == "success":
log(log.DEBUG, "Token is valid")
account = Account.query.filter_by(
ad_login=args["ad_login"]).first()
if account:
log(log.DEBUG, "Account was found")
try:
activeDate = datetime.fromtimestamp(
int(args["activation_date"]))
log(log.DEBUG, "Activation date from request: %s",
activeDate)
sub = Subscription()
sub.subscr_type = Subscription.SubscriptionType(
args["subscr_type"])
sub.subscr_period = Subscription.SubscriptionPeriod(
args["subscr_period"])
sub.activated_at = activeDate
sub.account_id = account.id
sub.save()
log(log.DEBUG, "Subscription was created")
return {
"status": "success",
"message": "Subscription was created",
"data": sub.to_json(),
}
except Exception as e:
log(log.ERROR, "Internall error: %s", e)
return {
"status": "error",
"message": str(e),
}
else:
log(log.ERROR, "Wrong account id")
return {
"status": "error",
"message": "Wrong account id",
}
else:
log(log.ERROR, "Token error: %s", status.message)
return status
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 subscriptions_create():
""" Function to create new subscription 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()
form = payment_form.create_plan()
if form.validate_on_submit():
billing_plan_attributes = {
"name":
request.form['name'],
"description":
request.form['description'],
"merchant_preferences": {
"auto_bill_amount": "yes",
"cancel_url": url_for('paymentbp.cancel', _external=True),
"initial_fail_amount_action": "continue",
"max_fail_attempts": "1",
"return_url": url_for('paymentbp.execute', _external=True),
"setup_fee": {
"currency": 'USD',
"value": request.form['setup_fee']
}
},
"payment_definitions": [{
"amount": {
"currency": 'USD',
"value": request.form['amount']
},
"cycles":
"0",
"frequency":
request.form['frequency'],
"frequency_interval":
"1",
"name":
request.form['payment_definition_name'],
"type":
'Regular'
}],
"type":
'INFINITE'
}
billing_plan = BillingPlan(billing_plan_attributes)
if billing_plan.create():
subs = Subscription(
subscription_name=request.form['name'],
subscription_price=Decimal(request.form['amount']),
subscription_id=billing_plan.id,
subscription_details=request.form['description'],
created_at=func.now(),
updated_at=func.now(),
status=False)
db.session.add(subs)
db.session.commit()
flash('Plan is Created', 'success')
return redirect(url_for('paymentbp.subscriptions'))
else:
flash('Plan could not Created', 'danger')
errorlog.error('Subscription Create Error',
details=str(billing_plan.error))
return render_template('payment/create_plan.html', cform=form)
except Exception as err:
errorlog.error('Subscription Create Error', details=str(err))
return render_template('error.html', message="Error!")
def setUp(self):
self.new_subie = Subscription(name='Jon Snow',
email='*****@*****.**')
def setUp(self):
self.new_subscriber = Subscription(id=123,
name='banana',
email='*****@*****.**')
def test_subscribed_tv_order_by_watched(self):
u1 = User(username='******', password='******', email='*****@*****.**')
u2 = User(username='******', password='******', email='*****@*****.**')
tv1 = TV(name='a',
serialized='1',
tv_type='剧情',
country='中国',
tv_release='2018-8-9')
tv2 = TV(name='b',
serialized='2',
tv_type='戏剧',
country='加拿大',
tv_release='2015-8-9')
tv3 = TV(name='c',
serialized='1',
tv_type='言情/古装',
country='中国',
tv_release='2018-8-9')
tv4 = TV(name='d',
serialized='2',
tv_type='纪录片',
country='中国',
tv_release='2014-8-9')
tv5 = TV(name='e',
serialized='1',
tv_type='剧情',
country='日本',
tv_release='2013-8-9')
db.session.add(u1)
db.session.add(u2)
db.session.add(tv1)
db.session.add(tv2)
db.session.add(tv3)
db.session.add(tv4)
db.session.add(tv5)
db.session.commit()
s1 = Subscription(user_id=u1.id, tv_id=tv1.id)
s2 = Subscription(user_id=u1.id, tv_id=tv2.id)
s3 = Subscription(user_id=u1.id, tv_id=tv3.id)
s4 = Subscription(user_id=u1.id, tv_id=tv5.id)
db.session.add(s1)
db.session.add(s2)
db.session.add(s3)
db.session.add(s4)
db.session.commit()
h1 = HistoryTV(user_id=u1.id,
tv_id=tv1.id,
timestamp_watched=datetime.datetime(2019, 1, 1))
h2 = HistoryTV(user_id=u1.id,
tv_id=tv2.id,
timestamp_watched=datetime.datetime(2019, 1, 3))
h3 = HistoryTV(user_id=u1.id,
tv_id=tv3.id,
timestamp_watched=datetime.datetime(2019, 1, 5))
h4 = HistoryTV(user_id=u1.id,
tv_id=tv5.id,
timestamp_watched=datetime.datetime(2019, 1, 12))
h5 = HistoryTV(user_id=u2.id,
tv_id=tv4.id,
timestamp_watched=datetime.datetime(2019, 1, 18))
db.session.add(h1)
db.session.add(h2)
db.session.add(h3)
db.session.add(h4)
db.session.add(h5)
db.session.commit()
result = u1.subscribed_tv_order_by_watched().all()
r_s = [i.subscribed_tv for i in u1.subscribed_tv.all()]
assert len(result) == len(r_s)
assert result[0].id == tv5.id
assert result[-1].id == tv1.id
assert tv4 not in r_s
assert u2.subscribed_tv_order_by_watched().first() is None
