def test_clears_all_subscriptions(self):
user3 = User(name="user3",
email="*****@*****.**",
email_confirmed=1)
user3.set_password('asdfasdf')
user3.save()
Subscription(user_id=self.sender.id, shake_id=2).save()
Subscription(user_id=user3.id, shake_id=2).save()
Notification.new_subscriber(self.sender, self.receiver, 1)
Notification.new_subscriber(user3, self.receiver, 2)
request = HTTPRequest(
self.get_url('/account/clear-notification'), 'POST',
{'Cookie': '_xsrf=%s;sid=%s' % (self.xsrf, self.receiver_sid)},
'_xsrf=%s&type=subscriber' % (self.xsrf))
self.http_client.fetch(request, self.stop)
response = self.wait()
j = json_decode(response.body)
self.assertEqual(j['response'], "You have 0 new followers")
ns = Notification.where('receiver_id=%s' % (self.receiver.id))
for n in ns:
self.assertTrue(n.deleted)
def subscribe(request):
classNumber = request.REQUEST['classNumber']
theclass = Class.objects.get(number=classNumber)
try:
# Subscribe email
email = request.user.username + "@princeton.edu"
log.log("subscribeEmail %s %s" % (classNumber, email))
subscription = Subscription(address=email,
theclass=theclass,
type="EMAIL")
subscription.save()
subscription.sendConfirmation()
# Subscribe text, if appropriate
if 'phoneNumber' in request.REQUEST:
phoneNumber = request.REQUEST['phoneNumber']
log.log("subscribeText %s %s" % (classNumber, phoneNumber))
theclass = Class.objects.get(number=classNumber)
subscription = Subscription(address=phoneNumber,
theclass=theclass,
type="TEXT")
subscription.save()
subscription.sendConfirmation()
return HttpResponse(
"+<b>Success!</b> You will soon receive an email and/or text verifying your subscription for <strong>%s</strong>."
% str(theclass))
except:
log.log("subscribe ERROR")
return HttpResponse(traceback.format_exc())
return HttpResponse(
"-<b>Something went wrong.</b> You are not subscribed for <strong>%s</strong>. If this problem persists, please <a href='mailto:[email protected]'>contact the developers</a>."
% str(theclass))
def post(self):
"""
New Subscription
@param username: str
@param subreddit: str
#return {}
"""
a = parser.parse_args()
s_username, s_subreddit = \
a['username'], a['subreddit']
if not s_username \
or not s_subreddit:
return {'message': 'all fields required'}, 400, cors
try:
s_user = User.objects(username=s_username).get()
except DoesNotExist:
return {'message': 'user does not exist'}, 400, cors
try:
s_subreddit = Subreddit.objects(name=s_subreddit).get()
except DoesNotExist:
return {'message': 'user does not exist'}, 400, cors
try:
Subscription.objects(Q(user=s_user)
& Q(subreddit=s_subreddit)).get()
except DoesNotExist:
pass
else:
return {'message': 'already subscribed'}, 400, cors
Subscription(user=s_user, subreddit=s_subreddit).save()
return {}, 200, cors
def process_add_subscription():
form_add_sub = SubscriptionAddForm()
if form_add_sub.validate():
# add source if it doesn't exist
source = Source.query.filter_by(rss_url=form_add_sub.rss_url.data).first()
if not source:
source = get_source_from_rss(form_add_sub.rss_url.data)
db.session.add(source)
db.session.commit()
# Find the user and source for subscription
sub_user = User.query.filter_by(id=current_user.id).first()
if not sub_user:
raise Exception('Current user not found in database. The account may have been deleted.')
# add subscription for current user
sub = Subscription(user=sub_user, source=source,
daily_amount=form_add_sub.daily_amount.data)
db.session.add(sub)
db.session.commit()
cache_subscription(sub)
return redirect(url_for('subscriptions'))
flash('Error: could not subscribe. Please check your url and daily amount.')
return redirect(url_for('subscriptions'))
def subscribe():
error = None
if request.method == 'POST':
username = session.get('user')
subscribee = request.form['subscribee']
s = Subscription(username, subscribee)
db_session().add(s)
db_session().commit()
flash('You subscribed!')
return redirect(url_for('manage_account'))
elif request.method == 'GET':
subscribed_users = [
result.subscribed_user for result in Subscription.query.filter_by(
email_id=session.get('user')).all()
]
rv = db_session().query(User).filter(
User.email != session.get('user')).all()
results = []
for row in rv:
if row.email not in subscribed_users:
results.append(row)
users = [
dict(email=row.email,
first_name=row.first_name,
last_name=row.last_name,
profilepic=row.profilepic) for row in results
]
return render_template('subscribe.html', entries=users)
def post(self):
data = json.loads(request.data)
print(data)
email = data.get("email")
if Subscription.query.filter_by(email=email).first():
print("already subscribed.")
return jsonify(status="ok", data="Already subscribed", error=True)
subscription_instance = Subscription(email=email)
subscription = subscription_instance.save_to_db()
if subscription:
# sending sms
# sms_message = "Thank you for registering for the event. We will send you a reminder on the day, so you don't miss out. Love Hive"
# sms_res = send_sms(phone, sms_message, network, STATUS_URL)
# print("sms response to user", sms_res)
# print("successfully saved")
# sending email
print("sending email...")
destination = "*****@*****.**"
email_message = f"Email: {email}"
subject = "SUBSCRIPTION"
send_email(subject, destination, email_message)
return jsonify(status="ok", data=data, error=False)
else:
print("an error occured....")
return jsonify(status="ok", data=data, error=True)
def signup_verify(request):
email = request.GET.get('email', '')
skey = request.GET.get('skey', '')
old = datetime.now() - timedelta(days=10)
blists = []
try:
optin = Optin.objects.get(skey=skey, email=email, created__gte=old)
for l in optin.bulk_lists.all():
if Subscription.subscribed.filter(email__iexact=optin.email,
bulk_list=l).count() == 0:
s = Subscription(email=optin.email,
signup_location=optin.signup_location,
bulk_list=l)
s.save()
blists.append(l)
optin.verify(request)
except Optin.DoesNotExist:
#they've already subscribed; let's show them that instead of a 404
#this prevents emails like "my link isn't working" after they've already clicked it once
subs = Subscription.objects.filter(email=email)
if len(subs):
for sub in subs:
blists.append(sub.bulk_list)
else:
raise Http404
c = {'lists': blists}
return TemplateResponse(request, 'signup_verified.html', c)
def get_subscriptions():
with sqlite3.connect("./rare.db") as conn:
conn.row_factory = sqlite3.Row
db_cursor = conn.cursor()
db_cursor.execute("""
SELECT
s.id,
s.user_id,
s.subscribe_id,
s.begin,
s.end
FROM Subscription s
""")
subscriptions = []
dataset = db_cursor.fetchall()
for row in dataset:
subscription = Subscription(row['id'], row['user_id'],
row['subscribe_id'], row['begin'],
row['end'])
subscriptions.append(subscription.__dict__)
return json.dumps(subscriptions)
def subscribe(request):
options = ""
text = ""
for catg in Categories.objects.all(): #fetch all the categories from DB
options += "<option value=\"" + catg.category + "\">" + catg.category + "</option>"
if options == "":
text = "No Categories in the list..Come back later"
if request.method == 'POST':
name = request.POST['name']
email = request.POST['email']
phnNo = request.POST['phnNo']
category = request.POST['category']
user = User(name=name, email=email, phnno=phnNo)
user.save() #save user details in the DB
subscription = Subscription(
user=User.objects.get(email=email),
category=Categories.objects.get(category=category))
subscription.save() #save users subscription details in the DB
mailgun.send_mail(
email, category + " News",
"Congratulations You have been subscribed to" + category +
"news\n\nThank you for subscribing to our news service"
) #Send subscription mail to the client
text = "Subscribed successfully"
return render(request, "CRM/subscribe.html", {
'options': options,
'message': text
})
def populate_tables():
logger.info("Started populating tables")
tracks = get_tracks()
vehicle_classes = get_vehicle_classes()
vehicles = get_vehicles()
populate_table(Track, tracks)
populate_table(TrackDetails, get_track_details())
populate_table(VehicleClass, vehicle_classes)
populate_table(Vehicle, vehicles)
populate_table(VehicleDetails, get_vehicle_details())
populate_table(Controller, get_controllers())
logger.info(
f"Adding {len(tracks) * len(vehicles)} rows to table 'subscriptions'")
ignored_classes = list(
vehicle_classes[vehicle_classes["ignored"] == True]["id"])
for _, track in tracks.iterrows():
for _, vehicle in vehicles.iterrows():
new_subscription = Subscription(track_id=track["id"],
vehicle_id=vehicle["id"])
if not (track["ignored"] or vehicle["ignored"]
or vehicle["class_id"] in ignored_classes):
new_subscription.update_interval_hours = MID_UPDATE_INTERVAL
db.session.merge(new_subscription)
db.session.commit()
logger.info(f"Finished populating table 'subscriptions'")
logger.info("Finished populating tables")
return True
def accountPage():
error = None
user = User.query.filter_by(username=g.user.username).first()
if request.method == 'POST':
if not request.form['subscription']:
error = 'You have to enter a streaming subscription'
else:
service = request.form['subscription']
if Subscription.query.filter_by(user_id=user.user_id,
subscription=service).first():
error = "You already added that streaming service to your subscriptions."
else:
db.session.add(
Subscription(user_id=user.user_id, subscription=service))
db.session.commit()
favorites = Favorite.query.filter_by(user_id=user.user_id).all()
subscriptions = Subscription.query.filter_by(user_id=user.user_id).all()
favorites = sorted(favorites, key=lambda favorite: favorite.movie)
subscriptions = sorted(subscriptions,
key=lambda subscription: subscription.subscription)
onAccount = True
return render_template('accountPage.html',
favorites=favorites,
subscriptions=subscriptions,
error=error)
def subscribe(request_id, method, address):
'''
Create a new subscription the request identified by request_id.
@param request_id: The request to subscribe to
@param method: The type of subscription (e.g. 'email' or 'sms')
@param address: The adress to send updates to (e.g. '*****@*****.**' or '63055512345')
'''
# TODO: validate the subscription by seeing if the request_id exists via Open311?
with db() as session:
subscription = get_subscription(request_id, method, address)
if subscription:
return subscription.key
else:
subscription = Subscription(sr_id=request_id,
method=method,
contact=address)
session.add(subscription)
# If we haven't ever updated, set the last update date
last_update_info = session.query(UpdateInfoItem).filter(
UpdateInfoItem.key == 'date').first()
if not last_update_info:
# TODO: get the SR's updated_datetime and use that
session.add(
UpdateInfoItem(key='date', value=datetime.datetime.now()))
return subscription.key
return False
def update_subscription(subscription_id, params):
original_subscription = db_session_users.query(Subscription).filter_by(
id=subscription_id).first()
new_subscription_dict = original_subscription.__dict__
today = datetime.datetime.utcnow()
new_subscription_dict['latest'] = True
new_subscription_dict['notes'] = None
if 'expiration_date' in params:
new_exiration_date = params['expiration_date']
new_exiration_date_obj = datetime.datetime.strptime(
new_exiration_date, "%Y-%m-%d")
new_subscription_dict['expiration_date'] = new_exiration_date_obj
# update status of subscription depending on new expiration date
if new_exiration_date_obj < today or new_exiration_date_obj.date(
) == today.date():
new_subscription_dict[
'status_reason'] = Subscription.EXPIRED_STATUS_REASON
new_subscription_dict['status'] = Subscription.INACTIVE_STATUS
elif new_subscription_dict['status'] != Subscription.ACTIVE_STATUS:
new_subscription_dict[
'status_reason'] = Subscription.REACTIVATED_STATUS_REASON
new_subscription_dict['status'] = Subscription.ACTIVE_STATUS
if 'plan_id' in params:
new_plan_id = params['plan_id']
plan = db_session_users().query(Plan).filter_by(id=new_plan_id).first()
if plan:
new_subscription_dict['plan_id'] = new_plan_id
new_subscription_dict['stripe_id'] = plan.stripe_id
new_subscription_dict['start_date'] = datetime.datetime.utcnow()
new_subscription_dict[
'status_reason'] = Subscription.REACTIVATED_STATUS_REASON
new_subscription_dict['status'] = Subscription.ACTIVE_STATUS
if plan.recurring:
new_subscription_dict['expiration_date'] = None
else:
new_subscription_dict[
'expiration_date'] = get_default_expiration_date(plan)
else:
return {'errors': "Plan is not found"}
if 'payment_type' in params:
new_subscription_dict['payment_type'] = params['payment_type']
if 'notes' in params:
new_subscription_dict['notes'] = params['notes']
new_subscription_dict['modified_by_user_id'] = g.user_id
new_subscription = Subscription(new_subscription_dict)
db_session_users.add(new_subscription)
# deactivate old subscription
deactivate_subscriptions(new_subscription_dict['user_id'])
db_session_users.commit()
db_session_users.refresh(new_subscription)
return {'new_subscription': new_subscription.to_dict()}
def _handle(self, url, tags, latlon, radius, period):
self._set_response_headers()
user = users.get_current_user()
if not user:
response = {'success': False, 'login': self._loginURL()}
else:
try:
period = int(period)
except:
period = 86400
try:
radius = int(radius)
except:
radius = None
if tags is not None:
tags = tags.split(',')
else:
tags = []
tags = [x for x in tags if len(x) > 0]
src = NotificationSource.query(
NotificationSource.url == url).fetch(1)
if len(src) == 1:
src = src[0]
else:
src = NotificationSource(url=url)
ndb.put_multi([src])
conditions = [
Subscription.user == user, Subscription.source == src.key,
Subscription.latlon == latlon, Subscription.radius == radius
]
if len(tags) > 0:
conditions.append(
ndb.AND(*[Subscription.tags == tag for tag in tags]))
subscription = Subscription.query(*conditions).fetch(1)
if len(subscription) == 1:
subscription = subscription[0]
subscription.period = period
else:
subscription = Subscription(user=user,
source=src.key,
tags=tags,
latlon=latlon,
radius=radius,
period=period,
next_poll=datetime.datetime.now(),
last_read=datetime.datetime.now() -
datetime.timedelta(hours=3))
ndb.put_multi([subscription])
response = {'success': True, 'id': subscription.key.urlsafe()}
return json.dumps(response)
def subscribe_set_number(set_number):
if request.method == 'POST':
email = request.form.get('email')
price_treshold = request.form.get('price_treshold')
s = Subscription(set_number = set_number, email = email, price_treshold = price_treshold)
db.session.add(s)
db.session.commit()
return {'data' : {'set_number' : set_number, 'email' : email, 'price_treshold' : price_treshold }}
return {'error' : 'no_data'}
def create_subscription(pigeon_id, name):
pigeon_key = ndb.Key(Pigeon, pigeon_id)
stream_list = Stream.query(Stream.name == name).fetch()
stream_key = stream_list[0].key
sub = Subscription()
sub.Pigeon_key = pigeon_key
sub.Stream_key = stream_key
sub.put()
return
def __init__(self,
session,
user_id,
subscription_type=SubscriptionType.hifi):
self._session = session
self.id = user_id
self._base_url = 'users/%s' % user_id
self.favorites = Favorites(session, user_id)
self.subscription = Subscription(
subscription={'type': subscription_type})
def test_quick_notifications(self):
"""
/account/quick-notifications should return without error when populated with
all possible notification types.
Page should also not be accessible if you're not signed in.
"""
self.user2 = User(name='example2',email='*****@*****.**', \
verify_email_token = 'created', password='******', email_confirmed=1,
is_paid=1)
self.user2.save()
self.sourcefile = Sourcefile(width=20,height=20,file_key="asdf", \
thumb_key="asdf_t")
self.sourcefile.save()
self.sharedfile = Sharedfile(source_id=self.sourcefile.id, name="my shared file", \
user_id=self.user.id, content_type="image/png", share_key="ok")
self.sharedfile.save()
self.shake = Shake(user_id=self.user2.id,
name='asdf',
type='group',
title='My Test Shake',
description='Testing this shake test.')
self.shake.save()
# new subscription
new_sub = Subscription(user_id=self.user2.id, shake_id=1)
new_sub.save()
new_subscriber = Notification.new_subscriber(sender=self.user2,
receiver=self.user,
action_id=new_sub.id)
# new favorite
new_favorite = Notification.new_favorite(sender=self.user2,
sharedfile=self.sharedfile)
# new save
new_save = Notification.new_save(sender=self.user2,
sharedfile=self.sharedfile)
# new comment
new_comment = Comment(user_id=self.user2.id,
sharedfile_id=self.sharedfile.id,
body="Testing comment")
new_comment.save()
# new mention
new_mention = Notification.new_mention(receiver=self.user,
comment=new_comment)
# new invitation
new_mention = Notification.new_invitation(sender=self.user2,
receiver=self.user,
action_id=self.shake.id)
response = self.fetch_url('/account/quick-notifications')
self.assertEqual(200, response.code)
self.sign_out()
response = self.fetch_url('/account/quick-notifications',
follow_redirects=False)
self.assertEqual(302, response.code)
def process():
form_add_sub = SubscriptionAddForm()
user_id = current_user.id
rss_url = form_add_sub.rss_url.data
daily_amount = form_add_sub.daily_amount.data
if form_add_sub.validate_on_submit():
new_sub = Subscription(user_id=user_id, rss_url=rss_url, daily_amount=daily_amount)
db.session.add(new_sub)
db.session.commit()
return jsonify({'rss_url': rss_url})
return jsonify({'error': f'Error! {form_add_sub.errors}'})
def subscribe(request):
"""
Subscribe to the blog posts of a given address.
"""
address = request.POST.get('address')
new_sub = Subscription(**{"address": address})
new_sub.save()
return HttpResponse(json.dumps({"status": "success"},
default=helpers.json_custom_parser),
content_type='application/json')
def subscriptions_db_add_sub(chat_id, streamer_id):
subs = Subscription.query.filter(
Subscription.user_id == chat_id,
Subscription.streamer_id == streamer_id).first()
if not subs:
print(subs)
sub_new = Subscription()
sub_new.streamer_id = streamer_id
sub_new.user_id = chat_id
db_session.add(sub_new)
# db_session.add(Subscription.user_id == chat_id, Subscription.streamer_id == streamer_id)
db_session.commit()
def create():
existing = Subscription.query.filter(
Subscription.email == request.form["email"]).first()
if existing is not None:
abort(409)
subscription = Subscription()
subscription.email = request.form["email"]
db.session.add(subscription)
db.session.commit()
return jsonify({"Subscription": "success"})
def post(self):
with db_session:
email = self.get_argument("email")
subscription = Subscription.get(email=email)
if subscription:
self.set_status(409)
self.finish()
return
Subscription(email=email)
self.set_status(201)
self.finish()
return
def __call__(self, chat_id, args):
args.reverse()
if args:
arg = args.pop().lower()
node_type = _parse_node_type(arg)
if node_type is not None:
node_id = node_type
else:
node_id = _parse_node_id(arg)
if node_id is None:
return MSG_INCORRECT_COMMAND
else:
return MSG_INCORRECT_COMMAND
exception = False
no_comments = False
no_replies = False
if 'no-replies' in args:
no_replies = True
args.remove('no-replies')
if 'no-comments' in args:
no_comments = True
no_replies = False
args.remove('no-comments')
if 'except' in args:
exception = True
no_comments = False
no_replies = False
args.remove('except')
if args:
return MSG_INCORRECT_COMMAND
node = self.bot.session.query(Node).filter_by(id=node_id).first()
if not node:
node = Node(id=node_id)
subscription = self.bot.session.query(Subscription).filter_by(
node_id=node_id, chat_id=chat_id).first()
if not subscription:
subscription = Subscription(node=node, chat_id=chat_id)
subscription.exception = exception
subscription.no_comments = no_comments
subscription.no_replies = no_replies
self.bot.session.add(subscription)
self.bot.session.commit()
return MSG_OK
def subscription_post(client, service):
exists = Subscription.query.filter_by(device=client).filter_by(
service=service).first() is not None
if exists:
return jsonify(Error.DUPLICATE_LISTEN)
subscription_new = Subscription(client, service)
db.session.add(subscription_new)
db.session.commit()
if zeromq_relay_uri:
queue_zmq_message(
json_encode({'subscription': subscription_new.as_dict()}))
return jsonify({'service': service.as_dict()})
def test_new_subscriber_notification(self):
#generate a notification
new_sub = Subscription(user_id=self.user2.id, shake_id=1)
new_sub.save()
notification = Notification.new_subscriber(sender=self.user2,
receiver=self.user,
action_id=new_sub.id)
sent_notification = Notification.get("id=%s", notification.id)
self.assertEqual(sent_notification.id, notification.id)
self.assertEqual(sent_notification.sender_id, self.user2.id)
self.assertEqual(sent_notification.receiver_id, self.user.id)
self.assertEqual(sent_notification.action_id, new_sub.id)
self.assertEqual(sent_notification.type, 'subscriber')
def _format_user_data(user_data):
user = None
subscription_list = []
# Loop through all users and subs
for item in user_data:
# print(item)
# If Dynamo item is user metadata, create User class
if 'Email address' in item:
print('user', item['Email address'])
user = User(
email_address=item['Email address'],
user_id=item['PK'][5:],
character_set_preference=item['Character set preference'],
date_created=item['Date created'],
user_alias=item['User alias'],
user_alias_pinyin=item['User alias pinyin'],
user_alias_emoji=item['User alias emoji'],
subscriptions=[])
# If Dynamo item is a list subscription, add the list to the user's lists dict
if 'List name' in item:
print('list', item['List name'])
# Shortening list id from unique id (ex, LIST#1ebcad40-bb9e-6ece-a366-acde48001122#SIMPLIFIED)
if 'SIMPLIFIED' in item['SK']:
list_id = item['SK'][5:-11]
if 'TRADITIONAL' in item['SK']:
list_id = item['SK'][5:-12]
sub = Subscription(list_name=item['List name'],
unique_list_id=item['SK'][5:],
list_id=list_id,
character_set=item['Character set'],
status=item['Status'],
date_subscribed=item['Date subscribed'])
subscription_list.append(sub)
# Sort lists by list id to appear in order (Level 1, Level 2, etc.)
subscription_list = sorted(subscription_list,
key=lambda k: k.list_id,
reverse=False)
user.subscriptions = subscription_list
print('formatted user ', user)
return user
def subscription(jwt):
data = request.get_json()
method = request.method
if method == 'POST':
nutritionist_id = data.get('nutritionist_id')
client_id = data.get('client_id')
subscription_status = True
check_nutritionist = Nutritionist.query.get(nutritionist_id)
check_client = Client.query.get(client_id)
subscription_check = Subscription.query.filter(
Subscription.client_id == client_id,
Subscription.nutritionist_id == nutritionist_id).all()
if not check_nutritionist or not check_client or not subscription_status:
abort(412)
return jsonify({
'success':
False,
'message':
'provide accurate data for required fields'
}), 412
elif subscription_check:
abort(422)
return jsonify({
'success':
False,
'message':
'Client already subscribed to this nutritionist'
}), 422
else:
try:
subscription = Subscription(
nutritionist_id=nutritionist_id,
client_id=client_id,
subscription_status=subscription_status)
subscription.insert()
return jsonify({
'success': True,
'message': 'Client subscription added'
})
except:
abort(422)
def create_subscription(pigeon_id, house_name):
pigeon_key = ndb.Key(Pigeon, pigeon_id)
house_list = House.query(House.name == house_name).fetch()
house_key = house_list[0].key
subscription = Subscription(pigeon_key=pigeon_key,
house_key=house_key,
num_per_day=0)
subscription.put()
card_list = Card.query(ancestor=house_key).fetch()
for card in card_list:
_initailize_progress(pigeon_key, card.key)
house = house_list[0]
house.num_of_subed = house.num_of_subed + 1
house.put()
return
def create_stream(pigeon_id, name, cover_url, sub_list, tag_list):
pigeon_key = ndb.Key(Pigeon, pigeon_id)
stream = Stream()
stream.key = ndb.Key(Stream, name, parent=pigeon_key)
stream.name = name
stream.cover_url = cover_url
stream.tags = tag_list
stream.put()
for pid in sub_list:
if pid != pigeon_id:
if not pigeon_exists(pid):
create_pigeon(pid)
suber_key = ndb.Key(Pigeon, pid)
sub = Subscription()
sub.Pigeon_key = suber_key
sub.Stream_key = stream.key
sub.put()
return
