def tearDown(self):
edb.get_analysis_timeseries_db().remove({'user_id': self.testUUID})
del_result = proxy.habiticaProxy(self.testUUID, "DELETE",
"/api/v3/user",
{'password': "******"})
edb.get_habitica_db().remove({'user_id': self.testUUID})
logging.debug("in tearDown, result = %s" % del_result)
def tearDown(self):
edb.get_analysis_timeseries_db().remove({'user_id': self.testUUID})
del_result = proxy.habiticaProxy(self.testUUID, "DELETE",
"/api/v3/user",
{'password': "******"})
edb.get_habitica_db().remove({'user_id': self.testUUID})
logging.debug("in tearDown, result = %s" % del_result)
def tearDown(self):
# https: // habitica.com / apidoc / # api-User-UserDelete
del_result = proxy.habiticaProxy(
self.testUserUUID, "DELETE", "/api/v3/user",
{'password': self.sampleAuthMessage1['password']})
edb.get_habitica_db().remove({'user_id': self.testUserUUID})
logging.debug("in tear_down, result = %s" % del_result)
def testJoinParty(self):
sampleAuthMessage1Ad = ad.AttrDict(self.sampleAuthMessage1)
proxy.habiticaRegister(sampleAuthMessage1Ad.username,
sampleAuthMessage1Ad.email,
sampleAuthMessage1Ad.password,
sampleAuthMessage1Ad.our_uuid)
#Create an inviter
inviterUUID = uuid.uuid4()
inviter = randomGen()
inviter_email = inviter + '@save.world'
inviter_id = proxy.habiticaRegister(inviter, inviter_email, inviter,
inviterUUID)['data']['id']
inviter_group_id = json.loads(
proxy.habiticaProxy(inviterUUID, 'POST', "/api/v3/groups", {
'type': 'party',
'privacy': 'private',
'name': inviter
}).text)['data']['id']
#Finally try to make this user (self) join the party
group_id_returned = proxy.setup_party(self.testUserUUID,
inviter_group_id, inviter_id)
self.assertEqual(group_id_returned, inviter_group_id)
#Now try to join again, it should throw an error
with self.assertRaises(RuntimeError):
proxy.setup_party(self.testUserUUID, inviter_group_id, inviter_id)
delete_inviter = proxy.habiticaProxy(inviterUUID, "DELETE",
"/api/v3/user",
{'password': inviter})
edb.get_habitica_db().remove({'user_id': inviterUUID})
def setup_party(user_id, group_id_from_url, inviterId):
#check if user is already in a party
method_url = "/api/v3/user"
result = habiticaProxy(user_id, 'GET', method_url, None)
data = result.json()
if '_id' in data['data']['party']:
group_id = data['data']['party']['_id']
logging.info("User %s is already part of group %s" %
(user_id, group_id))
raise RuntimeError("User %s is already a part of group %s" %
(user_id, group_id))
#if the user is not already in a party, then add them to the party to which they were invited
else:
group_id = group_id_from_url
invite_uri = "/api/v3/groups/" + group_id + "/invite"
logging.debug("invite user to party api url = %s" % invite_uri)
user_val = list(edb.get_habitica_db().find({"user_id": user_id}))[0]
method_args = {
'uuids': [user_val['habitica_id']],
'inviter': group_id,
'emails': []
}
emInviterId = edb.get_habitica_db().find_one(
{"habitica_id": inviterId})["user_id"]
response = habiticaProxy(emInviterId, 'POST', invite_uri, method_args)
logging.debug("invite user to party response = %s" % response)
join_url = "/api/v3/groups/" + group_id + "/join"
response2 = habiticaProxy(user_id, 'POST', join_url, {})
response.raise_for_status()
response2.raise_for_status()
return group_id
def tearDown(self):
# https: // habitica.com / apidoc / # api-User-UserDelete
del_result = proxy.habiticaProxy(self.testUserUUID, "DELETE",
"/api/v3/user",
{'password': self.sampleAuthMessage1['password']})
edb.get_habitica_db().remove({'user_id': self.testUserUUID})
logging.debug("in tear_down, result = %s" % del_result)
def testAddNewUser(self):
sampleAuthMessage1Ad = ad.AttrDict(self.sampleAuthMessage1)
proxy.habiticaRegister(sampleAuthMessage1Ad.username, sampleAuthMessage1Ad.email,
sampleAuthMessage1Ad.password, sampleAuthMessage1Ad.our_uuid)
find_it = edb.get_habitica_db().find({"user_id": self.testUserUUID})
self.assertEqual(edb.get_habitica_db().count_documents({"user_id": self.testUserUUID}), 1)
user_val = list(find_it)[0]
self.assertIsNotNone(user_val['habitica_id'])
self.assertEqual(user_val['habitica_username'], sampleAuthMessage1Ad.username)
def testAutomaticRewardActiveTransportation(self):
#Create test data -- code copied from TestTimeGrouping
key = (2016, 5, 3)
test_section_list = []
#
# Since PST is UTC-7, all of these will be in the same UTC day
# 13:00, 17:00, 21:00
# so we expect the local date and UTC bins to be the same
test_section_list.append(
self._createTestSection(
arrow.Arrow(2016, 5, 3, 6, tzinfo=tz.gettz(PST)), PST))
test_section_list.append(
self._createTestSection(
arrow.Arrow(2016, 5, 3, 10, tzinfo=tz.gettz(PST)), PST))
test_section_list.append(
self._createTestSection(
arrow.Arrow(2016, 5, 3, 14, tzinfo=tz.gettz(PST)), PST))
self._fillModeDistanceDuration(test_section_list)
#logging.debug("durations = %s" % [s.data.duration for s in test_section_list])
summary_ts = earmt.group_by_timestamp(
self.testUUID,
arrow.Arrow(2016, 5, 1).timestamp,
arrow.Arrow(2016, 6, 1).timestamp, None, earmts.get_distance)
logging.debug(
"in testAutomaticRewardActiveTransportation, result = %s" %
summary_ts)
#Get user data before scoring
user_before = list(edb.get_habitica_db().find(
{'user_id': self.testUUID}))[0]['metrics_data']
self.assertEqual(int(user_before['bike_count']), 0)
habits_before = proxy.habiticaProxy(self.testUUID, 'GET',
"/api/v3/tasks/user?type=habits",
None).json()
bike_pts_before = [
habit['history'] for habit in habits_before['data']
if habit['text'] == "Bike"
]
#Score points
autocheck.reward_active_transportation(self.testUUID)
#Get user data after scoring and check results
user_after = list(edb.get_habitica_db().find(
{'user_id': self.testUUID}))[0]['metrics_data']
self.assertEqual(int(user_after['bike_count']), 1500)
habits_after = proxy.habiticaProxy(self.testUUID, 'GET',
"/api/v3/tasks/user?type=habits",
None).json()
bike_pts_after = [
habit['history'] for habit in habits_after['data']
if habit['text'] == "Bike"
]
self.assertTrue(len(bike_pts_after[0]) - len(bike_pts_before[0]) == 2)
def reset_user(reset_em_uuid):
del_result = proxy.habiticaProxy(reset_em_uuid, "POST",
"/api/v3/user/reset", {})
update_result = edb.get_habitica_db().update({"user_id": reset_em_uuid},
{"$set": {'metrics_data':
{'last_timestamp': 0, 'bike_count': 0, 'walk_count': 0}}})
logging.debug("reset result for %s = %s, %s" % (reset_em_uuid, del_result, update_result))
def reset_user(reset_em_uuid):
del_result = proxy.habiticaProxy(reset_em_uuid, "POST",
"/api/v3/user/reset", {})
update_result = edb.get_habitica_db().update({"user_id": reset_em_uuid},
{"$set": {'metrics_data':
{'last_timestamp': 0, 'bike_count': 0, 'walk_count': 0}}})
logging.debug("reset result for %s = %s, %s" % (reset_em_uuid, del_result, update_result))
def testJoinParty(self):
sampleAuthMessage1Ad = ad.AttrDict(self.sampleAuthMessage1)
proxy.habiticaRegister(sampleAuthMessage1Ad.username, sampleAuthMessage1Ad.email,
sampleAuthMessage1Ad.password, sampleAuthMessage1Ad.our_uuid)
#Create an inviter
inviterUUID = uuid.uuid4()
inviter = randomGen()
inviter_email = inviter + '@save.world'
inviter_id = proxy.habiticaRegister(inviter, inviter_email, inviter, inviterUUID)['data']['id']
inviter_group_id = json.loads(proxy.habiticaProxy(inviterUUID, 'POST', "/api/v3/groups", {'type': 'party', 'privacy': 'private', 'name': inviter}).text)['data']['id']
#Finally try to make this user (self) join the party
group_id_returned = proxy.setup_party(self.testUserUUID, inviter_group_id, inviter_id)
self.assertEqual(group_id_returned, inviter_group_id)
#Now try to join again, it should throw an error
with self.assertRaises(RuntimeError):
proxy.setup_party(self.testUserUUID, inviter_group_id, inviter_id)
delete_inviter = proxy.habiticaProxy(inviterUUID, "DELETE", "/api/v3/user", {'password': inviter})
edb.get_habitica_db().remove({'user_id': inviterUUID})
def habiticaProxy(user_uuid, method, method_url, method_args):
logging.debug("For user %s, about to proxy %s method %s with args %s" %
(user_uuid, method, method_url, method_args))
user_query = {'user_id': user_uuid}
assert (edb.get_habitica_db().find(user_query).count() == 1)
stored_cfg = edb.get_habitica_db().find_one(user_query)
auth_headers = {
'x-api-user': stored_cfg['habitica_id'],
'x-api-key': stored_cfg['habitica_token']
}
logging.debug("auth_headers = %s" % auth_headers)
habitica_url = url + method_url
result = requests.request(method,
habitica_url,
headers=auth_headers,
json=method_args)
logging.debug("result = %s" % result)
result.raise_for_status()
return result
def setUp(self):
#load test user
party.create_party_leaders()
self.testUUID = uuid.uuid4()
autogen_string = randomGen()
autogen_email = autogen_string + '@test.com'
self.sampleAuthMessage1 = {
'username': autogen_string,
'email': autogen_email,
'password': "******",
'our_uuid': self.testUUID
}
sampleAuthMessage1Ad = ad.AttrDict(self.sampleAuthMessage1)
proxy.habiticaRegister(sampleAuthMessage1Ad.username,
sampleAuthMessage1Ad.email,
sampleAuthMessage1Ad.password,
sampleAuthMessage1Ad.our_uuid)
edb.get_habitica_db().update({"user_id": self.testUUID}, {
"$set": {
'metrics_data.last_timestamp': arrow.Arrow(2016, 5,
1).timestamp
}
},
upsert=True)
self.ts = esta.TimeSeries.get_time_series(self.testUUID)
bike_habit = {
'type': "habit",
'text': "Bike",
'up': True,
'down': False,
'priority': 2
}
bike_habit_id = proxy.create_habit(self.testUUID, bike_habit)
walk_habit = {
'type': "habit",
'text': "Walk",
'up': True,
'down': False,
'priority': 2
}
walk_habit_id = proxy.create_habit(self.testUUID, walk_habit)
logging.debug("in setUp, result = %s" % self.ts)
def testAddNewUser(self):
sampleAuthMessage1Ad = ad.AttrDict(self.sampleAuthMessage1)
proxy.habiticaRegister(sampleAuthMessage1Ad.username, sampleAuthMessage1Ad.email,
sampleAuthMessage1Ad.password, sampleAuthMessage1Ad.our_uuid)
find_it = edb.get_habitica_db().find({"user_id": self.testUserUUID})
self.assertEqual(find_it.count(), 1)
user_val = list(find_it)[0]
self.assertIsNotNone(user_val['habitica_id'])
self.assertEqual(user_val['habitica_username'], sampleAuthMessage1Ad.username)
def setup_party(user_id, group_id_from_url, inviterId):
#check if user is already in a party
method_url = "/api/v3/user"
result = habiticaProxy(user_id, 'GET', method_url, None)
data = result.json()
if '_id' in data['data']['party']:
group_id = data['data']['party']['_id']
logging.info("User %s is already part of group %s" % (user_id, group_id))
raise RuntimeError("User %s is already a part of group %s" % (user_id, group_id))
#if the user is not already in a party, then add them to the party to which they were invited
else:
group_id = group_id_from_url
invite_uri = "/api/v3/groups/"+group_id+"/invite"
logging.debug("invite user to party api url = %s" % invite_uri)
user_val = list(edb.get_habitica_db().find({"user_id": user_id}))[0]
method_args = {'uuids': [user_val['habitica_id']], 'inviter': group_id, 'emails': []}
emInviterId = edb.get_habitica_db().find_one({"habitica_id": inviterId})["user_id"]
response = habiticaProxy(emInviterId, 'POST', invite_uri, method_args)
logging.debug("invite user to party response = %s" % response)
join_url = "/api/v3/groups/"+group_id+"/join"
response2 = habiticaProxy(user_id, 'POST', join_url, {})
response.raise_for_status()
response2.raise_for_status()
return group_id
def setup_party(user_id):
group_id = list(edb.get_habitica_db().find({"user_id": user_id
}))[0]['habitica_group_id']
if group_id is None:
#check if user is already in a party
try:
method_url = "/api/v3/user"
result = habiticaProxy(user_id, 'GET', method_url, None)
data = result.json()
group_id = data['data']['party']['_id']
edb.get_habitica_db().update(
{"user_id": user_id},
{"$set": {
'habitica_group_id': group_id
}},
upsert=True)
except KeyError:
#parties = [{"leader": "Juliana", "group_id": "488cae51-aeee-4004-9fa0-dd4219a3a77e"}, {"leader": "Sunil", "group_id": "751e5f9a-bd2d-4c4c-ba81-6fb89bccdf5d"}, {"leader": "Shankari", "group_id": "93c35a70-f70e-4d6e-ac2b-3e1c81fedf0f"}]
parties = ["Juliana", "Sunil", "Shankari"]
group = random.randint(0, 2)
leader_val = list(edb.get_habitica_db().find(
{"habitica_username": parties[group]}))[0]
logging.debug("party leader = %s" % leader_val)
group_id = leader_val['habitica_group_id']
invite_uri = "/api/v3/groups/" + group_id + "/invite"
logging.debug("invite user to party api url = %s" % invite_uri)
user_val = list(edb.get_habitica_db().find({"user_id":
user_id}))[0]
method_args = {
'uuids': [user_val['habitica_id']],
'inviter': parties[group],
'emails': []
}
response = habiticaProxy(leader_val['user_id'], 'POST', invite_uri,
method_args)
logging.debug("invite user to party response = %s" % response)
response.raise_for_status()
edb.get_habitica_db().update(
{"user_id": user_id},
{"$set": {
'habitica_group_id': group_id
}},
upsert=True)
return group_id
def save_user_entry(user_id, user_entry):
assert (user_entry["user_id"] == user_id)
return edb.get_habitica_db().save(user_entry)
def get_user_entry(user_id):
user_query = {'user_id': user_id}
# TODO: Raise a real, descriptive exception here instead of asserting
assert (edb.get_habitica_db().find(user_query).count() == 1)
stored_cfg = edb.get_habitica_db().find_one(user_query)
return stored_cfg
def habiticaRegister(username, email, password, our_uuid):
user_dict = {}
#if user is already in e-mission db, try to load user data
if edb.get_habitica_db().find({'user_id': our_uuid}).count() == 1:
try:
result = habiticaProxy(our_uuid, 'GET', '/api/v3/user', None)
user_dict = result.json()
logging.debug("parsed json from GET habitica user = %s" %
user_dict)
#if it fails, then user is in db but not in Habitica, so needs to create new account
#FIX! Still need to test if this will throw an error correctly
except urllib2.HTTPError:
user_dict = newHabiticaUser(username, email, password, our_uuid)
edb.get_habitica_db().update(
{"user_id": our_uuid},
{"$set": initUserDoc(our_uuid, username, password, user_dict)},
upsert=True)
#if user_dict['data']['party']['_id']:
#edb.get_habitica_db().update({"user_id": our_uuid},{"$set": {'habitica_group_id': user_dict['data']['party']['_id']}},upsert=True)
#now we have the user data in user_dict, so check if db is correct
#Fix! should prob check here if our db is right
#if user is not in db, try to log in using email and password
else:
try:
login_url = url + '/api/v3/user/auth/local/login'
user_request = {
'username': username,
'email': email,
'password': password
}
logging.debug("About to login %s" % user_request)
login_response = requests.post(login_url, json=user_request)
logging.debug("response = %s" % login_response)
#if 401 error, then user is not in Habitica, so create new account and pass user to user_dict
if login_response.status_code == 401:
user_dict = newHabiticaUser(username, email, password,
our_uuid)
else:
logging.debug("habitica http response from login = %s" %
login_response)
user_auth = json.loads(login_response.text)
logging.debug("parsed json from habitica has keys = %s" %
user_auth)
#login only returns user auth headers, so now get authenticated user and put it in user_dict
auth_headers = {
'x-api-user': user_auth['data']['id'],
'x-api-key': user_auth['data']['apiToken']
}
get_user_url = url + '/api/v3/user'
result = requests.request('GET',
get_user_url,
headers=auth_headers,
json={})
logging.debug("result = %s" % result)
result.raise_for_status()
user_dict = result.json()
user_dict['data']['apiToken'] = user_auth['data']['apiToken']
logging.debug("parsed json from GET habitica user = %s" %
user_dict)
#If if fails to login AND to create new user, throw exception
except:
logging.exception("Exception while trying to login/signup!")
logging.debug("habitica user to be created in our db = %s" %
user_dict['data'])
#Now save new user (user_dict) to our db
#Since we are randomly generating the password, we store it in case users
#want to access their Habitica account from the browser
#Need to create a way from them to retrieve username/password
#metrics_data is used to calculate points based on km biked/walked
#last_timestamp is the last time the user got points, and bike/walk_count are the leftover km
habitica_user_table = edb.get_habitica_db()
insert_doc = initUserDoc(our_uuid, username, password, user_dict)
insert_doc.update({'user_id': our_uuid})
habitica_user_table.insert(insert_doc)
#Since we have a new user in our db, create its default habits (walk, bike)
setup_default_habits(our_uuid)
return user_dict
def get_user_entry(user_id):
user_query = {'user_id': user_id}
# TODO: Raise a real, descriptive exception here instead of asserting
assert(edb.get_habitica_db().find(user_query).count() == 1)
stored_cfg = edb.get_habitica_db().find_one(user_query)
return stored_cfg
def save_user_entry(user_id, user_entry): assert(user_entry["user_id"] == user_id) return edb.save(edb.get_habitica_db(), user_entry)
def habiticaRegister(username, email, password, our_uuid):
user_dict = {}
#if user is already in e-mission db, try to load user data
if edb.get_habitica_db().find({'user_id': our_uuid}).count() == 1:
try:
result = habiticaProxy(our_uuid, 'GET', '/api/v3/user', None)
user_dict = result.json()
logging.debug("parsed json from GET habitica user = %s" % user_dict)
#if it fails, then user is in db but not in Habitica, so needs to create new account
#FIX! Still need to test if this will throw an error correctly
except urllib.error.HTTPError:
user_dict = newHabiticaUser(username, email, password, our_uuid)
edb.get_habitica_db().update({"user_id": our_uuid},{"$set":
initUserDoc(our_uuid, username, password, user_dict)
},upsert=True)
#if user_dict['data']['party']['_id']:
#edb.get_habitica_db().update({"user_id": our_uuid},{"$set": {'habitica_group_id': user_dict['data']['party']['_id']}},upsert=True)
#now we have the user data in user_dict, so check if db is correct
#Fix! should prob check here if our db is right
#if user is not in db, try to log in using email and password
else:
try:
login_url = url + '/api/v3/user/auth/local/login'
user_request = {'username': username,'email': email,'password': password}
logging.debug("About to login %s"% user_request)
login_response = requests.post(login_url, json=user_request)
logging.debug("response = %s" % login_response)
#if 401 error, then user is not in Habitica, so create new account and pass user to user_dict
if login_response.status_code == 401:
user_dict = newHabiticaUser(username, email, password, our_uuid)
else:
logging.debug("habitica http response from login = %s" % login_response)
user_auth = json.loads(login_response.text)
logging.debug("parsed json from habitica has keys = %s" % user_auth)
#login only returns user auth headers, so now get authenticated user and put it in user_dict
auth_headers = {'x-api-user': user_auth['data']['id'], 'x-api-key': user_auth['data']['apiToken']}
get_user_url = url + '/api/v3/user'
result = requests.request('GET', get_user_url, headers=auth_headers, json={})
logging.debug("result = %s" % result)
result.raise_for_status()
user_dict = result.json()
user_dict['data']['apiToken'] = user_auth['data']['apiToken']
logging.debug("parsed json from GET habitica user = %s" % user_dict)
#If if fails to login AND to create new user, throw exception
except:
logging.exception("Exception while trying to login/signup!")
logging.debug("habitica user to be created in our db = %s" % user_dict['data'])
#Now save new user (user_dict) to our db
#Since we are randomly generating the password, we store it in case users
#want to access their Habitica account from the browser
#Need to create a way from them to retrieve username/password
#metrics_data is used to calculate points based on km biked/walked
#last_timestamp is the last time the user got points, and bike/walk_count are the leftover km
habitica_user_table = edb.get_habitica_db()
insert_doc = initUserDoc(our_uuid, username, password, user_dict)
insert_doc.update({'user_id': our_uuid})
habitica_user_table.insert(insert_doc)
#Since we have a new user in our db, create its default habits (walk, bike)
setup_default_habits(our_uuid)
return user_dict
import emission.core.get_database as edb
import emission.net.ext_service.habitica.proxy as proxy
import net.ext_service.habitica.executor as autocheck
def reset_user(reset_em_uuid):
del_result = proxy.habiticaProxy(reset_em_uuid, "POST",
"/api/v3/user/reset", {})
update_result = edb.get_habitica_db().update({"user_id": reset_em_uuid},
{"$set": {'metrics_data':
{'last_timestamp': 0, 'bike_count': 0, 'walk_count': 0}}})
logging.debug("reset result for %s = %s, %s" % (reset_em_uuid, del_result, update_result))
if __name__ == '__main__':
logging.basicConfig(level=logging.DEBUG)
parser = argparse.ArgumentParser()
parser.add_argument("-r", "--restore",
help="re-run pipeline and restore values", action="store_true")
args = parser.parse_args()
for creds in edb.get_habitica_db().find():
reset_uuid = creds["user_id"]
logging.debug("Processing emission user id %s" % reset_uuid)
reset_user(reset_uuid)
if args.restore:
autocheck.give_points_for_all_tasks(reset_uuid)
edb.get_uuid_db().update({"uuid" : user.uuid},
{"$set": {"uuid" : new_uuid}})
logging.debug("Resetting alternatives...")
reset_collection(edb.get_alternatives_db(), user.uuid, new_uuid)
logging.debug("Resetting analysis...")
reset_collection(edb.get_analysis_timeseries_db(), user.uuid, new_uuid)
logging.debug("Resetting client...")
reset_collection(edb.get_client_db(), user.uuid, new_uuid)
logging.debug("Resetting client_stats_backup...")
reset_collection(edb.get_client_stats_db_backup(), user.uuid, new_uuid)
logging.debug("Resetting server_stats_backup...")
reset_collection(edb.get_server_stats_db_backup(), user.uuid, new_uuid)
logging.debug("Resetting result_stats_backup...")
reset_collection(edb.get_result_stats_db_backup(), user.uuid, new_uuid)
logging.debug("Resetting edb.get_common_place_db...")
reset_collection(edb.get_common_place_db(), user.uuid, new_uuid)
logging.debug("Resetting edb.get_common_trip_db...")
reset_collection(edb.get_common_trip_db(), user.uuid, new_uuid)
logging.debug("Resetting edb.get_habitica_db...")
reset_collection(edb.get_habitica_db(), user.uuid, new_uuid)
logging.debug("Resetting edb.get_pipeline_state_db...")
reset_collection(edb.get_pipeline_state_db(), user.uuid, new_uuid)
logging.debug("Resetting edb.get_profile_db...")
reset_collection(edb.get_profile_db(), user.uuid, new_uuid)
logging.debug("Resetting edb.get_timeseries_db...")
reset_collection(edb.get_timeseries_db(), user.uuid, new_uuid)
logging.debug("Resetting edb.get_timeseries_error_db...")
reset_collection(edb.get_timeseries_error_db(), user.uuid, new_uuid)
logging.debug("Resetting edb.get_usercache_db...")
reset_collection(edb.get_usercache_db(), user.uuid, new_uuid)
import logging
import emission.core.get_database as edb
if __name__ == '__main__':
logging.basicConfig(level=logging.DEBUG)
for group_of_dups in edb.get_habitica_db().aggregate([{
"$group": {
"_id": {
"user_id": "$user_id"
},
"dups": {
"$push": "$user_id"
},
"count": {
"$sum": 1
}
}
}, {
"$match": {
"count": {
"$gt": 1
}
}
}])['result']:
logging.debug("Group of Duplicates %s" % group_of_dups)
bike = 0
walk = 0
for dup in group_of_dups['dups']:
logging.debug("Each Duplicate %s" % dup)
bike += list(edb.get_habitica_db().find(
"/api/v3/user/reset", {})
update_result = edb.get_habitica_db().update({"user_id": reset_em_uuid}, {
"$set": {
'metrics_data': {
'last_timestamp': 0,
'bike_count': 0,
'walk_count': 0
}
}
})
logging.debug("reset result for %s = %s, %s" %
(reset_em_uuid, del_result, update_result))
if __name__ == '__main__':
logging.basicConfig(level=logging.DEBUG)
parser = argparse.ArgumentParser()
parser.add_argument("-r",
"--restore",
help="re-run pipeline and restore values",
action="store_true")
args = parser.parse_args()
for creds in edb.get_habitica_db().find():
reset_uuid = creds["user_id"]
logging.debug("Processing emission user id %s" % reset_uuid)
reset_user(reset_uuid)
if args.restore:
autocheck.give_points_for_all_tasks(reset_uuid)
def reward_active_transportation(user_id):
logging.debug("Entering habitica autocheck for user %s" % user_id)
if edb.get_habitica_db().find({'user_id': user_id}).count() == 1:
logging.debug("Habitica user: %s" %
list(edb.get_habitica_db().find({'user_id': user_id})))
#make sure habits exist
#bike
bike_habit = {
'type': "habit",
'text': "Bike",
'up': True,
'down': False,
'priority': 2
}
bike_habit_id = proxy.create_habit(user_id, bike_habit)
#walk
walk_habit = {
'type': "habit",
'text': "Walk",
'up': True,
'down': False,
'priority': 2
}
walk_habit_id = proxy.create_habit(user_id, walk_habit)
#get timestamps
user_val = list(edb.get_habitica_db().find({"user_id": user_id
}))[0]['metrics_data']
timestamp_from_db = user_val['last_timestamp']
timestamp_now = arrow.utcnow().timestamp
#Get metrics
summary_ts = earmt.group_by_timestamp(user_id, timestamp_from_db,
timestamp_now, None,
earmts.get_distance)
logging.debug("Metrics response: %s" % summary_ts)
#get distances leftover from last timestamp
bike_distance = user_val['bike_count']
walk_distance = user_val['walk_count']
#iterate over summary_ts and look for bike/on foot
for item in summary_ts:
try:
bike_distance += item.BICYCLING
logging.debug("bike_distance += %s" % item.BICYCLING)
except AttributeError:
logging.debug("no bike")
try:
walk_distance += item.ON_FOOT
logging.debug("walk_distance += %s" % item.ON_FOOT)
except AttributeError:
logging.debug("no Android walk")
try:
walk_distance += item.WALKING
logging.debug("walk_distance += %s" % item.WALKING)
except AttributeError:
logging.debug("no ios walk")
try:
walk_distance += item.RUNNING
logging.debug("walk_distance += %s" % item.RUNNING)
except AttributeError:
logging.debug("no running")
logging.debug("Finished with bike_distance == %s" % bike_distance)
logging.debug("Finished with walk_distance == %s" % walk_distance)
method_uri_walk = "/api/v3/tasks/" + walk_habit_id + "/score/up"
method_uri_bike = "/api/v3/tasks/" + bike_habit_id + "/score/up"
#reward user by scoring + habits
# Walk: +1 for every km
walk_pts = int(walk_distance // 1000)
for i in range(walk_pts):
res = proxy.habiticaProxy(user_id, 'POST', method_uri_walk, None)
logging.debug("Request to score walk points %s" % res)
# Bike: +1 for every 3 km
bike_pts = int(bike_distance // 3000)
for i in range(bike_pts):
res2 = proxy.habiticaProxy(user_id, 'POST', method_uri_bike, None)
logging.debug("Request to score bike points %s" % res2)
#update the timestamp and bike/walk counts in db
edb.get_habitica_db().update({"user_id": user_id}, {
"$set": {
'metrics_data': {
'last_timestamp': arrow.utcnow().timestamp,
'bike_count': bike_distance % 3000,
'walk_count': walk_distance % 1000
}
}
},
upsert=True)
logging.debug("Habitica user after update: %s" %
list(edb.get_habitica_db().find({'user_id': user_id})))
reset_collection(edb.get_analysis_timeseries_db(), user.uuid,
new_uuid)
logging.debug("Resetting client...")
reset_collection(edb.get_client_db(), user.uuid, new_uuid)
logging.debug("Resetting client_stats_backup...")
reset_collection(edb.get_client_stats_db_backup(), user.uuid,
new_uuid)
logging.debug("Resetting server_stats_backup...")
reset_collection(edb.get_server_stats_db_backup(), user.uuid,
new_uuid)
logging.debug("Resetting result_stats_backup...")
reset_collection(edb.get_result_stats_db_backup(), user.uuid,
new_uuid)
logging.debug("Resetting edb.get_common_place_db...")
reset_collection(edb.get_common_place_db(), user.uuid, new_uuid)
logging.debug("Resetting edb.get_common_trip_db...")
reset_collection(edb.get_common_trip_db(), user.uuid, new_uuid)
logging.debug("Resetting edb.get_habitica_db...")
reset_collection(edb.get_habitica_db(), user.uuid, new_uuid)
logging.debug("Resetting edb.get_pipeline_state_db...")
reset_collection(edb.get_pipeline_state_db(), user.uuid, new_uuid)
logging.debug("Resetting edb.get_profile_db...")
reset_collection(edb.get_profile_db(), user.uuid, new_uuid)
logging.debug("Resetting edb.get_timeseries_db...")
reset_collection(edb.get_timeseries_db(), user.uuid, new_uuid)
logging.debug("Resetting edb.get_timeseries_error_db...")
reset_collection(edb.get_timeseries_error_db(), user.uuid,
new_uuid)
logging.debug("Resetting edb.get_usercache_db...")
reset_collection(edb.get_usercache_db(), user.uuid, new_uuid)
def create_new_tasks(uuid):
bike_walk_habit = {'type': "habit", 'text': "Bike and Walk", 'notes': "Automatically get points for every 1 km walked or biked. ***=== DO NOT EDIT BELOW THIS POINT ===*** AUTOCHECK: {\"mapper\": \"active_distance\", \"args\": {\"walk_scale\": 1000, \"bike_scale\": 1000}}", 'up': True, 'down': False, 'priority': 2}
bike_walk_habit_id = proxy.create_habit(uuid, bike_walk_habit)
invite_friends = {'type': "habit", 'text': "Spread the word", 'notes': "Get points for inviting your friends! We're better together.", 'up': True, 'down': False, 'priority': 2}
invite_friends_id = proxy.create_habit(uuid, invite_friends)
if __name__ == '__main__':
logging.basicConfig(level=logging.DEBUG)
parser = argparse.ArgumentParser()
group = parser.add_mutually_exclusive_group(required=True)
group.add_argument("-e", "--user_email")
group.add_argument("-u", "--user_uuid")
group.add_argument("-a", "--all", action="store_true")
args = parser.parse_args()
if args.all:
for uuid in edb.get_habitica_db().distinct("user_id"):
logging.debug("About to check user %s" % uuid)
fix_autocheck_for_user(uuid)
else:
if args.user_uuid:
del_uuid = uuid.UUID(args.user_uuid)
else:
del_uuid = ecwu.User.fromEmail(args.user_email).uuid
fix_autocheck_for_user(del_uuid)
import logging
import uuid
import emission.core.get_database as edb
import emission.core.wrapper.user as ecwu
import emission.net.ext_service.habitica.proxy as proxy
if __name__ == '__main__':
logging.basicConfig(level=logging.DEBUG)
parser = argparse.ArgumentParser()
group = parser.add_mutually_exclusive_group(required=True)
group.add_argument("-e", "--user_email")
group.add_argument("-u", "--user_uuid")
args = parser.parse_args()
if args.user_uuid:
del_uuid = uuid.UUID(args.user_uuid)
else:
del_uuid = ecwu.User.fromEmail(args.user_email).uuid
logging.debug("Found uuid %s" % del_uuid)
del_habitica_creds = edb.get_habitica_db().find_one({'user_id': del_uuid})
logging.debug("del_habitica_creds = %s" % del_habitica_creds)
del_result = proxy.habiticaProxy(del_uuid, "DELETE",
"/api/v3/user",
{'password': del_habitica_creds['habitica_password']})
logging.debug("delete result = %s" % del_result)
edb.get_habitica_db().remove({'user_id': del_uuid})
import argparse
import sys
import logging
import emission.core.get_database as edb
import emission.net.ext_service.habitica.proxy as proxy
if __name__ == '__main__':
logging.basicConfig(level=logging.DEBUG)
parser = argparse.ArgumentParser()
parser.add_argument(
"user_email",
help=
"the email address of the user whose habitica account you want to clean up"
)
args = parser.parse_args()
del_uuid = edb.get_uuid_db().find_one({'user_email':
args.user_email})['uuid']
logging.debug("Found uuid %s" % del_uuid)
del_habitica_creds = edb.get_habitica_db().find_one({'user_id': del_uuid})
logging.debug("del_habitica_creds = %s" % del_habitica_creds)
del_result = proxy.habiticaProxy(
del_uuid, "DELETE", "/api/v3/user",
{'password': del_habitica_creds['habitica_password']})
logging.debug("delete result = %s" % del_result)
from __future__ import division
from __future__ import absolute_import
from future import standard_library
standard_library.install_aliases()
from builtins import *
import logging
import emission.core.get_database as edb
if __name__ == '__main__':
logging.basicConfig(level=logging.DEBUG)
for group_of_dups in edb.get_habitica_db().aggregate([
{ "$group": {
"_id": { "user_id": "$user_id" },
"dups": { "$push": "$user_id" },
"count": { "$sum": 1 }
}},
{ "$match": { "count": { "$gt": 1 } }}
])['result']:
logging.debug("Group of Duplicates %s" % group_of_dups)
bike = 0
walk = 0
for dup in group_of_dups['dups']:
logging.debug("Each Duplicate %s" % dup)
bike += list(edb.get_habitica_db().find({'user_id': dup}))[0]['metrics_data']['bike_count']
walk += list(edb.get_habitica_db().find({'user_id': dup}))[0]['metrics_data']['walk_count']
if edb.get_habitica_db().find({'user_id': dup}).count() > 1:
edb.get_habitica_db().remove({'user_id': dup}, multi=False)
elif edb.get_habitica_db().find({'user_id': dup}).count() == 1:
edb.get_habitica_db().update({"user_id": dup},{"$set": {'metrics_data.bike_count': bike, 'metrics_data.walk_count': walk}},upsert=True)
