open event server

Read more about the article Implement Order Confirmation Feature in Eventyay

Implement Order Confirmation Feature in Eventyay

This post elaborates on the details of an endpoint which can be used to explicatively used to resend order confirmations. In the current implementation of the open event project, if the order has been confirmed, the ticket holders and buyers get an email each regarding their order confirmation. But in case that email has been accidentally deleted by any of the attendees, the event organizer / owner should have the power to resend the confirmations. The first step to the implementation was to create the appropriate endpoint for the server to be pinged. I utilized the existing blueprint being used for serving tickets on eventyay frontend project and created a new endpoint on the route : orders/resend-email [POST] # app/api/auth.py@ticket_blueprint.route('/orders/resend-email', methods=['POST'])@limiter.limit(   '5/minute', key_func=lambda: request.json['data']['user'], error_message='Limit for this action exceeded')@limiter.limit(   '60/minute', key_func=get_remote_address, error_message='Limit for this action exceeded')def resend_emails():   """   Sends confirmation email for pending and completed orders on organizer request   :param order_identifier:   :return: JSON response if the email was succesfully sent   """   order_identifier = request.json['data']['order']   order = safe_query(db, Order, 'identifier', order_identifier, 'identifier')   if (has_access('is_coorganizer', event_id=order.event_id)):       if order.status == 'completed' or order.status == 'placed':           # fetch tickets attachment           order_identifier = order.identifier           key = UPLOAD_PATHS['pdf']['tickets_all'].format(identifier=order_identifier)           ticket_path = 'generated/tickets/{}/{}/'.format(key, generate_hash(key)) + order_identifier + '.pdf'           key = UPLOAD_PATHS['pdf']['order'].format(identifier=order_identifier)           invoice_path = 'generated/invoices/{}/{}/'.format(key, generate_hash(key)) + order_identifier + '.pdf'           # send email.           send_email_to_attendees(order=order, purchaser_id=current_user.id, attachments=[ticket_path, invoice_path])           return jsonify(status=True, message="Verification emails for order : {} has been sent succesfully".                          format(order_identifier))       else:           return UnprocessableEntityError({'source': 'data/order'},                                           "Only placed and completed orders have confirmation").respond()   else:       return ForbiddenError({'source': ''}, "Co-Organizer Access Required").respond() I utilized exiting send_email_to_attendees for the email purpose but for security reasons, the endpoint was limited to make sure that an organizer can request only 5 order confrimations to be resent each minute (implemented using flask limiter). This was all for server implementation, to implement this on the front end, I just created a new action named as resendConfirmation implemented as given. // app/controllers/events/view/tickets/orders/list.jsasync resendConfirmation(order) {     let payload = {};     try {       payload = {         'data': {           'order' : order.identifier,           'user'  : this.authManager.currentUser.email         }       };       await this.loader.post('orders/resend-email', payload);       this.notify.success(this.l10n.t('Email confirmation has been sent to attendees successfully'));     } catch (error) {       if (error.status === 429) {        …

Continue ReadingImplement Order Confirmation Feature in Eventyay
Read more about the article Onsite Attendee in Open Event Server

Onsite Attendee in Open Event Server

The Open Event Server enables organizers to manage events from concerts to conferences and meetups. It offers features for events with several tracks and venues. The Event organizers may add orders on behalf of others and accept payments onsite. This blog post goes over the implementation of the onsite attendee feature in the Open Event Server. Route Normally we expect the payload for a POST request of order to contain already created attendees also. In this case we want to create the attendees internally inside the server. Hence we need some way to differentiate between the two types of orders. The most basic and easy to implement option is to use a query parameter to specify if the attendees are onsite or not. We use ?onsite=true in order to specify that the attendees are onsite and hence should be created internally. In the POST request, we check if the query parameters contains the onsite param as true or not. If it is true then we create the attendees using a helper function. The helper function will be discussed in detail later in the article. # Create on site attendees. if request.args.get('onsite', False): create_onsite_attendees_for_order(data) elif data.get('on_site_tickets'): del data['on_site_tickets'] require_relationship(['ticket_holders'], data)   OnsiteTicketSchema In order to create attendees on the server, we need the information about each ticket bought and it’s quantity. This data is expected in the format declared in the OnsiteTicketSchema. class OnSiteTicketSchema(SoftDeletionSchema): class Meta: type_ = 'on-site-ticket' inflect = dasherize id = fields.Str(load_only=True, required=True) quantity = fields.Str(load_only=True, required=True) Creating onsite Attendees Following are the few points which we need to focus on when creating onsite attendees: Validate if the ticket's data is provided or not. We raise an error if the ticket data is not provided. Verify if the ticket is sold out or not. We raise an error if the ticket is sold out. In case an error is raised in any step then we delete the already created attendees. This is a very important point to keep in mind. if not on_site_tickets: raise UnprocessableEntity({'pointer': 'data/attributes/on_site_tickets'}, 'on_site_tickets info missing') 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) ) The complete method can be checked here. References Query parameters in Flask: https://scotch.io/bar-talk/processing-incoming-request-data-in-flask#toc-query-arguments Optional attributes in Flask-rest-json-api: https://flask-rest-jsonapi.readthedocs.io/en/latest/resource_manager.html#optional-attributes Errors in Flask-rest-json-api: https://flask-rest-jsonapi.readthedocs.io/en/latest/errors.html    

Continue ReadingOnsite Attendee in Open Event Server
Read more about the article Modifying Tickets API in Open Event Server to Return Hidden Tickets Only for Organizers and Admins

Modifying Tickets API in Open Event Server to Return Hidden Tickets Only for Organizers and Admins

This blog article will illustrate how we can modify the permissions settings for an API to enable different kind of responses to users with different level of permissions. In this article we will discuss these changes with respect to Tickets API. Initially we had a query where we were returning only those tickets who were set to be visible by the admin. Query for this was: class TicketList(ResourceList): """ List Tickets based on different params """ def before_get(self, args, view_kwargs): """ before get method to get the resource id for assigning schema :param args: :param view_kwargs: :return: """ if view_kwargs.get('ticket_tag_id') or view_kwargs.get('access_code_id') or view_kwargs.get('order_identifier'): self.schema = TicketSchemaPublic def query(self, view_kwargs): """ query method for resource list :param view_kwargs: :return: """ query_ = self.session.query(Ticket).filter_by(is_hidden=False)   Problem with this query was that this returned same response irrespective of who is logged in. Hence even the organizers were not able to modify hidden tickets because they were not returned by server. Solution to this problem was to provide hidden tickets only to those who are organizer or are admin/super admins. For this we used the JWT token that was being sent from frontend in request headers for each authenticated request that was being made from frontend. We modified the code to something like this: class TicketList(ResourceList): """ List Tickets based on different params """ def before_get(self, args, view_kwargs): """ before get method to get the resource id for assigning schema :param args: :param view_kwargs: :return: """ if view_kwargs.get('ticket_tag_id') or view_kwargs.get('access_code_id') or view_kwargs.get('order_identifier'): self.schema = TicketSchemaPublic def query(self, view_kwargs): """ query method for resource list :param view_kwargs: :return: """ if 'Authorization' in request.headers: _jwt_required(current_app.config['JWT_DEFAULT_REALM']) if current_user.is_super_admin or current_user.is_admin: query_ = self.session.query(Ticket) elif view_kwargs.get('event_id') and has_access('is_organizer', event_id=view_kwargs['event_id']): query_ = self.session.query(Ticket) else: query_ = self.session.query(Ticket).filter_by(is_hidden=False) else: query_ = self.session.query(Ticket).filter_by(is_hidden=False)   Here we added some conditions which were used to check permission level of logged in user. After picking JWT token from request headers we check if the user was admin or super_admin, then we return all the tickets without any condition. Then we also check if the logged in user was organizer of event then also we send all the tickets without any conditions. However if request comes from unauthenticated users (without valid token) or users with normal privileges, then we returned tickets whose isHidden property was set to False. The functions such as is_organizer and is_super_admin acted as helpers as they were imported from other helper files where they were defined. Resources Open Event Server: Link to PR Open Event API Docs Open Event server ticketsAPI

Continue ReadingModifying Tickets API in Open Event Server to Return Hidden Tickets Only for Organizers and Admins
Read more about the article Open Event Server – Export Speakers as PDF File

Open Event Server – Export Speakers as PDF File

FOSSASIA‘s Open Event Server is the REST API backend for the event management platform, Open Event. Here, the event organizers can create their events, add tickets for it and manage all aspects from the schedule to the speakers. Also, once he/she makes his event public, others can view it and buy tickets if interested. The organizer can see all the speakers in a very detailed view in the event management dashboard. He can see the statuses of all the speakers. The possible statuses are pending, accepted, and rejected. He/she can take actions such as editing the speakers. If the organizer wants to download the list of all the speakers as a PDF file, he or she can do it very easily by simply clicking on the Export As PDF button in the top right-hand corner. Let us see how this is done on the server. Server side - generating the Speakers PDF file Here we will be using the pisa package which is used to convert from HTML to PDF. It is a html2pdf converter which uses ReportLab Toolkit, the HTML5lib and pyPdf. It supports HTML5 and CSS 2.1 (and some of CSS 3). It is completely written in pure Python so it is platform independent. from xhtml2pdf import pisa< We have a utility method create_save_pdf which creates and saves PDFs from HTML. It takes the following arguments: pdf_data - This contains the HTML template which has to be converted to PDF. key - This contains the file name dir_path - This contains the directory It returns the newly formed PDF file. The code is as follows: def create_save_pdf(pdf_data, key, dir_path='/static/uploads/pdf/temp/'):   filedir = current_app.config.get('BASE_DIR') + dir_path   if not os.path.isdir(filedir):       os.makedirs(filedir)   filename = get_file_name() + '.pdf'   dest = filedir + filename   file = open(dest, "wb")   pisa.CreatePDF(io.BytesIO(pdf_data.encode('utf-8')), file)   file.close()   uploaded_file = UploadedFile(dest, filename)   upload_path = key.format(identifier=get_file_name())   new_file = upload(uploaded_file, upload_path)   # Removing old file created   os.remove(dest)   return new_file The HTML file is formed using the render_template method of flask. This method takes the HTML template and its required variables as the arguments. In our case, we pass in 'pdf/speakers_pdf.html'(template) and speakers. Here, speakers is the list of speakers to be included in the PDF file. In the template, we loop through each item of speakers. We print his name, email, list of its sessions, mobile, a short biography, organization, and position. All these fields form a row in the table. Hence, each speaker is a row in our PDF file. The various columns are as follows: <thead> <tr>   <th>       {{ ("Name") }}   </th>   <th>       {{ ("Email") }}   </th>   <th>       {{ ("Sessions") }}   </th>   <th>       {{ ("Mobile") }}   </th>   <th>       {{ ("Short Biography") }}   </th>   <th>       {{ ("Organisation") }}   </th>   <th>       {{ ("Position") }}   </th> </tr> </thead> A snippet of the code which handles iterating over the speakers' list and forming a row is as follows: {% for speaker in speakers %}   <tr class="padded" style="text-align:center; margin-top: 5px">       <td>           {% if speaker.name %}               {{ speaker.name }}           {% else %}               {{ "-" }}           {% endif %}…

Continue ReadingOpen Event Server – Export Speakers as PDF File
Read more about the article Open Event Server – Export Sessions as PDF File

Open Event Server – Export Sessions as PDF File

FOSSASIA‘s Open Event Server is the REST API backend for the event management platform, Open Event. Here, the event organizers can create their events, add tickets for it and manage all aspects from the schedule to the speakers. Also, once he/she makes his event public, others can view it and buy tickets if interested. The organizer can see all the sessions in a very detailed view in the event management dashboard. He can see the statuses of all the sessions. The possible statuses are pending, accepted, confirmed and rejected. He/she can take actions such as accepting/rejecting the sessions. If the organizer wants to download the list of all the sessions as a PDF file, he or she can do it very easily by simply clicking on the Export As PDF button in the top right-hand corner. Let us see how this is done on the server. Server side - generating the Sessions PDF file Here we will be using the pisa package which is used to convert from HTML to PDF. It is a html2pdf converter which uses ReportLab Toolkit, the HTML5lib and pyPdf. It supports HTML5 and CSS 2.1 (and some of CSS 3). It is completely written in pure Python so it is platform independent. from xhtml2pdf import pisa We have a utility method create_save_pdf which creates and saves PDFs from HTML. It takes the following arguments: pdf_data - This contains the HTML template which has to be converted to PDF. key - This contains the file name dir_path - This contains the directory It returns the newly formed PDF file. The code is as follows: def create_save_pdf(pdf_data, key, dir_path='/static/uploads/pdf/temp/'):   filedir = current_app.config.get('BASE_DIR') + dir_path   if not os.path.isdir(filedir):       os.makedirs(filedir)   filename = get_file_name() + '.pdf'   dest = filedir + filename   file = open(dest, "wb")   pisa.CreatePDF(io.BytesIO(pdf_data.encode('utf-8')), file)   file.close()   uploaded_file = UploadedFile(dest, filename)   upload_path = key.format(identifier=get_file_name())   new_file = upload(uploaded_file, upload_path)   # Removing old file created   os.remove(dest)   return new_file The HTML file is formed using the render_template method of flask. This method takes the HTML template and its required variables as the arguments. In our case, we pass in 'pdf/sessions_pdf.html'(template) and sessions. Here, sessions is the list of sessions to be included in the PDF file. In the template, we loop through each item of sessions and check if it is deleted or not. If it not deleted then we print its title, state, list of its speakers, track, created at and has an email been sent or not. All these fields form a row in the table. Hence, each session is a row in our PDF file. The various columns are as follows: <thead> <tr>   <th>       {{ ("Title") }}   </th>   <th>       {{ ("State") }}   </th>   <th>       {{ ("Speakers") }}   </th>   <th>       {{ ("Track") }}   </th>   <th>       {{ ("Created At") }}   </th>   <th>       {{ ("Email Sent") }}   </th> </tr> </thead> A snippet of the code which handles iterating over the sessions list and forming a row is as follows: {% for session in sessions %}   {% if not session.deleted_at %}       <tr class="padded"…

Continue ReadingOpen Event Server – Export Sessions as PDF File
Read more about the article Updating User information in Open Event Android

Updating User information in Open Event Android

A user can update its information such as first name, last name from the Edit Profile Fragment in Open Event Android. Edit Profile Fragment can be accessed from the menu inside the Profile page. On opening Edit Profile Fragment user can interact with the simple UI to update his/her information. This blog post will guide you on how its implemented in Open Event Android. To update a User we send a patch request to Open Event Server. The patch request contains the Updated User as body and auth token as header and it returns the updated user in response. Following it what the interface method looks like @PATCH("users/{id}") fun updateUser(@Body user: User, @Path("id") id: Long): Single<User> This method is exposed to the View Model using a service layer function which calls the above function and also inserts the returned user in the database. fun updateUser(user: User, id: Long): Single<User> {        return authApi.updateUser(user, id).map {            userDao.insertUser(it)            it        }    } On using map on Single<User> returned by updateUser we can access the user inside the scope which is then inserted into the database using the DAO method insert user and the same user object is returned by the function. This service layer method is then used in updateUser method of EditProfileViewModel class which specifies how it is subscribed and on which thread observer should be set etc. The Edit Profile Fragment fragment calls this method whenever the user clicks on the Update button. fun updateUser(firstName: String, lastName: String) {        val id = authHolder.getId()        if (firstName.isEmpty() || lastName.isEmpty()) {            message.value = "Please provide first name and last name!"            return        }        compositeDisposable.add(authService.updateUser(User(id = id,          firstName = firstName, lastName = lastName), id)                .subscribeOn(Schedulers.io())                .observeOn(AndroidSchedulers.mainThread())                .doOnSubscribe {                    progress.value = true                }                .doFinally {                    progress.value = false                }                .subscribe({                    message.value = "User updated successfully!"                    Timber.d("User updated")                }) {                    message.value = "Error updating user!"                    Timber.e(it, "Error updating user!")                })    } UpdateUser takes two parameters first name and last name if any of these parameters is empty the function returns with an error message which is displayed on the UI else service layer update user function is called with argument a User object with first name and last name as provided to view model function and an id which is accessed using authHolder’s getId method. Whenever this is subscribed we set progress.value true which displays spinner on the UI this is set false after the operation is complete. If the patch request results in success then toast message is shown on screen and a success message is logged similar to this in case of error, an error toast is displayed and an error is logged. This goes for the logic to update user we also need UI and menu item which launches this fragment. Inside Menu.xml add the following snippet of code <item   android:id="@+id/edit_profile"   android:title="@string/edit_profile" /> This will create a menu item inside the ProfileFragment. The next step is to wire this logic which tells what happens when the user selects this menu item. The following code wires it…

Continue ReadingUpdating User information in Open Event Android
Read more about the article Open Event Server – Export Speakers as CSV File

Open Event Server – Export Speakers as CSV File

FOSSASIA‘s Open Event Server is the REST API backend for the event management platform, Open Event. Here, the event organizers can create their events, add tickets for it and manage all aspects from the schedule to the speakers. Also, once he/she makes his event public, others can view it and buy tickets if interested. The organizer can see all the speakers in a very detailed view in the event management dashboard. He can see the statuses of all the speakers. The possible statuses are pending, accepted and rejected. He/she can take actions such as editing/viewing speakers. If the organizer wants to download the list of all the speakers as a CSV file, he or she can do it very easily by simply clicking on the Export As CSV button in the top right-hand corner. Let us see how this is done on the server. Server side - generating the Speakers CSV file Here we will be using the csv package provided by python for writing the csv file. import csv We define a method export_speakers_csv which takes the speakers to be exported as a CSV file as the argument. Next, we define the headers of the CSV file. It is the first row of the CSV file. def export_speakers_csv(speakers):   headers = ['Speaker Name', 'Speaker Email', 'Speaker Session(s)',              'Speaker Mobile', 'Speaker Bio', 'Speaker Organisation', 'Speaker Position'] A list is defined called rows. This contains the rows of the CSV file. As mentioned earlier, headers is the first row. rows = [headers] We iterate over each speaker in speakers and form a row for that speaker by separating the values of each of the columns by a comma. Here, every row is one speaker. As a speaker can contain multiple sessions we iterate over each session for that particular speaker and append each session to a string. ‘;’ is used as a delimiter. This string is then added to the row. We also include the state of the session - accepted, rejected, confirmed. The newly formed row is added to the rows list. for speaker in speakers:   column = [speaker.name if speaker.name else '', speaker.email if speaker.email else '']   if speaker.sessions:       session_details = ''       for session in speaker.sessions:           if not session.deleted_at:               session_details += session.title + ' (' + session.state + '); '       column.append(session_details[:-2])   else:       column.append('')   column.append(speaker.mobile if speaker.mobile else '')   column.append(speaker.short_biography if speaker.short_biography else '')   column.append(speaker.organisation if speaker.organisation else '')   column.append(speaker.position if speaker.position else '')   rows.append(column) rows contains the contents of the CSV file and hence it is returned. return rows We iterate over each item of rows and write it to the CSV file using the methods provided by the csv package. with open(file_path, "w") as temp_file:   writer = csv.writer(temp_file)   from app.api.helpers.csv_jobs_util import export_speakers_csv   content = export_speakers_csv(speakers)   for row in content:       writer.writerow(row) Obtaining the Speakers CSV file: Firstly, we have an API endpoint which starts the task on the server. GET - /v1/events/{event_identifier}/export/speakers/csv Here, event_identifier is the unique ID of the event. This endpoint starts a celery task on the server…

Continue ReadingOpen Event Server – Export Speakers as CSV File
Read more about the article Open Event Server – Export Sessions as CSV File

Open Event Server – Export Sessions as CSV File

FOSSASIA‘s Open Event Server is the REST API backend for the event management platform, Open Event. Here, the event organizers can create their events, add tickets for it and manage all aspects from the schedule to the speakers. Also, once he/she makes his event public, others can view it and buy tickets if interested. The organizer can see all the sessions in a very detailed view in the event management dashboard. He can see the statuses of all the sessions. The possible statuses are pending, accepted, confirmed and rejected. He/she can take actions such as accepting/rejecting the sessions. If the organizer wants to download the list of all the sessions as a CSV file, he or she can do it very easily by simply clicking on the Export As CSV button in the top right-hand corner. Let us see how this is done on the server. Server side - generating the Sessions CSV file Here we will be using the csv package provided by python for writing the csv file. import csv We define a method export_sessions_csv which takes the sessions to be exported as a CSV file as the argument. Next, we define the headers of the CSV file. It is the first row of the CSV file. def export_sessions_csv(sessions):   headers = ['Session Title', 'Session Speakers',              'Session Track', 'Session Abstract', 'Created At', 'Email Sent'] A list is defined called rows. This contains the rows of the CSV file. As mentioned earlier, headers is the first row. rows = [headers] We iterate over each session in sessions and form a row for that session by separating the values of each of the columns by a comma. Here, every row is one session. As a session can contain multiple speakers we iterate over each speaker for that particular session and append each speaker to a string. ‘;’ is used as a delimiter. This string is then added to the row. The newly formed row is added to the rows list. for session in sessions:   if not session.deleted_at:       column = [session.title + ' (' + session.state + ')' if session.title else '']       if session.speakers:           in_session = ''           for speaker in session.speakers:               if speaker.name:                   in_session += (speaker.name + '; ')           column.append(in_session[:-2])       else:           column.append('')       column.append(session.track.name if session.track and session.track.name else '')       column.append(strip_tags(session.short_abstract) if session.short_abstract else '')       column.append(session.created_at if session.created_at else '')       column.append('Yes' if session.is_mail_sent else 'No')       rows.append(column) rows contains the contents of the CSV file and hence it is returned. return rows We iterate over each item of rows and write it to the CSV file using the methods provided by the csv package. writer = csv.writer(temp_file) from app.api.helpers.csv_jobs_util import export_sessions_csv content = export_sessions_csv(sessions) for row in content:   writer.writerow(row) Obtaining the Sessions CSV file: Firstly, we have an API endpoint which starts the task on the server. GET - /v1/events/{event_identifier}/export/sessions/csv Here, event_identifier is the unique ID of the event. This endpoint starts a celery task on the server to export the sessions of the event as a CSV file. It returns the URL of…

Continue ReadingOpen Event Server – Export Sessions as CSV File
Read more about the article Paypal Integration in Open Event Server

Paypal Integration in Open Event Server

The Open Event Server enables organizers to manage events from concerts to conferences and meetups. It offers features for events with several tracks and venues. This blog post explains how Paypal has been integrated in the Open Event Server in order to accept payments for tickets. The integration of Paypal in the server involved the following steps: An endpoint to accept the Paypal token from the client applications. Using the token to get the approved payment details. Capturing the payment using the fetched payment details. Endpoint for Paypal token The server exposes an endpoint to get the Paypal token in order to accept payments. api.route(ChargeList, 'charge_list', '/orders/<identifier>/charge', '/orders/<order_identifier>/charge') The above endpoint accepts the Paypal token and uses that to get the payment details from Paypal and then capture the payments. Getting Approved Payment Details We use the Paypal Name-Value pair API in the project. First we get the credentials of the event organizer who will be accepting the payments using a call to the get_credentials helper method. It returns the data as the following dictionary: credentials = { 'USER': settings['paypal_live_username'], 'PWD': settings['paypal_live_password'], 'SIGNATURE': settings['paypal_live_signature'], 'SERVER': 'https://api-3t.paypal.com/nvp', 'CHECKOUT_URL': 'https://www.paypal.com/cgi-bin/webscr', 'EMAIL': '' if not event or not event.paypal_email or event.paypal_email == "" else event.paypal_email } Next, we use the credentials to get the approved payment details from paypal using the following code snippet. @staticmethod def get_approved_payment_details(order, credentials=None): if not credentials: credentials = PayPalPaymentsManager.get_credentials(order.event) if not credentials: raise Exception('PayPal credentials have not been set correctly') data = { 'USER': credentials['USER'], 'PWD': credentials['PWD'], 'SIGNATURE': credentials['SIGNATURE'], 'SUBJECT': credentials['EMAIL'], 'METHOD': 'GetExpressCheckoutDetails', 'VERSION': PayPalPaymentsManager.api_version, 'TOKEN': order.paypal_token } if current_app.config['TESTING']: return data response = requests.post(credentials['SERVER'], data=data) return json.loads(response.text) Capturing the payments After successfully fetching the payment details, the final step is to capture the payment. We set the amount to be charged to the amount of the order and the payer_id to be the payer id received from step 2. Then we simply make a POST request to the Paypal nvp server and capture the payments. The below method is responsible for executing this task: @staticmethod def capture_payment(order, payer_id, 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 not currency: currency = order.event.payment_currency if not currency or currency == "": currency = "USD" data = { 'USER': credentials['USER'], 'PWD': credentials['PWD'], 'SIGNATURE': credentials['SIGNATURE'], 'SUBJECT': credentials['EMAIL'], 'METHOD': 'DoExpressCheckoutPayment', 'VERSION': PayPalPaymentsManager.api_version, 'TOKEN': order.paypal_token, 'PAYERID': payer_id, 'PAYMENTREQUEST_0_PAYMENTACTION': 'SALE', 'PAYMENTREQUEST_0_AMT': order.amount, 'PAYMENTREQUEST_0_CURRENCYCODE': currency, } response = requests.post(credentials['SERVER'], data=data) return json.loads(response.text) References Paypal NVP : https://developer.paypal.com/docs/classic/api/NVPAPIOverview/ Paypal Python SDK: https://github.com/paypal/PayPal-Python-SDK Flask REST JSON API: flask-rest-jsonapi

Continue ReadingPaypal Integration in Open Event Server
Read more about the article Charges Layer in Open Event Server

Charges Layer in Open Event Server

The Open Event Server enables organizers to manage events from concerts to conferences and meetups. It offers features for events with several tracks and venues. This blog post explains how the charge layer has been implemented in the Open Event Server in order to charge the user for tickets of an event. Schema We currently support payments via Stripe and Paypal. As a result the schema for Charges layer consists of fields for providing the token for stripe or paypal. It also contains a read only id field. class ChargeSchema(Schema): """ ChargeSchema """ class Meta: """ Meta class for ChargeSchema """ type_ = 'charge' inflect = dasherize self_view = 'v1.charge_list' self_view_kwargs = {'id': '<id>'} id = fields.Str(dump_only=True) stripe = fields.Str(allow_none=True) paypal = fields.Str(allow_none=True) Resource The ChargeList resource only supports POST requests since there is no need for other type of requests. We simply declare the schema, supported methods and the data layer. We also check for required permissions by declaring the decorators. class ChargeList(ResourceList): """ ChargeList ResourceList for ChargesLayer class """ methods = ['POST', ] schema = ChargeSchema data_layer = { 'class': ChargesLayer, 'session': db.session } decorators = (jwt_required,) Layer The data layer contains a single method create_object which does all the heavy lifting of charging the user according to the payment medium and the related order. It first loads the related order from the database using the identifier. We first check if the order contains one or more paid tickets or not. If not, then ConflictException is raised since it doesn’t make sense to charge a user without any paid ticket in the order. Next, it checks the payment mode of the order. If the payment mode is Stripe then it checks if the stripe_token is provided with the request or not. If not, an UnprocessableEntity exception is raised otherwise relevant methods are called in order to charge the user accordingly. A similar procedure is followed for payments via Paypal. Below is the full code for reference. class ChargesLayer(BaseDataLayer): def create_object(self, data, view_kwargs): """ create_object method for the Charges layer charge the user using paypal or stripe :param data: :param view_kwargs: :return: """ order = Order.query.filter_by(id=view_kwargs['id']).first() if not order: raise ObjectNotFound({'parameter': 'id'}, "Order with id: {} not found".format(view_kwargs['id'])) elif order.status == 'cancelled' or order.status == 'expired': raise ConflictException({'parameter': 'id'}, "You cannot charge payments on a cancelled or expired order") elif (not order.amount) or order.amount == 0: raise ConflictException({'parameter': 'id'}, "You cannot charge payments on a free order") # charge through stripe if order.payment_mode == 'stripe': if not data.get('stripe'): raise UnprocessableEntity({'source': ''}, "stripe token is missing") success, response = TicketingManager.charge_stripe_order_payment(order, data['stripe']) if not success: raise UnprocessableEntity({'source': 'stripe_token_id'}, response) # charge through paypal elif order.payment_mode == 'paypal': if not data.get('paypal'): raise UnprocessableEntity({'source': ''}, "paypal token is missing") success, response = TicketingManager.charge_paypal_order_payment(order, data['paypal']) if not success: raise UnprocessableEntity({'source': 'paypal'}, response) return order The charge_stripe_order_payment and charge_paypal_order_payment are helper methods defined to abstract away the complications of the procedure from the layer. References Flask REST JSON API: flask-rest-jsonapi SQLAlchemy: https://www.sqlalchemy.org/ Stripe connect: https://stripe.com/connect…

Continue ReadingCharges Layer in Open Event Server