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.
You'll need two sets of credentials from Google:
- An API key with access to both the Maps JavaScript API and the Geocoding API
- 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
- A set of credentials should be generated:
- origins and redirect uri should both be the root domain (e.g. http://atlas.example.com)
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=
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.
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
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 /
.
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 are bundled with the backend application, and run by Celery.
To launch the workers service (from within your virtualenv) run the following:
$ atlas worker
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 is done via the following:
- Perform a login mutation:
mutation {
login(email: "[email protected]", password: "bar") {
errors
ok
token
user {
id
email
name
}
}
}
- 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]
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
- Most models contain a GUID (UUID) primary key.
atlas
├── Office
└── User
├── Photo
├── Profile
└── Identity