This article is a guest post by Chidume Nnamdi. He wrote this blog post through the Write for the Community program. If you are passionate about everything jamstack, open-source or javascript and want to share, join the writer's guild!

In this tutorial, we will build a News app using Strapi and React.js. We will use the new Strapi i18n plugin to translate the backend content from a language to another. The Strapi will be used to build the backend and provide the API endpoints, and React.js we will use to build our frontend part.

Read on.

What is Strapi? Strapi is an open-source headless content management system based on Node.js. Strapi provides us a nice UI to build our APIs. We can build APIs in the form of collections. A collection is a web resource that has endpoints GET, DELETE, POST, and PUT. These endpoints perform a separate action to the web resource. Strapi provides the web resource endpoints without us writing any server code. The web resources content can be added to the Strapi via its admin panel, also using the API.

For example, If we create a movies collection from the admin panel. Strapi will provide us with the following endpoints:

• /movies GET: This gets all the movies in the backend.
• /movies/:id GET: This get a movie from the backend.
• /movies/:id PUT: This edit a movie.
• /movies POST: This add a new movie to the backend.
• /movies/:id DELETE: This removes a movie from the backend.

So with just a collection, we get the above API endpoints :)

Strapi is self-hosted. It has an in-built server that serves the collections we create. Also, a Strapi project can be hosted in the cloud. Strapi allows you to use your favorite database such as MongoDB, Postgresql, etc…. With Strapi, we only have to build the frontend (mobile, web, or desktop) and use HTTP to fetch the data from the Strapi backend.

The i18n Strapi plugin Content Internationalization is very popular these days. You build an app with content displayed in English, but there are chances that a Chinese user might use your app or a Spanish user. You wouldn't want a language to be a barrier that stops users from accessing your app. With Content Internationalization, you can translate the content of your application from a language to another. You can translate from English to Chinese, from English to Spanish, French to German, etc.

Strapi has an old way of add internationalization to Strapi, but recently they released a new plugin that simplifies the process. It is the i18n. This Strapi i18n plugin will allow users to create different localized/language versions of their API content. It will also help developers build different language versions of their projects by fetching the content based on the language/locale of the user.

Requirements In this tutorial, we will need to install some tools if not already installed.

• Nodejs: Both Strapi and Reactjs are Nodejs-based tools and frameworks respectively. To download Nodejs binary, get it from Nodejs.
• NPM: This is a Node package manager. This comes bundled with the Nodejs binary. Run the command npm --version to confirm.
• Yarn: This is a Node package manager. It is very fast to install it run the command npm i yarn -g. The -g sub-command makes it to be installed globally in your machine so it can be accessed from any directory.
• VS Code: A web editor from Microsoft. You can use other editors but VS Code is quite amazing and has a worldwide adoption by devs. So VS Code is recommended for this tutorial. You can download it from VS Code.

Scaffold a Strapi project Follow the below instructions to create a Strapi project:

• Create a central folder: mkdir newsapp
• Move inside the folder: cd newsapp
• Now, from here, we create a Strapi project:

1
2
3
npx create-strapi-app newsapp-api --quickstart
# or
yarn create strapi-app newsapp-api --quickstart

This will create a Strapi project in newsapp-api folder . Strapi will install the dependencies. NB: The Strapi project will be using an SQLite database (.tmp/data.db).

• Move inside the folder: cd newsapp-api

Install Strapi i18n plugin This Strapi i18n via two ways:

1. From the Terminal
2. From the Marketplace

Here, we will describe the plugin installation via the Terminal.

According to the installation docs:

The Internationalization plugin is installed by default on all Strapi applications running on version 3.6.0 or higher. For lower versions, an update of the Strapi app is needed, as well as a manual installation of the plugin.

Note: For users with Strapi version 3.6.0 and above, you should skip this section to Register section, but I will recommend you read this section in case you will ever need to upgrade your Strapi app.

To upgrade your Strapi app, go to the package.json and set the Strapi packages to the latest version you want to upgrade to.

Close the Strapi server before doing this.

For example, to upgrade the Strapi packages below from their 3.2.4 to 3.6.0, you do this:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
{
  //...
  "dependencies": {
    "strapi": "3.2.4",
    "strapi-admin": "3.2.4",
    "strapi-connector-bookshelf": "3.2.4",
    "strapi-plugin-content-manager": "3.2.4",
    "strapi-plugin-content-type-builder": "3.2.4",
    "strapi-plugin-email": "3.2.4",
    "strapi-plugin-graphql": "3.2.4",
    "strapi-plugin-upload": "3.2.4",
    "strapi-plugin-users-permissions": "3.2.4",
    "strapi-utils": "3.2.4"
    //...
  }
}

upgraded:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
{
  //...
  "dependencies": {
    "strapi": "3.6.0",
    "strapi-admin": "3.6.0",
    "strapi-connector-bookshelf": "3.6.0",
    "strapi-plugin-content-manager": "3.6.0",
    "strapi-plugin-content-type-builder": "3.6.0",
    "strapi-plugin-email": "3.6.0",
    "strapi-plugin-graphql": "3.6.0",
    "strapi-plugin-upload": "3.6.0",
    "strapi-plugin-users-permissions": "3.6.0",
    "strapi-utils": "3.6.0"
    //...
  }
}

We changed the version numbers to 3.6.0.

Re-install the packages by running the command:

1
2
3
yarn install
# or
npm install

This should install the packages with the latest versions it was upgraded to.

If there is an issue, do any or all of these:

• Remove your yarn.lock or package-lock.json, and re-run the command.
• Remove the node_modules and try again.

Now, we will install the i18n plugin. To do that, run the below command:

1
2
3
yarn strapi install i18n
# or
npm run strapi install i18n

Now, we run the build command and then start the server by running the develop command:

1
2
3
npm run build --clean && npm run develop
# or
yarn build --clean && yarn develop

Register

Strapi will start its server at http://localhost:1337, and load its admin panel to register. Fill in your details, and click on “LET’S START” button. This makes Strapi register your details and shows the admin panel.

Now we will begin creating our collections.

Build the Strapi collections We are building a news website, a single news item will have this model:

1
2
3
4
5
6
newspost {
    title
    body
    writtenBy
    imageUrl
}

• The title is the title of the news.
• The body is the content of the news.
• The writtenBy is the author of the news.
• The imageUrl is the head image of the news.

Now, we create a news collection. Strapi will provide us with the endpoints:

• /``newsposts GET: This endpoint will retrieve all the news content.
• /newsposts/:id GET: This endpoint will retrieve a piece of particular news from the :id.
• /newsposts POST: This endpoint will create a new news item.
• /newsposts/:id DELETE: This endpoint will delete a particular news item.
• /newsposts/:id PUT: This endpoint will edit a particular news item. The news item is gotten from the :id in the URL.

On the admin page, click on the “> CREATE YOUR FIRST CONTENT-TYPE” button. A modal will show up. On the “Create a collection type” modal that shows up type in “newspost”.

We need to enable localization for this collection, so move to the top-right of the modal and click on the “Advanced Settings” tab, scroll down and enable the “Enable localization for this Content-Type” checkbox. This will allow you to have content in different locales.

• Click on the “Continue” button.

• On the “Newspost” modal, select “Text, and on the “Add new Text field” modal, type in “title:

• Click on the “+ Add another field” button.

Repeat this process for body, writtenBy, imageUrl fields on the news model. At the end of imageUrl addition, click on the "Finish" button. We will see the “Newspost” page displaying the fields we just added. Now, click on the “Save” button.

Now, a “Newsposts” link will appear on the sidebar.

Adding languages With localization enabled, the content will be seeded in the database for each language or locale. English is by default the selected language.

• Click “Settings” on the sidebar, then, on the “GLOBAL SETTINGS”, click on “Internationalization”.

See English is the default locale/language. Let’s add French locale, click on the “+ Add a locale” button on the top-right.

A modal shows up. Click on the “Locales” dropdown, all locales supported by Strapi will cascade down.

• Now, select “fr-FR” French (France) (fr-FR).

• Click on “Add locale”. See that the “French (France) (fr-FR)” locale is added to our list of locales for our “Newsposts” collection.

Our app now supports both English and French languages.

Seeding our database Now, we will add content to our database.

• Click on the “Newsposts” on the sidebar,

See that we are currently adding content for “English”. Since we have added the fr-Fr French locale, clicking on the dropbox we will see the fr-Fr we added.

Languages added in the Internationalization section will appear in the dropdown, and we can select them to add content for that language. So, if we select the “French (France) (fr-FR)”, the content locale will then be for fr-Fr.

But for now, let’s add news content for “English” locale.

• On the right side, click on “+ Add New Newsposts” button,

Enter the data:

1
2
3
4
title -> Nepal's Minister sworn into office
imageUrl -> https://thehimalayantimes.com/uploads/imported_images/wp-content/uploads/2020/10/Ministers-Sworn-in.jpg
writtenBy -> Chidume Nnamdi
body -> Type_any_thing_here.

• Click on the “Save” button, and on “Publish”. You can add many more news items as you deem fit.

Let’s add two more:

1
2
3
4
title -> Angular 12 released.
imageUrl -> https://upload.wikimedia.org/wikipedia/commons/thumb/c/cf/Angular_full_color_logo.svg/1280px-Angular_full_color_logo.svg.png
writtenBy -> M. Hry
body -> Type_any_thing_here.

• Click on “Save” and them on “Publish”. Add this:

1
2
3
4
title -> React v13 released
imageUrl -> https://upload.wikimedia.org/wikipedia/commons/thumb/a/a7/React-icon.svg/1920px-React-icon.svg.png
writtenBy -> Dan Tierry
body -> Type_any_thing_here.

• Click on “Save” and then, on “Publish”. We are done adding for the “English” locale.

Let’s add news content for French locale

• Click on the “English” dropdown box and select “French (France) (fr-FR)”.

The page will reload:

There is no data for French (France) (fr-FR) yet. So we add them, here we will add the French translation of our English version.

For the first data on the French version, we will add this:

1
2
3
4
title -> Le ministre du Népal a prêté serment
imageUrl -> https://thehimalayantimes.com/uploads/imported_images/wp-content/uploads/2020/10/Ministers-Sworn-in.jpg
writtenBy -> Chidume Nnamdi
body -> Type_any_thing_here.

• Click on “+ Add New Newsposts” and add the above content. Click on “Save”, and then on “Publish”.

Now, do this for data 2 and 3:

1
2
3
4
5
6
7
8
9
10
title -> Angular 12 est sorti.
imageUrl -> https://upload.wikimedia.org/wikipedia/commons/thumb/c/cf/Angular_full_color_logo.svg/1280px-Angular_full_color_logo.svg.png
writtenBy -> M. Hry
body -> Type_any_thing_here.


title -> Sortie de React v13
imageUrl -> https://upload.wikimedia.org/wikipedia/commons/thumb/a/a7/React-icon.svg/1920px-React-icon.svg.png
writtenBy -> Dan Tierry
body -> Type_any_thing_here.

Our data content for the French fr-Fr locale is ready.

Open access for the Newsposts Now, only authenticated users can access our endpoints. Let’s make the endpoints to be accessible to the public.

To do that:

• Click on “Settings” on the sidebar.
• In the “USERS & PERMISSIONS PLUGIN “ section, click on “Roles”.

• On the “Roles” page, click on “Public”

• Scroll down to the “Permissions” section:

• There check the “Select all” checkbox. This makes all the endpoints to be accessible to the public and the CRUD actions can be performed on them.

• Now, scroll up to the top, and click on the “Save” button.

This saves our changes.

Testing our Strapi endpoints We test the endpoints. Open Postman, if you don’t have it already, you can download it from here.

Get all Newsposts Create a new collection so we can organize our requests. Add a request to the collection. In the input box type http://localhost:1337/newsposts and click on "Send".

See that only the English Newsposts locale is returned because the default is set to be "English". To get the French translation we add _locale=fr-Fr to the URL and send. The fr-FR is the standard language code for the French language.

Type http://localhost:1337/newsposts?_locale=fr-FR in the input box and press "Send". The result will be in French:

Notice that both the News posts in both English and French has unique ids. So if we fetch a News with its id we don’t have to add the _locale= param. It will fetch the content of the news with no effect on the locale.

Adding a news item To add a news item to a particular locale, we will have to pass the language code of the locale in the body payload, like this:

The payload:

1
2
3
4
5
title: Nouvelles fonctionnalités de Vue js et changements de rupture - Présentation de Vue 3
body: __add anything french here___
writtenBy:CJ
imageUrl: https://upload.wikimedia.org/wikipedia/commons/thumb/9/95/Vue.js_Logo_2.svg/1920px-Vue.js_Logo_2.svg.png
locale: fr-FR

See we set fr-FR to the locale prop so Strapi knows this goes into the French locale.

We are done with our Strapi backend, let’s build the frontend to see how the two meet.

Scaffold React app Now, we will build the frontend part of our app.

• First, make sure you have the create-react-app tool installed in your machine. If not, you can install globally by running this command:

1
npm i create-react-app -g

• Test the installation by running the command:

1
create-react-app --version

• Remember we are in the Strapi newsapp-api folder, so we move out:

1
cd ../

• Now, from here we scaffold the React project.

• Create a newsapp-strapi React project by running the following command:

1
create-react-strapi

• Move into the folder:

1
cd newsapp-strapi

• Now, we install the axios module, we will use for querying our Strapi endpoints: npm i axios

• Next, we will have routes in our app, so we install the react-router-dom: npm i react-router-dom

• Start the server: npm run start

• Go to your browser and navigate to localhost:3000.

We are set to go.

Build the components Our news app will have two routes:

• /news: This route will render all the news in our app.
• /newsview/:id: This route will render a particular news item. The id will be the id of the news item.

Our final app will look like this:

This displays a news.

Reading the full news.

Let’s break our app into components.

• Header: This will hold the header section of our app.
• NewsList: This component will be a page component. It will be rendered when we navigate to /news route. It will display the list of news. It is a smart component
• NewsCard: This component will displays an overview of a news item. It will be rendered by the NewsList component.
• NewsView: This component is a page component, it displays the full details of a news item. It is the news page, where users will read a piece of particular news.
• AddNewsDialog: This is a dialog component, it is where news is added to our app.

Our page components will be in pages folder while the presentational components will be in components folder.

We will create two folders pages and components inside the src folder. Follow the below instructions to create the folders:

• Run the following command: mkdir src/pages src/components

Now, we will create Header, AddNewsDialog, NewsCard components inside the components folder. Follow the below instructions:

• Move inside the components folder: cd src/components
• Then, run the below commands to create them all:

1
2
3
4
5
6
7
8
9
10
mkdir AddNewsDialog
touch AddNewsDialog/index.js

mkdir Header
touch Header/index.js
touch Header/Header.css

mkdir NewsCard
touch NewsCard/index.js
touch NewsCard/NewsCard.css

Let’s create the page components.

• Move out from the components folder: cd ../
• Move into the pages folder: cd pages
• Then, run the below commands to create the components:

1
2
3
4
5
6
7
mkdir NewsList
touch NewsList/index.js
touch NewsList/NewsList.css

mkdir NewsView
touch NewsView/index.js
touch NewsView/NewsView.css

• Open App.js, clear the content and paste the below code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
import "./App.css";
import { BrowserRouter, Route, Switch, Redirect } from "react-router-dom";
import Header from "./components/Header";
import NewsList from "./pages/NewsList";
import NewsView from "./pages/NewsView";

function App() {
  return (
    <>
      <Header />
      <div className="container">
        <main className="main">
          <BrowserRouter>
            <Switch>
              <Route path="/news">
                <NewsList />
              </Route>
              <Route path="/newsview/:id">
                <NewsView />
              </Route>
              <Route exact path="/">
                <Redirect to="/news" />
              </Route>
              <Route path="*">
                <NewsList />
              </Route>{" "}
            </Switch>
          </BrowserRouter>
        </main>
      </div>
    </>
  );
}
export default App;

See we set up our two routes: /news and newsview/:id. The first route will render the NewsList component while the last route will render the NewsView component. We used React Router to set up routing here.

The BrowserRouter component initializes the routing system, The Switch component wraps the dynamic routes and the Route configures the specific routes and wraps the component the route will render. Anything else outside the BrowserRouter component will render on every page. See that we render the Header component outside it, so the header appears on all our pages.

• Next, clear the code in App.css and save the file.

Header component

• Now, let’s add the below code to our Header.js file.

1
2
3
4
5
6
7
8
9
import "./Header.css";

export default function Header() {
  return (
    <section className="header">
      <div className="headerName">News24</div>
    </section>
  );
}

Just a simple UI that displays News24.

• Insert the following code in the Header.css file:

CSS:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
.header {
  height: 54px;
  background-color: black;
  color: white;
  display: flex;
  align-items: center;
  padding: 10px;
  font-family: sans-serif;
  /*width: 100%;*/
  padding-left: 27%;
}
.headerName {
  font-size: 1.8em;
}

NewsList page

• Insert the following code in NewsList.js file: import "./NewsList.css"; import NewsCard from "./../../components/NewsCard"; import { useEffect, useState } from "react"; import axios from "axios"; import AddNewsDialog from "../../components/AddNewsDialog"; export default function NewsList() {

  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30
  31
  32
  33
  34
  35
  36
  37
  38
  39
  40
  41
  42
  43
  44
  45
  46
  47
  48
  const [newsList, setNewsList] = useState([]);
  const [locale, setLocale] = useState("en");
  const [showModal, setShowModal] = useState(false);
  
  useEffect(() => {
    async function fetchNews() {
      const data = await axios.get(
        "http://localhost:1337/newsposts?_locale=" + locale
      );
      setNewsList([...data?.data]);
    }
    fetchNews();
  }, [locale]);
  
  function setLang() {
    setLocale(window.locales.value);
  }
  
  function showAddNewsDialog() {
    setShowModal(!showModal);
  }
  
  return (
    <div className="newslist">
      <div className="newslistbreadcrumb">
        <div className="newslisttitle">
          <h3>World News</h3>
        </div>
        <div style={{ display: "flex", alignItems: "center" }}>
          <div style={{ marginRight: "4px" }}>
            <button onClick={showAddNewsDialog}>Add News</button>
          </div>
          <div>
            <select name="locales" id="locales" onChange={setLang}>
              <option value="en">English</option>
              <option value="fr-FR">French</option>
            </select>
          </div>
        </div>
      </div>
      <div>
        {newsList?.map((newsItem, i) => (
          <NewsCard newsItem={newsItem} key={i} />
        ))}
      </div>
      {showModal ? <AddNewsDialog closeModal={showAddNewsDialog} /> : null}
    </div>
  );
  

  }

Here we set up three states, the first holds the list of news, the second holds the current locale/language. It is by default set to English en, and the last holds the modal visibility state.

The useEffect loads the news whenever the component mounts from the "http://localhost:1337/newsposts?_locale=" endpoint, the current locale is added to it based on the selected locale. This makes our news app to be internationalized, we can view and read news in both English and French. The result is set to the newsList state, this causes the component to render and the UI displays the news in a long list. We added a locale dependency to the useEffect so the callback runs when the locale state changes.

The functions setLang and showAddNewsDialog sets the selected locale to the locale state and toggles the showModal state respectively.

Let’s look at the UI code.

See that we added an Add News button that when clicked the AddNewsDialog modal shows up. We also added a language select element, this is where we can select the language the news will be rendered in. We have "English" and "French", this is so because we have internationalization on our backend for "English" and "French". When any of the options is clicked, the language version of the app is loaded.

• Let’s add the styling code, open NewsList.css and paste the below code:

1
2
3
4
5
6
7
8
9
10
11
12
13
.newslistbreadcrumb {
  display: flex;
  align-items: center;
  justify-content: space-between;
  border-bottom: 1px solid darkgray;
}
.newslisttitle {
  margin-left: 12px;
}
.newslisttitle h3 {
  color: rgb(107 107 107);
  font-weight: 500;
}

NewsView page This page component renders the news selected from the NewsList component.

• Insert the following code to NewsView.js file:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
import "./NewsView.css";
import { useParams } from "react-router-dom";
import axios from "axios";
import { useEffect, useState } from "react";

export default function NewsView() {
  let { id } = useParams();
  const [news, setNews] = useState();

  useEffect(() => {
    async function getNews() {
      const data = await axios.get("http://localhost:1337/newsposts/" + id);
      setNews(data?.data);
    }
    getNews();
  }, [id]);

  async function deleteNews() {
    if (window.confirm("Do you want to delete this news?")) {
      await axios.delete("http://localhost:1337/newsposts/" + id);
      window.history.pushState(null, "", "/news");
      window.location.reload();    
    }
  }
  return (
    <div className="newsview">
      <div
        className="newsviewimg"
        style={{ backgroundImage: `url(${news?.imageUrl})` }}
      ></div>
      <div>
        <div className="newsviewtitlesection">
          <div className="newsviewtitle">
            <h1>{news?.title}</h1>
          </div>
          <div className="newsviewdetails">
            <span style={{ flex: "1", color: "rgb(99 98 98)" }}>
              Written By: <span>{news?.writtenBy}</span>
            </span>
            <span style={{ flex: "1", color: "rgb(99 98 98)" }}>
              Date: <span>{news?.created_at}</span>
            </span>
            <span>
              <button className="btn-danger" onClick={deleteNews}>
                Delete
              </button>
            </span>
          </div>
        </div>
        <div className="newsviewbody">{news?.body}</div>
      </div>
    </div>
  );
}

We start by using the useParams hook to get the :id param and the value is stored in the id variable. We set a state to hold the current news being viewed.

The useEffect loads the news details from the endpoint http://localhost:1337/newsposts/ + id and set the result to the news state.

The deleteNews function deletes this news by performing a DELETE HTTP request to the endpoint http://localhost:1337/newsposts/" + id. Then, navigate back to the /news page. This component’s UI displays the news in its entirety.

• Let’s see the styling, open NewsView.css and paste the below code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
.newsview {
  margin-top: 7px;
}
.newsviewimg {
  background-color: darkgray;
  background-repeat: no-repeat;
  background-size: cover;
  background-position: center;
  height: 200px;
}
.newsviewdetails {
  display: flex;
  justify-content: space-between;
  align-items: center;
}
.newsviewtitlesection {
  margin-bottom: 20px;
}
.newsviewtitle h1 {
  margin-bottom: 6px;
}
.newsviewbody {
  font-size: large;
}
.newsviewbody::first-letter {
  font-weight: 700;
  font-size: 4em;
  line-height: 0.83;
  float: left;
  margin-right: 7px;
  margin-bottom: 4px;
}
.newsviewbody {
  clear: left;
  font-size: 21px;
  line-height: 1.58;
  letter-spacing: -0.003em;
}

We used the ::first-select pseudoselector here .newsviewbody::first-letter to make the first letter in the news body appear larger 😁. That's a great UI appeal just like what Medium.com does.

NewsCard component This component is rendered by the NewsList to display list of news in the app.

• Insert the following code to NewsCard.js file:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
import { Link } from "react-router-dom";
import "./NewsCard.css";
export default function NewsCard({ newsItem }) {
  const { title, body, imageUrl, id } = newsItem;
  const synopsis = body.slice(0, 150);
  return (
    <Link to={"/newsview/" + id}>
      <div className="newscard">
        <div
          className="newscardimg"
          style={{ backgroundImage: `url(${imageUrl})` }}
        ></div>
        <div>
          <div className="newscardtitle">
            <h1>{title}</h1>
          </div>
          <div>
            <span>{synopsis}</span>
          </div>
          <div></div>
        </div>
      </div>
    </Link>
  );
}

The newsItem is destructured from the component props, and then the news properties body, imageUrl, title, and id are destructured from it. Then, we generated synopsis of the news from the body, this is just a snippet of the whole news. We did this by slicing off 150 characters from the whole news in the body and then display it.

See that we set a link to the full news by wrapping the div#newscard in Link component with a link to newsview/ + id. This will load the NewsView component with the id param set to the param in the id variable. So paste the above code in NewsCard/index.js.

• Open the NewsCard.css and paste the below code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
.newscard {
  /*background-color: white;*/
  padding: 8px;
  /*box-shadow: 0 4px 8px 0 rgba(0, 0, 0, 0.2);
  transition: 0.3s;*/
  border-radius: 4px;
  margin: 8px;
  cursor: pointer;
  display: flex;
}
.newscardimg {
  width: 146px;
  height: 146px;
  background-color: darkgray;
  background-repeat: no-repeat;
  background-size: cover;
  background-position: center;
  margin-right: 9px;
  flex: 1 100%;
}
.newscardtitle {
  flex: 1 100%;
}
.newscardtitle h1 {
  margin-top: 0;
  margin-bottom: 1px;
}

AddNewsDialog component

• Let’s add the below code to AddNewsDialog.js file:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
import { useState } from "react";
import axios from "axios";

export default function AddNewsDialog({ closeModal }) {
  const [disable, setDisable] = useState(false);
  async function saveNews() {
    const title = window.newsTitle.value;
    const imageUrl = window.newsImageUrl.value;
    const writtenBy = window.newsWrittenBy.value;
    const body = window.newsBody.value;
    const lang = window.addNewsLocales.value;
    
    setDisable(true);
    await axios.post("http://localhost:1337/newsposts", {
      title,
      imageUrl,
      writtenBy,
      body,
      locale: lang,
    });
    window.location.reload();
    setDisable(false);
  }

  return (
    <div className="modal">
      <div className="modal-backdrop" onClick={closeModal}></div>
      <div className="modal-content">
        <div className="modal-header">
          <h3>Add News</h3>
          <span
            style={{ padding: "10px", cursor: "pointer" }}
            onClick={closeModal}
          >
            X
          </span>
        </div>
        <div className="modal-body content">
          <div style={{ display: "flex", flexWrap: "wrap" }}>
            <div className="inputField">
              <div className="label">
                <label>Title</label>
              </div>
              <div>
                <input id="newsTitle" type="text" />
              </div>
            </div>
            <div className="inputField">
              <div className="label">
                <label>Lang</label>
              </div>
              <div>
                <select name="addNewsLocales" id="addNewsLocales">
                  <option value="en">English</option>
                  <option value="fr-FR">French</option>
                </select>
              </div>
            </div>
            <div className="inputField">
              <div className="label">
                <label>ImageUrl</label>
              </div>
              <div>
                <input id="newsImageUrl" type="text" />
              </div>
            </div>
            <div className="inputField">
              <div className="label">
                <label>Written By</label>
              </div>
              <div>
                <input id="newsWrittenBy" type="text" />
              </div>
            </div>
            <div className="inputField" style={{ flex: "2 1 100%" }}>
              <div className="label">
                <label>Body</label>
              </div>
              <div>
                <textarea
                  id="newsBody"
                  style={{ width: "100%", height: "200px" }}
                ></textarea>
              </div>
            </div>
          </div>
        </div>
        <div className="modal-footer">
          <button
            disabled={disable}
            className="btn-danger"
            onClick={closeModal}
          >
            Cancel
          </button>
          <button disabled={disable} className="btn" onClick={saveNews}>
            Save
          </button>
        </div>
      </div>
    </div>
  );
}

We have a state that holds the disabling state of buttons. The UI displays input boxes and a text area where we enter our news info. Then, there is a lang select element where we can select the language we are adding. Here, we hardcoded our two locales “English” and “French”, so we are bound with two languages here. It was done this way just to show you how you can toggle between languages from your frontend. A better solution will be to fetch the locales for this collection and dynamically list them in the select element.

Now, when adding your locales to the option element, the locale code is very important. Omitting any part of it will make it fetch the wrong language version or not work at all. For example, the French locale code is fr-FR, adding something like fr will make it not work. So we should be very careful when hardcoding locale code, or better still fetching the locales is the best option.

The “Save” button calls the saveNews function. The saveNews function picks the title, imageUrl, writtenBy, body, lang values from the input boxes, text area and select element, and disables the buttons. It then calls the http://localhost:1337/newsposts endpoint, passing the picked values as payload in the POST body. See that the language type for the news is set in the payload’s locale property. Finally, the page is reloaded and the newly added news post will be displayed on the news page.

• Now we add our global styles in index.css:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
body {
  margin: 0;
  font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", "Roboto",
    "Oxygen", "Ubuntu", "Cantarell", "Fira Sans", "Droid Sans",
    "Helvetica Neue", sans-serif;
  -webkit-font-smoothing: antialiased;
  -moz-osx-font-smoothing: grayscale;
  background-color: rgba(234, 238, 243, 1);
}
code {
  font-family: source-code-pro, Menlo, Monaco, Consolas, "Courier New",
    monospace;
}
button {
  height: 30px;
  padding: 0px 15px 2px;
  font-weight: 400;
  font-size: 1rem;
  line-height: normal;
  border-radius: 2px;
  cursor: pointer;
  outline: 0px;
  background-color: rgb(0, 126, 255);
  border: 1px solid rgb(0, 126, 255);
  color: rgb(255, 255, 255);
  text-align: center;
}
.btn-danger {
  background-color: rgb(195 18 18);
  border: 1px solid rgb(195 18 18);
}
.container {
  min-height: 100vh;
  /*padding: 0 0.5rem; */
  display: flex;
  flex-direction: column;
  justify-content: center;
  align-items: center;
  background-color: rgba(234, 238, 243, 1);
}
.main {
  /*padding: 5rem 0;*/
  flex: 1;
  display: flex;
  flex-direction: column;
  width: 46%;
  /*justify-content: center;
  align-items: center;*/
}
.modal {
  position: fixed;
  top: 0;
  left: 0;
  width: 100%;
  height: 100%;
  display: flex;
  flex-direction: column;
  align-items: center;
  z-index: 1000;
  font-family: "Segoe UI", Tahoma, Geneva, Verdana, sans-serif;
}
.modal-backdrop {
  opacity: 0.5;
  width: inherit;
  height: inherit;
  background-color: grey;
  position: fixed;
}
.modal-body {
  padding: 5px;
  padding-top: 15px;
  padding-bottom: 15px;
}
.modal-footer {
  padding: 15px 5px;
  display: flex;
  justify-content: space-between;
}
.modal-header {
  display: flex;
  justify-content: space-between;
  align-items: center;
}
.modal-header h3 {
  margin: 0;
}
.modal-content {
  background-color: white;
  z-index: 1;
  padding: 10px;
  margin-top: 10px;
  width: 520px;
  box-shadow: 0px 11px 15px -7px rgba(0, 0, 0, 0.2), 0px 24px 38px 3px rgba(0, 0, 0, 0.14),
    0px 9px 46px 8px rgba(0, 0, 0, 0.12);
  border-radius: 4px;
}
input[type="text"] {
  width: 100%;
  /*height: 3.4rem;*/
  padding: 9px;
  font-weight: 400;
  /*font-size: 1.3rem;*/
  cursor: text;
  outline: 0px;
  border: 1px solid rgb(227, 233, 243);
  border-radius: 2px;
  color: rgb(51, 55, 64);
  background-color: transparent;
  box-sizing: border-box;
}
.label {
  padding: 4px 0;
  font-size: small;
  color: rgb(51, 55, 64);
}
.content {
  display: flex;
  flex-wrap: wrap;
  flex-direction: column;
}
.inputField {
  margin: 3px 7px;
  flex: 1 40%;
}
.disable {
  opacity: 0.5;
  cursor: not-allowed;
}
a[href] {
  text-decoration: none;
  color: black;
}
a:visited {
  color: black;
}

Test the app Let’s test our app. We will start by adding a news item.

• Go to /news page and add click on the Add News button.
• On the modal that shows up type in the data:

1
2
3
4
title -> Minnesota National Guard deployed after protests over the police killing of a man during a traffic stop
imageUrl -> https://logos-world.net/wp-content/uploads/2020/11/CNN-Logo-700x394.png
Body -> (CNN) -- Hundreds of people __TRUNC__t," Walz tweeted.
writtenBy -> CNN

• Click on “Save”

• The news is added. Now, click on it:

• Now, let’s add the “French fr-FR” version.

• Go back to /news page and click on "Add News", this time select the lang to French.

Add the data, I translated it to French using Google Translate:

1
2
3
4
title -> La Garde nationale du Minnesota déployée après des manifestations contre le meurtre par la police d'un homme lors d'un arrêt de la circulation
imageUrl -> https://logos-world.net/wp-content/uploads/2020/11/CNN-Logo-700x394.png
Body -> (CNN) Des __TRUNC__es forces de l'ordre", a tweeté Walz.
writtenBy -> CNN

• Click on “Save”. Now, select the “French” lang:

• See the news in French, click on it.

Now, we delete it.

• Click on “Delete” button and on “OK” button on the “confirm” dialog that shows up. See the news is gone. 😁

Source code

• Backend
• Frontend

Conclusion We learned how to use the Strapi i18n plugin to add internationalization to our Strapi API endpoints, and it is quite simple to use.

We started by learning what Strapi does and how it makes building APIs highly efficient. Next, we introduced the i18n plugin, and from there, we created a Strapi project to demonstrate how to use the i18n plugin in a Strapi project.

Next, we built a news app in React.js and showed how we could support multiple languages in a Reactjs app using Strapi as a backend with the help of the i18n plugin.

References

• 🌍 Internationalization (i18n)
• Translating content