def test_should_create_attendee_forms(self): """Method to test custom forms for attendees of an event.""" with app.test_request_context(): event = EventFactoryBasic() save_to_db(event) create_custom_forms_for_attendees(event) self.assertEqual(get_count(CustomForms.query), 3)
def charge_stripe_order_payment(order, token_id): order.stripe_token = token_id save_to_db(order) charge = StripePaymentsManager.capture_payment(order) if charge: order.paid_via = 'stripe' order.payment_mode = charge.source.object order.brand = charge.source.brand order.exp_month = charge.source.exp_month order.exp_year = charge.source.exp_year order.last4 = charge.source.last4 order.transaction_id = charge.id order.status = 'completed' order.completed_at = datetime.utcnow() save_to_db(order) invoice_id = order.get_invoice_number() order_url = make_frontend_url(path="/{identifier}/view/".format(identifier=order.identifier)) # send_email_for_after_purchase(order.user.email, invoice_id, order_url, order.event.name, # order.event.organizer_name) # send_notif_for_after_purchase(order.user, invoice_id, order_url) return True, order else: return False, 'Error'
def charge_paypal_order_payment(order): payment_details = PayPalPaymentsManager.get_approved_payment_details(order) if 'PAYERID' in payment_details: capture_result = PayPalPaymentsManager.capture_payment(order, payment_details['PAYERID']) if capture_result['ACK'] == 'Success': order.paid_via = 'paypal' order.status = 'completed' order.transaction_id = capture_result['PAYMENTINFO_0_TRANSACTIONID'] order.completed_at = datetime.utcnow() save_to_db(order) invoice_id = order.get_invoice_number() order_url = make_frontend_url(path="/{identifier}/view/".format(identifier=order.identifier)) # trigger_after_purchase_notifications(order.user.email, order.event_id, order.event, invoice_id, # order_url) # send_email_for_after_purchase(order.user.email, invoice_id, order_url, order.event.name, # order.event.organizer_name) # send_notif_for_after_purchase(order.user, invoice_id, order_url) return True, order else: return False, capture_result['L_SHORTMESSAGE0'] else: return False, 'Payer ID missing. Payment flow tampered.'
def change_password(): old_password = request.json['data']['old-password'] new_password = request.json['data']['new-password'] try: user = User.query.filter_by(id=current_user.id).one() except NoResultFound: return abort( make_response(jsonify(error="User not found"), 404) ) else: if user.is_correct_password(old_password): user.password = new_password save_to_db(user) send_email_with_action(user, PASSWORD_CHANGE, app_name=get_settings()['app_name']) send_notification_with_action(user, PASSWORD_CHANGE_NOTIF, app_name=get_settings()['app_name']) else: return abort( make_response(jsonify(error="Wrong Password"), 400) ) return jsonify({ "id": user.id, "email": user.email, "name": user.fullname if user.fullname else None, "password-changed": True })
def export_pentabarf_task(self, event_id, temp=True): event = safe_query(db, Event, 'id', event_id, 'event_id') try: if temp: filedir = os.path.join(current_app.config.get('BASE_DIR'), 'static/uploads/temp/' + event_id + '/') else: filedir = os.path.join(current_app.config.get('BASE_DIR'), 'static/uploads/' + event_id + '/') if not os.path.isdir(filedir): os.makedirs(filedir) filename = "pentabarf.xml" file_path = os.path.join(filedir, filename) with open(file_path, "w") as temp_file: temp_file.write(str(PentabarfExporter.export(event_id), 'utf-8')) pentabarf_file = UploadedFile(file_path=file_path, filename=filename) if temp: pentabarf_url = upload(pentabarf_file, UPLOAD_PATHS['exports-temp']['pentabarf'].format(event_id=event_id)) else: pentabarf_url = upload(pentabarf_file, UPLOAD_PATHS['exports']['pentabarf'].format(event_id=event_id)) result = { 'download_url': pentabarf_url } if not temp: event.pentabarf_url = pentabarf_url save_to_db(event) except Exception as e: print(traceback.format_exc()) result = {'__error': True, 'result': str(e)} return result
def after_create_object(self, role_invite, data, view_kwargs): """ after create object method for role invite links :param role_invite: :param data: :param view_kwargs: :return: """ user = User.query.filter_by(email=role_invite.email).first() if 'status' in data and data['status'] == 'accepted': role = Role.query.filter_by(name=role_invite.role_name).first() event = Event.query.filter_by(id=role_invite.event_id).first() uer = UsersEventsRoles.query.filter_by(user=user).filter_by( event=event).filter_by(role=role).first() if not uer: uer = UsersEventsRoles(user, event, role) save_to_db(uer, 'Role Invite accepted') event = Event.query.filter_by(id=role_invite.event_id).first() frontend_url = get_settings()['frontend_url'] link = "{}/events/{}/role-invites/{}" \ .format(frontend_url, event.id, role_invite.hash) send_email_role_invite(role_invite.email, role_invite.role_name, event.name, link) if user: send_notif_event_role(user, role_invite.role_name, event.name, link, event.id)
def test_is_coorganizer_endpoint_related_to_event(self): with app.test_request_context(headers=self.auth, method="POST"): uer, is_created = get_or_create(UsersEventsRoles, user_id=1, event_id=1) uer.role_id = 2 save_to_db(uer) self.assertTrue(has_access('is_coorganizer', event_id=1))
def update_import_job(task, result, result_status): """update import job status""" ij = ImportJob.query.filter_by(task=task).first() if not ij: return ij.result = result ij.result_status = result_status save_to_db(ij, 'Import job updated')
def test_safe_query(self): """Method to test the function safe_query""" with app.test_request_context(): event = EventFactoryBasic() save_to_db(event) obj = safe_query(db, Event, 'id', event.id, 'event_id') self.assertEqual(obj.name, event.name)
def test_save_to_db(self): """Method to test the function save_to_db""" with app.test_request_context(): obj = EventFactoryBasic() save_to_db(obj) event = db.session.query(Event).filter(Event.id == obj.id).first() self.assertEqual(obj.name, event.name)
def test_is_registrar(self): with app.test_request_context(headers=self.auth, method="POST"): uer, is_created = get_or_create(UsersEventsRoles, user_id=1, event_id=1) uer.role_id = 6 save_to_db(uer) self.assertTrue(has_access('is_registrar', event_id=1))
def after_delete_object(self, stripe_authorization, view_kwargs): """Make work after delete object :param stripe_authorization: stripe authorization. :param dict view_kwargs: kwargs from the resource view """ event = stripe_authorization.event event.is_stripe_linked = False save_to_db(event)
def test_modify_email_for_user_to_be_deleted(self): """Method to test modification of email for user to be deleted""" with self.app.test_request_context(): user = create_user(email="*****@*****.**", password="******") save_to_db(user) modified_user = modify_email_for_user_to_be_deleted(user) self.assertEqual("*****@*****.**", modified_user.email)
def test_is_registrar(self): """Method to test whether a user is registrar of an event or not""" with app.test_request_context(headers=self.auth, method="POST"): uer, is_created = get_or_create(UsersEventsRoles, user_id=1, event_id=1) uer.role_id = 6 save_to_db(uer) self.assertTrue(has_access('is_registrar', event_id=1))
def accept_invite(): token = request.json['data']['token'] try: role_invite = RoleInvite.query.filter_by(hash=token).one() except NoResultFound: raise NotFoundError({'source': ''}, 'Role Invite Not Found') else: try: user = User.query.filter_by(email=role_invite.email).first() except NoResultFound: raise NotFoundError( {'source': ''}, 'User corresponding to role invite not Found' ) try: role = Role.query.filter_by(name=role_invite.role_name).first() except NoResultFound: raise NotFoundError( {'source': ''}, 'Role corresponding to role invite not Found' ) event = Event.query.filter_by(id=role_invite.event_id).first() uer = ( UsersEventsRoles.query.filter_by(user=user) .filter_by(event=event) .filter_by(role=role) .first() ) if not uer: if role_invite.role_name == 'owner': past_owner = UsersEventsRoles.query.filter_by( event=event, role=role ).first() oldrole = Role.query.filter_by(name='organizer').first() prevuser = User.query.filter_by(id=past_owner.user_id).first() if past_owner: delete_previous_uer(past_owner) puer = UsersEventsRoles(user=prevuser, event=event, role=oldrole) save_to_db(puer, 'User Event Role changed') role_invite.status = "accepted" save_to_db(role_invite, 'Role Invite Accepted') # reset the group of event event.group_id = None save_to_db(event, 'Group ID Removed') uer = UsersEventsRoles(user=user, event=event, role=role) save_to_db(uer, 'User Event Role Created') if not user.is_verified: user.is_verified = True save_to_db(user, 'User verified') return jsonify( { "email": user.email, "event": role_invite.event_id, "event_identifier": role_invite.event.identifier, "name": user.fullname if user.fullname else None, "role": uer.role.name, } )
def create_order(): data, errors = OrderAmountInputSchema().load(request.get_json()) if errors: return make_response(jsonify(errors), 422) tickets_dict = data['tickets'] order_amount = calculate_order_amount(tickets_dict, data.get('discount_code')) ticket_ids = {ticket['id'] for ticket in tickets_dict} ticket_map = {int(ticket['id']): ticket for ticket in tickets_dict} tickets = ( Ticket.query.filter_by(deleted_at=None).filter(Ticket.id.in_(ticket_ids)).all() ) if not tickets: raise UnprocessableEntityError( {'source': 'tickets'}, "Tickets missing in Order request", ) event = tickets[0].event try: attendees = [] for ticket in tickets: for _ in range(ticket_map[ticket.id]['quantity']): ticket.raise_if_unavailable() attendees.append( TicketHolder(firstname='', lastname='', ticket=ticket, event=event) ) db.session.commit() except Exception as e: db.session.rollback() raise e validate_attendees({attendee.id for attendee in attendees}) if data.get('amount') is not None and ( current_user.is_staff or has_access('is_coorganizer', event_id=event.id) ): # If organizer or admin has overrided the amount of order order_amount['total'] = data['amount'] order = Order( amount=order_amount['total'], event=event, discount_code_id=data.get('discount_code'), ticket_holders=attendees, ) db.session.commit() order.populate_and_save() order_tickets = OrderTicket.query.filter_by(order_id=order.id).all() for order_ticket in order_tickets: ticket_info = ticket_map[order_ticket.ticket.id] order_ticket.price = ticket_info.get('price') save_to_db(order_ticket) return OrderSchema().dump(order)
def send_event_fee_notification(): from app.instance 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 ticket in order.tickets: if order.paid_via != 'free' and order.amount > 0 and ticket.price > 0: fee = ticket.price * ( get_fee(event.payment_country, 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.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_notification(user, action, title, message): if not current_app.config['TESTING']: notification = Notification(user_id=user.id, title=title, message=message, action=action ) save_to_db(notification, msg="Notification saved") record_activity('notification_event', user=user, action=action, title=title)
def create_user(email, password, is_verified=True): """ Registers the user but not logs in """ user = User(email=email, password=password, is_verified=is_verified) save_to_db(user, "User created") return user
def test_is_registrar(self): """Method to test whether a user is registrar of an event or not""" with self.app.test_request_context(headers=self.auth, method="POST"): uer = UsersEventsRolesSubFactory(user_id=1, event_id=1, role__name='registrar') save_to_db(uer) assert has_access('is_registrar', event_id=1)
def send_monthly_event_invoice(): from app.instance 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 try: ticket_fee_object = (db.session.query(TicketFees).filter_by( currency=currency).one()) except NoResultFound: logger.error('Ticket Fee not found for event id {id}'.format( id=event.id)) continue 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() invoice_amount = gross_revenue * (ticket_fee_percentage / 100) if invoice_amount > ticket_fee_maximum: invoice_amount = ticket_fee_maximum net_revenue = gross_revenue - invoice_amount payment_details = { 'tickets_sold': event.tickets_sold, 'gross_revenue': gross_revenue, 'net_revenue': net_revenue, 'amount_payable': invoice_amount, } # 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=invoice_amount, invoice_pdf_url=pdf, event_id=event.id) save_to_db(event_invoice)
def create_onsite_attendees_for_order(data): """ Creates on site ticket holders for an order and adds it into the request data. :param data: data initially passed in the POST request for order. :return: """ on_site_tickets = data.get('on_site_tickets') if not on_site_tickets: raise UnprocessableEntity( {'pointer': 'data/attributes/on_site_tickets'}, 'on_site_tickets info missing') data['ticket_holders'] = [] for on_site_ticket in on_site_tickets: ticket_id = on_site_ticket['id'] quantity = int(on_site_ticket['quantity']) ticket = safe_query_without_soft_deleted_entries( db, Ticket, 'id', ticket_id, 'ticket_id') ticket_sold_count = get_count( db.session.query(TicketHolder.id).filter_by(ticket_id=int( ticket.id), deleted_at=None)) # Check if the ticket is already sold out or not. if ticket_sold_count + quantity > ticket.quantity: # delete the already created attendees. for holder in data['ticket_holders']: ticket_holder = db.session.query(TicketHolder).filter( id == int(holder)).one() db.session.delete(ticket_holder) try: db.session.commit() except Exception as e: logging.error('DB Exception! %s' % e) db.session.rollback() raise ConflictException( {'pointer': '/data/attributes/on_site_tickets'}, "Ticket with id: {} already sold out. You can buy at most {} tickets" .format(ticket_id, ticket.quantity - ticket_sold_count)) for _ in range(1, quantity): ticket_holder = TicketHolder(firstname='onsite', lastname='attendee', email='*****@*****.**', ticket_id=ticket.id, event_id=data.get('event')) save_to_db(ticket_holder) data['ticket_holders'].append(ticket_holder.id) # delete from the data. del data['on_site_tickets']
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 test_is_track_organizer(self): """Method to test whether a user is track organizer of an event or not""" with app.test_request_context(headers=self.auth, method="POST"): uer, is_created = get_or_create(UsersEventsRoles, user_id=1, event_id=1) uer.role_id = 4 save_to_db(uer) self.assertTrue(has_access('is_moderator', event_id=1))
def used_payment(payment_id, order): """ Function to check for recycling of payment IDs """ if Order.query.filter(Order.paypal_token == payment_id).first() is None: order.paypal_token = payment_id save_to_db(order) return False else: return True
def test_export(self): """Test to check event contents in pentabarfxml format""" with app.test_request_context(): test_event = EventFactoryBasic() save_to_db(test_event) pentabarf_export = PentabarfExporter() pentabarf_string = pentabarf_export.export(test_event.id) pentabarf_original = fromstring(pentabarf_string) self.assertEqual(fromstring(tostring(pentabarf_original))[0][0].text, "example") self.assertEqual(fromstring(tostring(pentabarf_original))[0][1].text, "2099-12-13")
def test_save_to_db(self): """Check DBHelper: save to db""" with app.test_request_context(): with mixer.ctx(commit=False): mixer.init_app(app) obj = mixer.blend(User) save_to_db(obj) user = db.session.query(User).filter(User.id == obj.id).first() self.assertEqual(obj.name, user.name)
def after_update_object(self, role_invite, data, view_kwargs): user = User.query.filter_by(email=role_invite.email).first() if 'status' in data and data['status'] == 'accepted': role = Role.query.filter_by(name=role_invite.role_name).first() event = Event.query.filter_by(id=role_invite.event_id).first() uer = UsersEventsRoles.query.filter_by(user=user).filter_by( event=event).filter_by(role=role).first() if not uer: uer = UsersEventsRoles(user, event, role) save_to_db(uer, 'Role Invite accepted')
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 after_update_object(self, session, data, view_kwargs): """ Send email if session accepted or rejected """ if ('state' in data and data.get('send_email', None) and (session.state == 'accepted' or session.state == 'rejected')): event = session.event # Email for speaker speakers = session.speakers for speaker in speakers: frontend_url = get_settings()['frontend_url'] link = "{}/events/{}/sessions/{}".format( frontend_url, event.identifier, session.id) if not speaker.is_email_overridden: send_email_session_accept_reject(speaker.email, session, link) send_notif_session_accept_reject(speaker, session.title, session.state, link, session.id) # Email for owner if session.event.get_owner(): owner = session.event.get_owner() owner_email = owner.email frontend_url = get_settings()['frontend_url'] link = "{}/events/{}/sessions/{}".format( frontend_url, event.identifier, session.id) send_email_session_accept_reject(owner_email, session, link) send_notif_session_accept_reject(owner, session.title, session.state, link, session.id) if 'state' in data: entry_count = SessionsSpeakersLink.query.filter_by( session_id=session.id) if entry_count.count() == 0: is_patch_request = False else: is_patch_request = True if is_patch_request: for focus_session in entry_count: focus_session.session_state = session.state db.session.commit() else: current_session = Session.query.filter_by( id=session.id).first() for speaker in current_session.speakers: session_speaker_link = SessionsSpeakersLink( session_state=session.state, session_id=session.id, event_id=session.event.id, speaker_id=speaker.id, ) save_to_db(session_speaker_link, "Session Speaker Link Saved")
def before_get(self, args, kwargs): events = Event.query.all() for event in events: sales = summary(event) event.completed_order_sales = sales['completed']['sales_total'] event.placed_order_sales = sales['placed']['sales_total'] event.pending_order_sales = sales['pending']['sales_total'] event.completed_order_tickets = sales['completed']['ticket_count'] event.placed_order_tickets = sales['placed']['ticket_count'] event.pending_order_tickets = sales['pending']['ticket_count'] save_to_db(event)
def send_notification(user, action, title, message): if not current_app.config['TESTING']: notification = Notification(user_id=user.id, title=title, message=message, action=action) save_to_db(notification, msg="Notification saved") record_activity('notification_event', user=user, action=action, title=title)
def sponsor_logos_url_task(self, event_id): sponsors = Sponsor.query.filter_by(event_id=event_id, deleted_at=None).all() for sponsor in sponsors: try: logging.info('Sponsor logo url generation task started {}'.format(sponsor.logo_url)) new_logo_url = create_save_resized_image(image_file=sponsor.logo_url, resize=False) sponsor.logo_url = new_logo_url save_to_db(sponsor) logging.info('Sponsor logo url successfully generated') except(urllib.error.HTTPError, urllib.error.URLError): logging.exception('Error encountered while logo generation')
def get_event_exported_actions(download_url): """ Get the actions associated with a notification about an event being successfully exported. :param download_url: download url of the event. :return: actions. """ download_action = NotificationAction(subject='event-export', link=download_url, action_type='download') save_to_db(download_action) return [download_action]
def after_create_object(self, stripe_authorization, data, view_kwargs): """ after create object method for StripeAuthorizationListPost Class :param stripe_authorization: Stripe authorization created from mashmallow_jsonapi :param data: :param view_kwargs: :return: """ event = db.session.query(Event).filter_by(id=int(data['event'])).one() event.is_stripe_linked = True save_to_db(event)
def get_ticket_purchased_attendee_notification_actions(pdf_url): """ Get the actions associated with a notification of tickets purchased for an attendee that is not the buyer. :param pdf_url: :return: actions """ view_ticket_action = NotificationAction(subject='tickets-pdf', link=pdf_url, action_type='view') save_to_db(view_ticket_action) return [view_ticket_action]
def test_export(self): """Test to check event contents in xCal format""" with self.app.test_request_context(): test_event = EventFactoryBasic() save_to_db(test_event) xcal = XCalExporter() xcal_string = xcal.export(test_event.id) xcal_original = fromstring(xcal_string) assert fromstring(tostring(xcal_original))[0][3].text == "example" assert fromstring(tostring(xcal_original))[0][2].text == \ "Schedule for sessions at example"
def test_get_or_create(self): with app.test_request_context(): event = EventFactoryBasic() save_to_db(event) obj, is_created = get_or_create(Event, name=event.name) self.assertEqual(event.id, obj.id) self.assertFalse(is_created) obj, is_created = get_or_create(Event, name="new event", starts_at=event.starts_at, ends_at=event.ends_at) self.assertNotEqual(event.id, obj.id) self.assertTrue(is_created)
def test_export(self): """Test to check event contents in pentabarfxml format""" with self.app.test_request_context(): test_event = EventFactoryBasic() save_to_db(test_event) pentabarf_export = PentabarfExporter() pentabarf_string = pentabarf_export.export(test_event.id) pentabarf_original = fromstring(pentabarf_string) self.assertEqual(pentabarf_original.find('conference/title').text, "example") self.assertEqual( pentabarf_original.find('conference/start').text, "2099-12-13" )
def resize_speaker_images_task(self, speaker_id, photo_url): speaker = safe_query(db, Speaker, 'id', speaker_id, 'speaker_id') try: logging.info('Speaker image resizing tasks started for speaker with id {}'.format(speaker_id)) uploaded_images = create_save_image_sizes(photo_url, 'speaker-image', speaker_id) speaker.small_image_url = uploaded_images['small_image_url'] speaker.thumbnail_image_url = uploaded_images['thumbnail_image_url'] speaker.icon_image_url = uploaded_images['icon_image_url'] save_to_db(speaker) logging.info('Resized images saved successfully for speaker with id: {}'.format(speaker_id)) except (urllib.error.HTTPError, urllib.error.URLError): logging.exception('Error encountered while generating resized images for event with id: {}'.format(speaker_id))
def resize_event_images_task(self, event_id, original_image_url): event = safe_query(db, Event, 'id', event_id, 'event_id') try: logging.info('Event image resizing tasks started {}'.format(original_image_url)) uploaded_images = create_save_image_sizes(original_image_url, 'event-image', event.id) event.large_image_url = uploaded_images['large_image_url'] event.thumbnail_image_url = uploaded_images['thumbnail_image_url'] event.icon_image_url = uploaded_images['icon_image_url'] save_to_db(event) logging.info('Resized images saved successfully for event with id: {}'.format(event_id)) except (urllib.error.HTTPError, urllib.error.URLError): logging.exception('Error encountered while generating resized images for event with id: {}'.format(event_id))
def get_ticket_purchased_notification_actions(order_id, order_url): """ Get the actions associated with a notification of tickets purchased. :param order_id: order id :param order_url: order invoice url. :return: """ view_order_invoice_action = NotificationAction( subject='order', link=order_url, subject_id=order_id, action_type='view' ) save_to_db(view_order_invoice_action) return [view_order_invoice_action]
def get_event_exported_actions(download_url): """ Get the actions associated with a notification about an event being successfully exported. :param download_url: download url of the event. :return: actions. """ download_action = NotificationAction( subject='event-export', link=download_url, action_type='download' ) save_to_db(download_action) return [download_action]
def get_ticket_purchased_attendee_notification_actions(pdf_url): """ Get the actions associated with a notification of tickets purchased for an attendee that is not the buyer. :param pdf_url: :return: actions """ view_ticket_action = NotificationAction( subject='tickets-pdf', link=pdf_url, action_type='view' ) save_to_db(view_ticket_action) return [view_ticket_action]
def create_onsite_attendees_for_order(data): """ Creates on site ticket holders for an order and adds it into the request data. :param data: data initially passed in the POST request for order. :return: """ on_site_tickets = data.get('on_site_tickets') if not on_site_tickets: raise UnprocessableEntity({'pointer': 'data/attributes/on_site_tickets'}, 'on_site_tickets info missing') data['ticket_holders'] = [] for on_site_ticket in on_site_tickets: ticket_id = on_site_ticket['id'] quantity = int(on_site_ticket['quantity']) ticket = safe_query_without_soft_deleted_entries(db, Ticket, 'id', ticket_id, 'ticket_id') ticket_sold_count = get_count(db.session.query(TicketHolder.id). filter_by(ticket_id=int(ticket.id), deleted_at=None)) # Check if the ticket is already sold out or not. if ticket_sold_count + quantity > ticket.quantity: # delete the already created attendees. for holder in data['ticket_holders']: ticket_holder = db.session.query(TicketHolder).filter(id == int(holder)).one() db.session.delete(ticket_holder) try: db.session.commit() except Exception as e: logging.error('DB Exception! %s' % e) db.session.rollback() raise ConflictException( {'pointer': '/data/attributes/on_site_tickets'}, "Ticket with id: {} already sold out. You can buy at most {} tickets".format(ticket_id, ticket.quantity - ticket_sold_count) ) for _ in range(1, quantity): ticket_holder = TicketHolder(firstname='onsite', lastname='attendee', email='*****@*****.**', ticket_id=ticket.id, event_id=data.get('event')) save_to_db(ticket_holder) data['ticket_holders'].append(ticket_holder.id) # delete from the data. del data['on_site_tickets']
def get_ticket_purchased_organizer_notification_actions(order_id, order_url): """ Get the actions associated with a notification of tickets purchased for the event organizer. :param order_id: order id :param order_url: order url :return: actions """ view_ticket_action = NotificationAction( subject='order', subject_id=order_id, link=order_url, action_type='view' ) save_to_db(view_ticket_action) return [view_ticket_action]
def get_event_imported_actions(event_id, event_url): """ Get the actions associated with a notification about an event being successfully imported. :param event_id: id of the event. :param event_url: url of the event. :return: actions """ view_event_action = NotificationAction( subject='event', # subject is still 'event' since the action will be to view the imported event. link=event_url, subject_id=event_id, action_type='view' ) save_to_db(view_event_action) return [view_event_action]
def get_session_accept_reject_notification_actions(session_id, link): """ Get the actions associated with a notification of a session getting accepted/rejected. :param session_id: id of the session. :param link: link to view the session. :return: actions """ view_session_action = NotificationAction( subject='session', link=link, subject_id=session_id, action_type='view' ) save_to_db(view_session_action) return [view_session_action]
def get_next_event_notification_actions(event_id, link): """ Get the actions associated with a notification of next event. :param event_id: id of the event. :param link: link to view the event. :return: actions """ view_event_action = NotificationAction( subject='event', link=link, subject_id=event_id, action_type='view' ) save_to_db(view_event_action) return [view_event_action]
def get_event_published_notification_actions(event_id, event_link): """ Get the actions associated with a notification of an event getting published. :param event_id: event id :param event_link: event url :return: actions """ view_event_action = NotificationAction( subject='event', subject_id=event_id, link=event_link, action_type='view' ) save_to_db(view_event_action) return [view_event_action]
def set_expiry_for_order(order, override=False): """ Expire the order after the time slot(10 minutes) if the order is pending. Also expires the order if we want to expire an order regardless of the state and time. :param order: Order to be expired. :param override: flag to force expiry. :return: """ if order and not order.paid_via and (override or (order.status == 'pending' and ( order.created_at + timedelta(minutes=order.event.order_expiry_time)) < datetime.now(timezone.utc))): order.status = 'expired' delete_related_attendees_for_order(order) save_to_db(order) return order
def get_monthly_payment_follow_up_notification_actions(event_id, payment_url): """ Get the actions associated with a follow up notification of monthly payments. :param event_id: id of the event. :param payment_url: url to view invoice. :return: actions """ view_invoice_action = NotificationAction( subject='invoice', link=payment_url, subject_id=event_id, action_type='view' ) save_to_db(view_invoice_action) return [view_invoice_action]
def get_event_role_notification_actions(event_id, invitation_link): """ Get the actions associated with a notification of an event role. :param event_id: ID of the event. :param invitation_link: link for invitation. :return: actions """ accept_event_role_action = NotificationAction( subject='event-role', subject_id=event_id, link=invitation_link, action_type='view' ) save_to_db(accept_event_role_action) return [accept_event_role_action]
def after_create_object(self, event, data, view_kwargs): """ after create method to save roles for users :param event: :param data: :param view_kwargs: :return: """ role = Role.query.filter_by(name=ORGANIZER).first() user = User.query.filter_by(id=view_kwargs['user_id']).first() uer = UsersEventsRoles(user, event, role) save_to_db(uer, 'Event Saved') if data.get('original_image_url'): uploaded_images = create_save_image_sizes(data['original_image_url'], 'event', event.id) self.session.query(Event).filter_by(id=event.id).update(uploaded_images) self.session.commit()
def get_checkout_url(order, currency=None, credentials=None): if not credentials: credentials = PayPalPaymentsManager.get_credentials(order.event) if not credentials: raise Exception('PayPal credentials have not be set correctly') if current_app.config['TESTING']: return credentials['CHECKOUT_URL'] currency = order.event.payment_currency if not currency and order.event.payment_currency != "" else "USD" data = { 'USER': credentials['USER'], 'PWD': credentials['PWD'], 'SIGNATURE': credentials['SIGNATURE'], 'SUBJECT': credentials['EMAIL'], 'METHOD': 'SetExpressCheckout', 'VERSION': PayPalPaymentsManager.api_version, 'PAYMENTREQUEST_0_PAYMENTACTION': 'SALE', 'PAYMENTREQUEST_0_AMT': order.amount, 'PAYMENTREQUEST_0_CURRENCYCODE': currency, 'RETURNURL': make_frontend_url(path='/orders/{identifier}/payment/success'. format(identifier=order.identifier)), 'CANCELURL': make_frontend_url(path='/orders/{identifier}/payment/cancelled'. format(identifier=order.identifier)) } count = 1 if type(order) is Order: for ticket_order in order.order_tickets: data['L_PAYMENTREQUEST_' + str(count) + '_NAMEm'] = ticket_order.ticket.name data['L_PAYMENTREQUEST_' + str(count) + '_QTYm'] = ticket_order.quantity data['L_PAYMENTREQUEST_' + str(count) + '_AMTm'] = ticket_order.ticket.price count += 1 response = requests.post(credentials['SERVER'], data=data) if 'TOKEN' not in dict(urlparse.parse_qsl(response.text)): raise Exception('PayPal Token could not be retrieved') token = dict(urlparse.parse_qsl(response.text))['TOKEN'] order.paypal_token = token save_to_db(order) return credentials['CHECKOUT_URL'] + "?" + urlencode({ 'cmd': '_express-checkout', 'token': token })
def create_export_job(task_id, event_id): """ Create export job for an export that is going to start """ export_job = ExportJob.query.filter_by(event_id=event_id).first() task_url = url_for('tasks.celery_task', task_id=task_id) if export_job: export_job.task = task_url export_job.user_email = current_identity.email export_job.event = Event.query.get(event_id) export_job.starts_at = datetime.now(pytz.utc) else: export_job = ExportJob( task=task_url, user_email=current_identity.email, event=Event.query.get(event_id) ) save_to_db(export_job, 'ExportJob saved')