def mysubscription():
client = gocardless_pro.Client(access_token=access_token,
environment='sandbox')
# Gets record lists from GC
customers = client.customers.list().records
mandates = client.mandates.list().records
subscrips = client.subscriptions.list().records
mysubs = 0
dict = {'email': '', 'amount': ''}
# Loops through subscriptions on GC to count up monthly total of subscription donations, skipping if cancelled
for subscrip in subscrips:
if subscrip.status == 'cancelled':
continue
dict['amount'] = (format(subscrip.amount))
# Connects via subscriptions to mandates using their IDs, and then to customers via mandates using customer IDs
for mandate in mandates:
if mandate.id != subscrip.links.mandate:
continue
for customer in customers:
if mandate.links.customer != customer.id:
continue
# Pulls out names and plugs into name array
dict['email'] = customer.email
if dict['email'] == session["email"]:
mysubs = int(int(dict['amount']) / 100)
return render_template("mysubscription.html", mysubs=mysubs)
def Handle_Payment(request):
client = gocardless_pro.Client(
access_token= "sandbox_B0pUDWsTgiJ-jK-jo4-M8KUp7xxS0-I_pgnc4-vr",
environment='sandbox'
)
redirect_flow = client.redirect_flows.create(
params={
"description" : "EBENEZER CHURCH Subscription Setup", # This will be shown on the payment pages
"session_token" : "Jl0--Klnzjdlw30fjallZKo", # Not the access token
"success_redirect_url" : "https://developer.gocardless.com/example-redirect-uri/",
# "prefilled_customer": { # Optionally, prefill customer details on the payment page
# "given_name": "Tim",
# "family_name": "Rogers",
# "email": "*****@*****.**",
# "address_line1": "338-346 Goswell Road",
# "city": "London",
# "postal_code": "EC1V 7LQ"
# }
}
)
# Hold on to this ID - we'll need it when we
# "confirm" the redirect flow later
print("ID: {} ".format(redirect_flow.id))
print("URL: {} ".format(redirect_flow.redirect_url))
ru = redirect_flow.redirect_url
return redirect(ru)
def initialize_client(self):
self.environment = self.get_environment()
try:
self.client = gocardless_pro.Client(access_token=self.access_token,
environment=self.environment)
return self.client
except Exception as e:
frappe.throw(e)
def get_gocardless_client():
if not getattr(settings, "GOCARDLESS_ACCESS_TOKEN", None) or not getattr(
settings, "GOCARDLESS_ENVIRONMENT", None):
raise Exception("No GoCardless credentials configured")
return gocardless_pro.Client(
access_token=settings.GOCARDLESS_ACCESS_TOKEN,
environment=settings.GOCARDLESS_ENVIRONMENT,
)
def client_from_settings(access_token=None, environment=None):
"""Get GoCardless Client from token and environment.
Uses access_token and environment by default if nothing was given.
"""
access_token = settings.GOCARDLESS['access_token'] \
if access_token is None else access_token
environment = settings.GOCARDLESS['environment'] \
if environment is None else environment
return gocardless_pro.Client(access_token=access_token,
environment=environment)
def loggedin():
client = gocardless_pro.Client(access_token=access_token,
environment='sandbox')
# Gets record lists from GC
customers = client.customers.list().records
mandates = client.mandates.list().records
subscrips = client.subscriptions.list().records
# Initialises variables to plug into page
total = 0
donors = 0
names = []
GCemails = []
# Loops through subscriptions on GC to count up monthly total of subscription donations, skipping if cancelled
for subscrip in subscrips:
if subscrip.status == 'cancelled':
continue
donors += 1
monthlyamount = (format(subscrip.amount))
total += int(monthlyamount)
# Connects via subscriptions to mandates using their IDs, and then to customers via mandates using customer IDs
for mandate in mandates:
if mandate.id != subscrip.links.mandate:
continue
for customer in customers:
if mandate.links.customer != customer.id:
continue
# Pulls out names and plugs into name array
firstname = customer.given_name
lastname = customer.family_name
name = firstname + ' ' + lastname[0]
names.append(name)
GCemails.append(customer.email)
if session["email"] in GCemails:
db.execute("UPDATE users SET ispatron = 1 WHERE id=:user_id",
user_id=session["user_id"])
session["ispatron"] = 1
# Formats monthly total back to float from GC int
monthlytotal = total / 100
return render_template("index.html",
donors=donors,
names=names,
monthlytotal=monthlytotal)
def __init__(self, request):
self.request = request
# We need the session to be saved before it gets a session_key
# This is because the code is called from a middleware
self.request.session.save()
if getattr(settings, 'GOCARDLESS_USE_SANDBOX', False):
gc_environment = "sandbox"
else:
gc_environment = "live"
self.client = gocardless_pro.Client(
access_token=settings.GOCARDLESS_ACCESS_TOKEN,
environment=gc_environment)
def __init__(self, request):
self.request = request
# We need the session to be saved before it gets a session_key
# This is because the code is called from a middleware
self.request.session.save()
if not self.request.session.get("GC_SESSION_KEY"):
self.request.session["GC_SESSION_KEY"] = get_random_string(
length=50)
if getattr(settings, "GOCARDLESS_USE_SANDBOX", False):
gc_environment = "sandbox"
else:
gc_environment = "live"
self.client = gocardless_pro.Client(
access_token=settings.GOCARDLESS_ACCESS_TOKEN,
environment=gc_environment,
)
def direct_debit_callback():
if not session.get('commitment', False):
return redirect(url_for('condition'))
try:
#save the commitment (double check not a duplicate)
commitment = models.Commitment()
commitment.name = session['commitment']['name']
commitment.mobile_number = session['commitment']['mobile_number']
commitment.rate = session['commitment']['rate']
commitment = commitment.save()
#complete the direct debit mandate
client = gocardless_pro.Client(
access_token=app.config['GOCARDLESS_ACCESS_TOKEN'],
environment=app.config['GOCARDLESS_ENVIRONMENT'])
redirect_flow_id = request.args.get('redirect_flow_id')
redirect_flow = client.redirect_flows.complete(
redirect_flow_id,
params={'session_token': session['gocardless_session_token']})
#save the mandate
commitment.gocardless_mandate_id = redirect_flow.links.mandate
commitment.save()
except NotUniqueError:
flash('Someone has already signed up with that phone number', 'error')
return redirect(url_for('condition'))
except gocardless_pro.errors.GoCardlessProError:
flash(
'Sorry, something went wrong, the direct debit mandate has not been created',
'error')
commitment.delete()
return redirect(url_for('condition'))
#clear session
session.pop('gocardless_session_token', None)
session.pop('commitment', None)
#off to the final page
return redirect(url_for('committed'))
def __init__(self, construct):
try:
access_token = construct["access_token"]
except KeyError:
access_token = None
try:
environment = construct["environment"]
except KeyError:
environment = 'live'
self.transactions = []
self.partners = []
# We recommend storing your access token in an
# environment variable for security
if access_token is None:
access_token = os.getenv('gocardless')
self.gcclient = gocardless_pro.Client(
# Change this to 'live' when you are ready to go live.
access_token,
environment=environment)
def direct_debit():
if not session.get('commitment', False):
return redirect(url_for('condition'))
if request.method == 'POST':
client = gocardless_pro.Client(
access_token=app.config['GOCARDLESS_ACCESS_TOKEN'],
environment=app.config['GOCARDLESS_ENVIRONMENT'])
flow = client.redirect_flows.create(
params={
'scheme':
'bacs',
'session_token':
session['gocardless_session_token'],
'description':
'No payments will be taken unless the target is reached',
'success_redirect_url':
url_for('direct_debit_callback', _external=True)
})
return redirect(flow.redirect_url)
return render_template('direct-debit.html')
def create_subscriptions():
if len(models.Milestone.objects(name='subscriptions-created')) == 0:
commitment_count = models.Commitment.objects.count()
if float(commitment_count) >= (float(app.config['BECKTON_TARGET'])):
milestone = models.Milestone(name='subscriptions-created')
if milestone.save():
for commitment in models.Commitment.objects():
client = gocardless_pro.Client(access_token=app.config['GOCARDLESS_ACCESS_TOKEN'], environment=app.config['GOCARDLESS_ENVIRONMENT'])
client.subscriptions.create(params={
"amount": str(commitment.rate),
"currency": app.config['BECKTON_DIRECT_DEBIT_CURRENCY'],
"name": app.config['BECKTON_DIRECT_DEBIT_NAME'],
"interval_unit": "monthly",
"day_of_month": "1",
"links": {
"mandate": commitment.gocardless_mandate_id
}
})
time.sleep(1)
def create_app(dev_server=False, config_override=None):
app = Flask(__name__)
app.config.from_envvar("SETTINGS_FILE")
if config_override:
app.config.from_mapping(config_override)
app.jinja_options["extensions"].append("jinja2.ext.do")
if install_logging:
create_logging_manager(app)
# Flask has now kindly installed its own log handler which we will summarily remove.
app.logger.propagate = 1
app.logger.handlers = []
if not app.debug:
logging.root.setLevel(logging.INFO)
else:
logging.root.setLevel(logging.DEBUG)
from apps.metrics import request_duration, request_total
# Must be run before crsf.init_app
@app.before_request
def before_request():
request._start_time = time.time()
@app.after_request
def after_request(response):
try:
request_duration.labels(
request.endpoint,
request.method).observe(time.time() - request._start_time)
except AttributeError:
logging.exception(
"Request without _start_time - check app.before_request ordering"
)
request_total.labels(request.endpoint, request.method,
response.status_code).inc()
return response
for extension in (csrf, cache, db, mail, static_digest, toolbar):
extension.init_app(app)
def log_email(message, app):
app.logger.info("Emailing %s: %r", message.recipients, message.subject)
email_dispatched.connect(log_email)
cors_origins = ["https://map.emfcamp.org", "https://wiki.emfcamp.org"]
if app.config.get("DEBUG"):
cors_origins = ["http://localhost:8080", "https://maputnik.github.io"]
CORS(app,
resources={r"/api/*": {
"origins": cors_origins
}},
supports_credentials=True)
migrate.init_app(app, db)
login_manager.init_app(app, add_context_processor=True)
app.login_manager.login_view = "users.login"
from models.user import User, load_anonymous_user
from models import site_state, feature_flag
@login_manager.user_loader
def load_user(userid):
user = User.query.filter_by(id=userid).first()
if user:
set_user_id(user.email)
return user
login_manager.anonymous_user = load_anonymous_user
global gocardless_client
gocardless_client = gocardless_pro.Client(
access_token=app.config["GOCARDLESS_ACCESS_TOKEN"],
environment=app.config["GOCARDLESS_ENVIRONMENT"],
)
stripe.api_key = app.config["STRIPE_SECRET_KEY"]
pytransferwise.environment = app.config["TRANSFERWISE_ENVIRONMENT"]
pytransferwise.api_key = app.config["TRANSFERWISE_API_TOKEN"]
@app.before_request
def load_per_request_state():
site_state.get_states()
feature_flag.get_db_flags()
if app.config.get("NO_INDEX"):
# Prevent staging site from being displayed on Google
@app.after_request
def send_noindex_header(response):
response.headers["X-Robots-Tag"] = "noindex, nofollow"
return response
@app.before_request
def simple_cache_warning():
if not dev_server and app.config.get("CACHE_TYPE", "null") == "simple":
logging.warning(
"Per-process cache being used outside dev server - refreshing will not work"
)
@app.context_processor
def add_csp_nonce():
g.csp_nonce = secrets.token_urlsafe(16)
return {"csp_nonce": g.csp_nonce}
@app.after_request
def send_security_headers(response):
use_hsts = app.config.get("HSTS", False)
if use_hsts:
max_age = app.config.get("HSTS_MAX_AGE", 3600 * 24 * 30 * 6)
response.headers[
"Strict-Transport-Security"] = "max-age=%s" % max_age
response.headers["X-Frame-Options"] = "deny"
response.headers["X-Content-Type-Options"] = "nosniff"
response.headers["X-XSS-Protection"] = "1; mode=block"
response.headers["Referrer-Policy"] = "strict-origin-when-cross-origin"
csp = {
"script-src": ["'self'", "https://js.stripe.com"],
"style-src":
["'self'", "'unsafe-inline'", "https://fonts.googleapis.com"],
# Note: the below is more strict as it only allows inline styles in style=
# attributes, however it's unsupported by Safari at this time...
# "style-src-attr": ["'unsafe-inline'"],
"font-src": ["'self'", "https://fonts.gstatic.com"],
"frame-src": [
"https://js.stripe.com/",
"https://media.ccc.de",
"https://www.youtube.com",
"https://archive.org",
],
}
# Edit record hash to support the modal dialogues in flask-admin
csp["script-src"].append(
"'sha256-Jxve8bBSodQplIZw4Y1walBJ0hFTx8sZ5xr+Pjr/78Y='")
# View record hash to support the modal dialogues in flask-admin
csp["script-src"].append(
"'sha256-XOlW2U5UiDeV2S/HgKqbp++Fo1I5uiUT2thFRUeFW/g='")
if app.config.get("DEBUG_TB_ENABLED"):
# This hash is for the flask debug toolbar. It may break once they upgrade it.
csp["script-src"].append(
"'sha256-zWl5GfUhAzM8qz2mveQVnvu/VPnCS6QL7Niu6uLmoWU='")
if "csp_nonce" in g:
csp["script-src"].append(f"'nonce-{g.csp_nonce}'")
value = "; ".join(k + " " + " ".join(v) for k, v in csp.items())
if app.config.get("DEBUG"):
response.headers["Content-Security-Policy"] = value
else:
response.headers["Content-Security-Policy-Report-Only"] = (
value +
"; report-uri https://emfcamp.report-uri.com/r/d/csp/reportOnly"
)
response.headers[
"Report-To"] = '{"group":"default","max_age":31536000,"endpoints":[{"url":"https://emfcamp.report-uri.com/a/d/g"}],"include_subdomains":false}'
# Disable Network Error Logging.
# This doesn't seem to be very useful and it's using up our report-uri quota.
response.headers["NEL"] = '{"max_age":0}'
return response
if not app.debug:
@app.errorhandler(Exception)
def handle_exception(e):
""" Generic exception handler to catch and log unhandled exceptions in production. """
if isinstance(e, HTTPException):
# HTTPException is used to implement flask's HTTP errors so pass it through.
return e
app.logger.exception("Unhandled exception in request: %s", request)
return render_template("errors/500.html"), 500
@app.errorhandler(404)
def handle_404(e):
return render_template("errors/404.html"), 404
@app.errorhandler(500)
def handle_500(e):
return render_template("errors/500.html"), 500
@app.shell_context_processor
def shell_imports():
ctx = {}
# Import models and constants
import models
for attr in dir(models):
if attr[0].isupper():
ctx[attr] = getattr(models, attr)
# And just for convenience
ctx["db"] = db
return ctx
from apps.common import load_utility_functions
load_utility_functions(app)
from apps.base import base
from apps.metrics import metrics
from apps.users import users
from apps.tickets import tickets
from apps.payments import payments
from apps.cfp import cfp
from apps.cfp_review import cfp_review
from apps.schedule import schedule
from apps.arrivals import arrivals
from apps.api import api_bp
from apps.villages import villages
app.register_blueprint(base)
app.register_blueprint(users)
app.register_blueprint(metrics)
app.register_blueprint(tickets)
app.register_blueprint(payments)
app.register_blueprint(cfp)
app.register_blueprint(cfp_review, url_prefix="/cfp-review")
app.register_blueprint(schedule)
app.register_blueprint(arrivals, url_prefix="/arrivals")
app.register_blueprint(api_bp, url_prefix="/api")
app.register_blueprint(villages, url_prefix="/villages")
if app.config.get("VOLUNTEERS"):
from apps.volunteer import volunteer
app.register_blueprint(volunteer, url_prefix="/volunteer")
from flask_admin import Admin
from apps.volunteer.flask_admin_base import VolunteerAdminIndexView
global volunteer_admin
volunteer_admin = Admin(
url="/volunteer/admin",
name="EMF Volunteers",
template_mode="bootstrap3",
index_view=VolunteerAdminIndexView(url="/volunteer/admin"),
base_template="volunteer/admin/flask-admin-base.html",
)
volunteer_admin.endpoint_prefix = "volunteer_admin"
volunteer_admin.init_app(app)
import apps.volunteer.admin # noqa: F401
from apps.admin import admin
app.register_blueprint(admin, url_prefix="/admin")
from apps.notification import notify
app.register_blueprint(notify, url_prefix="/notify")
return app
# WARNING: Do not edit by hand, this file was generated by Crank:
#
# https://github.com/gocardless/crank
#
import os
import re
import json
import responses
import gocardless_pro
def load_fixture(resource):
fixtures_path = os.path.join(os.path.dirname(__file__), 'fixtures')
fixture_filename = '{0}.json'.format(resource)
fixture_path = os.path.join(fixtures_path, fixture_filename)
return json.load(open(fixture_path))
def stub_response(resource_fixture):
path = re.sub(r':(\w+)', r'\w+', resource_fixture['path_template'])
url_pattern = re.compile('http://example.com' + path)
json_body = json.dumps(resource_fixture['body'])
responses.add(resource_fixture['method'], url_pattern, body=json_body)
client = gocardless_pro.Client(access_token='secret',
base_url='http://example.com')
def create_app(dev_server=False):
app = Flask(__name__)
app.config.from_envvar('SETTINGS_FILE')
app.jinja_options['extensions'].append('jinja2.ext.do')
if install_logging:
create_logging_manager(app)
# Flask has now kindly installed its own log handler which we will summarily remove.
app.logger.propagate = 1
app.logger.handlers = []
if not app.debug:
logging.root.setLevel(logging.INFO)
else:
logging.root.setLevel(logging.DEBUG)
for extension in (cdn, csrf, cache, db, mail, assets, toolbar):
extension.init_app(app)
migrate.init_app(app, db)
login_manager.setup_app(app, add_context_processor=True)
app.login_manager.login_view = 'users.login'
from models.user import User, load_anonymous_user
from models import site_state, feature_flag
@login_manager.user_loader
def load_user(userid):
user = User.query.filter_by(id=userid).first()
if user:
set_user_id(user.email)
return user
login_manager.anonymous_user = load_anonymous_user
if app.config.get('TICKETS_SITE'):
global gocardless_client
gocardless_client = gocardless_pro.Client(
access_token=app.config['GOCARDLESS_ACCESS_TOKEN'],
environment=app.config['GOCARDLESS_ENVIRONMENT'])
stripe.api_key = app.config['STRIPE_SECRET_KEY']
@app.before_request
def load_per_request_state():
site_state.get_states()
feature_flag.get_db_flags()
if app.config.get('NO_INDEX'):
# Prevent staging site from being displayed on Google
@app.after_request
def send_noindex_header(response):
response.headers['X-Robots-Tag'] = 'noindex, nofollow'
return response
@app.before_request
def simple_cache_warning():
if not dev_server and app.config.get('CACHE_TYPE', 'null') == 'simple':
logging.warn(
'Per-process cache being used outside dev server - refreshing will not work'
)
@app.after_request
def send_security_headers(response):
use_hsts = app.config.get('HSTS', False)
if use_hsts:
max_age = app.config.get('HSTS_MAX_AGE', 3600 * 24 * 7 * 4)
response.headers[
'Strict-Transport-Security'] = 'max-age=%s' % max_age
response.headers['X-Frame-Options'] = 'deny'
response.headers['X-Content-Type-Options'] = 'nosniff'
return response
from apps.metrics import request_duration, request_total
@app.before_request
def before_request():
request._start_time = time.time()
@app.after_request
def after_request(response):
try:
request_duration.labels(
request.endpoint,
request.method).observe(time.time() - request._start_time)
except AttributeError:
# In some cases this isn't present?
logging.exception("Request without _start_time")
request_total.labels(request.endpoint, request.method,
response.status_code).inc()
return response
@app.errorhandler(404)
def handle_404(e):
return render_template('errors/404.html'), 404
@app.errorhandler(500)
def handle_500(e):
return render_template('errors/500.html'), 500
from apps.common import load_utility_functions
load_utility_functions(app)
from apps.base import base
from apps.metrics import metrics
from apps.users import users
from apps.tickets import tickets
from apps.payments import payments
from apps.cfp import cfp
from apps.cfp_review import cfp_review
from apps.schedule import schedule
from apps.arrivals import arrivals
app.register_blueprint(base)
app.register_blueprint(users)
app.register_blueprint(metrics)
app.register_blueprint(tickets)
app.register_blueprint(payments)
app.register_blueprint(cfp)
app.register_blueprint(cfp_review, url_prefix='/cfp-review')
app.register_blueprint(schedule)
app.register_blueprint(arrivals, url_prefix='/arrivals')
if app.config.get('VOLUNTEERS'):
from apps.volunteering import volunteering
app.register_blueprint(volunteering, url_prefix='/volunteering')
from apps.volunteers import volunteers
app.register_blueprint(volunteers, url_prefix='/volunteers')
from apps.admin import admin
app.register_blueprint(admin, url_prefix='/admin')
return app
def get_gocardless_client():
return gocardless_pro.Client(
access_token=getattr(settings, "GOCARDLESS_ACCESS_TOKEN", None),
environment=getattr(settings, "GOCARDLESS_ENVIRONMENT", None)
)
def create_app(dev_server=False):
app = Flask(__name__)
app.config.from_envvar("SETTINGS_FILE")
app.jinja_options["extensions"].append("jinja2.ext.do")
if install_logging:
create_logging_manager(app)
# Flask has now kindly installed its own log handler which we will summarily remove.
app.logger.propagate = 1
app.logger.handlers = []
if not app.debug:
logging.root.setLevel(logging.INFO)
else:
logging.root.setLevel(logging.DEBUG)
from apps.metrics import request_duration, request_total
# Must be run before crsf.init_app
@app.before_request
def before_request():
request._start_time = time.time()
@app.after_request
def after_request(response):
try:
request_duration.labels(
request.endpoint,
request.method).observe(time.time() - request._start_time)
except AttributeError:
logging.exception(
"Request without _start_time - check app.before_request ordering"
)
request_total.labels(request.endpoint, request.method,
response.status_code).inc()
return response
for extension in (csrf, cache, db, mail, static_digest, toolbar):
extension.init_app(app)
def log_email(message, app):
app.logger.info("Emailing %s: %r", message.recipients, message.subject)
email_dispatched.connect(log_email)
cors_origins = ["https://map.emfcamp.org", "https://wiki.emfcamp.org"]
if app.config.get("DEBUG"):
cors_origins = ["http://localhost:8080", "https://maputnik.github.io"]
CORS(app,
resources={r"/api/*": {
"origins": cors_origins
}},
supports_credentials=True)
migrate.init_app(app, db)
login_manager.init_app(app, add_context_processor=True)
app.login_manager.login_view = "users.login"
from models.user import User, load_anonymous_user
from models import site_state, feature_flag
@login_manager.user_loader
def load_user(userid):
user = User.query.filter_by(id=userid).first()
if user:
set_user_id(user.email)
return user
login_manager.anonymous_user = load_anonymous_user
global gocardless_client
gocardless_client = gocardless_pro.Client(
access_token=app.config["GOCARDLESS_ACCESS_TOKEN"],
environment=app.config["GOCARDLESS_ENVIRONMENT"],
)
stripe.api_key = app.config["STRIPE_SECRET_KEY"]
@app.before_request
def load_per_request_state():
site_state.get_states()
feature_flag.get_db_flags()
if app.config.get("NO_INDEX"):
# Prevent staging site from being displayed on Google
@app.after_request
def send_noindex_header(response):
response.headers["X-Robots-Tag"] = "noindex, nofollow"
return response
@app.before_request
def simple_cache_warning():
if not dev_server and app.config.get("CACHE_TYPE", "null") == "simple":
logging.warn(
"Per-process cache being used outside dev server - refreshing will not work"
)
@app.after_request
def send_security_headers(response):
use_hsts = app.config.get("HSTS", False)
if use_hsts:
max_age = app.config.get("HSTS_MAX_AGE", 3600 * 24 * 30 * 6)
response.headers[
"Strict-Transport-Security"] = "max-age=%s" % max_age
response.headers["X-Frame-Options"] = "deny"
response.headers["X-Content-Type-Options"] = "nosniff"
return response
if not app.debug:
@app.errorhandler(Exception)
def handle_exception(e):
""" Generic exception handler to catch and log unhandled exceptions in production. """
if isinstance(e, HTTPException):
# HTTPException is used to implement flask's HTTP errors so pass it through.
return e
app.logger.exception("Unhandled exception in request: %s", request)
return render_template("errors/500.html"), 500
@app.errorhandler(404)
def handle_404(e):
return render_template("errors/404.html"), 404
@app.errorhandler(500)
def handle_500(e):
return render_template("errors/500.html"), 500
@app.shell_context_processor
def shell_imports():
ctx = {}
# Import models and constants
import models
for attr in dir(models):
if attr[0].isupper():
ctx[attr] = getattr(models, attr)
# And just for convenience
ctx["db"] = db
return ctx
from apps.common import load_utility_functions
load_utility_functions(app)
from apps.base import base
from apps.metrics import metrics
from apps.users import users
from apps.tickets import tickets
from apps.payments import payments
from apps.cfp import cfp
from apps.cfp_review import cfp_review
from apps.schedule import schedule
from apps.arrivals import arrivals
from apps.api import api_bp
app.register_blueprint(base)
app.register_blueprint(users)
app.register_blueprint(metrics)
app.register_blueprint(tickets)
app.register_blueprint(payments)
app.register_blueprint(cfp)
app.register_blueprint(cfp_review, url_prefix="/cfp-review")
app.register_blueprint(schedule)
app.register_blueprint(arrivals, url_prefix="/arrivals")
app.register_blueprint(api_bp, url_prefix="/api")
if app.config.get("VOLUNTEERS"):
from apps.volunteer import volunteer
app.register_blueprint(volunteer, url_prefix="/volunteer")
from flask_admin import Admin
from apps.volunteer.flask_admin_base import VolunteerAdminIndexView
global volunteer_admin
volunteer_admin = Admin(
url="/volunteer/admin",
name="EMF Volunteers",
template_mode="bootstrap3",
index_view=VolunteerAdminIndexView(url="/volunteer/admin"),
base_template="volunteer/admin/flask-admin-base.html",
)
volunteer_admin.endpoint_prefix = "volunteer_admin"
volunteer_admin.init_app(app)
import apps.volunteer.admin # noqa: F401
from apps.admin import admin
app.register_blueprint(admin, url_prefix="/admin")
from apps.notification import notify
app.register_blueprint(notify, url_prefix="/notify")
return app
import gocardless_pro
import csv
token = os.environ['ACCESS_TOKEN']
client = gocardless_pro.Client(access_token=token, environment='sandbox')
#Create empty array
array = []
#Setup the search query, we are using created from
mandates = client.mandates.list(
params={"created_at[gte]": "2021-04-14T00:00:00.123Z"})
for mandate in mandates.records:
customer = client.customers.get(mandate.links.customer)
bankaccount = client.customer_bank_accounts.get(
mandate.links.customer_bank_account)
array.append([
mandate.id, customer.id, customer.given_name, customer.family_name,
customer.company_name, customer.email, bankaccount.currency
])
while mandates.after:
mandates = client.mandates.list(params={
"created_at[gte]": "2021-04-14T00:00:00.123Z",
"after": mandates.after
})
for mandate in mandates.records:
customer = client.customers.get(mandate.links.customer)
bankaccount = client.customer_bank_accounts.get(
def __init__(self):
# gocardless are changing there api, not sure if we can switch yet
self.client = gocardless_pro.Client(
access_token=payment_providers['gocardless']['credentials']
['access_token'],
environment=payment_providers['gocardless']['environment'])
def create_app(dev_server=False):
app = Flask(__name__)
app.config.from_envvar('SETTINGS_FILE')
app.jinja_options['extensions'].append('jinja2.ext.do')
if install_logging:
create_logging_manager(app)
# Flask has now kindly installed its own log handler which we will summarily remove.
app.logger.propagate = 1
app.logger.handlers = []
if not app.debug:
logging.root.setLevel(logging.INFO)
else:
logging.root.setLevel(logging.DEBUG)
from apps.metrics import request_duration, request_total
# Must be run before crsf.init_app
@app.before_request
def before_request():
request._start_time = time.time()
@app.after_request
def after_request(response):
try:
request_duration.labels(
request.endpoint,
request.method).observe(time.time() - request._start_time)
except AttributeError:
logging.exception(
"Request without _start_time - check app.before_request ordering"
)
request_total.labels(request.endpoint, request.method,
response.status_code).inc()
return response
for extension in (cdn, csrf, cache, db, mail, assets, toolbar):
extension.init_app(app)
cors_origins = ['https://map.emfcamp.org', 'https://wiki.emfcamp.org']
if app.config.get('DEBUG'):
cors_origins = ['http://localhost:8080', 'https://maputnik.github.io']
CORS(app,
resources={r"/api/*": {
"origins": cors_origins
}},
supports_credentials=True)
migrate.init_app(app, db)
login_manager.setup_app(app, add_context_processor=True)
app.login_manager.login_view = 'users.login'
from models.user import User, load_anonymous_user
from models import site_state, feature_flag
@login_manager.user_loader
def load_user(userid):
user = User.query.filter_by(id=userid).first()
if user:
set_user_id(user.email)
return user
login_manager.anonymous_user = load_anonymous_user
if app.config.get('TICKETS_SITE'):
global gocardless_client
gocardless_client = gocardless_pro.Client(
access_token=app.config['GOCARDLESS_ACCESS_TOKEN'],
environment=app.config['GOCARDLESS_ENVIRONMENT'])
stripe.api_key = app.config['STRIPE_SECRET_KEY']
@app.before_request
def load_per_request_state():
site_state.get_states()
feature_flag.get_db_flags()
if app.config.get('NO_INDEX'):
# Prevent staging site from being displayed on Google
@app.after_request
def send_noindex_header(response):
response.headers['X-Robots-Tag'] = 'noindex, nofollow'
return response
@app.before_request
def simple_cache_warning():
if not dev_server and app.config.get('CACHE_TYPE', 'null') == 'simple':
logging.warn(
'Per-process cache being used outside dev server - refreshing will not work'
)
@app.after_request
def send_security_headers(response):
use_hsts = app.config.get('HSTS', False)
if use_hsts:
max_age = app.config.get('HSTS_MAX_AGE', 3600 * 24 * 7 * 4)
response.headers[
'Strict-Transport-Security'] = 'max-age=%s' % max_age
response.headers['X-Frame-Options'] = 'deny'
response.headers['X-Content-Type-Options'] = 'nosniff'
return response
@app.errorhandler(404)
def handle_404(e):
return render_template('errors/404.html'), 404
@app.errorhandler(500)
def handle_500(e):
return render_template('errors/500.html'), 500
@app.shell_context_processor
def shell_imports():
ctx = {}
# Import models and constants
import models
for attr in dir(models):
if attr[0].isupper():
ctx[attr] = getattr(models, attr)
# And just for convenience
ctx['db'] = db
return ctx
from apps.common import load_utility_functions
load_utility_functions(app)
from apps.base import base
from apps.metrics import metrics
from apps.users import users
from apps.tickets import tickets
from apps.payments import payments
from apps.cfp import cfp
from apps.cfp_review import cfp_review
from apps.schedule import schedule
from apps.arrivals import arrivals
from apps.api import api_bp
app.register_blueprint(base)
app.register_blueprint(users)
app.register_blueprint(metrics)
app.register_blueprint(tickets)
app.register_blueprint(payments)
app.register_blueprint(cfp)
app.register_blueprint(cfp_review, url_prefix='/cfp-review')
app.register_blueprint(schedule)
app.register_blueprint(arrivals, url_prefix='/arrivals')
app.register_blueprint(api_bp, url_prefix='/api')
if app.config.get('VOLUNTEERS'):
from apps.volunteer import volunteer
app.register_blueprint(volunteer, url_prefix='/volunteer')
from flask_admin import Admin
from apps.volunteer.flask_admin_base import VolunteerAdminIndexView
global volunteer_admin
volunteer_admin = Admin(
url='/volunteer/admin',
name='EMF Volunteers',
template_mode='bootstrap3',
index_view=VolunteerAdminIndexView(url='/volunteer/admin'),
base_template='volunteer/admin/flask-admin-base.html')
volunteer_admin.endpoint_prefix = 'volunteer_admin'
volunteer_admin.init_app(app)
import apps.volunteer.admin # noqa: F401
from apps.admin import admin
app.register_blueprint(admin, url_prefix='/admin')
return app
from django.shortcuts import redirect
from django.http import HttpResponse
from django.conf import settings
from django.contrib.auth.decorators import login_required
from django.urls import reverse as url_reverse
import gocardless_pro as gocardless
from gocardless_pro.errors import InvalidApiUsageError, InvalidStateError
from .models import Customer, Subscription
from lhspayments.models import Payment
from lhspayments import membershiptools
gc_client = gocardless.Client(
access_token=settings.GOCARDLESS_CREDENTIALS['access_token'],
environment=settings.GOCARDLESS_ENV)
# Helpers
def require_gocardless_user(f):
@wraps(f)
def decorator(request):
if not request.user.gocardless_user:
# User isn't a gocardless user, send them to the main mambers page
return redirect("/members/")
return f(request)
return login_required(decorator)
