From 4fa09020baeced89cbe4a5d0a45b21f6c7db52a7 Mon Sep 17 00:00:00 2001
From: TianMing2018 <2452146988@qq.com>
Date: Sat, 19 Nov 2022 09:16:15 +0000
Subject: [PATCH] remove duplicated lesson and modify link in relative pages
---
docs/create/cloud/gcp/index-gcp.mdx | 2 +-
docs/create/gcp/index-gcp.mdx | 2 +-
docs/howtos/hackernews/index-hackernews.mdx | 2 +-
docs/howtos/index-howtos.mdx_inprogress | 2 +-
.../getting-started/index-gettingstarted.mdx | 2 +-
.../redisjson/using-go/index-usinggo.mdx | 2 +-
.../redisjson/using-java/index-usingjava.mdx | 2 +-
.../using-nodejs/index-usingnodejs.mdx | 2 +-
.../index-usingredisinsight.mdx | 2 +-
.../shoppingcart/index-shoppingcart.mdx | 806 ------------------
docs/howtos/shoppingcart/shopping2.png | Bin 90142 -> 0 bytes
docs/howtos/shoppingcart/shoppingcart.png | Bin 55794 -> 0 bytes
docs/howtos/shoppingcart/shoppingcart2.png | Bin 269911 -> 0 bytes
docs/howtos/shoppingcart/shoppingcart3.png | Bin 66224 -> 0 bytes
docs/howtos/shoppingcart/shoppingcart5.png | Bin 323485 -> 0 bytes
docs/modules/redisjson/index-redisjson.mdx | 2 +-
src/theme/Demos/index.tsx | 2 +-
17 files changed, 11 insertions(+), 817 deletions(-)
delete mode 100644 docs/howtos/shoppingcart/index-shoppingcart.mdx
delete mode 100644 docs/howtos/shoppingcart/shopping2.png
delete mode 100644 docs/howtos/shoppingcart/shoppingcart.png
delete mode 100644 docs/howtos/shoppingcart/shoppingcart2.png
delete mode 100644 docs/howtos/shoppingcart/shoppingcart3.png
delete mode 100644 docs/howtos/shoppingcart/shoppingcart5.png
diff --git a/docs/create/cloud/gcp/index-gcp.mdx b/docs/create/cloud/gcp/index-gcp.mdx
index d6671990d2..224581aae1 100644
--- a/docs/create/cloud/gcp/index-gcp.mdx
+++ b/docs/create/cloud/gcp/index-gcp.mdx
@@ -44,4 +44,4 @@ Launch [Redis Enterprise Cloud page](https://console.cloud.google.com/apis/libra
### Next Steps
- [Connecting to the database using RedisInsight](/explore/redisinsight/)
-- [How to list & search Movies database using Redisearch](/howtos/shoppingcart/)
+- [How to list & search Movies database using Redisearch](/howtos/redisjson/shoppingcart/)
diff --git a/docs/create/gcp/index-gcp.mdx b/docs/create/gcp/index-gcp.mdx
index e8590a8bb1..b43c4da9ae 100644
--- a/docs/create/gcp/index-gcp.mdx
+++ b/docs/create/gcp/index-gcp.mdx
@@ -49,7 +49,7 @@ Launch [Redis Enterprise Cloud page](https://console.cloud.google.com/apis/libra
### Next Steps
- [Connecting to the database using RedisInsight](/explore/redisinsight/)
-- [How to list & search Movies database using Redisearch](/howtos/shoppingcart/)
+- [How to list & search Movies database using Redisearch](/howtos/redisjson/shoppingcart/)
##
diff --git a/docs/howtos/hackernews/index-hackernews.mdx b/docs/howtos/hackernews/index-hackernews.mdx
index 59afa04be4..23e161a611 100644
--- a/docs/howtos/hackernews/index-hackernews.mdx
+++ b/docs/howtos/hackernews/index-hackernews.mdx
@@ -426,5 +426,5 @@ It will require new hash and new JSON record
- [How to store and retrieve nested JSON document](/howtos/redisjson/storing-complex-json-document)
- [Importing JSON data into Redis using NodeJS](/howtos/redisjson/using-nodejs)
- Learn more about [RedisJSON](https://oss.redis.com/redisjson/) in the Quickstart tutorial.
-- [How to build shopping cart app using NodeJS and RedisJSON](/howtos/shoppingcart)
+- [How to build shopping cart app using NodeJS and RedisJSON](/howtos/redisjson/shoppingcart/)
- [Indexing, Querying, and Full-Text Search of JSON Documents with Redis](https://redis.com/blog/index-and-query-json-docs-with-redis/)
diff --git a/docs/howtos/index-howtos.mdx_inprogress b/docs/howtos/index-howtos.mdx_inprogress
index 962fc9d0c9..dd4dccd884 100644
--- a/docs/howtos/index-howtos.mdx_inprogress
+++ b/docs/howtos/index-howtos.mdx_inprogress
@@ -26,7 +26,7 @@ This page holds a catalog with dozens of ready-to-use app listings from Redis. N
diff --git a/docs/howtos/redisjson/getting-started/index-gettingstarted.mdx b/docs/howtos/redisjson/getting-started/index-gettingstarted.mdx
index 4467706336..099dc77583 100644
--- a/docs/howtos/redisjson/getting-started/index-gettingstarted.mdx
+++ b/docs/howtos/redisjson/getting-started/index-gettingstarted.mdx
@@ -272,7 +272,7 @@ A JSON object can also have another object. Here is a simple example of a JSON o
- [RU204: Storing, Querying and Indexing JSON at Speed](https://university.redis.com/courses/ru204/) - a course at Redis University
- Learn more about [RedisJSON](https://oss.redis.com/redisjson/) in the Quickstart tutorial.
-- [How to build shopping cart app using NodeJS and RedisJSON](/howtos/shoppingcart)
+- [How to build shopping cart app using NodeJS and RedisJSON](/howtos/redisjson/shoppingcart/)
- [Indexing, Querying, and Full-Text Search of JSON Documents with Redis](https://redis.com/blog/index-and-query-json-docs-with-redis/)
##
diff --git a/docs/howtos/redisjson/using-go/index-usinggo.mdx b/docs/howtos/redisjson/using-go/index-usinggo.mdx
index 7c4cecd7c0..f1183455bc 100644
--- a/docs/howtos/redisjson/using-go/index-usinggo.mdx
+++ b/docs/howtos/redisjson/using-go/index-usinggo.mdx
@@ -131,5 +131,5 @@ Follow the below steps to get started with RedisJSON using Go client.
- [How to store and retrieve nested JSON document](/howtos/redisjson/storing-complex-json-document)
- [Importing JSON data into Redis using NodeJS](/howtos/redisjson/using-nodejs)
- Learn more about [RedisJSON](https://oss.redis.com/redisjson/) in the Quickstart tutorial.
-- [How to build shopping cart app using NodeJS and RedisJSON](/howtos/shoppingcart)
+- [How to build shopping cart app using NodeJS and RedisJSON](/howtos/redisjson/shoppingcart/)
- [Indexing, Querying, and Full-Text Search of JSON Documents with Redis](https://redis.com/blog/index-and-query-json-docs-with-redis/)
diff --git a/docs/howtos/redisjson/using-java/index-usingjava.mdx b/docs/howtos/redisjson/using-java/index-usingjava.mdx
index 61d914adea..4ffd3193ad 100644
--- a/docs/howtos/redisjson/using-java/index-usingjava.mdx
+++ b/docs/howtos/redisjson/using-java/index-usingjava.mdx
@@ -125,5 +125,5 @@ This example just scratches the surface. You can atomically manipulate JSON docu
- [How to store and retrieve nested JSON document](/howtos/redisjson/storing-complex-json-document)
- [Importing JSON data into Redis using NodeJS](/howtos/redisjson/using-nodejs)
- Learn more about [RedisJSON](https://oss.redis.com/redisjson/) in the Quickstart tutorial.
-- [How to build shopping cart app using NodeJS and RedisJSON](/howtos/shoppingcart)
+- [How to build shopping cart app using NodeJS and RedisJSON](/howtos/redisjson/shoppingcart/)
- [Indexing, Querying, and Full-Text Search of JSON Documents with Redis](https://redis.com/blog/index-and-query-json-docs-with-redis/)
diff --git a/docs/howtos/redisjson/using-nodejs/index-usingnodejs.mdx b/docs/howtos/redisjson/using-nodejs/index-usingnodejs.mdx
index 611a308975..b46dda1970 100644
--- a/docs/howtos/redisjson/using-nodejs/index-usingnodejs.mdx
+++ b/docs/howtos/redisjson/using-nodejs/index-usingnodejs.mdx
@@ -129,5 +129,5 @@ OK
- [How to store and retrieve nested JSON documents](/howtos/redisjson/storing-complex-json-document)
- [Importing JSON data into Redis using Node.js](/howtos/redisjson/using-nodejs)
- Learn more about [RedisJSON](https://redisjson.io/) in the Quickstart tutorial.
-- [How to build a shopping cart app using Node.js and RedisJSON](/howtos/shoppingcart)
+- [How to build a shopping cart app using Node.js and RedisJSON](/howtos/redisjson/shoppingcart)
- [Indexing, Querying, and Full-Text Search of JSON Documents with Redis](https://redis.com/blog/index-and-query-json-docs-with-redis/)
diff --git a/docs/howtos/redisjson/using-redisinsight/index-usingredisinsight.mdx b/docs/howtos/redisjson/using-redisinsight/index-usingredisinsight.mdx
index a45d22604a..cb8179f168 100644
--- a/docs/howtos/redisjson/using-redisinsight/index-usingredisinsight.mdx
+++ b/docs/howtos/redisjson/using-redisinsight/index-usingredisinsight.mdx
@@ -92,5 +92,5 @@ Select "employee_profile" to display the JSON data
- [How to store and retrieve nested JSON document](/howtos/redisjson/storing-complex-json-document)
- [Importing JSON data into Redis using NodeJS](/howtos/redisjson/using-nodejs)
- Learn more about [RedisJSON](https://oss.redis.com/redisjson/) in the Quickstart tutorial.
-- [How to build shopping cart app using NodeJS and RedisJSON](/howtos/shoppingcart)
+- [How to build shopping cart app using NodeJS and RedisJSON](/howtos/redisjson/shoppingcart/)
- [Indexing, Querying, and Full-Text Search of JSON Documents with Redis](https://redis.com/blog/index-and-query-json-docs-with-redis/)
diff --git a/docs/howtos/shoppingcart/index-shoppingcart.mdx b/docs/howtos/shoppingcart/index-shoppingcart.mdx
deleted file mode 100644
index 3a8ca7f802..0000000000
--- a/docs/howtos/shoppingcart/index-shoppingcart.mdx
+++ /dev/null
@@ -1,806 +0,0 @@
----
-id: index-shoppingcart
-title: How to build a Shopping cart app using NodeJS and Redis
-sidebar_label: How to build a Shopping cart app using NodeJS and Redis
-slug: /howtos/shoppingcart
-authors: [ajeet]
----
-
-import Authors from '@theme/Authors';
-
-
-
-It’s hard to imagine an online store without a shopping cart. Almost every online store must have the shopping cart functionality to be able to sell products to customers. In order to build a scalable ecommerce platform, you need a powerful framework and a simple storage system. At times, a lot of developers focus on improving the frontend performance of an ecommerce platform to rectify these things. The real bottleneck, however, remains the slow backend load time.
-A slow backend load time can have a serious impact on your search engine rankings. A good rule of thumb is that backend load time should take no more than 20% of your total load time. A good backend load time to aim for is 200ms or less.
-In this tutorial, you will see how to build a shopping cart application using Node.js, Vue.js, Express and Redis.
-
-
-
-
-
-### Content
-
-- What will you build?
-- What do you need?
-- Getting started
-- Setting up the backend (Node.js Express)
-- Setting up the frontend (Vue.js)
-- Running the application
-- Conclusion
-
-### What will you build?
-
-This tutorial will show you how to harness the power of Redis by creating a basic ecommerce shopping cart application with Node.js. Usually, the shopping cart data is stored on the client-side as a cookie. Cookies are small text files stored in a web user's browser directory or data folder. The advantage of doing this is that you wouldn't need to store such temporary data in your database. However, this will require you to send the cookies with every web request, which can slow down the request in case of large cookies. Storing shopping cart data in Redis is a good idea since you can retrieve the items very fast at any time and persist this data if needed.
-
-
-
-### What do you need?
-
-- Redis compiled with RedisJSON module
-- Express 4 backend
-- Node 15.5.0 (at least v12.9.0+)
-- NPM 7.3.0 (at least v6.14.8+)
-- Docker 19.03.X (Optional)
-- Docker Compose (Optional)
-
-Building an ecommerce app with Node.js makes a lot more sense because it ensures the balance between frontend and backend load time due to its asynchronous nature (the ability to handle multiple concurrent users at a time). Node.js helps developers make the best use of event loops and callbacks for I/O operations. Node.js runs single-threaded, non-blocking, asynchronous programming, which is very memory efficient.
-
-In order to create a shopping cart we need a simple storage system where we can collect products and the cart's total. Node.js provides us with the express-session package, middleware for ExpressJS. We will be using express-session middleware to manage sessions in Node.js The session is stored in the express server itself.
-
-The default server-side session storage, MemoryStore, is purposely not designed for a production environment. It will leak memory under most conditions, does not scale past a single process, and is meant for debugging and developing. To manage multiple sessions for multiple users, we have to create a global map and put each session object to it. Global variables in NodeJs are memory consuming and can prove to be terrible security holes in production-level projects.This can be solved by using an external session store. We have to store every session in the store so that each one will belong to only a single user. One popular session store is built using Redis.
-
-We will start by setting up the backend for our application. Let’s create a new directory for our application and initialize a new Node.js application. Open up your terminal and type the following:
-
-### Getting Started
-
-Clone the repository:
-
-```
-$ git clone https://github.com/redis-developer/basic-redis-shopping-chart-nodejs
-```
-
-#### Compiling Redis with RedisJSON module
-
-You can use the below docker compose file to run Redis server compiled with RedisJSON module:
-
-```
-version: '3'
-
-services:
- redis:
- image: redislabs/rejson:latest
- container_name: redis.redisshoppingcart.docker
- restart: unless-stopped
- environment:
- REDIS_PASSWORD: ${REDIS_PASSWORD}
- command: redis-server --loadmodule "/usr/lib/redis/modules/rejson.so" --requirepass "$REDIS_PASSWORD"
- ports:
- - 127.0.0.1:${REDIS_PORT}:6379
- networks:
- - global
-networks:
- global:
- external: true
-```
-
-I assume that you have Docker and Docker Compose up and installed on your local environment. Execute the below compose CLI to bring up Redis server:
-
-```
-$ docker network create global
-$ docker-compose up -d --build
-```
-
-The `docker-compose ps` shows the list of running Redis services:
-
-```
-$ docker-compose ps
-Name Command State Ports
-
-redis.redisshoppingcart.docker docker-entrypoint.sh redis ... Up 127.0.0.1:55000->6379/tcp
-```
-
-### Setting up the backend server
-
-
-
-Node.js is a runtime environment that allows software developers to launch both the frontend and backend of web apps using JavaScript. To save your time, the directory /server/src has already been created for you.This is where we will be creating our modules by adding the following sub-directories -
-
-- routes
-- controller
-- middleware
-- services
-
-Routes forward the supported requests (and any information encoded in request URLs) to the appropriate controller functions, whereas controller functions get the requested data from the models, create an HTML page displaying the data, and return it to the user to view in the browser. Services hold your actual business logic. Middleware functions are functions that have access to the request object (req), the response object (res), and the next middleware function in the application’s request-response cycle.
-
-#### Project directory structure
-
-```
-% tree
-.
-├── controllers
-│ ├── Cart
-│ │ ├── DeleteItemController.js
-│ │ ├── EmptyController.js
-│ │ ├── IndexController.js
-│ │ └── UpdateController.js
-│ └── Product
-│ ├── IndexController.js
-│ └── ResetController.js
-├── index.js
-├── middleware
-│ └── checkSession.js
-├── products.json
-├── routes
-│ ├── cart.js
-│ ├── index.js
-│ └── products.js
-└── services
- └── RedisClient.js
-
-6 directories, 13 files
-```
-
-Let us first initialize the application server through the index.js shown below:
-
-```
-// server/src/index.js
-
-
-const express = require('express');
-const redis = require('redis');
-const rejson = require('redis-rejson');
-const session = require('express-session');
-const RedisStore = require('connect-redis')(session);
-const path = require('path');
-const bodyParser = require('body-parser');
-const cors = require('cors');
-const RedisClient = require('./services/RedisClient');
-
-rejson(redis);
-
-require('dotenv').config();
-
-const { REDIS_ENDPOINT_URI, REDIS_HOST, REDIS_PORT, REDIS_PASSWORD, PORT } = process.env;
-
-const app = express();
-
-app.use(
- cors({
- origin(origin, callback) {
- callback(null, true);
- },
- credentials: true
- })
-);
-
-const redisEndpointUri = REDIS_ENDPOINT_URI
- ? REDIS_ENDPOINT_URI.replace(/^(redis\:\/\/)/, '')
- : `${REDIS_HOST}:${REDIS_PORT}`;
-
-const redisClient = redis.createClient(`redis://${redisEndpointUri}`, {
- password: REDIS_PASSWORD
-});
-
-const redisClientService = new RedisClient(redisClient);
-
-app.set('redisClientService', redisClientService);
-
-app.use(
- session({
- store: new RedisStore({ client: redisClient }),
- secret: 'someSecret',
- resave: false,
- saveUninitialized: false,
- rolling: true,
- cookie: {
- maxAge: 3600 * 1000 * 3
- }
- })
-);
-
-app.use(bodyParser.json());
-
-app.use('/', express.static(path.join(__dirname, '../../client-dist')));
-
-const router = require('./routes')(app);
-
-app.use('/api', router);
-
-const port = PORT || 3000;
-
-app.listen(port, () => {
- console.log(`App listening on port ${port}`);
-});
-```
-
-You'll see that the responsibility of this index.js is to simply set up the server. It initializes all the middleware, sets up the view engine, etc. The last thing to do is set up routes by deferring that responsibility to the index.js within the routes folder.
-
-As shown above, app.use, app.set, and app.listen are endpoints, for the purposes of this demo, we will need to be able to add and get items from the basket ( Keeping it simple ).
-We need to define our basic routes to get all products, get single product details, remove products, and create products.
-
-#### Routes
-
-The routes directory is only responsible for defining our routes. Within index.js in this folder, you'll see that its responsibility is to set up our top level routes and delegate their responsibilities to each of their respective route files. Each respective route file will further define any additional subroutes and controller actions for each one.
-
-The web server skeleton already has a ./routes folder containing routes for the index, products and cart. (as shown under https://github.com/redis-developer/basic-redis-shopping-chart-nodejs/tree/main/server/src/routes)
-
-```
-// routes/index.js
-
-const fs = require('fs');
-const express = require('express');
-const router = express.Router();
-
-module.exports = app => {
- fs.readdirSync(__dirname).forEach(function (route) {
- route = route.split('.')[0];
-
- if (route === 'index') {
- return;
- }
-
- router.use(`/${route}`, require(`./${route}`)(app));
- });
-
- return router;
-};
-```
-
-A route is a section of Express code that associates an HTTP verb (GET, POST, PUT, DELETE, etc.), a URL path/pattern, and a function that is called to handle that pattern.
-There are several ways to create routes. For this demo app we're going to use the express.Router middleware as it allows us to group the route handlers for a particular part of a site together and access them using a common route-prefix.
-The module requires Express and then uses it to create a Router object. The routes are all set up on the router, which is then exported.The routes are defined either using .get() or .post() methods on the router object. All the paths are defined using strings (we don't use string patterns or regular expressions). Routes that act on some specific resource (e.g. book) use path parameters to get the object id from the URL.
-The handler functions are all imported from the controller modules we created in the previous section.
-
-#### Controllers
-
-Controllers are responsible for invoking the appropriate action. If a controller's responsibility is to render a view, it will render the appropriate view from the app/views directory.
-
-```
-// controller/Product/IndexController.js
-
-
-const { products } = require('../../products.json');
-
-class ProductIndexController {
- constructor(redisClientService) {
- this.redisClientService = redisClientService;
- }
-
- async index(req, res) {
- const productKeys = await this.redisClientService.scan('product:*');
- const productList = [];
-
- if (productKeys.length) {
- for (const key of productKeys) {
- const product = await this.redisClientService.jsonGet(key);
-
- productList.push(JSON.parse(product));
- }
-
- return res.send(productList);
- }
-
- for (const product of products) {
- const { id } = product;
-
- await this.redisClientService.jsonSet(`product:${id}`, '.', JSON.stringify(product));
-
- productList.push(product);
- }
-
- return res.send(productList);
- }
-}
-
-module.exports = ProductIndexController;
-```
-
-#### Services
-
-Services hold your actual business logic.The service layer carries out the application logic and delegates CRUD operations to a database/persistent storage (Redis in our case). Let us look at each condition and try to understand how the data is stored, modified, and accessed:
-
-#### How the data is stored:
-
-The product data is stored in an external JSON file. After the first request, this data is saved in a JSON data type in Redis like:
-
-```
-JSON.SET product:{productId} . '{ "id": "productId", "name": "Product Name", "price": "375.00", "stock": 10 }'.
-```
-
-#### Example:
-
-```
-JSON.SET product:e182115a-63d2-42ce-8fe0-5f696ecdfba6 . '{ "id": "e182115a-63d2-42ce-8fe0-5f696ecdfba6", "name": "Brilliant Watch", "price": "250.00", "stock": 2 }'
-```
-
-The cart data is stored in a hash like:
-
-```
-HSET cart:{cartId} product:{productId} {productQuantity},
-```
-
-where cartId is a random generated value and stored in the user session. Please note that Redis’s hash management command HSET stores 2 keys-cart and product-as shown in the below example.
-
-#### Example:
-
-```
-HSET cart:77f7fc881edc2f558e683a230eac217d product:e182115a-63d2-42ce-8fe0-5f696ecdfba6 1
-```
-
-#### How the data is modified:
-
-The product data is modified like
-
-```
-JSON.SET product:{productId} . '{ "id": "productId", "name": "Product Name", "price": "375.00", "stock": {newStock} }'.
-```
-
-#### Example:
-
-```
-JSON.SET product:e182115a-63d2-42ce-8fe0-5f696ecdfba6 . '{ "id": "e182115a-63d2-42ce-8fe0-5f696ecdfba6", "name": "Brilliant Watch", "price": "250.00", "stock": 1 }'
-```
-
-The cart data is modified like
-
-```
-HSET cart:{cartId} product:{productId} {newProductQuantity} or HINCRBY cart:{cartId} product:{productId} {incrementBy}.
-```
-
-#### Example:
-
-```
-HSET cart:77f7fc881edc2f558e683a230eac217d product:e182115a-63d2-42ce-8fe0-5f696ecdfba6 2
-
-HINCRBY cart:77f7fc881edc2f558e683a230eac217d product:e182115a-63d2-42ce-8fe0-5f696ecdfba6 1
-
-HINCRBY cart:77f7fc881edc2f558e683a230eac217d product:e182115a-63d2-42ce-8fe0-5f696ecdfba6 -1
-```
-
-The product can be removed from the cart like
-
-```
-HDEL cart:{cartId} product:{productId}
-```
-
-#### Example:
-
-```
-HDEL cart:77f7fc881edc2f558e683a230eac217d product:e182115a-63d2-42ce-8fe0-5f696ecdfba6
-```
-
-The cart can be cleared using
-
-```
-HGETALL cart:{cartId} and then HDEL cart:{cartId} {productKey} in loop.
-```
-
-#### Example:
-
-```
-HGETALL cart:77f7fc881edc2f558e683a230eac217d => product:e182115a-63d2-42ce-8fe0-5f696ecdfba6, product:f9a6d214-1c38-47ab-a61c-c99a59438b12, product:1f1321bb-0542-45d0-9601-2a3d007d5842 => HDEL cart:77f7fc881edc2f558e683a230eac217d product:e182115a-63d2-42ce-8fe0-5f696ecdfba6, HDEL cart:77f7fc881edc2f558e683a230eac217d product:f9a6d214-1c38-47ab-a61c-c99a59438b12, HDEL cart:77f7fc881edc2f558e683a230eac217d product:1f1321bb-0542-45d0-9601-2a3d007d5842
-```
-
-All carts can be deleted when reset data is requested like:
-
-```
- SCAN {cursor} MATCH cart:* and then DEL cart:{cartId} in loop.
-```
-
-#### Example:
-
-```
- SCAN {cursor} MATCH cart:* => cart:77f7fc881edc2f558e683a230eac217d, cart:217dedc2f558e683a230eac77f7fc881, cart:1ede77f558683a230eac7fc88217dc2f => DEL cart:77f7fc881edc2f558e683a230eac217d, DEL cart:217dedc2f558e683a230eac77f7fc881, DEL cart:1ede77f558683a230eac7fc88217dc2f
-```
-
-#### How the data is accessed:
-
-Products: SCAN {cursor} MATCH product:\* to get all product keys and then JSON.GET {productKey}
-
-#### Example:
-
-```
-SCAN {cursor} MATCH product:* => product:e182115a-63d2-42ce-8fe0-5f696ecdfba6, product:f9a6d214-1c38-47ab-a61c-c99a59438b12, product:1f1321bb-0542-45d0-9601-2a3d007d5842
-=> JSON.GET product:e182115a-63d2-42ce-8fe0-5f696ecdfba6, JSON.GET product:f9a6d214-1c38-47ab-a61c-c99a59438b1, JSON.GET product:1f1321bb-0542-45d0-9601-2a3d007d5842
-```
-
-Cart: HGETALL cart:{cartId} to get quantity of products and JSON.GET product:{productId} to get products data in loop.
-
-#### Example:
-
-```
-HGETALL cart:77f7fc881edc2f558e683a230eac217d => product:e182115a-63d2-42ce-8fe0-5f696ecdfba6 (quantity: 1), product:f9a6d214-1c38-47ab-a61c-c99a59438b12 (quantity: 0), product:1f1321bb-0542-45d0-9601-2a3d007d5842 (quantity: 2) => JSON.GET product:e182115a-63d2-42ce-8fe0-5f696ecdfba6, JSON.GET product:f9a6d214-1c38-47ab-a61c-c99a59438b12, JSON.GET product:1f1321bb-0542-45d0-9601-2a3d007d5842
-```
-
-HGETALL returns an array of keys and corresponding values from hash data type.
-Open up RedisClient.js file using your favourite editor as shown below:
-
-```
-// services/RedisClient.js
-
-const { promisify } = require('util');
-
-class RedisClient {
- constructor(redisClient) {
- ['json_get', 'json_set', 'hgetall', 'hset', 'hget', 'hdel', 'hincrby', 'del', 'scan'].forEach(
- method => (redisClient[method] = promisify(redisClient[method]))
- );
- this.redis = redisClient;
- }
-
- async scan(pattern) {
- let matchingKeysCount = 0;
- let keys = [];
-
- const recursiveScan = async (cursor = '0') => {
- const [newCursor, matchingKeys] = await this.redis.scan(cursor, 'MATCH', pattern);
- cursor = newCursor;
-
- matchingKeysCount += matchingKeys.length;
- keys = keys.concat(matchingKeys);
-
- if (cursor === '0') {
- return keys;
- } else {
- return await recursiveScan(cursor);
- }
- };
-
- return await recursiveScan();
- }
-
- jsonGet(key) {
- return this.redis.json_get(key);
- }
-
- jsonSet(key, path, json) {
- return this.redis.json_set(key, path, json);
- }
-
- hgetall(key) {
- return this.redis.hgetall(key);
- }
-
- hset(hash, key, value) {
- return this.redis.hset(hash, key, value);
- }
-
- hget(hash, key) {
- return this.redis.hget(hash, key);
- }
-
- hdel(hash, key) {
- return this.redis.hdel(hash, key);
- }
-
- hincrby(hash, key, incr) {
- return this.redis.hincrby(hash, key, incr);
- }
-
- del(key) {
- return this.redis.del(key);
- }
-}
-
-module.exports = RedisClient;
-```
-
-#### How does the overall process work?
-
-The process flow is fairly straightforward. Once a request is sent to an endpoint on this shopping cart application e.g http://localhost:8081/. It first hits the router for that endpoint and then if it is a public endpoint such as this one it goes to the controller that handles that. As an analogy, the controller is just like a manager, while the service is the worker. A controller manages the incoming work HTTP requests whereas services receives the request data it needs from the manager in order to perform its tasks
-
-Next, we create routes for a cart in a module named cart.js. The code first imports the Express application object, uses it to get a Router object and then adds a couple of routes to it using the get() method. Last of all the module returns the Router object.
-
-First let us define the product model to our controllers/Product/IndexController.js file(https://github.com/redis-developer/basic-redis-shopping-chart-nodejs/tree/main/server/src/controllers/Product):
-
-Our product model will be basic as possible as it holds the product name, price and image.
-
-```
-{
- "products": [
- {
- "id": "e182115a-63d2-42ce-8fe0-5f696ecdfba6",
- "name": "Brilliant Watch",
- "price": "250.00",
- "stock": 2
- },
- {
- "id": "f9a6d214-1c38-47ab-a61c-c99a59438b12",
- "name": "Old fashion cellphone",
- "price": "24.00",
- "stock": 2
- },
- {
- "id": "1f1321bb-0542-45d0-9601-2a3d007d5842",
- "name": "Modern iPhone",
- "price": "1000.00",
- "stock": 2
- },
- {
- "id": "f5384efc-eadb-4d7b-a131-36516269c218",
- "name": "Beautiful Sunglasses",
- "price": "12.00",
- "stock": 2
- },
- {
- "id": "6d6ca89d-fbc2-4fc2-93d0-6ee46ae97345",
- "name": "Stylish Cup",
- "price": "8.00",
- "stock": 2
- },
- {
- "id": "efe0c7a3-9835-4dfb-87e1-575b7d06701a",
- "name": "Herb caps",
- "price": "12.00",
- "stock": 2
- },
- {
- "id": "x341115a-63d2-42ce-8fe0-5f696ecdfca6",
- "name": "Audiophile Headphones",
- "price": "550.00",
- "stock": 2
- },
- {
- "id": "42860491-9f15-43d4-adeb-0db2cc99174a",
- "name": "Digital Camera",
- "price": "225.00",
- "stock": 2
- },
- {
- "id": "63a3c635-4505-4588-8457-ed04fbb76511",
- "name": "Empty Bluray Disc",
- "price": "5.00",
- "stock": 2
- },
- {
- "id": "97a19842-db31-4537-9241-5053d7c96239",
- "name": "256BG Pendrive",
- "price": "60.00",
- "stock": 2
- }
- ]
-}
-```
-
-#### Testing the Server
-
-Copy `.env.example` to `.env` file and set environment variables as shown below:
-
-```
-REDIS_PORT=6379
-REDIS_HOST=127.0.0.1
-REDIS_PASSWORD=demo
-
-COMPOSE_PROJECT_NAME=redis-shopping-cart
-```
-
-:::info
-
-In case you’re using Redis Enterprise Cloud instead of localhost, then you need to enter the database endpoint under REDIS_HOST (without port) while rest of the entries like REDIS_PORT and REDIS_PASSWORD are quite obvious
-
-:::
-
-#### Installing the dependencies
-
-```
-$ npm install
-```
-
-#### Testing the Routes
-
-After adding this, you can run your application by typing npm install in your terminal. Once you run this command, it will return Application is running on 3000.
-
-```
-$ npm run dev
-```
-
-```
-$ npm run dev
-
-> redis-shopping-cart-backend@1.0.0 dev
-> nodemon src/index.js
-
-[nodemon] 2.0.7
-[nodemon] to restart at any time, enter `rs`
-[nodemon] watching path(s): *.*
-[nodemon] watching extensions: js,mjs,json
-[nodemon] starting `node src/index.js`
-App listening on port 3000
-```
-
-### Setting up the frontend web Client using Vue.js
-
-Now that we have the application’s backend running, let us begin developing its frontend. We will be leveraging Vue.js - a robust but simple JavaScript framework for building our frontend web client. It has one of the lowest barriers to entry of any modern framework while providing all the required features for high performance web applications.
-
-```
-.
-├── README.md
-├── babel.config.js
-├── node_modules
-├── package-lock.json
-├── package.json
-├── public
-├── src
-└── vue.config.js
-```
-
-The files at the root level (babel.config.js, package.json, node_modules) are used to configure the project.
-The most interesting part, at least for now, is located in the src directory(directory structure is shown below):
-
-The main.js file is the main JavaScript file of the application, which will load all common elements and call the App.vue main screen.
-The App.vue is a file that contains in the HTML, CSS, and JavaScript for a specific page or template. As an entry point for the application, this part is shared by all screens by default, so it is a good place to write the notification-client piece in this file.
-The public/index.html is the static entry point from where the DOM will be loaded.
-
-#### Directory Structure:
-
-```
-% tree
-.
-├── App.vue
-├── assets
-│ ├── RedisLabs_Illustration.svg
-│ └── products
-│ ├── 1f1321bb-0542-45d0-9601-2a3d007d5842.jpg
-│ ├── 42860491-9f15-43d4-adeb-0db2cc99174a.jpg
-│ ├── 63a3c635-4505-4588-8457-ed04fbb76511.jpg
-│ ├── 6d6ca89d-fbc2-4fc2-93d0-6ee46ae97345.jpg
-│ ├── 97a19842-db31-4537-9241-5053d7c96239.jpg
-│ ├── e182115a-63d2-42ce-8fe0-5f696ecdfba6.jpg
-│ ├── efe0c7a3-9835-4dfb-87e1-575b7d06701a.jpg
-│ ├── f5384efc-eadb-4d7b-a131-36516269c218.jpg
-│ ├── f9a6d214-1c38-47ab-a61c-c99a59438b12.jpg
-│ └── x341115a-63d2-42ce-8fe0-5f696ecdfca6.jpg
-├── components
-│ ├── Cart.vue
-│ ├── CartItem.vue
-│ ├── CartList.vue
-│ ├── Info.vue
-│ ├── Product.vue
-│ ├── ProductList.vue
-│ └── ResetDataBtn.vue
-├── config
-│ └── index.js
-├── main.js
-├── plugins
-│ ├── axios.js
-│ └── vuetify.js
-├── store
-│ ├── index.js
-│ └── modules
-│ ├── cart.js
-│ └── products.js
-└── styles
- └── styles.scss
-
-8 directories, 27 files
-```
-
-In the client directory, under the subdirectory src, open the file App.vue. You will see the below content:
-
-```
-
-
-
-