def load(self): """ Load cases from persistant storage. """ the_redis = DARedis() cases = the_redis.get_data(self.user_cases_key) or {} self.cases = cases
def delete_credentials(self): """Deletes the stored credentials.""" self._setup() r = DARedis() r.delete(self._get_redis_key()) storage = self._get_redis_cred_storage() storage.locked_delete()
def read(self) -> dict: """ Read the list of counties from file storage. """ the_redis = DARedis() result = the_redis.get_data(STORE) return result
def _get_random_unique_id(self): r = DARedis() tries = 10 while tries > 0: key = random_alphanumeric(32) if r.setnx('da:' + self.appname + ':status:uniqueid:' + key, 'None'): r.expire('da:' + self.appname + ':status:uniqueid:' + key, 300) return key tries -= 1 raise Exception("DAOAuth: unable to set a random unique id")
def read(self) -> dict: """ Read the list of counties from local storage. """ result = None try: the_redis = DARedis() result = the_redis.get_data(STORE) except Exception as e: logmessage(f"Unable to read cached list of courts: {str(e)}") return result
class RedisCredStorage(oauth2client.client.Storage): def __init__(self, app): self.r = DARedis() self.key = 'da:' + app + ':user:'******'da:' + app + ':lock:user:' + user_info().email def acquire_lock(self): pipe = self.r.pipeline() pipe.set(self.lockkey, 1) pipe.expire(self.lockkey, 5) pipe.execute() def release_lock(self): self.r.delete(self.lockkey) def locked_get(self): json_creds = self.r.get(self.key) creds = None if json_creds is not None: json_creds = json_creds.decode() try: creds = oauth2client.client.Credentials.new_from_json( json_creds) except: log("RedisCredStorage: could not read credentials from " + str(json_creds)) return creds def locked_put(self, credentials): self.r.set(self.key, credentials.to_json()) def locked_delete(self): self.r.delete(self.key)
def save(self, courts: dict, courts_by_county: dict) -> bool: """ Persist the list of courts to local storage. Args: courts (dict): Dict of courts indexed by court id courts_by_county (dict): Dict where index is County and value is list of courts Returns: (bool): True if successful, otherwise False """ try: the_redis = DARedis() the_redis.set_data(STORE, cache_record(courts, courts_by_county)) return True except Exception as e: logmessage(f"Unable to cache list of courts: {str(e)}") return False
def save(self, case) -> bool: """ Save the revised case list. If a case is provided, then add it to the case list before saving. If no case is provided, then save the case list without doing anything else. (This is probably called by a delete operation.) Args: case (Case): Case to add to list or None Returns: (bool): True is successful save, otherwise raises exception. """ if case: key = case_key(case) case.key = key self.cases[key] = case the_redis = DARedis() the_redis.set_data(self.user_cases_key, self.cases) return True
def get_credentials(self): r = DARedis() r_key = 'da:' + self.appname + ':status:user:'******'code' in self.url_args and 'state' in self.url_args: r.delete(r_key) if self.url_args['state'] != stored_state.decode(): raise Exception("State did not match") flow = self._get_flow() credentials = flow.step2_exchange(self.url_args['code']) storage = RedisCredStorage(self.appname) storage.put(credentials) del self.url_args['code'] del self.url_args['state'] else: message("Please wait.", "You are in the process of authenticating.") storage = RedisCredStorage(self.appname) credentials = storage.get() if not credentials or credentials.invalid: state_string = random_string(16) pipe = r.pipeline() pipe.set(r_key, state_string) pipe.expire(r_key, 60) pipe.execute() flow = self._get_flow() uri = flow.step1_get_authorize_url(state=state_string) if 'state' in self.url_args: del self.url_args['state'] if 'code' in self.url_args: del self.url_args['code'] response(url=uri) return credentials
def fetch_philadox_info(self): r = DARedis() while r.get('using_philadox') is not None: time.sleep(5) pipe = r.pipeline() pipe.set('using_philadox', 1) pipe.expire('using_philadox', 120) pipe.execute() tdir = tempfile.mkdtemp() info = urllib.quote(json.dumps([self.address['number'], self.address['direction'], self.address['street'], tdir, get_config('philadox username'), get_config('philadox password')])) step = ['casperjs', DAStaticFile(filename='eagleweb.js').path(), info] result = subprocess.call(step) r.delete('using_philadox') if result != 0: raise Exception("Failed to fetch Philadox information") outfiles = [] for pdf_file in sorted([f for f in os.listdir(tdir) if f.endswith('.pdf')]): new_file = DAFile() new_file.set_random_instance_name() new_file.initialize(filename=pdf_file) new_file.copy_into(os.path.join(tdir, pdf_file)) new_file.retrieve() new_file.commit() outfiles.append(new_file) self.philadox_files = outfiles
def get_credentials(self): self._setup() r = DARedis() r_key = self._get_redis_key() stored_state = r.get(r_key) if stored_state is not None and stored_state.decode() == 'None': stored_state = None if stored_state is not None: if 'code' in self.url_args and 'state' in self.url_args: r.delete(r_key) if self.url_args['state'] != stored_state.decode(): raise Exception("State did not match. " + repr(self.url_args['state']) + " vs " + repr(stored_state.decode()) + " where r_key is " + repr(r_key)) flow = self._get_flow() credentials = flow.step2_exchange(self.url_args['code']) storage = self._get_redis_cred_storage() storage.put(credentials) del self.url_args['code'] del self.url_args['state'] else: message("Please wait.", "You are in the process of authenticating.", dead_end=True) storage = self._get_redis_cred_storage() credentials = storage.get() if not credentials or credentials.invalid: state_string = safeid(user_info().filename + '^' + random_string(8)) pipe = r.pipeline() pipe.set(r_key, state_string) pipe.expire(r_key, 300) pipe.execute() flow = self._get_flow() uri = flow.step1_get_authorize_url(state=state_string) if 'state' in self.url_args: del self.url_args['state'] if 'code' in self.url_args: del self.url_args['code'] response(url=uri) return credentials
def __init__(self, app): self.r = DARedis() self.key = 'da:' + app + ':user:'******'da:' + app + ':lock:user:' + user_info().email
def del_cases(self): logmessage(f"del_cases(): " + "Deleting all cases for user = {self.user_id}") the_redis = DARedis() the_redis.set_data(self.user_cases_key, None) return
from docassemble.base.util import log, DARedis #, Individual, #, DAObject redis = DARedis() def amend_signer(data, key, value): if 'action_key' in data: party_id = data['party_id'] action_data = redis.get_data(data['action_key']) # set party key action_data['parties'][party_id][key] = value redis.set_data(data['action_key'], action_data) return action_data['parties'][party_id] else: return None def get_signer(data): #if 'action_key' in url_args: # data = url_args # ## Will this error? #elif action_argument('action_key'): # data = { # #'parent_interview_data_id': action_argument('parent_interview_data_id'), # 'action_key': action_argument('action_key'), # 'party_id': action_argument('party_id') # }
def __init__(self, key, lock, expires): self.r = DARedis() self.key = key self.lockkey = lock self.expires = expires
def potential_panelists() -> Iterable[Tuple[str, datetime]]: red = DARedis() return [(item, datetime.fromtimestamp(score)) for item, score in red.zrange(redis_panel_emails_key, 0, -1, withscores=True)]
def save(self, courts, clerks): """ Persist the directory info to file storage. """ the_redis = DARedis() the_redis.set_data(STORE, cache_record(courts, clerks))
def add_panel_participant(email: str): """Adds this email to a list of potential participants for a qualitative research panel. Adds the email and when they responded, as we shouldn't link their feedback to their identity at all. """ red = DARedis() red.zadd(redis_panel_emails_key, {email: datetime.now().timestamp()})
def service_areas(): redis = DARedis() result = redis.get('lsc_service_areas') if result is None: #sys.stderr.write('service_areas: calling arcgis.\n') r = requests.get( 'https://services3.arcgis.com/n7h3cEoHTyNCwjCf/ArcGIS/rest/services/BasicFieldServiceAreas_GrantCycle/FeatureServer/0/query?where=OBJECTID%3E%3D0&objectIds=&time=&geometry=&geometryType=esriGeometryEnvelope&inSR=&spatialRel=esriSpatialRelIntersects&resultType=none&distance=0.0&units=esriSRUnit_Meter&returnGeodetic=false&outFields=*&returnGeometry=false&returnCentroid=false&multipatchOption=xyFootprint&maxAllowableOffset=&geometryPrecision=&outSR=&datumTransformation=&applyVCSProjection=false&returnIdsOnly=false&returnUniqueIdsOnly=false&returnCountOnly=false&returnExtentOnly=false&returnQueryGeometry=false&returnDistinctValues=false&orderByFields=&groupByFieldsForStatistics=&outStatistics=&having=&resultOffset=&resultRecordCount=&returnZ=false&returnM=false&returnExceededLimitFeatures=true&quantizationParameters=&sqlFormat=none&f=pjson&token=' ) if r.status_code != 200: redis.set('lsc_service_areas', '{}') sys.stderr.write( 'load_service_areas: got error code {} from ArcGIS. Response: {}\n' .format(r.status_code, r.text)) else: try: the_dict = r.json() assert 'features' in the_dict assert len(the_dict['features']) > 0 redis.set('lsc_service_areas', r.text) except Exception as the_err: redis.set('lsc_service_areas', '{}') sys.stderr.write( 'load_service_areas: got invalid response from server: {}\n' .format(text_type(the_err))) redis.expire('lsc_service_areas', 60 * 60 * 24 * 7) result = redis.get('lsc_service_areas') return json.loads(result.decode())
def restore_ls_fields(redis_secret, redis_key): r = DARedis() encrypted_object_string = r.get_data(redis_key) return decrypt_object(encrypted_object_string, redis_secret)
def save_ls_fields(ls_variables, redis_secret, redis_key, expire=30): r = DARedis() encrypted_vars = encrypt_object(ls_variables, redis_secret) r.set_data(redis_key, encrypted_vars, expire=expire)
def save(self, counties): """ Persist the list of counties to file storage. """ the_redis = DARedis() the_redis.set_data(STORE, counties)
def delete_credentials(self): """Deletes the stored credentials.""" r = DARedis() r.delete('da:' + self.appname + ':status:user:' + user_info().email) storage = RedisCredStorage(self.appname) storage.locked_delete()
def me(): the_redis = DARedis() key = ME_KEY.format(__user_id()) me = the_redis.get_data(key) return me
class RedisCredStorage(oauth2client.client.Storage): def __init__(self, key, lock, expires): self.r = DARedis() self.key = key self.lockkey = lock self.expires = expires def acquire_lock(self): pipe = self.r.pipeline() pipe.set(self.lockkey, 1) pipe.expire(self.lockkey, 5) pipe.execute() def release_lock(self): self.r.delete(self.lockkey) def locked_get(self): json_creds = self.r.get(self.key) creds = None if json_creds is not None: self.r.expire(self.key, self.expires) json_creds = json_creds.decode() try: creds = oauth2client.client.Credentials.new_from_json(json_creds) except: log("RedisCredStorage: could not read credentials from " + str(json_creds)) return creds def locked_put(self, credentials): if self.expires: pipe = self.r.pipeline() pipe.set(self.key, credentials.to_json()) pipe.expire(self.key, self.expires) pipe.execute() else: self.r.set(self.key, credentials.to_json()) def locked_delete(self): self.r.delete(self.key)
def save_me(about_me): the_redis = DARedis() key = ME_KEY.format(__user_id()) the_redis.set_data(key, about_me) return True