Now that we've got Django installed - we can CRUD! For this activity, we want to get comfortable interacting with our database three different ways:

1. Directly interacting with sqlite
2. Via the django shell
3. Via the Django admin interface

Follow these steps to practice each of these:

1. First - take a look at the admin interface. After running the migrations and creating your superuser account, navigate to http://0.0.0.0:8000/admin/ and login with your superuser account. There are a lot of tables here for you to explore, but the simplest one that we'll focus on for now is called Posts all the way at the bottom. When you click on Posts, use the button at the top-right to Add Post. Note that the "owner" field is a dropdown that is pre-populated with only one option - your admin account.
2. Next, explore sqlite. In a new Terminal window, run this command to open sqlite:
   sqlite3 db.sqlite3 In the prompt that opens, run these commands to inspect the posts table:

           sqlite> .headers on
           sqlite> .mode markdown
           sqlite> SELECT * from well_post;
               

   You should be able to see your post there! If you like, practice writing simple INSERT and DELETE queries here to directly manipulate the data in this table, and refresh the admin interface to see your changes.
3. In a third terminal window, start the Django shell with this command: python3 manage.py shell From there, practice creating and saving posts, like this:

           >>> from well.models import Post
           >>> p = Post(title="asf",text="asf",owner_id=1)
           >>> p.save()
                   

   (1 is the id of your superuser account) Then compare with the sqlite interface and the admin interface to see your new post.
4. Blow it all up and start over! Run this command at the terminal: rm db.sqlite3 Then re-run the migrations, re-create your superuser, and do it all again! Practice this a few times until you're sure you're comfortable with each of these steps.

1. Watch Dr. Chuck's 7 minute video lecture, Model View Controller in Django in Lesson 9: Understanding Model View Controller (MVC).
2. Read Christopher Yong's blog post MVC pattern in Django.
3. Prepare a one 8 1/2 by 11 inch page of notes (front and back), which you could use on any quiz that might happen at the beginning of class on Tuesday. NOTE: BE SURE TO HAVE YOUR SHEET OF PAPER WITH YOU WHEN YOU COME TO CLASS!

We will begin class today with the promised quiz based on the study questions from your last homework. There are 14 possible points, and your grade will be derived by taking your total points divided by 12 and then mapping that to a letter grade using the standard A: score >= 90, B: 90 > score >= 80 etc.).

After the quiz we will install and configure the dj4e_samples repo that we will use to learn Django.

Do each of the following:

1. Clone the dj4e_samples repo into a suitable place on your development machine.
2. Add .venv to your .gitignore in preperation for setting up a virtual environment. A good .gitignore for our purposes here should include at least the following:

   *.swp
   __pycache__
   *.sqlite3
   *.db
   .DS_Store
   *.pyc
   .venv
   

3. Create your virtual environment inside your project directory by running:

   % python3 -m venv .venv
   

4. Activate it with:

   % source .venv/bin/activate
   

5. Now install all the Django modules we will need with:

   (.venv) % pip3 install -r requirements.txt
   

6. Finally, launch the Django webserver with:

   (.venv) % python manage.py runserver 0.0.0.0:8000 
   

   and point your browser at it.

At this point you should see a message in your terminal containing:

You have 61 unapplied migration(s). Your project may not work properly until you apply the migrations for app(s): admin, auth, autos, bookmany, bookone, cats, chat, contenttypes, favs, favsql, form, forums, gview, many, myarts, pics, rest, sessions, social_django, taggit, tagme, tracks, users, well. Run 'python manage.py migrate' to apply them.

After you last homework, you should know what this is about!

With the time remaining in our short class today, we will begin looking at what this application offers us and discuss what we will do with our homework time.

We ran out of time as we were introducing this activity, so we've copied it to the classwork section for Friday.

6 of the 9 of you have completed your NVCC course evaluation. The 3 of you who have yet to do this should do it now at the beginning of class.

Today we will begin looking at the big picture of the Django web appliation framework:

using Dr. Chuck's mini_django.

Watch the Django Data Models video from Lesson 8: Django Data Models, taking notes in a markdown file in your git repo.

You will have a quiz at the beginning of class on Wednesday. You can use one 8 1/2 by 11 inch sheet of paper, front and back, for notes that you can use during the quiz.

As you watch the videos, prepare to answer the following questions ( answers to these would be the best thing to put in your notes - hint, hint! ):

1. Dr. Chuck makes a statement about the learning curve for SQL. What exactly does he say?
2. In your own words, how would you define Object-relational mapping (ORM)? How will we use it in Django and what specifically will it do?
3. What does Dr. Chuck say are the advantages of the ORM? What disadvantages (if any) does it have?
4. Dr. Chucks that most (he mentions a percentage) of the things you want to do with SQL can be done effectively with an ORM. What exactly does he say?
5. What is the name of the file in which the ORM data objects are defined?
6. In the example of an ORM object:

   class User(models.Model):
       name = models.CharField(max_length=128)
       email = models.CharField(max_length=128)
   

   Dr. Chuck draws a line to models.Model and mentions what that is. What does he say? Of which OOP feature is this an example?
7. What two commands do you need to run to go from an ORM to deployment in a database?
8. What does running python3 manage.py shell do? Be specific!
9. In the example session Dr. Chuck talks about, he creates a new user named Kristen with email address kf@umich.edu. Where is this user created when:

   u = User(name='Kristen', email='kf@umich.edu')
   

   is run? What command needs to be used to add this new user to the database?