Adam McQuistan

Single Page Apps with Vue.js and Flask: JWT Authentication

Chidume Nnamdi

Deploy Node.js Apps on Google App Engine

<h2 id="ajaxintegrationwithrestapi">AJAX Integration with REST API</h2>
Thanks for joining me for the fifth post on using Vue.js and Flask for full-stack web development. This post will be fairly short, but highly valuable as I will be demonstrating how to connect the front-end and back-end applications using Asynchronous JavaScript and XML (aka, AJAX).
The code for this post can be found on my GitHub account under the branch <a rel="nofollow" target="_blank" href="https://github.com/amcquistan/flask-vuejs-survey/tree/FifthPost">FifthPost</a>.
<h2 id="seriescontent">Series Content</h2>
<ol>
<li><a href="/single-page-apps-with-vue-js-and-flask-setting-up-vue-js/">Seup and Getting to Know VueJS</a></li>
<li><a href="/single-page-apps-with-vue-js-and-flask-navigating-vue-router/">Navigating Vue Router</a></li>
<li><a href="/single-page-apps-with-vue-js-and-flask-state-management-with-vuex/">State Management with Vuex</a></li>
<li><a href="/single-page-apps-with-vue-js-and-flask-restful-api-with-flask/">RESTful API with Flask</a></li>
<li>AJAX Integration with REST API (you are here)</li>
<li><a href="/single-page-apps-with-vue-js-and-flask-jwt-authentication/">JWT Authentication</a></li>
<li><a href="/single-page-apps-with-vue-js-and-flask-deployment/">Deployment to a Virtual Private Server</a></li>
</ol>
<h2 id="briefexplanationofajaxandthickclientapps">Brief Explanation of AJAX and Thick Client Apps</h2>
<a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/Ajax_(programming)">AJAX</a> is a powerful technology that has had enormous success in building highly interactive and fast web applications. In fact, I believe AJAX is probably the most impactful technology that has fueled a major paradigm shift from the era of <a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/Thin_client">thin client</a> web apps to the increasingly thick or <a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/Fat_client">fat client</a> web apps we see today. The survey application that I have been demonstrating in this series is considered a distributed client server application implemented as a thick client. This means that the majority of the logic and behavior is implemented on the client via JavaScript (mainly using Vue.js) while the server side is a fairly dumb RESTful API that simply consumes and serves up data.
There are two major technologies that enable this thick client application to juggle the maintenance of state (data), behavior, and data driven presentation.
<ol>
<li>The Vue.js framework with its excellent reactivity system shared along with the Vuex flux-like library</li>
<li>AJAX functionality implemented within a well designed JavaScript library called <a rel="nofollow" target="_blank" href="https://github.com/axios/axios">axios</a></li>
</ol>
You should already be familiar with the awesomeness afforded by Vue.js and Vuex from my prior posts in this series. So I will focus on explaining AJAX in this article. AJAX is a network communication technology that uses HTTP to push and pull data to and from a server in an asynchronous manner within the browser. In this way the browser is able to rapidly update individual components that are dependent on small amounts of data, rather than updating the entire page, which leads to a far more responsive experience.
<h2 id="settingupaxiosandenablingcors">Setting up Axios and Enabling CORS</h2>
To install Axios I will use npm and save it to the <code> package.json</code> file with the following command:
<pre><code class="hljs">$ npm install --save axios
</code></pre>
Now, in order to use Axios to make AJAX requests from the client to the back-end server I will need to make a change to the Flask application to enable <a rel="nofollow" target="_blank" href="https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS">Cross Origin Resource Sharing</a> (CORS). Anytime a client makes a request for a resource that resides on another machine as defined by protocol, IP address / domain name, or port number then additional headers associated with CORS must be added. Luckily, the there is a handy little Flask extension, <a rel="nofollow" target="_blank" href="https://flask-cors.readthedocs.io/en/latest/">Flask-CORS</a>, that makes integration with Flask very easy. As done previously I use pip to install it like so.
<pre><code class="hljs">(venv)$ pip install Flask-CORS
</code></pre>
Next I need to import and instantiate the <code>CORS</code> extension object then register it with the Flask application object within the <code>application.py</code> module of the back-end application.
<pre><code class="hljs">&quot;&quot;&quot;
application.py
- creates a Flask app instance and registers the database object
&quot;&quot;&quot;

from flask import Flask
from flask_cors import CORS

def create_app(app_name=&#x27;SURVEY_API&#x27;):
 app = Flask(app_name)
 app.config.from_object(&#x27;surveyapi.config.BaseConfig&#x27;)

 cors = CORS(app, resources={r&quot;/api/*&quot;: {&quot;origins&quot;: &quot;*&quot;}})

 from surveyapi.api import api
 app.register_blueprint(api, url_prefix=&quot;/api&quot;)

 from surveyapi.models import db
 db.init_app(app)

 return app
</code></pre>
<h2 id="implementingajaxrequestswithaxios">Implementing AJAX Requests with Axios</h2>
Next up I need to replace the mock functions I implemented previously in <code>scr/api/index.js</code> with <code>GET</code>, <code>POST</code>, and <code>PUT</code> requests using the Axios library. If you remember from the <a href="/single-page-apps-with-vue-js-and-flask-restful-api-with-flask/">last article</a> I defined the following RESTful API endpoints in the Flask application which will need to be called from JavaScript within the browser.
<table class="table table-striped">
 <thead>
 <tr>
 <th>Route</th>
 <th>Method</th>
 <th>Functionaility</th>
 </tr>
 </thead>
 <tbody>
 <tr>
 <td><code>/api/surveys/</code></td>
 <td>GET</td>
 <td>Retrieve all surveys</td>
 </tr>
 <tr>
 <td><code>/api/surveys/</code></td>
 <td>POST</td>
 <td>Create a new survey</td>
 </tr>
 <tr>
 <td><code>/api/surveys/id/</code></td>
 <td>GET</td>
 <td>Retrieve a survey by id</td>
 </tr>
 <tr>
 <td><code>/api/surveys/id/</code></td>
 <td>PUT</td>
 <td>Update a survey's choice selections</td>
 </tr>
 </tbody>
</table>
In <code>src/api/index.js</code> I need to import the Axios library and for reusability I also define a variable called <code>API_URL</code> that is equal to the root of the API resource <code>http://127.0.0.1:5000/api</code>. Then I replace the body of the existing functions to use the Axios methods <code>get(...)</code>, <code>put(...)</code>, and <code>post(...)</code> like so:
<pre><code class="hljs">// api/index.js

import axios from &#x27;axios&#x27;

const API_URL = &#x27;http://127.0.0.1:5000/api&#x27;

export function fetchSurveys() {
 return axios.get(`${API_URL}/surveys/`)
}

export function fetchSurvey(surveyId) {
 return axios.get(`${API_URL}/surveys/${surveyId}/`)
}

export function saveSurveyResponse(surveyResponse) {
 return axios.put(`${API_URL}/surveys/${surveyResponse.id}/`, surveyResponse)
}

export function postNewSurvey(survey) {
 return axios.post(`${API_URL}/surveys/`, survey)
}
</code></pre>
Now there are only two small changes to make in <code>src/store/index.js</code> to accommodate the convention used by Axios to return data from get requests. In the <code>loadSurvey(...)</code> and <code>loadSurveys(...)</code> action methods, they are each calling the function that in turn calls the <code>axios.get(...)</code> methods, which return promises. When these promises resolve they will contain the data returned by the AJAX request to the server and that data will be held in a <code>.data</code> member of the resolved promise object. So, the data passed to the mutations will need to be <code>response.data</code> instead of just <code>response</code>.
<pre><code class="hljs">const actions = {
 // asynchronous operations
 loadSurveys(context) {
 return fetchSurveys()
 .then((response) =&gt; {
 // context.commit(&#x27;setSurveys&#x27;, { surveys: response })
 context.commit(&#x27;setSurveys&#x27;, { surveys: response.data })
 })
 },
 loadSurvey(context, { id }) {
 return fetchSurvey(id)
 .then((response) =&gt; {
 // context.commit(&#x27;setSurvey&#x27;, { survey: response })
 context.commit(&#x27;setSurvey&#x27;, { survey: response.data })
 })
 },
</code></pre>
And Voilà! How simple is that?
Since all the heavy lifting was already taken care of building out the front-end and back-end in prior posts the work required to integrate AJAX communication is literally that simple. All there is left to do is just fire up the dev servers and take the survey application for a drive.
<h2 id="conclusion">Conclusion</h2>
In this short article I have demonstrated how to connect the front-end and back-end application via the powerful AJAX communication technology. To accomplish this I utilized the Axios library to handle the client side of things, and on the back-end I utilized the Flask-CORS extension to enable CORS.
Thank you for reading and please join me for the next article where I am going to cover how to implement registering and authenticating users. As always I welcome any comments or criticism below.

Single Page Apps with Vue.js and Flask: AJAX Integration

This article continues with our series on interacting with the file system in Python. The previous articles dealt with <a href="/reading-files-with-python">reading</a> and <a href="/writing-files-using-python">writing</a> files. Interestingly, the file system is much more than a way to store/retrieve data to disk. There are also various other types of entries such as files, directories, sockets (for inter-process communication), named pipes, both soft and hard links, as well as special files (block devices). Reading and writing from and to them is done in a similar way as we saw in the previous articles.
This article focuses on the handling of directories. Other operating systems, like UNIX/Linux, instead use a different terminology, where an &quot;entry&quot; is named a &quot;folder&quot;. Next, we will show you how to identify the current working directory, how to create both a persistent and a temporary, single directory as well as nested directory structures with subfolders, and how to remove a directory if no longer needed. Therefore, the two Python modules <code>os</code> and <code>tempfile</code> come into play.
<h2 id="requiredpythonmodules">Required Python Modules</h2>
Reading and writing files does not require loading an additional module, but accessing the file system functions (like handling directories) requires that we use a separate module. First, the <code>os</code> module has to be loaded. <code>os</code> is a Python module which belongs to the core part of the Python ecosystem. It is done using an import statement as follows:
<pre><code class="hljs">import os
</code></pre>
The <code>os</code> module contains most of the methods we'll need throughout this article. However, as you'll see later on, if you want to something more advanced, like create a temporary file for storing data, then we'll also be needing the <code>tempfile</code> module.
<h2 id="detectingthecurrentworkingdirectory">Detecting the Current Working Directory</h2>
Before we get in to creating/removing directories, let's see how to perform some other basic directory operations, like detecting the <a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/Working_directory">current working directory</a> using the method <code>getcwd()</code>. This method will return a string containing the path of your working directory. Listing 1 shows how to integrate this method in a Python script.
<pre><code class="hljs"># import the os module
import os

# detect the current working directory and print it
path = os.getcwd()
print (&quot;The current working directory is %s&quot; % path)
</code></pre>
Listing 1
The output should look something like this:
<pre><code class="hljs">$ python3 cwd.py
The current working directory is /home/frank/
</code></pre>
Furthermore, the <code>os</code> module contains the additional <code>getcwdb()</code> method. This one is similar to the <code>getcwd()</code> method but returns the path as a binary string, instead.
There are quite a few other directory operations not covered in this article, like <a href="/python-check-if-a-file-or-directory-exists/">checking if a file or directory exists</a>. But for now we'll move on to the main purpose of this article.
<h2 id="creatingadirectory">Creating a Directory</h2>
Creating a single directory is done using the <code>mkdir()</code> method. As a parameter, <code>mkdir()</code> first requires the path name for the directory in order for it to be created. For an example, see the code below:
<pre><code class="hljs">import os

# define the name of the directory to be created
path = &quot;/tmp/year&quot;

try:
 os.mkdir(path)
except OSError:
 print (&quot;Creation of the directory %s failed&quot; % path)
else:
 print (&quot;Successfully created the directory %s &quot; % path)
</code></pre>
Listing 2
Keep in mind that the <code>mkdir()</code> method cannot create sub-directories on a deeper level than one in a single call. To create an entire path you have to call <code>mkdir()</code> once per directory level. Alternatively, if you want to create multiple directories at once, make use of the <code>makedirs()</code> method instead (which you can see in Listing 4 below).
As an optional parameter you can specify the <a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/File_system_permissions">access rights</a> to the directory within your <code>mkdir()</code> call. The default setting is 777, which means it is readable and writable by the owner, group members, and all other users as well. In case you require a more restrictive setting, like 755, (readable and accessible by all users, and write access by only the owner) you may call it as follows:
<pre><code class="hljs">import os

# define the name of the directory to be created
path = &quot;/tmp/year&quot;

# define the access rights
access_rights = 0o755

try:
 os.mkdir(path, access_rights)
except OSError:
 print (&quot;Creation of the directory %s failed&quot; % path)
else:
 print (&quot;Successfully created the directory %s&quot; % path)
</code></pre>
Listing 3
One thing to note about this code - you may have noticed that the access rights (755 here) are specified using the octal prefix (<code>0o</code>), which is done so you don't need to convert the number to decimal first. Since the OS represents the access permissions as octal, that's how we'll represent them here too.
However, as the <a rel="nofollow" target="_blank" href="https://docs.python.org/3/library/os.html#os.mkdir">Python documentation</a> states, some systems ignore the <code>mode</code> parameter and you should use <code>os.chmod</code> instead.
<h2 id="creatingadirectorywithsubdirectories">Creating a Directory with Subdirectories</h2>
As already mentioned above, the <code>mkdir()</code> method allows us to create a single directory, only. To create multi-level subdirectories the <code>makedirs()</code> method comes into play. Actually, <code>makedirs()</code> is implemented in such a way that it calls <code>mkdir()</code> to create one directory after the next.
As a parameter <code>makedirs()</code> accepts the entire path to be created. This method is similar to the UNIX/Linux command <code>mkdir -p</code>. Listing 4 shows an example of how to use this method.
<pre><code class="hljs">import os

# define the name of the directory to be created
path = &quot;/tmp/year/month/week/day&quot;

try:
 os.makedirs(path)
except OSError:
 print (&quot;Creation of the directory %s failed&quot; % path)
else:
 print (&quot;Successfully created the directory %s&quot; % path)
</code></pre>
Listing 3
<h2 id="creatingatemporarydirectory">Creating a Temporary Directory</h2>
So far, we've created permanent entries in the file system. For various reasons like parking data temporarily it can be necessary to just have a temporary directory. The <code>tempfile</code> module contains methods that handle such cases in a safe and consistent way.
Listing 5 shows an example that uses the <code>TemporaryDirectory()</code> method in combination with the <code>with</code> statement. After the <code>with</code> statement the temporary directory does not exist anymore because both the directory, and its contents have been entirely removed.
<pre><code class="hljs">import tempfile

# create a temporary directory
with tempfile.TemporaryDirectory() as directory:
 print(&#x27;The created temporary directory is %s&#x27; % directory)

# directory and its contents have been removed by this point
</code></pre>
Listing 5
Listing 6 shows the output of the Python script from Listing 5. In order to create temporary files, on UNIX/Linux systems the three directories /tmp, /var/tmp, and /usr/tmp are tried, and the first match of them is taken. In this current case it is the /tmp directory that is used.
<pre><code class="hljs">$ python3 mkdir-temporary.py
The created temporary directory is /tmp/tmpf6o0hy3c
</code></pre>
Listing 6
<h2 id="deletingadirectory">Deleting a Directory</h2>
Deleting a directory is the opposite case of creating one. You can do that using the <code>rmdir()</code> method of the <code>os</code> module. <code>rmdir()</code> requires a path string that contains the directory name, and only deletes the deepest entry in the path string. Note that this only works when the directory is entirely empty. If it is not empty then an <code>OSError</code> is raised. Listing 7 shows the according Python code.
<pre><code class="hljs">import os

# define the name of the directory to be deleted
path = &quot;/tmp/year&quot;

try:
 os.rmdir(path)
except OSError:
 print (&quot;Deletion of the directory %s failed&quot; % path)
else:
 print (&quot;Successfully deleted the directory %s&quot; % path)
</code></pre>
Listing 7
In case you would like to remove an entire directory tree the <code>rmtree()</code> method from the <code>shutil</code> module will help you with that task.
<h2 id="conclusion">Conclusion</h2>
As you may have noted, handling directories is very simple in Python. It takes you only a few lines of code to create and to remove this kind of file entry.
<h2 id="linksandreferences">Links and References</h2>
<ul>
<li>The Linux Documentation project (TLDP), <a rel="nofollow" target="_blank" href="https://www.tldp.org/LDP/intro-linux/html/sect_03_01.html#sect_03_01_01">General overview of the Linux 
file system, Files</a></li>
</ul>
<h2 id="acknowledgements">Acknowledgements</h2>
The author would like to thank <a rel="nofollow" target="_blank" href="http://www.upsurgesa.co.za/">Zoleka Hatitongwe</A> for her support while preparing the article.

Single Page Apps with Vue.js and Flask: JWT Authentication

Deploy Node.js Apps on Google App Engine

Single Page Apps with Vue.js and Flask: AJAX Integration

Creating and Deleting Directories with Python

Single Page Apps with Vue.js and Flask: RESTful API with Flask

Decision Trees in Python with Scikit-Learn

Single Page Apps with Vue.js and Flask: State Management with Vuex

Python Metaclasses and Metaprogramming

Single Page Apps with Vue.js and Flask: Navigating Vue Router