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 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)