Merge pull request #21 from mongodb-developer/edit-mapping-rules

Edit mapping rules

Author: dfreniche

docs/20-prerequisites/10-postgres.mdx

@@ -6,31 +6,31 @@ import useBaseUrl from '@docusaurus/useBaseUrl';
 
 # 👐 PostgreSQL Database
 
-In this lab you will be migrating data from a PostgreSQL relational database. You have a few options to set up this database. __Choose one option for your PostgreSQL database__.
+In this lab you will be migrating data from a PostgreSQL relational database. You have a few options to set up this database. __Choose just one option for your PostgreSQL database__.
 
 ## 👐 Option 1: Use a pre-configured database
 
 If you are participating in an instructor-led lab, they may have already set up this database for you. Ask your instructor for the connection URI and credentials.
 
 :::info
-In an intructor-led lab you will use the provisioned PostgreSQL database, no need to do anything else
+In an intructor-led lab you will use the provisioned PostgreSQL database, no need to do anything else.
 :::
 
 ## 🦸 Option 2: Load the schema and data into your own PostgreSQL server
 
 If you already have a PostgreSQL server set up, you can import the schema and data used in this lab. Download the file 
 [1-library-schema-and-data.sql](https://github.com/mongodb-developer/relational-migrator-lab/blob/main/docker/sample-postgres-library/init/1-library-schema-and-data.sql)
-file and load it using psql or [pgAdmin](https://www.pgadmin.org/download/).
+ and load it using [psql](https://www.postgresql.org/docs/10/app-psql.html) or [pgAdmin](https://www.pgadmin.org/download/).
 
 ## 🦸 Option 3: Run a PostgreSQL container using Docker
 
 If you don't have an existing PostgreSQL server but have Docker installed, you can easily load a container pre-configured with 
 PostgreSQL and the sample database:
 
 1. Clone or download the code from this lab's [Github repo](https://github.com/mongodb-developer/relational-migrator-lab).
-2. Open a terminal window and navigate to the repo root
+2. Open a terminal window and navigate to the repo root.
 3. Build the Docker image by running the command: 
-```
+```sh
 docker build -f ./docker/sample-postgres-library/Dockerfile -t sample-postgres-library .
 ```
 4. Start the Docker container by running the command:
@@ -40,8 +40,8 @@ docker run -p 5432:5432 sample-postgres-library
 The PostgreSQL server can be accessed at localhost:5432 with a username of `postgres` and a password of `postgres`.
 
 ## 🦸 Option 4: Load an SQL file
-Choose this option if you just want a quick hands-on experience and you don't need to run actual migration.
+Choose this option if you just want a quick hands-on experience and you don't need to run an actual migration.
 Download the file [library-schema.sql](https://github.com/mongodb-developer/relational-migrator-lab/blob/main/resource/library-schema.sql)
-and upload this file to the Relational Migrator later, at the **create a project** step. 
+and upload this file to the Relational Migrator later, at the [create a project](/docs/category/-create-a-project) step. 
 
 This is just the schema of the database, without actual data, so, you will not be able to perform an actual migration since you do not have a source database. But you can model the schema and play around with the Relational Migrator.

docs/220-Generate code/10-generate-app-code.mdx renamed to docs/210-Generate code/10-generate-app-code.mdx

@@ -2,16 +2,16 @@ import Screenshot from "@site/src/components/Screenshot";
 
 # 👐 Generate app code
 
-Relational Migrator allows you to generate application code in a variety of languges, dervied from your MongoDB schema definition.
-While this code is not production-ready, it can save developers significant time compared to creating entity classes by hand. 
+The Relational Migrator allows you to generate application code in a variety of languages, derived from your MongoDB schema definition.
+While this code is not a full-blown app, it can save developers significant time compared to creating entity classes by hand. 
 
 - At the top, switch to Code Generation tab
-- Under Language, select `C#`
+- Under Language, select `C#` (or your preferred language)
 - Under Template, select `Persistence Layer`
 - Click each of the collections in the list. Notice the tabs containing entity classes and CRUD helpers for each collection or embedded object.
 - Under Language, select `JSON'
 - Under Template, select `Sample Documents`. Notice how you can view examples of how data in each collection will be structured.
-- Under Template, select `JSON Schema (MongoDB)`. Notice how you can view and download JSON Schema validators which could be used to enforce schema compliance.
+- Under Template, select `JSON Schema (MongoDB)`. Notice how you can view and download JSON [Schema validators](https://mongodb-developer.github.io/intro-lab/docs/category/schema-validation) which could be used to enforce schema compliance.
 
-<Screenshot url="https://www.mongodb.com/products/tools/relational-migrator" src="img/generate-app-code.png" alt="Screenshot of the connect modal" />
+<Screenshot url="http://127.0.0.1:8278" src="img/generate-app-code.png" alt="Code generation tab" />
 

docs/220-Generate code/20-convert-queries.mdx renamed to docs/210-Generate code/20-convert-queries.mdx

@@ -3,17 +3,17 @@ import Screenshot from "@site/src/components/Screenshot";
 # 👐 Convert SQL queries
 
 Relational Migrator can help convert SQL queries to MongoDB Query Language, wrapped 
-in your choice of programming langauge. This feature uses Artifical Intelligence and requires an Atlas account and internet connectivity.
+in your choice of programming langauge. This feature uses Artifical Intelligence and requires an <Link to="http://mongodb.com/try">Atlas account</Link> and internet connectivity.
 
 - At the top, switch to Code Generation tab
 - Click Query Converter
-- Sign into with your MongoDB Atlas account
+- Sign into your MongoDB Atlas account
 - Accept the Query Converter licence terms
 - Click `Paste SQL query`
 - In the empty query, type `SELECT * FROM books WHERE "bookOfTheMonth" = true AND pages > 500` 
 - Leave the language as JavaScript and click Convert. 
 
 After a while, the equivalent MongoDB query will be shown at the right of the page. 
 
-<Screenshot url="https://www.mongodb.com/products/tools/relational-migrator" src="img/convert-sql-queries.png" alt="Screenshot of the connect modal" />
+<Screenshot url="http://127.0.0.1:8278" src="img/convert-sql-queries.png" alt="Screenshot of the connect modal" />
 

docs/220-Generate code/30-convert-sprocs.mdx renamed to docs/210-Generate code/30-convert-sprocs.mdx

@@ -5,14 +5,13 @@ import Screenshot from "@site/src/components/Screenshot";
 Relational Migrator can import and convert views and stored procedures to MongoDB Query Language, wrapped 
 in your choice of programming langauge. This feature uses Artifical Intelligence and requires an Atlas account and internet connectivity.
 
-- If needed, open Query Converter and sign in with your Atlas account
-- Click Manage database objects
-- Enter the details for your PostgreSQL server and click Connect
-- Check all discovered Views and Stored Procedures and click Save
+- If needed, open Query Converter and sign in with your Atlas account.
+- Click on the `Add` button, the `Import from database`.
+- Check all Views and Stored Procedures and click `Save`.
 - Click one of the imported views or stored procedures
 - Select your preferred programming language and click Convert. 
 
 After a while, the equivalent MongoDB query will be shown at the right of the page. Try some other queries and langauges!
 
-<Screenshot url="https://www.mongodb.com/products/tools/relational-migrator" src="img/convert-sprocs.png" alt="Screenshot of the connect modal" />
+<Screenshot url="http://127.0.0.1:8278" src="img/convert-sprocs.png" alt="Screenshot of the connect modal" />
 

docs/220-Generate code/40-testing-queries.mdx renamed to docs/210-Generate code/40-testing-queries.mdx

@@ -13,26 +13,26 @@ Relation Migrator allows you to go a step further, and verify the converted quer
 2. If you source data resides in the `public` schema in your PostgreSQL database, you may skip this step. Otherwise, you will need to add your source data schema into PostgreSQL's search path in order for the queries execute properly.
 
     Go to **Manage Connections**:
-    <Screenshot url="https://www.mongodb.com/products/tools/relational-migrator" src="img/testing-queries-001.png" alt="Screenshot to manage connection" />
+    <Screenshot url="http://127.0.0.1:8278" src="img/testing-queries-001.png" alt="Screenshot to manage connection" />
 
     Edit your **JDBC URI** to include the search path. For example, if your source schema is `library`, add `options=-c%20search_path%3Dlibrary` as a query parameter to your URI:
 
-    <Screenshot url="https://www.mongodb.com/products/tools/relational-migrator" src="img/testing-queries-002.png" alt="Screenshot to add search path" />
+    <Screenshot url="http://127.0.0.1:8278" src="img/testing-queries-002.png" alt="Screenshot to add search path" />
 
     Click **Save** and you can use the browser's **back button** to navigate back to the Query Converter page. 
 
 3. After which, you may expand the test query panel to begin executing your source query or converted query.
 
-    <Screenshot url="https://www.mongodb.com/products/tools/relational-migrator" src="img/testing-queries-003.png" alt="Screenshot to expand query test panel" />
+    <Screenshot url="http://127.0.0.1:8278" src="img/testing-queries-003.png" alt="Screenshot to expand query test panel" />
 
 ## Executing queries for comparison
 
 1. Select the source query you want to test on the left pane. As an example, we will select the `get_books_by_genre` stored procedure.
 2. Convert the query to a MongoDB query if you have not done so, but note that the converted query may not always be correct.
 3. If it is a stored procedure, you will need to replace the placeholder parameter with a test value. In this example, we will replace it with `'Literature'`.
-    <Screenshot url="https://www.mongodb.com/products/tools/relational-migrator" src="img/testing-queries-004.png" alt="Screenshot to show placeholder replacement" />
+    <Screenshot url="http://127.0.0.1:8278" src="img/testing-queries-004.png" alt="Screenshot to show placeholder replacement" />
 4. Click **RUN SOURCE QUERY** and **RUN CONVERTED QUERY** to execute the queries and  compare the results.
-    <Screenshot url="https://www.mongodb.com/products/tools/relational-migrator" src="img/testing-queries-005.png" alt="Screenshot to show result comparison" />
+    <Screenshot url="http://127.0.0.1:8278" src="img/testing-queries-005.png" alt="Screenshot to show result comparison" />
 5. If the query results are different, check your MongoDB query. In this example, your MongoDB query should look like:
     ```js
         async function get_books_by_genre(db, genre_param) {

docs/210-Migrate Data/10-migration.mdx

@@ -0,0 +1,30 @@
+import Screenshot from "@site/src/components/Screenshot";
+
+# 👐 Run a Snapshot Migration Job
+
+- At the top, switch to Data Migration tab
+
+<Screenshot url="http://127.0.0.1:8278" src="img/210-image-001.png" alt="Screenshot of the connect modal" />
+
+- Click create sync job
+- Specify source DB connection details
+  - The details will be populated from when you created the project. 
+
+<Screenshot url="http://127.0.0.1:8278" src="img/210-image-002.png" alt="Screenshot of the connect modal" />
+
+- Specify MongoDB connection details
+  - Enter the URI, database, username and password for your MongoDB cluster
+  - If you are using Atlas, you can retrieve the details from the [Atlas portal](https://cloud.mongodb.com)
+
+<Screenshot url="http://127.0.0.1:8278" src="img/210-image-003.png" alt="Screenshot of the connect modal" />
+
+- Specify migration options 
+  - Choose the `Drop destination collections before migration` option
+
+<Screenshot url="http://127.0.0.1:8278" src="img/210-image-004.png" alt="Screenshot of the connect modal" />
+
+- Read migration summary to confirm details
+- Run Start
+- Monitor the progress of the job
+
+<Screenshot url="http://127.0.0.1:8278" src="img/210-image-005.png" alt="Screenshot of the connect modal" />

docs/220-Migrate Data/10-migration.mdx

@@ -11,4 +11,4 @@ MongoDB Compass, or MongoDB Atlas. This topic assumes you have migrated your dat
 - Select the database you migrated data to
 - Select each of the collections and view the documents, confirming they conform to the schema you created.
 
-<Screenshot url="https://www.mongodb.com/products/tools/relational-migrator" src="img/view-migrated-data-atlas.png" alt="Screenshot of the connect modal" />
+<Screenshot url="http://127.0.0.1:8278" src="img/view-migrated-data-atlas.png" alt="Screenshot of the connect modal" />

docs/210-Migrate Data/20-view-migrated-data.mdx renamed to docs/220-Migrate Data/20-view-migrated-data.mdx

@@ -2,7 +2,7 @@ import Screenshot from "@site/src/components/Screenshot";
 
 # 📘 Schema in PostgreSQL
 
-The following screenshot shows an entity-relationship diagram of the relational database we wish to migrate. This is a library management app that stores information about books, where a book can have many authors, an author can write many books, and users can borrow books and leave reviews. You can have many copies of the same book (issue_details) and those are what users borrow and return. A library user can have many addresses.
+The following screenshot shows an entity-relationship diagram of the relational database we wish to migrate. This is a library management app that stores information about books, where a book can have many authors, an author can write many books, and users can borrow books and leave reviews. You can have many copies of the same book and those are what users borrow and return. All this is registered in the `operations` collection. A library user can have many addresses.
 
 This is the sample schema we use during our [Developer Days's Intro Lab](https://mongodb-developer.github.io/intro-lab/docs/importing-data/intro).