def send_after_event_mail():
from app import current_app as app
with app.app_context():
events = Event.query.all()
upcoming_events = get_upcoming_events()
upcoming_event_links = "<ul>"
for upcoming_event in upcoming_events:
frontend_url = get_settings()['frontend_url']
upcoming_event_links += "<li><a href='{}/events/{}'>{}</a></li>" \
.format(frontend_url, upcoming_event.id, upcoming_event.name)
upcoming_event_links += "</ul>"
for event in events:
organizers = get_user_event_roles_by_role_name(event.id, 'organizer')
speakers = get_user_event_roles_by_role_name(event.id, 'speaker')
current_time = datetime.datetime.now(pytz.timezone(event.timezone))
time_difference = current_time - event.ends_at
time_difference_minutes = (time_difference.days * 24 * 60) + \
(time_difference.seconds / 60)
if current_time > event.ends_at and time_difference_minutes < 1440:
for speaker in speakers:
send_email_after_event(speaker.user.email, event.name, upcoming_event_links)
send_notif_after_event(speaker.user, event.name)
for organizer in organizers:
send_email_after_event(organizer.user.email, event.name, upcoming_event_links)
send_notif_after_event(organizer.user.email, event.name)
def empty_trash():
from app import current_app as app
with app.app_context():
events = Event.query.filter(Event.deleted_at.isnot(None)).all()
users = User.query.filter(User.deleted_at.isnot(None)).all()
sessions = Session.query.filter(Session.deleted_at.isnot(None)).all()
pending_orders = Order.query.filter_by(status="pending")
for event in events:
if datetime.now() - event.deleted_at >= timedelta(days=30):
DataManager.delete_event(event.id)
for user in users:
if datetime.now() - user.deleted_at >= timedelta(days=30):
transaction = transaction_class(Event)
transaction.query.filter_by(user_id=user.id).delete()
delete_from_db(user, "User deleted permanently")
for session_ in sessions:
if datetime.now() - session_.deleted_at >= timedelta(days=30):
delete_from_db(session_, "Session deleted permanently")
for pending_order in pending_orders:
if datetime.now() - pending_order.created_at >= timedelta(days=3):
pending_order.status = "expired"
save_to_db(pending_order, "Pending order expired.")
def send_after_event_mail():
from app import current_app as app
with app.app_context():
events = Event.query.filter_by(state='published',
deleted_at=None).all()
for event in events:
organizers = get_user_event_roles_by_role_name(
event.id, 'organizer')
speakers = Speaker.query.filter_by(event_id=event.id,
deleted_at=None).all()
owner = get_user_event_roles_by_role_name(event.id,
'owner').first()
current_time = datetime.datetime.now(pytz.timezone(event.timezone))
time_difference = current_time - event.ends_at
time_difference_minutes = (time_difference.days * 24 * 60) + \
(time_difference.seconds / 60)
frontend_url = get_settings()['frontend_url']
if current_time > event.ends_at and time_difference_minutes < 1440:
for speaker in speakers:
if not speaker.is_email_overridden:
send_email_after_event(speaker.user.email, event.name,
frontend_url)
send_notif_after_event(speaker.user, event.name)
for organizer in organizers:
send_email_after_event(organizer.user.email, event.name,
frontend_url)
send_notif_after_event(organizer.user, event.name)
if owner:
send_email_after_event(owner.user.email, event.name,
frontend_url)
send_notif_after_event(owner.user, event.name)
def empty_trash():
from app import current_app as app
with app.app_context():
events = Event.query.filter(Event.deleted_at.isnot(None)).all()
users = User.query.filter(User.deleted_at.isnot(None)).all()
sessions = Session.query.filter(Session.deleted_at.isnot(None)).all()
pending_orders = Order.query.filter_by(status="pending")
for event in events:
if datetime.now() - event.deleted_at >= timedelta(days=30):
DataManager.delete_event(event.id)
for user in users:
if datetime.now() - user.deleted_at >= timedelta(days=30):
transaction = transaction_class(Event)
transaction.query.filter_by(user_id=user.id).delete()
delete_from_db(user, "User deleted permanently")
for session_ in sessions:
if datetime.now() - session_.deleted_at >= timedelta(days=30):
delete_from_db(session_, "Session deleted permanently")
for pending_order in pending_orders:
if datetime.now() - pending_order.created_at >= timedelta(days=3):
pending_order.status = "expired"
save_to_db(pending_order, "Pending order expired.")
def initialize_db(credentials):
with app.app_context():
populate_data = True
inspector = reflection.Inspector.from_engine(db.engine)
table_name = 'events'
table_names = inspector.get_table_names()
print("[LOG] Existing tables:")
print("[LOG] " + ','.join(table_names))
if table_name not in table_names:
print("[LOG] Table not found. Attempting creation")
try:
db.create_all()
stamp()
except Exception:
populate_data = False
print(
"[LOG] Could not create tables. Either database does not exist or tables already created"
)
if populate_data:
credentials = credentials.split(":")
admin_email = os.environ.get('SUPER_ADMIN_EMAIL',
credentials[0])
admin_password = os.environ.get('SUPER_ADMIN_PASSWORD',
credentials[1])
create_super_admin(admin_email, admin_password)
populate()
else:
print(
"[LOG] Tables already exist. Skipping data population & creation."
)
def send_event_fee_notification_followup():
from app import current_app as app
with app.app_context():
incomplete_invoices = EventInvoice.query.filter(EventInvoice.status != 'completed').all()
for incomplete_invoice in incomplete_invoices:
if incomplete_invoice.amount > 0:
prev_month = monthdelta(incomplete_invoice.created_at, 1).strftime(
"%b %Y") # Displayed as Aug 2016
app_name = get_settings()['app_name']
frontend_url = get_settings()['frontend_url']
link = '{}/invoices/{}'.format(frontend_url,
incomplete_invoice.identifier)
send_followup_email_for_monthly_fee_payment(incomplete_invoice.user.email,
incomplete_invoice.event.name,
prev_month,
incomplete_invoice.amount,
app_name,
link)
send_followup_notif_monthly_fee_payment(incomplete_invoice.user,
incomplete_invoice.event.name,
prev_month,
incomplete_invoice.amount,
app_name,
link,
incomplete_invoice.event.id)
def send_monthly_event_invoice():
from app import current_app as app
with app.app_context():
events = Event.query.filter_by(deleted_at=None, state='published').all()
for event in events:
# calculate net & gross revenues
user = event.owner
admin_info = get_settings()
currency = event.payment_currency
ticket_fee_object = db.session.query(TicketFees).filter_by(currency=currency).one()
ticket_fee_percentage = ticket_fee_object.service_fee
ticket_fee_maximum = ticket_fee_object.maximum_fee
orders = Order.query.filter_by(event=event).all()
gross_revenue = event.calc_monthly_revenue()
ticket_fees = event.tickets_sold * (ticket_fee_percentage / 100)
if ticket_fees > ticket_fee_maximum:
ticket_fees = ticket_fee_maximum
net_revenue = gross_revenue - ticket_fees
payment_details = {
'tickets_sold': event.tickets_sold,
'gross_revenue': gross_revenue,
'net_revenue': net_revenue,
'amount_payable': ticket_fees
}
# save invoice as pdf
pdf = create_save_pdf(render_template('pdf/event_invoice.html', orders=orders, user=user,
admin_info=admin_info, currency=currency, event=event,
ticket_fee_object=ticket_fee_object, payment_details=payment_details,
net_revenue=net_revenue), UPLOAD_PATHS['pdf']['event_invoice'],
dir_path='/static/uploads/pdf/event_invoices/', identifier=event.identifier)
# save event_invoice info to DB
event_invoice = EventInvoice(amount=net_revenue, invoice_pdf_url=pdf, event_id=event.id)
save_to_db(event_invoice)
def expire_pending_tickets():
from app import current_app as app
with app.app_context():
db.session.query(Order).filter(Order.status == 'pending',
(Order.created_at + datetime.timedelta(minutes=30)) <= datetime.datetime.now()).\
update({'status': 'expired'})
db.session.commit()
def expire_pending_tickets_after_one_day():
from app import current_app as app
with app.app_context():
db.session.query(Order).filter(Order.status == 'pending',
(datetime.datetime.today() - Order.created_at).days > 1).\
update({'status': 'expired'})
db.session.commit()
def send_monthly_event_invoice():
from app import current_app as app
with app.app_context():
events = Event.query.all()
for event in events:
# calculate net & gross revenues
currency = event.payment_currency
ticket_fee_object = db.session.query(TicketFees).filter_by(
currency=currency).one()
ticket_fee_percentage = ticket_fee_object.service_fee
ticket_fee_maximum = ticket_fee_object.maximum_fee
orders = Order.query.filter_by(event=event).all()
gross_revenue = event.calc_monthly_revenue()
ticket_fees = event.tickets_sold * ticket_fee_percentage
if ticket_fees > ticket_fee_maximum:
ticket_fees = ticket_fee_maximum
net_revenue = gross_revenue - ticket_fees
# save invoice as pdf
pdf = create_save_pdf(
render_template('pdf/event_invoice.html',
orders=orders,
ticket_fee_object=ticket_fee_object,
gross_revenue=gross_revenue,
net_revenue=net_revenue),
UPLOAD_PATHS['pdf']['event_invoice'],
dir_path='/static/uploads/pdf/event_invoices/',
identifier=event.identifier)
# save event_invoice info to DB
event_invoice = EventInvoice(amount=net_revenue,
invoice_pdf_url=pdf,
event_id=event.id)
save_to_db(event_invoice)
def send_after_event_mail():
from app import current_app as app
with app.app_context():
events = Event.query.all()
upcoming_events = get_upcoming_events()
upcoming_event_links = "<ul>"
for upcoming_event in upcoming_events:
frontend_url = get_settings()['frontend_url']
upcoming_event_links += "<li><a href='{}/events/{}'>{}</a></li>" \
.format(frontend_url, upcoming_event.id, upcoming_event.name)
upcoming_event_links += "</ul>"
for event in events:
organizers = get_user_event_roles_by_role_name(
event.id, 'organizer')
speakers = Speaker.query.filter_by(event_id=event.id,
deleted_at=None).all()
current_time = datetime.datetime.now(pytz.timezone(event.timezone))
time_difference = current_time - event.ends_at
time_difference_minutes = (time_difference.days * 24 * 60) + \
(time_difference.seconds / 60)
if current_time > event.ends_at and time_difference_minutes < 1440:
for speaker in speakers:
send_email_after_event(speaker.user.email, event.name,
upcoming_event_links)
send_notif_after_event(speaker.user, event.name)
for organizer in organizers:
send_email_after_event(organizer.user.email, event.name,
upcoming_event_links)
send_notif_after_event(organizer.user, event.name)
def change_session_state_on_event_completion():
from app import current_app as app
with app.app_context():
sessions_to_be_changed = Session.query.join(Event).filter(Session.state == 'pending')\
.filter(Event.ends_at < datetime.datetime.now())
for session in sessions_to_be_changed:
session.state = 'rejected'
save_to_db(session, 'Changed {} session state to rejected'.format(session.title))
def send_mail_to_expired_orders():
from app import current_app as app
with app.app_context():
orders = DataGetter.get_expired_orders()
for order in orders:
send_email_for_expired_orders(order.user.email, order.event.name, order.get_invoice_number(),
url_for('ticketing.view_order_after_payment',
order_identifier=order.identifier, _external=True))
def send_mail_to_expired_orders():
from app import current_app as app
with app.app_context():
orders = DataGetter.get_expired_orders()
for order in orders:
send_email_for_expired_orders(order.user.email, order.event.name, order.get_invoice_number(),
url_for('ticketing.view_order_after_payment',
order_identifier=order.identifier, _external=True))
def send_event_fee_notification():
from app import current_app as app
with app.app_context():
events = Event.query.filter_by(deleted_at=None,
state='published').all()
for event in events:
latest_invoice = EventInvoice.query.filter_by(
event_id=event.id).order_by(
EventInvoice.created_at.desc()).first()
if latest_invoice:
orders = Order.query \
.filter_by(event_id=event.id) \
.filter_by(status='completed') \
.filter(Order.completed_at > latest_invoice.created_at).all()
else:
orders = Order.query.filter_by(event_id=event.id).filter_by(
status='completed').all()
fee_total = 0
for order in orders:
for order_ticket in order.tickets:
ticket = safe_query(db, Ticket, 'id',
order_ticket.ticket_id, 'ticket_id')
if order.paid_via != 'free' and order.amount > 0 and ticket.price > 0:
fee = ticket.price * (
get_fee(order.event.payment_currency) / 100.0)
fee_total += fee
if fee_total > 0:
owner = get_user_event_roles_by_role_name(event.id,
'owner').first()
new_invoice = EventInvoice(amount=fee_total,
event_id=event.id,
user_id=owner.user.id)
if event.discount_code_id and event.discount_code:
r = relativedelta(datetime.utcnow(), event.created_at)
if r <= event.discount_code.valid_till:
new_invoice.amount = fee_total - \
(fee_total * (event.discount_code.value / 100.0))
new_invoice.discount_code_id = event.discount_code_id
save_to_db(new_invoice)
prev_month = monthdelta(new_invoice.created_at, 1).strftime(
"%b %Y") # Displayed as Aug 2016
app_name = get_settings()['app_name']
frontend_url = get_settings()['frontend_url']
link = '{}/invoices/{}'.format(frontend_url,
new_invoice.identifier)
send_email_for_monthly_fee_payment(new_invoice.user.email,
event.name, prev_month,
new_invoice.amount,
app_name, link)
send_notif_monthly_fee_payment(new_invoice.user, event.name,
prev_month, new_invoice.amount,
app_name, link,
new_invoice.event_id)
def send_event_fee_notification():
from app import current_app as app
with app.app_context():
events = Event.query.all()
for event in events:
latest_invoice = EventInvoice.query.filter_by(
event_id=event.id).order_by(EventInvoice.created_at.desc()).first()
if latest_invoice:
orders = Order.query \
.filter_by(event_id=event.id) \
.filter_by(status='completed') \
.filter(Order.completed_at > latest_invoice.created_at).all()
else:
orders = Order.query.filter_by(
event_id=event.id).filter_by(status='completed').all()
fee_total = 0
for order in orders:
for order_ticket in order.tickets:
ticket = safe_query(db, Ticket, 'id', order_ticket.ticket_id, 'ticket_id')
if order.paid_via != 'free' and order.amount > 0 and ticket.price > 0:
fee = ticket.price * (get_fee(order.event.payment_currency) / 100.0)
fee_total += fee
if fee_total > 0:
organizer = get_user_event_roles_by_role_name(event.id, 'organizer').first()
new_invoice = EventInvoice(
amount=fee_total, event_id=event.id, user_id=organizer.user.id)
if event.discount_code_id and event.discount_code:
r = relativedelta(datetime.utcnow(), event.created_at)
if r <= event.discount_code.valid_till:
new_invoice.amount = fee_total - \
(fee_total * (event.discount_code.value / 100.0))
new_invoice.discount_code_id = event.discount_code_id
save_to_db(new_invoice)
prev_month = monthdelta(new_invoice.created_at, 1).strftime(
"%b %Y") # Displayed as Aug 2016
app_name = get_settings()['app_name']
frontend_url = get_settings()['frontend_url']
link = '{}/invoices/{}'.format(frontend_url, new_invoice.identifier)
send_email_for_monthly_fee_payment(new_invoice.user.email,
event.name,
prev_month,
new_invoice.amount,
app_name,
link)
send_notif_monthly_fee_payment(new_invoice.user,
event.name,
prev_month,
new_invoice.amount,
app_name,
link,
new_invoice.event_id)
def event_invoices_mark_due():
from app import current_app as app
with app.app_context():
db.session.query(EventInvoice).filter(
EventInvoice.status == 'upcoming',
Event.id == EventInvoice.event_id,
Event.ends_at >= datetime.datetime.now(),
(EventInvoice.created_at + datetime.timedelta(days=30) <=
datetime.datetime.now())).update({EventInvoice.status: 'due'},
synchronize_session=False)
def delete_ticket_holders_no_order_id():
from app import current_app as app
with app.app_context():
order_expiry_time = get_settings()['order_expiry_time']
TicketHolder.query.filter(
TicketHolder.order_id == None, TicketHolder.deleted_at.is_(None),
TicketHolder.created_at +
datetime.timedelta(minutes=order_expiry_time) <
datetime.datetime.utcnow()).delete(synchronize_session=False)
db.session.commit()
def empty_csv_export():
from app import current_app as app
with app.app_context():
events = Event.query.filter(Event.deleted_at.isnot(None)).all()
for event in events:
key = UPLOAD_PATHS['exports']['csv'].format(event_id=event_id)
file_relative_path = 'static/media/' + key + '/'
file_path = app.config['BASE_DIR'] + '/' + file_relative_path
shutil.rmtree(file_path)
def empty_csv_export():
from app import current_app as app
with app.app_context():
events = Event.query.filter(Event.deleted_at.isnot(None)).all()
for event in events:
key = UPLOAD_PATHS['exports']['csv'].format(event_id=event_id)
file_relative_path = 'static/media/' + key + '/'
file_path = app.config['BASE_DIR'] + '/' + file_relative_path
shutil.rmtree(file_path)
def event_invoices_mark_due():
from app import current_app as app
with app.app_context():
db.session.query(EventInvoice).\
filter(EventInvoice.status == 'upcoming',
EventInvoice.event.ends_at >= datetime.datetime.now(),
(EventInvoice.created_at + datetime.timedelta(days=30) <=
datetime.datetime.now())).\
update({'status': 'due'})
db.session.commit()
def initialize_db():
with app.app_context():
populate_data = True
try:
db.drop_all()
db.create_all()
stamp()
except Exception:
populate_data = False
print("[LOG] Could not create tables. Either database does not exist or tables already created")
if populate_data:
populate()
def send_event_fee_notification():
from app import current_app as app
with app.app_context():
events = Event.query.all()
for event in events:
latest_invoice = EventInvoice.filter_by(
event_id=event.id).order_by(
EventInvoice.created_at.desc()).first()
if latest_invoice:
orders = Order.query \
.filter_by(event_id=event.id) \
.filter_by(status='completed') \
.filter(Order.completed_at > latest_invoice.created_at).all()
else:
orders = Order.query.filter_by(event_id=event.id).filter_by(
status='completed').all()
fee_total = 0
for order in orders:
for order_ticket in order.tickets:
ticket = TicketingManager.get_ticket(
order_ticket.ticket_id)
if order.paid_via != 'free' and order.amount > 0 and ticket.price > 0:
fee = ticket.price * (
get_fee(order.event.payment_currency) / 100.0)
fee_total += fee
if fee_total > 0:
organizer = DataGetter.get_user_event_roles_by_role_name(
event.id, 'organizer').first()
new_invoice = EventInvoice(amount=fee_total,
event_id=event.id,
user_id=organizer.user.id)
if event.discount_code_id and event.discount_code:
r = relativedelta(datetime.utcnow(), event.created_at)
if r <= event.discount_code.max_quantity:
new_invoice.amount = fee_total - \
(fee_total * (event.discount_code.value / 100.0))
new_invoice.discount_code_id = event.discount_code_id
save_to_db(new_invoice)
prev_month = monthdelta(new_invoice.created_at, 1).strftime(
"%b %Y") # Displayed as Aug 2016
send_email_for_monthly_fee_payment(
new_invoice.user.email, event.name, prev_month,
new_invoice.amount,
url_for('event_invoicing.view_invoice',
invoice_identifier=new_invoice.identifier,
_external=True))
def send_event_fee_notification_followup():
from app import current_app as app
with app.app_context():
incomplete_invoices = EventInvoice.query.filter(EventInvoice.status != 'completed').all()
for incomplete_invoice in incomplete_invoices:
if incomplete_invoice.amount > 0:
prev_month = monthdelta(incomplete_invoice.created_at, 1).strftime("%b %Y") # Displayed as Aug 2016
send_followup_email_for_monthly_fee_payment(incomplete_invoice.user.email,
incomplete_invoice.event.name,
prev_month,
incomplete_invoice.amount,
url_for('event_invoicing.view_invoice',
invoice_identifier=incomplete_invoice.identifier,
_external=True))
def send_event_fee_notification_followup():
from app import current_app as app
with app.app_context():
incomplete_invoices = EventInvoice.query.filter(EventInvoice.status != 'completed').all()
for incomplete_invoice in incomplete_invoices:
if incomplete_invoice.amount > 0:
prev_month = monthdelta(incomplete_invoice.created_at, 1).strftime("%b %Y") # Displayed as Aug 2016
send_followup_email_for_monthly_fee_payment(incomplete_invoice.user.email,
incomplete_invoice.event.name,
prev_month,
incomplete_invoice.amount,
url_for('event_invoicing.view_invoice',
invoice_identifier=incomplete_invoice.identifier,
_external=True))
def send_event_fee_notification():
from app import current_app as app
with app.app_context():
events = Event.query.all()
for event in events:
latest_invoice = EventInvoice.filter_by(event_id=event.id).order_by(
EventInvoice.created_at.desc()).first()
if latest_invoice:
orders = Order.query \
.filter_by(event_id=event.id) \
.filter_by(status='completed') \
.filter(Order.completed_at > latest_invoice.created_at).all()
else:
orders = Order.query.filter_by(
event_id=event.id).filter_by(status='completed').all()
fee_total = 0
for order in orders:
for order_ticket in order.tickets:
ticket = TicketingManager.get_ticket(order_ticket.ticket_id)
if order.paid_via != 'free' and order.amount > 0 and ticket.price > 0:
fee = ticket.price * (get_fee(order.event.payment_currency) / 100.0)
fee_total += fee
if fee_total > 0:
organizer = DataGetter.get_user_event_roles_by_role_name(
event.id, 'organizer').first()
new_invoice = EventInvoice(
amount=fee_total, event_id=event.id, user_id=organizer.user.id)
if event.discount_code_id and event.discount_code:
r = relativedelta(datetime.utcnow(), event.created_at)
if r <= event.discount_code.max_quantity:
new_invoice.amount = fee_total - \
(fee_total * (event.discount_code.value / 100.0))
new_invoice.discount_code_id = event.discount_code_id
save_to_db(new_invoice)
prev_month = monthdelta(new_invoice.created_at, 1).strftime(
"%b %Y") # Displayed as Aug 2016
send_email_for_monthly_fee_payment(new_invoice.user.email,
event.name,
prev_month,
new_invoice.amount,
url_for('event_invoicing.view_invoice',
invoice_identifier=new_invoice.identifier, _external=True))
def send_after_event_mail():
from app import current_app as app
with app.app_context():
events = Event.query.all()
for event in events:
upcoming_events = DataGetter.get_upcoming_events()
organizers = DataGetter.get_user_event_roles_by_role_name(
event.id, 'organizer')
speakers = DataGetter.get_user_event_roles_by_role_name(event.id,
'speaker')
if datetime.now() > event.end_time:
for speaker in speakers:
send_after_event(speaker.user.email, event.id,
upcoming_events)
for organizer in organizers:
send_after_event(organizer.user.email, event.id,
upcoming_events)
def initialize_db(credentials):
with app.app_context():
populate_data = True
inspector = reflection.Inspector.from_engine(db.engine)
table_name = 'events'
table_names = inspector.get_table_names()
if table_name not in table_names:
try:
db.create_all()
stamp()
except:
populate_data = False
print "Could not create tables. Either database does not exist or tables already created"
if populate_data:
credentials = credentials.split(":")
DataManager.create_super_admin(credentials[0], credentials[1])
populate()
def initialize_db(credentials):
with app.app_context():
populate_data = True
inspector = reflection.Inspector.from_engine(db.engine)
table_name = 'events'
table_names = inspector.get_table_names()
if table_name not in table_names:
try:
db.create_all()
stamp()
except:
populate_data = False
print "Could not create tables. Either database does not exist or tables already created"
if populate_data:
credentials = credentials.split(":")
DataManager.create_super_admin(credentials[0], credentials[1])
populate()
def send_after_event_mail():
from app import current_app as app
with app.app_context():
events = Event.query.all()
for event in events:
upcoming_events = DataGetter.get_upcoming_events()
organizers = DataGetter.get_user_event_roles_by_role_name(
event.id, 'organizer')
speakers = DataGetter.get_user_event_roles_by_role_name(
event.id, 'speaker')
if datetime.now() > event.end_time:
for speaker in speakers:
send_after_event(speaker.user.email, event.id,
upcoming_events)
for organizer in organizers:
send_after_event(organizer.user.email, event.id,
upcoming_events)
def empty_trash():
from app import current_app as app
with app.app_context():
events = Event.query.filter_by(in_trash=True)
users = User.query.filter_by(in_trash=True)
sessions = Session.query.filter_by(in_trash=True)
for event in events:
if datetime.now() - event.trash_date >= timedelta(days=30):
DataManager.delete_event(event.id)
for user in users:
if datetime.now() - user.trash_date >= timedelta(days=30):
transaction = transaction_class(Event)
transaction.query.filter_by(user_id=user.id).delete()
delete_from_db(user, "User deleted permanently")
for session_ in sessions:
if datetime.now() - session_.trash_date >= timedelta(days=30):
delete_from_db(session_, "Session deleted permanently")
def empty_trash():
from app import current_app as app
with app.app_context():
events = Event.query.filter_by(in_trash=True)
users = User.query.filter_by(in_trash=True)
sessions = Session.query.filter_by(in_trash=True)
for event in events:
if datetime.now() - event.trash_date >= timedelta(days=30):
DataManager.delete_event(event.id)
for user in users:
if datetime.now() - user.trash_date >= timedelta(days=30):
transaction = transaction_class(Event)
transaction.query.filter_by(user_id=user.id).delete()
delete_from_db(user, "User deleted permanently")
for session_ in sessions:
if datetime.now() - session_.trash_date >= timedelta(days=30):
delete_from_db(session_, "Session deleted permanently")
def initialize_db(credentials):
with app.app_context():
populate_data = True
inspector = reflection.Inspector.from_engine(db.engine)
table_name = 'events'
table_names = inspector.get_table_names()
print "[LOG] Existing tables:"
print "[LOG] " + ','.join(table_names)
if table_name not in table_names:
print "[LOG] Table not found. Attempting creation"
try:
db.create_all()
stamp()
except:
populate_data = False
print "[LOG] Could not create tables. Either database does not exist or tables already created"
if populate_data:
credentials = credentials.split(":")
create_super_admin(credentials[0], credentials[1])
populate()
else:
print "[LOG] Tables already exist. Skipping data population & creation."
def initialize_db(credentials):
with app.app_context():
populate_data = True
inspector = reflection.Inspector.from_engine(db.engine)
table_name = 'events'
table_names = inspector.get_table_names()
print("[LOG] Existing tables:")
print("[LOG] " + ','.join(table_names))
if table_name not in table_names:
print("[LOG] Table not found. Attempting creation")
try:
db.create_all()
stamp()
except Exception:
populate_data = False
print("[LOG] Could not create tables. Either database does not exist or tables already created")
if populate_data:
credentials = credentials.split(":")
create_super_admin(credentials[0], credentials[1])
populate()
else:
print("[LOG] Tables already exist. Skipping data population & creation.")
def empty_trash():
from app import current_app as app
with app.app_context():
events = Event.query.filter_by(in_trash=True)
users = User.query.filter_by(in_trash=True)
sessions = Session.query.filter_by(in_trash=True)
orders = Order.query.filter_by(status="deleted")
pending_orders = Order.query.filter_by(status="pending")
expired_orders = Order.query.filter_by(status="expired")
for event in events:
if datetime.now() - event.trash_date >= timedelta(days=30):
DataManager.delete_event(event.id)
for user in users:
if datetime.now() - user.trash_date >= timedelta(days=30):
transaction = transaction_class(Event)
transaction.query.filter_by(user_id=user.id).delete()
delete_from_db(user, "User deleted permanently")
for session_ in sessions:
if datetime.now() - session_.trash_date >= timedelta(days=30):
delete_from_db(session_, "Session deleted permanently")
for order in orders:
if datetime.now() - order.trashed_at >= timedelta(days=30):
delete_from_db(order, "Order deleted permanently")
for pending_order in pending_orders:
if datetime.now() - pending_order.created_at >= timedelta(days=3):
pending_order.status = "expired"
save_to_db(pending_order, "Pending order expired.")
for expired_order in expired_orders:
if datetime.now() - expired_order.created_at >= timedelta(days=6):
expired_order.status = "deleted"
expired_order.trashed_at = datetime.now()
save_to_db(expired_order, "Expired order deleted")
def prepare_kubernetes_db(credentials='[email protected]:password'): with app.app_context(): initialize_db(credentials)
def initialize_db(credentials):
with app.app_context():
db.create_all()
credentials = credentials.split(":")
DataManager.create_super_admin(credentials[0], credentials[1])
populate()
def prepare_kubernetes_db():
with app.app_context():
initialize_db('[email protected]:fossasia')
def prepare_kubernetes_db():
with app.app_context():
initialize_db('[email protected]:fossasia')
else:
get_or_create(MessageSettings, action=mail, mail_status=0, notif_status=0, user_control_status=0)
def populate():
"""
Create defined Roles, Services and Permissions.
"""
print
print 'Creating roles...'
create_roles()
print 'Creating services...'
create_services()
print 'Creating permissions...'
create_permissions()
print 'Creating custom system roles...'
create_custom_sys_roles()
print 'Creating admin panel permissions...'
create_panel_permissions()
print 'Creating user permissions...'
create_user_permissions()
print 'Creating admin message settings...'
create_admin_message_settings()
db.session.commit()
if __name__ == '__main__':
with current_app.app_context():
populate()
def initialize_db(credentials):
with app.app_context():
db.create_all()
credentials = credentials.split(":")
DataManager.create_super_admin(credentials[0], credentials[1])
populate()
