maymc / consume-more-stuff Goto Github PK

MVP

As far as MVP goes, it looks like using JSON Web Tokens changes the process a little.

In our current setup, we are kinda stuck using the Auth0 database. As far as my understanding goes right now, we can write to local storage and also grab data from JWT, I guess similar to how we would grab from local storage.

The issue is that I'm not too sure how we can scope the user to see specific content pertaining to them.

Auth0 also uses a method called scope that helps to define what a user is allowed to see, but I'm not sure it's exactly what we wanted to do initially. Will probably need extra help understanding this concept to its completion.

...Then again it might be something simple like grabbing specific data from the JWT, or creating a method specific information to a user defined location.

• Design basic CSS layout
• [optional] update routing into index.js with switch statements (suggested by @ba5eem/jocelyn)
• Create/refine more components (templates)
• Approve/Deny comment functions to work in tandem with transactions
• Refine HTML // Stylish & modern CSS
• Change favicon in Public/index.js to reflect 2cent logo

remember to change tab name:

<title>React App</title>

• Research how to implement
• Test Implementation
• Completed Implementation

• Register a Domain Name

possible future urls available: 
twocentexchange.com 
twocentsforyou.com mytwo-cents.com 
my-two-centz.com

• Point S3 to namecheap domain name via Amazon route 53

• (Optional) SSL certificate - Secure website with https

• Authenticated view to show user profile pic/profile name in top right corner

(I believe that we will have to grab from either our user database or auth0's. However, I think we still need to look up how we can inject information into localstorage and maybe call upon those ids/keys)

• Research localstorage injection with Auth0 and JWT (json web tokens)

(1) Finish wireframe page/component planning

• Re-clarify MVP due on 11/14

  • Have main concept working for MVP e.g.
    • post request
    • method that selects amount offered within 'request'
    • comment to request
    • pseudo transaction => accepted comment completes transaction && now is seen from main view

• Profile dashboard

  • To include user information
    • Bio?
    • Profile picture? - stretch goal (Are we able to upload pictures to a database???)
    • Change password
    • Delete profile
    • Change email/username

• post view (poster pov) (possible modal?)

• Draw up/Create a high fidelity mockup for the website to help clarify/streamline ui/ux and new possible enhancements - Reference

• Finish/review database structure and relationships

  • Completed by @wyminc

Stretch Goal

It seems to me that we can use our own custom database, but I'm not entirely sure how it works with auth0.

In order to start using our own database, we must first wipe the users table currently on Auth0 from the auth0 dashboard.

I'm not sure, but it kinda looks like if we did use our own database, we can also customize the look and feel of log-in and sign up - which imo is more fitting over being redirected in plain sight to a third-party (at least in terms of the end product).

https://manage.auth0.com/?#/connections/database/con_ctODbr9TMdTd20np/plug

• Hello world for auth
• Merge to development
• Grab users from database
• Get/Create unique ids for users to see exclusive content

• Research ideal search functions
• Decide on what to implement
• Test Implementation
• Completed Implementation

Need establish basic crud routes for server.js

To include:

GET all posts
GET all comments
GET my comments
GET post by id
GET comments by post_id
POST post
POST comment
POST drafted post
PUT drafted post (?)
PUT accepted comments (?)
(additional ones TBD or will create a new issue)

@drcox23 11/8

• Setup redux

@wyminc 11/8

Set up:

• docker
• express files
• db (migrate and seed)
• knex

@demifire || @maymc 11/8

• Finish pages and front end routing
  • Review how to create pages
  • Create pages/views folder
    • Create pages/views in pages folder with “hello world”
  • Review front end react routing
  • Get simple authenticated and unauthenticated routes working

@maymc

• Set up react environment
• Push environment
• Pull initial environment
• Install node modules
• Check out into feature branches
• Setup github repo and development branch properly

• Research ways to make the application "pop"
• Refine components and components styling
• Convert CSS to inline scoped per component (better compatibility for mobile?)
• Create a cache (with catch) for CRUD to speed front end
• Adjust/Make sure components are mobile-browser friendly

Sorry to pull you guys into my auth issues. x)

I noticed last night, that when being redirected to auth0 for login, I'm getting an error, because it's forcing the url to localhost:3000/callback somewhere in react (i believe - not sure).

Not sure what the fix is at the moment. I would say we should just time-box this issue for now and if not, we can just try to work with a "pseudo" auth for now, as it may require more research with auth0.

If you have time, please try diving into the Auth0 tutorials

Just a question, should we consider a higher-fidelity mockup for the site, so we are aligned on the look/feel of the site?

just a thought

Would probably just need to do a get request when scroll bar hits the bottom of the page.

Can we do get requests in chunks?

• Draw up/Create a high fidelity mockup for the website to help clarify/streamline ui/ux and new possible enhancements

Add quick getting started to the readme, like what i need to do - to get going. You can add a script in package.json as well - like a setup app script, for example:

"setup": "npm i && docker-compose up --build -d && npm run migrate && npm run seed"

• Work on deploying react-native app

Go with one style?

//Models
const Users = require('./knex/models/Users.js');
const Posts = require('./knex/models/Posts.js');
const Comments = require('./knex/models/Comments.js');
const Transactions = require('./knex/models/Transactions.js');
const Type = require('./knex/models/Type.js');
const draftPosts = require('./knex/models/draftPosts.js');
const draftComments = require('./knex/models/draftComments.js');
const archivedPosts = require('./knex/models/archivedPosts.js');
const archivedComments = require('./knex/models/archivedComments.js');

get data to dispatch to home page

• Pull repo to ec2 instance & compose up to run server
  • Create EC2 instance
  • Curl localhost crud route within container
  • Curl IP address crud route outside container

• Build front end and deploy on S3
  • Connect front-end to EC2 server
  • Rebuild S3 image and upload

• Update S3 build with new master pushes

Add res.json('err') to catch.
'.serialize()' not neccessary

// get all the posts when any user lands on home page
app.get('/home', (req, res) => {
  Posts
    .fetchAll()
    .then(items => {
      res.json(items)
    })
    .catch(err => {
      console.log('error', err)
     res.json('err')
    })
});

Organize who will do what

• Get public id_rsa keys
• Chown
• Make superusers
• @maymc Create public/private rsa key for github repo and add it into repo settings
• Compose-down -v on current repo, delete, and reclone latest into shared directory
• Reinstall npm, node, docker, etc.. as needed. Update Dockerfile as needed
• Run server, and rebake S3 image

Will need to move the repo to a shared view location and get everyone to send their public ssh keys.

Following, I will make everyone a superuser, and that should give everyone access to the live server - where we can pull the latest repo.

@maymc, you may also need to generate a public/private rsa key pair for the github repo, so we can clone via ssh.

• Group has installed and is using Git Kraken

As recommended by @lorecrafting, it may be useful and to our benefit to play around with this tool, to aid in the completion of this project.

Will close this issue when we have a connected work flow.

• Research 3rd party add ons
• Decide on what to implement: via stripe/venmo api (or Baseem's credit idea), etc...
• Test Implementation
• Completed Implementation