atlas

Atlas is an internal portal, offering a variety of features helping bring visibility within your organization.

It's built on top of G Suite by Google, and currently features:

• A two-way synced employee directory
• An automatically generated organization chart

This project is still in its infancy, and pull requests are absolutely welcome.

API Keys

You'll need two sets of credentials from Google:

1. An API key with access to both the Maps JavaScript API and the Geocoding API
2. An OAuth application configured:
   • application type is internal
   • authorized domains should include your ___domain name (e.g. example.com)
   • scopes should include email, profile, and openid
3. A set of credentials should be generated:
   • origins and redirect uri should both be the root ___domain (e.g. http://atlas.example.com)

Development

Make sure you disable Adblock as it seems to break Google Auth

You'll need Postgres and Redis instances running with standard credentials. A basic set of docker services are included and can be run with compose:

$ docker-compose up -d

From there, activate a virtualenv using Python 3.7.x (this is automatic if you're using pyenv and direnv), and install the dependencies:

$ make

Apply database migrations:

$ atlas migrate

Lastly, grab the Google, and place them in .env. See the included .env.example for additional configuration:

GOOGLE_CLIENT_SECRET=
GOOGLE_CLIENT_ID=
GOOGLE_MAPS_KEY=

Mock Data

You can load some example mock data with a basic organization structure by running the following command:

$ atlas load_mocks

Note: If you run this multiple times you will end up with multiple similar profiles, as they're not unique.

Syncing People

You will need an account with ___domain permission to sync data

Once you've authenticated with your Google Auth, you can sync the directory with the following command:

$ atlas sync_google

Services

Atlas is made up of two key services.

The backend service is a Django application exporting a graphql API. It runs on top of a Postgres database and is completely stateless.

The frontend service is a SPA built on React implementing the majority of user interactions as well as authentication.

These services can be run easily in local development using the included proxy with the following:

$ npm start

From there you can access the UI at http://localhost:8080. This will expose the backend at /graphql/ and the UI at /.

Backend

The backend is a GraphQL implementation powered by Graphene. The exposed endpoint is /graphql/.

To launch the backend service (from within your virtualenv) run the following:

$ atlas runserver

Offline Workers

Offline workers are bundled with the backend application, and run by Celery.

To launch the workers service (from within your virtualenv) run the following:

$ atlas worker

Frontend

The frontend service is built on top of React as a Single Page Application (SPA). It contains all user interface logic as well as various business flows.

To launch the frontend service run the following:

$ cd frontend && npm start

Authentication

Authentication is done via the following:

1. Perform a login mutation:

mutation {
  login(email: "[email protected]", password: "bar") {
    errors
    ok
    token
    user {
      id
      email
      name
    }
  }
}

2. Capture the token in the response and send it with future requests:

Authorization: Token {value}

Here's a helpful app which lets you bind an auth header:

https://github.com/skevy/graphiql-app

Note: You can also use the included helper to generate an auth token:

$ atlas generate_auth_token [email address]

Repository Layout

atlas
├── backend
|   ├── atlas               // django backend service
|   |   ├── models          // database schema
|   |   ├── mutations       // registered mutations
|   |   └── queries         // registered queries
└── frontend
    └── src
        ├── actions             // redux actions
        ├── components          // standard react components
        ├── pages               // core routing components
        └── reducers            // redux reducers

Data Model

• Most models contain a GUID (UUID) primary key.

atlas
├── Office
└── User
    ├── Photo
    ├── Profile
    └── Identity