25 |
26 | 
27 |
28 | |
29 |
Great, we have found an employees.csv file. Let‘s import that!
14 | {% include theme("import_employees_form.html") %} 15 | 16 | Note: Once you hit the Import button the import will be kicked off and handled 17 | in the background. Depending on how many employees you are importing this process can take a few seconds. 18 | When the import finishes successfully you will see the imported employees 19 | here. 20 | 21 | {% else %} 22 |23 | Oh, we couldn‘t find an employees.csv file. Please read the instructions 24 | in the README on what options you have to import employee data. 25 |
26 | {% endif %} 27 | {% endblock %} 28 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | The MIT License (MIT) 2 | Copyright (c) 2016 Yelp, Inc. 3 | 4 | Permission is hereby granted, free of charge, to any person obtaining a copy of 5 | this software and associated documentation files (the "Software"), to deal in 6 | the Software without restriction, including without limitation the rights to 7 | use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies 8 | of the Software, and to permit persons to whom the Software is furnished to do 9 | so, subject to the following conditions: 10 | 11 | The above copyright notice and this permission notice shall be included in all 12 | copies or substantial portions of the Software. 13 | 14 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 15 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 16 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 17 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 18 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 19 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 20 | SOFTWARE. -------------------------------------------------------------------------------- /.pre-commit-config.yaml: -------------------------------------------------------------------------------- 1 | repos: 2 | - repo: https://github.com/pre-commit/pre-commit-hooks.git 3 | rev: v0.7.1 4 | hooks: 5 | - id: autopep8-wrapper 6 | - id: check-added-large-files 7 | - id: check-ast 8 | - id: check-byte-order-marker 9 | - id: check-case-conflict 10 | - id: check-docstring-first 11 | - id: check-json 12 | - id: check-merge-conflict 13 | - id: check-yaml 14 | - id: debug-statements 15 | - id: detect-private-key 16 | - id: double-quote-string-fixer 17 | - id: end-of-file-fixer 18 | - id: flake8 19 | language_version: python3.11 20 | - id: fix-encoding-pragma 21 | - id: name-tests-test 22 | - id: pretty-format-json 23 | args: ['--autofix'] 24 | - id: requirements-txt-fixer 25 | - id: trailing-whitespace 26 | - repo: https://github.com/asottile/reorder-python-imports 27 | rev: v3.12.0 28 | hooks: 29 | - id: reorder-python-imports 30 | 31 | - repo: https://github.com/Yelp/detect-secrets 32 | rev: 0.9.1 33 | hooks: 34 | - id: detect-secrets 35 | args: ['--baseline', '.secrets.baseline'] 36 | exclude: .*tests/.*|\.pre-commit-config\.yaml 37 | -------------------------------------------------------------------------------- /loveapp/logic/toggle.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | from time import sleep 3 | 4 | from errors import InvalidToggleName 5 | from errors import InvalidToggleState 6 | from loveapp.models import Toggle 7 | from loveapp.models.toggle import TOGGLE_NAMES 8 | from loveapp.models.toggle import TOGGLE_STATES 9 | 10 | 11 | def _validate_and_maybe_create_toggle(name, state): 12 | if name not in TOGGLE_NAMES: 13 | raise InvalidToggleName(name) 14 | if state not in TOGGLE_STATES: 15 | raise InvalidToggleState(str(state)) 16 | 17 | toggle = Toggle.query(Toggle.name == name).get() 18 | if toggle is None: 19 | toggle = Toggle(name=name, state=state) 20 | toggle.put() 21 | return toggle 22 | 23 | 24 | def get_toggle_state(name, default=True): 25 | toggle = _validate_and_maybe_create_toggle(name, default) 26 | return toggle.state 27 | 28 | 29 | def set_toggle_state(name, state): 30 | toggle = _validate_and_maybe_create_toggle(name, state) 31 | if toggle.state != state: 32 | toggle.state = state 33 | toggle.put() 34 | 35 | # It hurts me to have to do this, but the datastore is eventually consistent so... 36 | key = toggle.key 37 | while True: 38 | sleep(2) 39 | toggle = key.get() 40 | if toggle.state == state: 41 | break 42 | -------------------------------------------------------------------------------- /AUTHORS.md: -------------------------------------------------------------------------------- 1 | # Current Maintainers 2 | * Stephan Jaensch [sjaensch](https://github.com/sjaensch) 3 | * Sven Steinheißer [rockdog](https://github.com/rockdog) 4 | * Yoann Roman [silentsound](https://github.com/silentsound) 5 | 6 | # Original Authors 7 | * Adam Rothman [adamrothman](https://github.com/adamrothman) 8 | * Ben Asher [benasher44](https://github.com/benasher44) 9 | * Andrew Martinez-Fonts [amartinezfonts](https://github.com/amartinezfonts) 10 | * Wei Wu [wuhuwei](https://github.com/wuhuwei) 11 | 12 | # Contributors 13 | * Alex Levy [mesozoic](https://github.com/mesozoic) 14 | * Anthony Sottile [asottile](https://github.com/asottile) 15 | * Jenny Lemmnitz [jetze](https://github.com/jetze) 16 | * Kurtis Freedland [KurtisFreedland](https://github.com/KurtisFreedland) 17 | * Michał Czapko [michalczapko](https://github.com/michalczapko) 18 | * Prayag Verma [pra85](https://github.com/pra85) 19 | * Stephen Brennan [brenns10](https://github.com/brenns10) 20 | * Wayne Crasta [waynecrasta](https://github.com/waynecrasta) 21 | * Dennis Coldwell [dencold](https://github.com/dencold) 22 | * Andrew Lau [ajlau](https://github.com/ajlau) 23 | * Alina Rada [transcedentalia](https://github.com/transcedentalia) 24 | * Matthew Bentley [matthewbentley](https://github.com/matthewbentley) 25 | * Kevin Hock [KevinHock](https://github.com/KevinHock) 26 | * Duncan Cook [theletterd](https://github.com/theletterd) 27 | -------------------------------------------------------------------------------- /loveapp/themes/default/templates/aliases.html: -------------------------------------------------------------------------------- 1 | {% extends theme("layout.html") %} 2 | 3 | {% import theme("parts/flash.html") as flash %} 4 | 5 | {% block title %}Aliases{% endblock %} 6 | 7 | {% block body %} 8 | {{ flash.display_flash_messages() }} 9 || Alias | 15 |Owner | 16 |17 | |
|---|---|---|
| {{ a.name }} | 23 |{{ a.owner_key.get().username }} | 24 |25 | 29 | | 30 |
No aliases have been saved yet.
36 | {% endif %} 37 |3 | We’ll POST Json to the URL below with details of any subscribed event. 4 |
5 | 37 | -------------------------------------------------------------------------------- /tests/conftest.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | import os 3 | 4 | import mock 5 | import pytest 6 | from flask import template_rendered 7 | from flask_themes2 import load_themes_from 8 | from google.appengine.ext import testbed 9 | 10 | from loveapp import create_app 11 | 12 | 13 | @pytest.fixture 14 | def app(): # noqa 15 | # do we need this? for what? 16 | def test_loader(app): 17 | return load_themes_from(os.path.join(os.path.dirname(__file__), '../loveapp/themes/')) 18 | app = create_app(theme_loaders=[test_loader]) 19 | 20 | with app.app_context(): 21 | yield app 22 | 23 | 24 | @pytest.fixture 25 | def client(app): 26 | with app.test_client() as test_client: 27 | yield test_client 28 | 29 | 30 | @pytest.fixture 31 | def recorded_templates(app): 32 | recorded = [] 33 | 34 | def record(sender, template, context, **extra): 35 | recorded.append((template, context)) 36 | 37 | template_rendered.connect(record, app) 38 | try: 39 | yield recorded 40 | finally: 41 | template_rendered.disconnect(record, app) 42 | 43 | 44 | @pytest.fixture 45 | def mock_config(): 46 | with mock.patch('loveapp.config') as mock_config: 47 | mock_config.DOMAIN = 'example.com' 48 | yield mock_config 49 | 50 | 51 | @pytest.fixture(scope='function') 52 | def gae_testbed(): 53 | tb = testbed.Testbed() 54 | tb.activate() 55 | tb.init_memcache_stub() 56 | tb.init_datastore_v3_stub() 57 | tb.init_search_stub() 58 | tb.init_taskqueue_stub() 59 | tb.init_user_stub() 60 | 61 | yield tb 62 | 63 | tb.deactivate() 64 | -------------------------------------------------------------------------------- /tests/logic/email_test.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | import unittest 3 | 4 | import mock 5 | import pytest 6 | 7 | import loveapp.logic.email 8 | 9 | 10 | @pytest.mark.usefixtures('gae_testbed') 11 | class EmailTest(unittest.TestCase): 12 | """We really just want to test that configuration is honored here.""" 13 | 14 | sender = 'test@example.com' 15 | recipient = 'test@example.com' 16 | subject = 'test subject' 17 | html = 'hello test
' 18 | text = 'hello test' 19 | 20 | @mock.patch('loveapp.logic.email.EMAIL_BACKENDS') 21 | @mock.patch('loveapp.logic.email.config') 22 | def test_send_email_appengine(self, mock_config, mock_backends): 23 | mock_config.EMAIL_BACKEND = 'appengine' 24 | mock_backends['appengine'] = mock.Mock() 25 | loveapp.logic.email.send_email(self.sender, self.recipient, self.subject, 26 | self.html, self.text) 27 | mock_backends['appengine'].assert_called_once_with( 28 | self.sender, self.recipient, self.subject, self.html, self.text 29 | ) 30 | 31 | @mock.patch('loveapp.logic.email.EMAIL_BACKENDS') 32 | @mock.patch('loveapp.logic.email.config') 33 | def test_send_email_sendgrid(self, mock_config, mock_backends): 34 | mock_config.EMAIL_BACKEND = 'sendgrid' 35 | mock_backends['sendgrid'] = mock.Mock() 36 | loveapp.logic.email.send_email(self.sender, self.recipient, self.subject, 37 | self.html, self.text) 38 | mock_backends['sendgrid'].assert_called_once_with( 39 | self.sender, self.recipient, self.subject, self.html, self.text 40 | ) 41 | -------------------------------------------------------------------------------- /loveapp/themes/default/templates/keys.html: -------------------------------------------------------------------------------- 1 | {% extends theme("layout.html") %} 2 | 3 | {% import theme("parts/love_message.html") as love_message %} 4 | {% import theme("parts/flash.html") as flash %} 5 | 6 | {% block title %}API Keys{% endblock %} 7 | 8 | {% block body %} 9 || Photo | 16 |Username | 17 |Name | 18 |Department | 19 |Terminated | 20 |
|---|---|---|---|---|
| {{ photobox.user_icon(employee) }} | 26 |{{ employee.username }} | 27 |{{ employee.full_name }} | 28 |{{ employee.department }} | 29 |{{ employee.terminated }} | 30 |
Oops, there are no employees yet. Let‘s import some.
49 | {% endif %} 50 | {% endblock %} 51 | 52 | {% block javascript %} 53 | 58 | {% endblock %} 59 | -------------------------------------------------------------------------------- /loveapp/logic/notification_request.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | import hashlib 3 | import hmac 4 | import json 5 | import logging 6 | 7 | import urllib3 8 | 9 | import loveapp.config as config 10 | 11 | 12 | CONTENT_TYPE_JSON = 'application/json' 13 | 14 | 15 | pool = urllib3.PoolManager() 16 | 17 | 18 | class NotificationRequest(object): 19 | 20 | def __init__(self, subscription, payload): 21 | self.url = subscription.request_url 22 | self.method = subscription.request_method 23 | self.format = subscription.request_format 24 | self.secret = subscription.secret 25 | self.event = subscription.event 26 | self.content = self._content(self.format, payload) 27 | 28 | def send(self): 29 | try: 30 | return pool.urlopen( 31 | self.method, 32 | self.url, 33 | body=self.content.payload, 34 | headers=self.headers, 35 | ) 36 | except Exception: 37 | logging.info('Could not send request to %s', self.url) 38 | return False 39 | 40 | @property 41 | def headers(self): 42 | # hmac does not like unicode 43 | digest = hmac.new(str(self.secret), str(self.content.payload), hashlib.sha1) 44 | return { 45 | 'Content-type': self.content.content_type, 46 | 'X-YelpLove-Event': self.event, 47 | 'User-Agent': '{} ({})'.format(config.APP_NAME, config.APP_BASE_URL), 48 | 'X-Hub-Signature': digest.hexdigest(), 49 | } 50 | 51 | def _content(self, format, payload): 52 | if CONTENT_TYPE_JSON == format: 53 | return JSONContent(payload) 54 | else: 55 | raise RuntimeError('Unsupported format %s' % format) 56 | 57 | 58 | class JSONContent(object): 59 | 60 | def __init__(self, payload): 61 | self.content_type = CONTENT_TYPE_JSON 62 | self.payload = json.dumps(payload) 63 | -------------------------------------------------------------------------------- /loveapp/themes/default/templates/love_link.html: -------------------------------------------------------------------------------- 1 | {% extends theme("layout.html") %} 2 | {% import theme("parts/facetile.html") as facetile %} 3 | 4 | {% block title %}Send Love{% endblock %} 5 | 6 | {% block body %} 7 |You can use the link below to have others join this lovefest!
24 || Active | 15 |Event | 16 |Owner | 17 |URL | 18 |Secret | 19 |20 | |
|---|---|---|---|---|---|
| 26 | {% if s.active %} 27 | Yes 28 | {% else %} 29 | No 30 | {% endif %} 31 | | 32 |{{ s.event }} | 33 |{{ s.owner_key.get().username }} | 34 |{{ s.request_url }} | 35 |{{ s.secret }} | 36 |37 | 41 | | 42 |
Nobody is using webhooks yet. :[
48 | {% endif %} 49 | }}){kind=logo}
23 | {{ user.department }}
30 || 18 | |
19 |
20 |
21 |
22 |
32 |
33 |
|
34 | 35 | |
| 42 | |
43 |
44 |
45 |
|
84 | 85 | |
| 92 | |
93 |
94 |
95 |
96 |
106 |
107 |
|
108 | 109 | |
git clone git@github.com:Yelp/love.git
114 | * Follow the [Prepare for deployment](#prepare-for-deployment) section
115 | * Run the app: make run-dev will start both [Yelp Love](http://localhost:8080) as well as the [Admin server](http://localhost:8000)
116 | * Follow the [CSV import](#csv) section to locally import user data
117 | * Make your changes
118 |
119 | ## Deployment
120 |
121 | When you bumped versions in the appropriate files you can deploy your changes by running
122 | make deploy.
123 |
124 | If you are seeing the following error:
125 | ```
126 | Error 404: --- begin server output ---
127 | This application does not exist (project_id=u'PROJECT-ID'). To create an App Engine application in this project, run "gcloud app create" in your console.
128 | ```
129 |
130 | This is because GAE is no longer automatically initialized, you must run `gcloud app create` using the **Google Cloud Shell** (not your terminal...I know...confusing) before deploying on App Engine for the first time. See the screenshot below:
131 | 
132 |
133 | Once your code has been uploaded to Google, you must activate the newly deployed version
134 | in the [Developer Console](https://console.developers.google.com/). Then you're done!
135 |
136 | ## API
137 |
138 | Yelp Love also ships with an API which will be available under [https://project_id.appspot.com/api](https://project_id.appspot.com/api).
139 | All data of successful GET requests is sent as JSON.
140 |
141 | ### Authentication
142 |
143 | Successful requests to the API require an API key. These can be created in the Admin section of the
144 | application. Authenticating with an invalid API key will return 401 Unauthorized.
145 |
146 | ### Endpoints
147 |
148 | All names, e.g. sender or recipient in the following examples refer to employee usernames.
149 |
150 | #### Retrieve love
151 |
152 | ```
153 | GET /love?sender=foo&recipient=bar&limit=20
154 | ```
155 |
156 | You must provide either a sender or a recipient. The limit parameter is optional - no limiting will
157 | be applied if omitted.
158 |
159 | ##### Example
160 |
161 | ```
162 | curl "https://project_id.appspot.com/api/love?sender=hammy&api_key=secret"
163 | ```
164 | ```javascript
165 | [
166 | {
167 | "timestamp": "2017-02-10T18:10:08.552636",
168 | "message": "New Barking Release! <3",
169 | "sender": "hammy",
170 | "recipient": "darwin"
171 | }
172 | ]
173 | ```
174 |
175 | #### Send love
176 |
177 | ```
178 | POST /love
179 | ```
180 |
181 | Sending love requires 3 parameters: sender, recipient, and message. The recipient parameter may contain
182 | multiple comma-separated usernames.
183 |
184 | ##### Example
185 |
186 | ```
187 | curl -X POST -F "sender=hammy" -F "recipient=john,jane" -F "message=YOLO" -F "api_key=secret" https://project_id.appspot.com/api/love
188 | ```
189 | ```
190 | Love sent to john, jane!
191 | ```
192 |
193 | #### Autocomplete usernames
194 |
195 | ```
196 | GET /autocomplete?term=ham
197 | ```
198 |
199 | The autocomplete endpoint will return all employees which first_name, last_name, or username match the given term.
200 |
201 | ##### Example
202 |
203 | ```
204 | curl "https://project_id.appspot.com/api/autocomplete?term=ha&api_key=secret"
205 | ```
206 | ```javascript
207 | [
208 | {
209 | "label": "Hammy Yo (hammy)",
210 | "value": "hammy"
211 | },
212 | {
213 | "label": "Johnny Hamburger (jham)",
214 | "value": "jham"
215 | }
216 | ]
217 | ```
218 |
219 | ## Original Authors and Contributors
220 |
221 | * [adamrothman](https://github.com/adamrothman)
222 | * [amartinezfonts](https://github.com/amartinezfonts)
223 | * [benasher44](https://github.com/benasher44)
224 | * [jetze](https://github.com/jetze)
225 | * [KurtisFreedland](https://github.com/KurtisFreedland)
226 | * [mesozoic](https://github.com/mesozoic)
227 | * [michalczapko](https://github.com/michalczapko)
228 | * [wuhuwei](https://github.com/wuhuwei)
229 |
230 | For more info check out the [Authors](AUTHORS.md) file.
231 |
232 | ## License
233 |
234 | Yelp Love is licensed under the [MIT license](LICENSE).
235 |
236 | ## Contributing
237 |
238 | Everyone is encouraged to contribute to Yelp Love by forking the
239 | [Github repository](http://github.com/Yelp/love) and making a pull request or
240 | opening an issue.
241 |
--------------------------------------------------------------------------------
/loveapp/logic/love.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | from datetime import datetime
3 |
4 | from google.appengine.api import taskqueue
5 |
6 | import loveapp.config as config
7 | import loveapp.logic.alias
8 | import loveapp.logic.email
9 | import loveapp.logic.event
10 | from errors import TaintedLove
11 | from loveapp.logic.toggle import get_toggle_state
12 | from loveapp.models import Employee
13 | from loveapp.models import Love
14 | from loveapp.models import LoveCount
15 | from loveapp.models.toggle import LOVE_SENDING_ENABLED
16 | from loveapp.util.company_values import get_hashtag_value_mapping
17 | from loveapp.util.render import render_template
18 |
19 |
20 | def _love_query(start_dt, end_dt, include_secret):
21 | query = Love.query().order(-Love.timestamp)
22 | if type(start_dt) is datetime:
23 | query = query.filter(Love.timestamp >= start_dt)
24 | if type(end_dt) is datetime:
25 | query = query.filter(Love.timestamp <= end_dt)
26 | if type(include_secret) is bool and include_secret is False:
27 | query = query.filter(Love.secret == False) # noqa
28 | return query
29 |
30 |
31 | def _sent_love_query(employee_key, start_dt, end_dt, include_secret):
32 | return _love_query(start_dt, end_dt, include_secret).filter(Love.sender_key == employee_key)
33 |
34 |
35 | def _received_love_query(employee_key, start_dt, end_dt, include_secret):
36 | return _love_query(start_dt, end_dt, include_secret).filter(Love.recipient_key == employee_key)
37 |
38 |
39 | def recent_sent_love(employee_key, start_dt=None, end_dt=None, include_secret=True, limit=None):
40 | query = _sent_love_query(employee_key, start_dt, end_dt, include_secret)
41 | return query.fetch_async(limit) if type(limit) is int else query.fetch_async()
42 |
43 |
44 | def recent_received_love(employee_key, start_dt=None, end_dt=None, include_secret=True, limit=None):
45 | query = _received_love_query(employee_key, start_dt, end_dt, include_secret)
46 | return query.fetch_async(limit) if type(limit) is int else query.fetch_async()
47 |
48 |
49 | def _love_query_by_company_value(employee_key, company_value, start_dt, end_dt, include_secret):
50 | return _love_query(start_dt, end_dt, include_secret).filter(Love.company_values == company_value)
51 |
52 |
53 | def _love_query_with_any_company_value(employee_key, start_dt, end_dt, include_secret):
54 | company_values = [value.id for value in config.COMPANY_VALUES]
55 | return _love_query(start_dt, end_dt, include_secret).filter(Love.company_values.IN(company_values))
56 |
57 |
58 | def recent_loves_by_company_value(employee_key, company_value, start_dt=None, end_dt=None,
59 | include_secret=False, limit=None):
60 | query = _love_query_by_company_value(employee_key, company_value, start_dt, end_dt, include_secret)
61 | return query.fetch_async(limit) if type(limit) is int else query.fetch_async()
62 |
63 |
64 | def recent_loves_with_any_company_value(employee_key, start_dt=None, end_dt=None,
65 | include_secret=False, limit=None):
66 | query = _love_query_with_any_company_value(employee_key, start_dt, end_dt, include_secret)
67 | return query.fetch_async(limit) if type(limit) is int else query.fetch_async()
68 |
69 |
70 | def send_love_email(l): # noqa
71 | """Send an email notifying the recipient of l about their love."""
72 | sender_future = l.sender_key.get_async()
73 | recipient_future = l.recipient_key.get_async()
74 |
75 | # Remove this love from recent_love if present (datastore is funny sometimes)
76 | recent_love = recent_received_love(l.recipient_key, limit=4).get_result()
77 | index_to_remove = None
78 | for i, love in enumerate(recent_love):
79 | if l.sender_key == love.sender_key and l.recipient_key == love.recipient_key and l.message == love.message:
80 | index_to_remove = i
81 | break
82 | if index_to_remove is not None:
83 | del recent_love[index_to_remove]
84 |
85 | sender = sender_future.get_result()
86 | recipient = recipient_future.get_result()
87 |
88 | from_ = config.LOVE_SENDER_EMAIL
89 | to = recipient.user.email()
90 | subject = u'Love from {}'.format(sender.full_name)
91 |
92 | body_text = u'"{}"\n\n{}'.format(
93 | l.message,
94 | '(Sent secretly)' if l.secret else ''
95 | )
96 |
97 | body_html = render_template(
98 | 'email.html',
99 | love=l,
100 | sender=sender,
101 | recipient=recipient,
102 | recent_love_and_lovers=[(love, love.sender_key.get()) for love in recent_love[:3]]
103 | )
104 |
105 | loveapp.logic.email.send_email(from_, to, subject, body_html, body_text)
106 |
107 |
108 | def get_love(sender_username=None, recipient_username=None, limit=None):
109 | """Get all love from a particular sender or to a particular recipient.
110 |
111 | :param sender_username: If present, only return love sent from a particular user.
112 | :param recipient_username: If present, only return love sent to a particular user.
113 | :param limit: If present, only return this many items.
114 | """
115 | sender_username = loveapp.logic.alias.name_for_alias(sender_username)
116 | recipient_username = loveapp.logic.alias.name_for_alias(recipient_username)
117 |
118 | if not (sender_username or recipient_username):
119 | raise TaintedLove('Not gonna give you all the love in the world. Sorry.')
120 |
121 | if sender_username == recipient_username:
122 | raise TaintedLove('Who sends love to themselves? Honestly?')
123 |
124 | love_query = (
125 | Love.query()
126 | .filter(Love.secret == False) # noqa
127 | .order(-Love.timestamp)
128 | )
129 |
130 | if sender_username:
131 | sender_key = Employee.get_key_for_username(sender_username)
132 | love_query = love_query.filter(Love.sender_key == sender_key)
133 |
134 | if recipient_username:
135 | recipient_key = Employee.get_key_for_username(recipient_username)
136 | love_query = love_query.filter(Love.recipient_key == recipient_key)
137 |
138 | if limit:
139 | return love_query.fetch_async(limit)
140 | else:
141 | return love_query.fetch_async()
142 |
143 |
144 | def send_loves(recipients, message, sender_username=None, secret=False):
145 | if get_toggle_state(LOVE_SENDING_ENABLED) is False:
146 | raise TaintedLove('Sorry, sending love is temporarily disabled. Please try again in a few minutes.')
147 |
148 | recipient_keys, unique_recipients = validate_love_recipients(recipients)
149 |
150 | if sender_username is None:
151 | sender_username = Employee.get_current_employee().username
152 |
153 | sender_username = loveapp.logic.alias.name_for_alias(sender_username)
154 | sender_key = Employee.query(
155 | Employee.username == sender_username,
156 | Employee.terminated == False, # noqa
157 | ).get(keys_only=True) # noqa
158 |
159 | if sender_key is None:
160 | raise TaintedLove(u'Sorry, {} is not a valid user.'.format(sender_username))
161 |
162 | # Only raise an error if the only recipient is the sender.
163 | if sender_key in recipient_keys:
164 | recipient_keys.remove(sender_key)
165 | unique_recipients.remove(sender_username)
166 | if len(recipient_keys) == 0:
167 | raise TaintedLove(u'You can love yourself, but not on {}!'.format(
168 | config.APP_NAME
169 | ))
170 |
171 | for recipient_key in recipient_keys:
172 | _send_love(recipient_key, message, sender_key, secret)
173 |
174 | return unique_recipients
175 |
176 |
177 | def validate_love_recipients(recipients):
178 | unique_recipients = set([loveapp.logic.alias.name_for_alias(name) for name in recipients])
179 |
180 | if len(recipients) != len(unique_recipients):
181 | raise TaintedLove(u'Sorry, you are trying to send love to a user multiple times.')
182 |
183 | # validate all recipients before carrying out any Love transactions
184 | recipient_keys = []
185 | for recipient_username in unique_recipients:
186 | recipient_key = Employee.query(
187 | Employee.username == recipient_username,
188 | Employee.terminated == False # noqa
189 | ).get(keys_only=True) # noqa
190 |
191 | if recipient_key is None:
192 | raise TaintedLove(u'Sorry, {} is not a valid user.'.format(recipient_username))
193 | else:
194 | recipient_keys += [recipient_key]
195 |
196 | return recipient_keys, unique_recipients
197 |
198 |
199 | def _send_love(recipient_key, message, sender_key, secret):
200 | """Send love and do associated bookkeeping."""
201 | new_love = Love(
202 | sender_key=sender_key,
203 | recipient_key=recipient_key,
204 | message=message,
205 | secret=(secret is True),
206 | )
207 | new_love.company_values = _get_company_values(new_love, message)
208 | new_love.put()
209 | LoveCount.update(new_love)
210 |
211 | # Send email asynchronously
212 | taskqueue.add(
213 | url='/tasks/love/email',
214 | params={
215 | 'id': new_love.key.id()
216 | }
217 | )
218 |
219 | if not secret:
220 | loveapp.logic.event.add_event(
221 | loveapp.logic.event.LOVESENT,
222 | {'love_id': new_love.key.id()},
223 | )
224 |
225 |
226 | def _get_company_values(new_love, message):
227 | # Handle hashtags.
228 | hashtag_value_mapping = get_hashtag_value_mapping()
229 |
230 | matched_categories = set()
231 | for hashtag, category in hashtag_value_mapping.items():
232 | if hashtag in message.lower():
233 | matched_categories.add(category)
234 |
235 | company_values = []
236 | for value in matched_categories:
237 | company_values.append(value)
238 |
239 | return company_values
240 |
--------------------------------------------------------------------------------
/loveapp/logic/employee.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | import csv
3 | import json
4 | import logging
5 | import os.path
6 |
7 | import boto3
8 | from google.appengine.api import search
9 | from google.appengine.api.runtime import memory_usage
10 | from google.appengine.ext import ndb
11 |
12 | import loveapp.config as config
13 | from errors import NoSuchEmployee
14 | from loveapp.logic import chunk
15 | from loveapp.logic.office import OfficeParser
16 | from loveapp.logic.secret import get_secret
17 | from loveapp.logic.toggle import set_toggle_state
18 | from loveapp.models import Employee
19 | from loveapp.models import Love
20 | from loveapp.models import LoveCount
21 | from loveapp.models.toggle import LOVE_SENDING_ENABLED
22 |
23 |
24 | INDEX_NAME = 'employees'
25 |
26 |
27 | def csv_import_file():
28 | return os.path.join(
29 | os.path.dirname(os.path.abspath(__file__)),
30 | '../import/employees.csv'
31 | )
32 |
33 |
34 | def load_employees_from_csv():
35 | employee_dicts = _get_employee_info_from_csv()
36 | set_toggle_state(LOVE_SENDING_ENABLED, False)
37 | _update_employees(employee_dicts)
38 | set_toggle_state(LOVE_SENDING_ENABLED, True)
39 | rebuild_index()
40 |
41 |
42 | def _get_employee_info_from_csv():
43 | logging.info('Reading employees from csv file...')
44 | employees = csv.DictReader(open(csv_import_file()))
45 | logging.info('Done reading employees from csv file.')
46 | return employees
47 |
48 |
49 | def _clear_index():
50 | logging.info('Clearing index... {}MB'.format(memory_usage().current))
51 | index = search.Index(name=INDEX_NAME)
52 | last_id = None
53 | while True:
54 | # We can batch up to 200 doc_ids in the delete call, and
55 | # batching is better according to the docs. Because we're deleting
56 | # async, we need to keep track of where we left off each time
57 | # we do get_range
58 | use_start_object = False
59 | if last_id is None:
60 | use_start_object = True
61 | doc_ids = [
62 | doc.doc_id for doc in index.get_range(
63 | ids_only=True,
64 | limit=200,
65 | start_id=last_id,
66 | include_start_object=use_start_object,
67 | )
68 | ]
69 | if not doc_ids:
70 | break
71 | last_id = doc_ids[-1]
72 | index.delete(doc_ids)
73 |
74 | logging.info('Done clearing index. {}MB'.format(memory_usage().current))
75 |
76 |
77 | def _generate_substrings(string):
78 | """Given a string, return a string of all its substrings (not including the original)
79 | anchored at the first character, concatenated with spaces.
80 |
81 | Example:
82 | _concatenate_substrings('arothman') => 'a ar aro arot aroth arothm arothma'
83 | """
84 | return ' '.join([string[:i] for i in range(1, len(string))])
85 |
86 |
87 | def _get_employee_info_from_s3():
88 | logging.info('Reading employees file from S3... {}MB'.format(memory_usage().current))
89 | session = boto3.Session(
90 | aws_access_key_id=get_secret('AWS_ACCESS_KEY_ID'),
91 | aws_secret_access_key=get_secret('AWS_SECRET_ACCESS_KEY'),
92 | )
93 | s3 = session.resource('s3')
94 | bucket = s3.Bucket(config.S3_BUCKET)
95 | obj = bucket.Object('employees_appeng.json')
96 | employee_dicts = json.loads(obj.get()['Body'].read().decode('utf-8'))
97 | logging.info('Done reading employees file from S3. {}MB'.format(memory_usage().current))
98 | return employee_dicts
99 |
100 |
101 | def _index_employees(employees):
102 | logging.info('Indexing employees... {}MB'.format(memory_usage().current))
103 | index = search.Index(name=INDEX_NAME)
104 | # According to appengine, put can handle a maximum of 200 documents,
105 | # and apparently batching is more efficient
106 | for chunk_of_200 in chunk(employees, 200):
107 | documents = []
108 | for employee in chunk_of_200:
109 | if employee is not None:
110 | # Gross hack to support prefix matching, see documentation for _generate_substrings
111 | substrings = u' '.join([
112 | _generate_substrings(employee.first_name),
113 | _generate_substrings(employee.last_name),
114 | _generate_substrings(employee.username),
115 | ])
116 | doc = search.Document(fields=[
117 | # Full name is already unicode
118 | search.TextField(name='full_name', value=employee.full_name),
119 | search.TextField(name='username', value=employee.username),
120 | search.TextField(name='substrings', value=substrings),
121 | ])
122 | documents.append(doc)
123 | index.put(documents)
124 | logging.info('Done indexing employees. {}MB'.format(memory_usage().current))
125 |
126 |
127 | def _update_employees(employee_dicts):
128 | """Given a JSON string in the format "[{employee info 1}, {employee info 2}, ...]",
129 | create new employee records and update existing records as necessary.
130 |
131 | Then determine whether any employees have been terminated since the last update,
132 | and mark these employees as such.
133 | """
134 | employee_dicts = list(employee_dicts)
135 |
136 | logging.info('Updating employees... {}MB'.format(memory_usage().current))
137 |
138 | db_employee_dict = {
139 | employee.username: employee
140 | for employee in Employee.query()
141 | }
142 |
143 | all_employees, new_employees = [], []
144 | current_usernames = set()
145 | office_parser = OfficeParser(employee_dicts)
146 |
147 | for d in employee_dicts:
148 | d['office'] = office_parser.get_office_name(
149 | employee_office_location=d['office'],
150 | employee_department=d.get('department'),
151 | ) if d.get('office') else None
152 | existing_employee = db_employee_dict.get(d['username'])
153 |
154 | if existing_employee is None:
155 | new_employee = Employee.create_from_dict(d, persist=False)
156 | all_employees.append(new_employee)
157 | new_employees.append(new_employee)
158 | else:
159 | existing_employee.update_from_dict(d)
160 | # If the user is in the S3 dump, then the user is no longer
161 | # terminated.
162 | existing_employee.terminated = False
163 | all_employees.append(existing_employee)
164 |
165 | current_usernames.add(d['username'])
166 | if len(all_employees) % 200 == 0:
167 | logging.info('Processed {} employees, {}MB'.format(len(all_employees), memory_usage().current))
168 | ndb.put_multi(all_employees)
169 |
170 | # Figure out if there are any employees in the DB that aren't in the S3
171 | # dump. These are terminated employees, and we need to mark them as such.
172 | db_usernames = set(db_employee_dict.keys())
173 |
174 | terminated_usernames = db_usernames - current_usernames
175 | terminated_employees = []
176 | for username in terminated_usernames:
177 | employee = db_employee_dict[username]
178 | employee.terminated = True
179 | terminated_employees.append(employee)
180 | ndb.put_multi(terminated_employees)
181 |
182 | logging.info('Done updating employees. {}MB'.format(memory_usage().current))
183 |
184 |
185 | def combine_employees(old_username, new_username):
186 | set_toggle_state(LOVE_SENDING_ENABLED, False)
187 |
188 | old_employee_key = Employee.query(Employee.username == old_username).get(keys_only=True)
189 | new_employee_key = Employee.query(Employee.username == new_username).get(keys_only=True)
190 | if not old_employee_key:
191 | raise NoSuchEmployee(old_username)
192 | elif not new_employee_key:
193 | raise NoSuchEmployee(new_username)
194 |
195 | # First, we need to update the actual instances of Love sent to/from the old employee
196 | logging.info('Reassigning {}\'s love to {}...'.format(old_username, new_username))
197 |
198 | love_to_save = []
199 |
200 | # Reassign all love sent FROM old_username
201 | for sent_love in Love.query(Love.sender_key == old_employee_key).iter():
202 | sent_love.sender_key = new_employee_key
203 | love_to_save.append(sent_love)
204 |
205 | # Reassign all love sent TO old_username
206 | for received_love in Love.query(Love.recipient_key == old_employee_key).iter():
207 | received_love.recipient_key = new_employee_key
208 | love_to_save.append(received_love)
209 |
210 | ndb.put_multi(love_to_save)
211 | logging.info('Done reassigning love.')
212 |
213 | # Second, we need to update the LoveCount table
214 | logging.info('Updating LoveCount table...')
215 |
216 | love_counts_to_delete, love_counts_to_save = [], []
217 |
218 | for old_love_count in LoveCount.query(ancestor=old_employee_key).iter():
219 | # Try to find a corresponding row for the new employee
220 | new_love_count = LoveCount.query(
221 | ancestor=new_employee_key,
222 | filters=(LoveCount.week_start == old_love_count.week_start)
223 | ).get()
224 |
225 | if new_love_count is None:
226 | # If there's no corresponding row for the new user, create one
227 | new_love_count = LoveCount(
228 | parent=new_employee_key,
229 | received_count=old_love_count.received_count,
230 | sent_count=old_love_count.sent_count,
231 | week_start=old_love_count.week_start
232 | )
233 | else:
234 | # Otherwise, combine the two rows
235 | new_love_count.received_count += old_love_count.received_count
236 | new_love_count.sent_count += old_love_count.sent_count
237 |
238 | # You `delete` keys but you `put` entities... Google's APIs are weird
239 | love_counts_to_delete.append(old_love_count.key)
240 | love_counts_to_save.append(new_love_count)
241 |
242 | ndb.delete_multi(love_counts_to_delete)
243 | ndb.put_multi(love_counts_to_save)
244 | logging.info('Done updating LoveCount table.')
245 |
246 | # Now we can delete the old employee
247 | logging.info('Deleting employee {}...'.format(old_username))
248 | old_employee_key.delete()
249 | logging.info('Done deleting employee.')
250 |
251 | # ... Which means we need to rebuild the index
252 | rebuild_index()
253 |
254 | set_toggle_state(LOVE_SENDING_ENABLED, True)
255 |
256 |
257 | def employees_matching_prefix(prefix):
258 | """Returns a list of (full name, username) tuples for users that match the given prefix."""
259 | if not prefix:
260 | return []
261 |
262 | user_tuples = set()
263 |
264 | search_query = search.Query(
265 | query_string=prefix,
266 | options=search.QueryOptions(
267 | limit=15))
268 | results = search.Index(name=INDEX_NAME).search(search_query)
269 | for r in results:
270 | username, full_name = None, None
271 | for f in r.fields:
272 | if f.name == 'full_name':
273 | full_name = f.value
274 | elif f.name == 'username':
275 | username = f.value
276 | else:
277 | continue
278 | if username is not None and full_name is not None:
279 | photo_url = Employee.query(Employee.username == username).get().get_photo_url()
280 | user_tuples.add((full_name, username, photo_url))
281 |
282 | user_tuples = list(user_tuples)
283 | user_tuples.sort()
284 | return user_tuples
285 |
286 |
287 | def load_employees():
288 | employee_dicts = _get_employee_info_from_s3()
289 | set_toggle_state(LOVE_SENDING_ENABLED, False)
290 | _update_employees(employee_dicts)
291 | set_toggle_state(LOVE_SENDING_ENABLED, True)
292 | rebuild_index()
293 |
294 |
295 | def rebuild_index():
296 | active_employees_future = Employee.query(Employee.terminated == False).fetch_async() # noqa
297 | _clear_index()
298 | _index_employees(active_employees_future.get_result())
299 |
--------------------------------------------------------------------------------