{
  type: 'email' | 'slack' | 'linkedin' | 'facebook' | 'twitter' | 'github' | 'website',
  id: string
][]

minimum: 1
maximum: 3

Each one of them should be validating (as much as we can) following this table:
https://github.com/Coding-Coach/find-a-mentor#channels

I added my own test template id in this PR and forgot to change it back to the correct template id that was created here #85

Is your feature request related to a problem? Please describe.
We currently lack visibility into errors that occur on our site and rely on the goodwill of others to report these errors. There are tools on the market that will automatically capture errors while providing enhanced workflows for resolving the bugs. My favorite among these tools is Sentry.io; I've been using them for years with great success.

Sentry offers open-source sponsorship and has accepted our request for sponsorship because they. are. awesome.

The only thing left to do is actually install and configure their tool.

If anyone has suggestions to offer, or questions before Sentry is installed please comment below.

We need to create a script to pull the data from mentors.json and save to the DB.

Additionally, when a new user registers, we need to find out if this new user is an existing mentor and link the new account to the profile.

We need to return all lists for the given user.

Request:

GET /users/{user._id}/lists

Response:

{
  success: true,
  lists: [
    { _id: 123, public: false, name: "QA Mentors", mentors: [{_id: 123, name: "John Doe", avatar: "..."}] },
    { _id: 456, public: true, name: "Designers", mentors: [] },
  ]
}

Restrictions

• Members can only get their own private lists
• Only admins can get other user's private list
• Other members can see public lists from other users

We need support for CORS, currently @moshfeu had to create a proxy in order to access the API deployed at api.codingcoach.io

We are going to deploy a development API frontend devs can use in their local environments, so they don't have to install the backend in their local.

I think we should use an environment variable to set the origin value, in development we will have origin=* but when going to production origin=codingcoach.io

Here's are some links on how enable CORS in nestjs
https://docs.nestjs.com/techniques/security#cors
https://github.com/expressjs/cors#configuration-options

Now that we have the pagination in place, we need to return the total amount of mentor that match the given filters, this is needed in the client to find out if there's a need to load more records or not.

The proposed response looks like this:

{
  success: true,
  "pagination": {
      "total": 281,
      "page": 15,
      "perpage": 20,
      "hasMore": false
  },
  filters: { ... },
  data: [ .... ]
}

We want to allow users to create a list of favorite mentors. We need to create a new endpoint to add or remove a single mentor from this list, and if this list doesn't exist yet, we need to automatically create it.

Request

POST /users/{user._id}/favorites/{mentor._id}

Response

{ success: true }

When calling the endpoint, if the user doesn't exist in the list we need to add it, if the user exist in the list we need to remove it.

Validations

• Make sure mentor exist
• only admins can add favorites to different users
• only admins can remove favorites to different users

Currently we are returning the whole list of mentors, we need to add pagination to return the results by the given page.

This is where we are getting the list of mentors:
https://github.com/Coding-Coach/find-a-mentor-api/blob/master/src/modules/mentors/mentors.controller.ts#L24

Per this TODO It would appear we need to delete the channels from the mentors payload for unauthenticated users.

Can you confirm that this is accurate @crysfel?

Describe the bug
As a mentor is possible to enter an email address is too long (254+ chars)
Also there is an arbitrary limits of 50-100 chars?

Expected behavior
RFC5321 specifies an email address can't exceed 254 chars.
However, there is 71-char limit:
jan@abcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcde0123456789abc.com

reports no client side validation message, only:

Also: the channel-email field takes a longer email address, I did not test its limits, but it appears to work fine.

It'd be great if we use docker to run the project :)

We need to generate a slug for all users in the database (and all new users), we are going to use it to create links in the FE for their profile pages.

• This task requires to update the user schema and add a new slug field, it should be unique and indexed in the database.
• When a new user is created we need to generate a new slug for the new user
• Update all user endpoints to find the user by slug or _id
• Create a script to assign a slug to the current user in the database

We need to store the favorite mentors by the current user, for this we need:

An endpoint to get all favorite mentors for the current user

GET /mentors/favorites

An endpoint to like or dislike a mentor. If the mentor is not a favorite, then it will become a favorite mentor. If is already in favorites, the it will be removed from the list.

POST /mentors/favorites/{mentor_id}

We want to allow users to update the name and public field from existing lists. We need a new endpoint that receives these values, validates and update the records in the database

Request

PUT /users/{user._id}/lists/{list._id}

{
  "name": "Updating title",
  "public": true
}

Response

{ "success": true  }

Restrictions

• Other users can't update other people's lists
• Admin can update other people's lists
• Users can't update the favorite list, this list should always be private. There's a isFavorite flag in the DB

Validations

• name is required

We want to let the user to know that we deleted them.

Something like

if (res.ok && current.roles.includes(Role.ADMIN)) {
  const emailData = {
    to: user.email,
    templateId: Template.USER_DELETED,
    dynamic_template_data: {
      reason: params.reason,
    },
  };

  this.emailService.send(emailData);
}

I'll create the template in SendGrid
Template Id: de2e0c5217b6422a88274a6affd327e7

Relates to: Coding-Coach/find-a-mentor#628

Right now, if a User is updated with anything that fails validation at the DB level, the API returns a 500 with a generic response. It would be much better if a 400 was returned with a specific error message so it's easier to figure out what went wrong.

There's an error while deleting the user from mongo:

0|CodingCo | [Nest] 31013   - 08/07/2019, 6:41 PM   [ExceptionsHandler] Cast to ObjectId failed for value "auth0|123456789abc" at path "_id" for model "User" +927906ms
0|CodingCo | CastError: Cast to ObjectId failed for value "auth0|123456789abc" at path "_id" for model "User"
0|CodingCo |     at new CastError (/var/www/api.codingcoach.com/staging/releases/19/node_modules/mongoose/lib/error/cast.js:29:11)
0|CodingCo |     at ObjectId.cast (/var/www/api.codingcoach.com/staging/releases/19/node_modules/mongoose/lib/schema/objectid.js:242:11)
0|CodingCo |     at ObjectId.SchemaType.applySetters (/var/www/api.codingcoach.com/staging/releases/19/node_modules/mongoose/lib/schematype.js:892:12)
0|CodingCo |     at ObjectId.SchemaType._castForQuery (/var/www/api.codingcoach.com/staging/releases/19/node_modules/mongoose/lib/schematype.js:1304:15)
0|CodingCo |     at ObjectId.SchemaType.castForQuery (/var/www/api.codingcoach.com/staging/releases/19/node_modules/mongoose/lib/schematype.js:1294:15)
0|CodingCo |     at ObjectId.SchemaType.castForQueryWrapper (/var/www/api.codingcoach.com/staging/releases/19/node_modules/mongoose/lib/schematype.js:1273:15)
0|CodingCo |     at cast (/var/www/api.codingcoach.com/staging/releases/19/node_modules/mongoose/lib/cast.js:307:32)
0|CodingCo |     at model.Query.Query.cast (/var/www/api.codingcoach.com/staging/releases/19/node_modules/mongoose/lib/query.js:4528:12)
0|CodingCo |     at model.Query.Query._castConditions (/var/www/api.codingcoach.com/staging/releases/19/node_modules/mongoose/lib/query.js:1762:10)
0|CodingCo |     at model.Query.<anonymous> (/var/www/api.codingcoach.com/staging/releases/19/node_modules/mongoose/lib/query.js:2015:8)
0|CodingCo |     at model.Query._wrappedThunk [as _findOne] (/var/www/api.codingcoach.com/staging/releases/19/node_modules/mongoose/lib/helpers/query/wrapThunk.js:16:8)
0|CodingCo |     at process.nextTick (/var/www/api.codingcoach.com/staging/releases/19/node_modules/kareem/index.js:369:33)
0|CodingCo |     at process._tickCallback (internal/process/next_tick.js:61:11)

Based on the error all we need to do is fix the casting.

When a new member signs up as a mentor, we need to send an email right after the user submitted the application. Informing them we will review their application shortly.

Once the admin accepts a mentor request, we need to send an email to the new mentor with a confirmation/welcome message.

If the admin rejects the application, we need to send another email notifying the user the application has been rejected, we need to include the reason why the admin rejected the application.

In an effort to increase confidence when updating our codebase, or adding a new feature. We want to increase the test coverage with unit test.

The goal of this issue is to write unit tests for the MentorsController, when writing tests keep the following guidelines in mind:

• We are testing each method in its own, meaning we need to mock all service dependencies and test calls to services when it makes sense.
• Group all tests for a single method together:

describe('modules/mentors/MentorController', () => {
  describe('index', () => {
    it('should return all mentors', () => expect(true).toBe(true));
  });

  describe('featured', () => {
    it('should return a single mentor', () => expect(true).toBe(true));
  });

  describe('applications', () => {
    it('should throw an error if current user is not admin', () => expect(true).toBe(true));

    it('should return all applications', () => expect(true).toBe(true));

    it('should return applications by the given status', () => expect(true).toBe(true));

   // etc...
  });

  // etc...
});

• Test
• Lint
• Build
• Deploy

Currently it's not possible to view the swagger docs without running the BE which comes with its own config requirements and dependencies. It would be ideal to see the swagger docs on an established environment.

We need to remove the user from auth0 when the users delete their accounts in the platform, right now the user still exist in auth0 😅

Background

We want to keep all mentors in a marketing list so we can communicate through email easily, so far @moshfeu has been manually adding mentors when approving PRs (mailchimp), however now that we deployed the new version we need to add those emails automatically when approving a mentor application.

Acceptance Criteria

• Create a list in sendgrid
• Add email to the list when approving a mentor

As of now it's possible to get a user object into the database with invalid data. To guard against this, the following fields on the UserSchema should be marked as required:

• auth0Id
• email
• name
• avatar

Look here for an example of how to set a field in the schema as required.

Currently tags' schema

[
  {
    "label": {
        "value": "chocolate",
        "label": "Chocolate"
    },
    "value": {
        "value": "chocolate",
        "label": "Chocolate"
    }
  }
]

But it should be (like currently in the app)

[
  "frontend",
  "reactjs",
  "vuejs"
]

Currently, when user is not loggedin, the server returns 401 error.
Expected result will be to return the mentors but without the channels so user will have to do login to contact a mentor.

We need a script to add roles to users in the database, right now there's no way we can set users as an admin manually.

Right now, the api return always status code 200 and in the response itself, it returns the actual status.

Right now, any errors surfaced by the validation routines send back a response with a fairly dense payload that makes isolating the error text complicated on the front end. It also leaks database identifiers, which is not ideal.

Here's an example of a constraint error:

{
   "statusCode":400,
   "error":"Bad Request",
   "message":[
      {
         "target":{
            "spokenLanguages":[
               "en"
            ],
            "tags":[
               "reactjs",
               "html",
               "css",
               "python",
               "graphql"
            ],
            "roles":[
               "Member",
               "Mentor"
            ],
            "name":"Brent M Clark",
            "email":"[email protected]",
            "avatar":"https://s.gravatar.com/avatar/2a2d22c34d297073e37687d3a846de47?s=80",
            "title":"Sr. Software Engineer",
            "country":"US",
            "channels":[
               {
                  "_id":"...",
                  "type":"linkedin",
                  "id":""
               },
               {
                  "_id":"...",
                  "type":"twitter",
                  "id":"brent_m_clark"
               },
               {
                  "_id":"...",
                  "type":"github",
                  "id":"brentmclark"
               },
               {
                  "type":"slack",
                  "id":"12345"
               }
            ]
         },
         "value":[
            {
               "_id":"...",
               "type":"linkedin",
               "id":""
            },
            {
               "_id":"...",
               "type":"twitter",
               "id":"brent_m_clark"
            },
            {
               "_id":"...",
               "type":"github",
               "id":"brentmclark"
            },
            {
               "type":"slack",
               "id":"12345"
            }
         ],
         "property":"channels",
         "children":[

         ],
         "constraints":{
            "arrayMaxSize":"channels must contain not more than 3 elements"
         }
      }
   ]
}

Eventually, you'll notice the useful portion of the payload: channels must contain not more than 3 elements. The rest of the information is seemingly unnecessary.

How about shrinking this down to something like:

{
   "statusCode":400,
   "error":"Bad Request",
   "messages": [
      "Error Message #1",
      "Error Message #2",
   ]
}

We need to return all mentors in the platform, additionally we need to filter the results based on:

• name
• language
• technology
• country

Should get

{
  reason: string
}

There's no example .env file, making getting started on this repo a little bit harder. So, I think we should add one.

Description

Now that we have pagination in place, we need to provide the filters to the client. We need a single endpoint that returns all the data.

{
  "success": true,
  "data": {
    "countries": [{"id": "us", "label": "United State"}, ....],
    "languages": [{"id": "en", "label": "English"}, ....],
    "technologies": ["javascript", "reactjs", ....]
  }
}

The name filter will have its own endpoint.

We need to make sure all data returned has at least one mentor associated, we are not going to list countries, languages or technologies without any mentor

We need to explain how to setup auth0 :)

Currently, when user receiving the rejection email he can't know why his application rejected.
Seems like sendGrid has params / placeholders mechanizm - https://sendgrid.com/docs/ui/sending-email/how-to-send-an-email-with-dynamic-transactional-templates/#send-a-transactional-email

When deleting a user, we need to remove all their applications as well. Right now those records become orphan, this brakes the UI.

We need to delete the user's email from sendgrid, if the user is a mentor we need to delete it from the mentors. All Members should be removed from the newsletter list.

We need to create an endpoint to return only the favorite list for the given user.

Request

GET /users/{user._id}/favorites

{
  success: true,
  data: {
    name: "Favorites"
    mentors: [{ name: "john doe" }, .... ]
  }
}

Restrictions

• This list is always private
• Only current user (or admin) can get the favorite list

When user already sent his application and he wants to update his details, the client saves his details and try to create an application (and get an error of course).

This is because the client doesn't know if the current user has an application or not. We need an endpoint to check if this users have an application pending or not.

In an effort to increase confidence when updating our codebase, or adding a new feature. We want to increase the test coverage with unit test.

The goal of this issue is to write unit tests for the UsersController, when writing tests keep the following guidelines in mind:

• We are testing each method in its own, meaning we need to mock all service dependencies and test calls to services when it makes sense.
• Group all tests for a single method together, for example:

describe('modules/mentors/MentorController', () => {
  describe('index', () => {
    it('should return all mentors', () => expect(true).toBe(true));
  });

  describe('featured', () => {
    it('should return a single mentor', () => expect(true).toBe(true));
  });

  describe('applications', () => {
    it('should throw an error if current user is not admin', () => expect(true).toBe(true));

    it('should return all applications', () => expect(true).toBe(true));

    it('should return applications by the given status', () => expect(true).toBe(true));

   // etc...
  });

  // etc...
});

I was thinking of a way for allowing users to review a mentor or giving him some kind of kudo(congrats) for his help.

My suggested flow is:

1. User asks mentor help clicking in an action button.
2. Mentor accepts it.
3. After being accepted, the user at any time could thank the mentor by a review or something like that.

It is just an idea. But, having this we could have a base for a ranking system.

Regards.

We want to allow users to add mentors to any of the available lists. We need an endpoint to update add a new mentor to the existing list.

Request

PUT /users/{user._id}/lists/{list._id}/add

{
  mentors: [{ _id: "12345"}, { _id: "a user._id"}]
}

Response

{ success: true }

Restrictions

• Members can only add their mentors to their own lists
• Admins can add mentors to any list

The response will be:

{
  success: boolean,
  data: object (user / mentor / mentors)
}

Actually, I'm not sure about the success: true, since we will get the status implicit from the request's status code.

We want to show to the admin all information related to the user applying to become a mentor, therefore we need to return all user's data when calling GET /mentors/applications?status=pending

Users can create lists of mentors, for example: QA Mentors, Rockstars Devs, etc..

We need one endpoint to receive the name of the new list, along with the mentors we want to add to the list:

Request:

POST /users/{user._id}/lists

{
  "name": "QA Mentors",
  "public": false,
  "mentors": [{ _id: "1234" }, ... ]
}

Response:

{
  success: true,
  list: { _id: "12345" }
}

Validations

• name should be required
• public is optional and defaults to false
• mentors is optional and defaults to an empty array

Restrictions

• Members can create their own lists
• Members can't create lists for other members
• Admin can create lists for any other member