ankitr / gunnapps Goto Github PK

It'd be nice to have a base template where we can put things like Google Analytics, etc. and not worry about it. Maybe something with Jinja2 macros?

We need to start unit testing, because honestly, without it everything will eventually end up breaking.

We also should email students at their personal email addresses to verify that they're active and correct.

Users should be able to see the information that has been entered into the database. It should remain minimal and simple. It should also be private to users, so nobody from the outside can see it.

Right now, we've hardcoded 2015-2018 into registrations. That should be dynamically done (and with that, we'll begin using JavaScript (unless we want to templatify it, which might be the smarter move)).

We need to serve a session login page so apps can redirect their users to a page where they can login with their GunnApps account. It needs to have a redirect page and create a user session for the app.

There needs to be an endpoint where an app can find all user IDs in a graduating year. It will be exposed as follows:

GET /api/year/<year:int> [
    [int] # ids of all registered users of some year
] throws 404

We need profile pictures for users. Hopefully, we can store them off our servers (so they don't explode) and have some pretty-looking identicons for people who don't put a picture. We should also consider using something like Filepicker for image upload.

That is, someone should be able to deploy this for their own school with very little code changes; ideally just some mucking about in a JSON config file.

People will want something to look at when building their own thing. For documentation purposes, we should build an app as an example of how the API works.

It looks really ugly at low screen sizes. Actually, it looks kinda ugly at all screen sizes. That should be fixed with responsive design.

I don't grok CSS, but I wrote quite a bit (read: all) of it. Someone should really look it over and iron out the hacks.

Some relics of the past application architecture are still under the apps directory. They should be removed, and possibly stored as ideas for later implementation.

There needs to be an endpoint to ping a user and change the moment they were last active. It will be exposed as follows:

POST /api/ping/<id:int>
    str                                # refresh lastActive
throws 404

Currently, we are relying on Flask-login, which is okay, but honestly doesn't make any sense as a long term solution for an open login system. By building our own system, we'll also have the advantage of being able to reuse a part of it for our API authentication.

Somebody's gotta do it.

We need to ask for gender and Student ID as part of the registration process.

There needs to be an endpoint to get user information. It will return information in this format:

GET /api/titan/<id:int> {
    'name':       [readonly] str,
    'email':      [readonly] str,          # Personal email address
    'year':       [readonly] int,          # > 2000
    'isAlumnus':  [readonly] bool,       # year <= now?
    'image':      [readonly] str or None,  # A URL
    'lastActive': [writable] str           # ISO-8601 Timestamp
} throws 404

For interaction with the API, applications need user sessions. Naturally, there needs to be a system to manage these. I suggest putting these under an API utils directory, but that depends on what other people (@Hardmath123) think. It will probably be exceedingly simple, but will get the job done.

We need a page thoroughly detailing the features of the API and the purpose of GunnApps for student developers.

api/ is starting to become a mess. We need a util module in it, and refactor the code to use it.

There needs to be a page where you can see every app you use, see what permissions they have, and revoke their access to your information.

There should be an endpoint where apps can send emails to a user. This will likely be via a service like SendGrid. It will be exposed as follows:

POST /api/mail/<id:int> <subject:str> <content:str>
    throws 404

NOTE: This is still up for debate and is not scheduled for immediate release.

We need to be able to validate emails, and thus Student IDs. @Hardmath123 is looking into SMTP requests that can be used to verify, at least through Google Mail, that an email address exists.

There will be an endpoint that allows an app to get a user's @palo-alto.edu email address. It will be exposed as follows:

GET /api/email/<id:int>
    [readonly] str                     # @palo-alto.edu email
throws 404

Users should be able to create apps that can access the API. This will require some level of cooperation between the frontend and the API. Currently, apps need a name and ID. Every app also has a 32 character secret.

There needs to be a page where you can see all your apps, change their names, and reset their IDs.

Currently, there is no logging within the application. Naturally, this is problematic when testing. We need to improve logs.py to stop its reliance on top level directories and instead work within the scope of the project. I suggest creating a _run directory to store runtime information in.

If your information is incorrect, you should be able to change it. Things you can't change should include your name, year, and ID.