iOS client

Basically, as we’re constructing our dictionary, our key is flowDates. We use an array of strings as our value.

Server side

The json packet comes to our server via the request object.

In the request object’s body, we use key flowDates to get the array of strings passed in from the iOS client. We loop through this flowDates array to get the strings.

While we loop, we create a temp object called flowDay with keys startDate and endDate, and enter the strings from the array flowDates as their value.

Then we push that object onto an empty array.

Finally, we use that array to create a new user:

Server side code

Authentication – POST for /api/authenticate using parameters ‘name’ and ‘password’

Here’s we authenticate by giving the server a name and password. If the name and password match the ones stored in the database, then we return it a token for the iOS client to use. Whenever that the iOS client needs to access a protected URL, we use that token.

Server side

/config.js

First notice that in the beginning of the file, we use set to have
superSecret name as an application setting name.

/server.js

We set the key ‘superSecret’ to match config.secret which is ‘ilovescotchyscotch’ in /config.js

Later we will use jwt’s sign function on this string along with the user object in order to create a token for the iOS client to use.

We use express’s router function to get variable apiRoutes. We prefix all routes with ‘/api’.

Then for POST on url /authenticate, we use mongoose’s model User to find if the user exist. If it does, it will then run the async method to see if the passwords match.

If the passwords match, then we use jwt’s sign function to return a token for the user to use. We wrap that token along with other string info in a json object and return it via the response object.

iOS client

We create NSDictionary with name and password key. Then we encode it into a NSString.

Notice we then call the URL ‘http://192.168.1.102:8080/api/authenticate’ with POST, and the json string in the body of the request.

After we POST this request, our server will hit the apiRoutes.post(‘/authenticate’, function(req, res) {…}) function, which uses jwt.sign(user, app.get(‘superSecret’)) to return a token for this particular user.

It returns:

res.json({
success: true,
message: ‘Enjoy your token!’,
token: token
});

Hence the server code, we see that the returned json object has 3 keys:
success, message, and token. Use the value from key token in order to authenticate yourself when doing updates and other restricted activities.

Using Token to authenticate itself and access protected URLs

Reading list of users using approved authentication

Now that we have the authentication, we need to use it to read protected data

In your server.js, put this code to protect your URLs:

So that when you hit

http://localhost:8080/api/users

You’ll get:

{“success”:false,”message”:”No token provided.”}

So as you can see a client that does not provide the correct token and user name cannot access that what http://localhost:8080/api/users has to offer.

Thus, we access it by using the token received earlier when we authenticated with our user name and password. We set the token and our username into the header of the request packet.

AppDelegate.m

As you can see, once you log in, use the token string to get info.

GetInfoConnection.h

GetInfoConnection.m

Notice how we set the request’s header with the user name and token value in the method getUserInfo.

These values are then sent to the server where they get processed by apiRoutes.use(function(req, res, next) {…}), which uses jwt.verify to verify if this username and token is valid.

Then the server passes it onto the next middleware layer, namely, apiRoutes.get(‘/users’, function(req, res) {…}) to have the database retrieve the valid user.

Full server code

iOS client

Basically keep in mind that when you want to hit a local node js server, the address on the network from the iOS cient’s pov is 192.168.1.102.

You go to System Preferences > Wi-Fi (or Ethernet, or whatever you use to get internet connection ). Then on the right hand side, the status should say ‘connected’ and you’ll see something like “Wi-Fi is connected to TP-LINK_3DF056 and has the IP address 192.168.1.102.”

192.168.1.102 is the network address of the computer that’s running the node js server. Hence when iOS clients look for the server, they will need to hit that address.

We are simply trying to hit a url using GET, and expect json data back.

GET for /

Notice that we use “message” as the key for our json data because in our node code, we are returning a json object using the key “message”.

Node server

POST /setup with parameters ‘name’ and ‘password’

iOS client side

So we use NSDictionary to create dictionary object with keys name and password.
Then, we encode it into a NSUTF8StringEncoding string.

We then use that dictionary string and set it as Http body using setHTTPBody for the request object. We also set our http method to POST using setHTTPMethod on the request object.

Node server side

Checking mongo db via terminal

Open your terminal and type in

mongo

2015-07-05T22:05:14.298+0800 I CONTROL [initandlisten] ** WARNING: soft rlimits too low. Number of files is 256, should be at least 1000
> show dbs
PersonDatabase 0.078GB
local 0.078GB
> use PersonDatabase;
switched to db PersonDatabase
> db.user.count()
3
> db.user.find()

the result is that Shirley Qian has been inserted:

{ “_id” : ObjectId(“55973f3702e8b0094967b544”), “name” : “rtsao”, “password” : “compaq”, “admin” : true, “__v” : 0 }
{ “_id” : ObjectId(“55977f4b06112d75860f9af6”), “name” : “rtsao6680”, “password” : “abcde12345”, “admin” : true, “__v” : 0 }
{ “_id” : ObjectId(“5599cc4ec1fa2c05496b5c34”), “name” : “Shirley Qian”, “password” : “12345678”, “admin” : true, “__v” : 0 }
>

Full server code