class AlgoliaSearchModel: def __init__(self, handle, ring, tid=None, ip=None): logger = logging.getLogger('Avispa') self.lggr = AvispaLoggerAdapter(logger, {'tid': tid, 'ip': ip}) self.handle = handle self.ring = ring client = algoliasearch.Client(ALGOLIA_APPLICATION_ID, ALGOLIA_ADMIN_API_KEY) indexname = '%s-%s' % (handle, ring) self.index = client.init_index(indexname) def indexer(self, content, idx): print content item = self.clean_content(content) self.lggr.info('Algolia Indexing %s/%s/%s' % (self.handle, self.ring, idx)) self.lggr.info('Item to index: %s' % (item)) r = self.index.add_object(item, object_id=idx) print(r) return r def unindexer(self, idx): r = self.index.delete_object(self, idx) return check_response_status(r.status_code) def clean_content(self, content): item = content['item'] clean = {} for k in item: if k[0] != '_': if k[-5:] != '_flag': if k[-5:] != '_rich': clean[k] = item[k] return clean
app.config.from_object('default_config') if 'DEBUG' in app.config: app_debug = app.config['DEBUG'] else: app_debug = True #setup_logging() LS = LoggingSetUp() LS.setup(logfile_path=app.config['LOGFILE_PATH'], app_debug=app_debug) logger = logging.getLogger('Avispa') lggr = AvispaLoggerAdapter(logger, {'tid': '0', 'ip': '0'}) # Log something lggr.info('Flask App defined!') lggr.debug('Debug log is ON') lggr.info('Klaun was here') if app.config['DEBUG']: from flask_debugtoolbar import DebugToolbarExtension toolbar = DebugToolbarExtension(app) # Flask BCrypt will be used to salt the user password flask_bcrypt = Bcrypt(app) # Associate Flask-Login manager with current app login_manager = LoginManager() lggr.info('Login Manager defined!') login_manager.init_app(app) lggr.info('Login Manager initialized!') lggr.info(login_manager)
class ElasticSearchModel: def __init__(self, tid=None, ip=None): logger = logging.getLogger('Avispa') self.lggr = AvispaLoggerAdapter(logger, {'tid': tid, 'ip': ip}) def get_a_b(self, handle, ring, q=None): # Connect to Elastic Search Node es_url = ES_NODE connections.create_connection(hosts=[es_url]) field = '_all' s = Search(index=handle,doc_type=ring) \ .query("match", **{field:q}) response = s.execute() print("Searching in %s/%s" % (handle, ring)) print(s.to_dict()) #return response out = [] for hit in response: # hit meta contains: index,score,id,doc_type # i.e: hit.meta.score item = collections.OrderedDict() item['_id'] = hit.meta.id #print #print(hit.meta.score) #print('%s/%s/%s'%(hit.meta.index,hit.meta.doc_type,hit.meta.id)) for m in hit: item[m] = hit[m] item[m + '_flag'] = u'1000' #print (m,hit[m]) out.append(item) return out def unindexer(self, handle, ring=None, idx=None): # Connect to Elastic Search Node es = Elasticsearch([ES_NODE]) out = {} out['unindexed'] = [] if handle and ring and idx: es.delete(index=handle, doc_type=ring, id=idx, ignore=[400, 404]) i = '%s/%s/%s' % (handle, ring, idx) elif handle and ring: #es.delete(index=handle,doc_type=ring, ignore=[400, 404]) This doesnt work # Could not make elasticsearch_py delete a doc_type only requests.delete('%s/%s/%s' % (ES_NODE, handle, ring)) i = '%s/%s' % (handle, ring) elif handle: es.indices.delete(index=handle, ignore=[400, 404]) i = '%s' % (handle) self.lggr.info('UnIndexing:%s' % i) out['unindexed'].append(i) d = {} d['json_out'] = json.dumps(out) d['template'] = 'base_json.html' return d #'index':handle,'type':ringname,'id': idx def handle_indexer(self, url, handle): #1. Get all the active rings for this handle self.RIM = RingsModel() ringlist = self.RIM.user_get_rings(handle) print('RINGLIST:', ringlist) #2. Index one by one out = {} out['indexed'] = [] for ring in ringlist: result = self.indexer(url, handle, ring['ringname']) x = json.loads(result['json_out']) out['indexed'] += x['indexed'] self.lggr.info('Handle Indexed:%s' % handle) d = {} d['json_out'] = json.dumps(out) d['template'] = 'base_json.html' return d def indexer(self, url, handle, ring, idx=None): self.lggr.info('START indexer') # Good to Index (a/b) and (a/b/c) as they use same ring_class. # If you want to index a whole handle (a) use handle_indexer # Connect to Elastic Search Node es_url = ES_NODE self.lggr.info('START @ create_connection') connections.create_connection(hosts=[es_url]) self.lggr.info('END @ create_connection') o = urlparse.urlparse(url) if idx: path = '_api/%s/%s/%s' % (handle, ring, idx) else: path = '_api/%s/%s' % (handle, ring) origin_url = urlparse.urlunparse( (URL_SCHEME, o.netloc, path, '', '', '')) schema, items = self.get_items(origin_url) #Preprare the ES Map (as a class) ring_class, ring_map = self.prepare_class(schema) #Create the index in the ES Cluster (indempotent action) self.create_index(ring_class, origin_url) #Index the item d = {} out = {} out['indexed'] = [] for item in items: #Check that item is valid before attempting to index it if self.valid_item(item, ring_map): #try: if True: handle, ring, idx = self.index_item( ring_class, origin_url, item) i = '%s/%s/%s' % (handle, ring, idx) out['indexed'].append(i) self.lggr.info('Indexed:%s' % i) else: #Here we store possible indexing errors if 'not_indexed' not in out: out['not_indexed'] = [] out['not_indexed'].append(item) self.lggr.error('Document invalid. Not Indexed:%s' % item) d['json_out'] = json.dumps(out) d['template'] = 'base_json.html' self.lggr.info('END indexer') return d def valid_item(self, item, ring_map): self.lggr.info('START valid_item') print("Check item against map:") print(ring_map) v_item = {} for f in ring_map: #print(f) valid = False if f in item: #print(ring_map[f],type(ring_map[f])) #if ring_map[f] is elasticsearch_dsl.field.String: if isinstance(ring_map[f], String): #Check if item[f] is a string if (isinstance(item[f], str) or isinstance(item[f], unicode)): valid = True self.lggr.info('%s -> %s is a string (%s)' % (f, item[f], type(item[f]))) else: self.lggr.error('%s -> %s not a string (%s)' % (f, item[f], type(item[f]))) #elif ring_map[f] is elasticsearch_dsl.field.Object: elif isinstance(ring_map[f], Object): #Check if item[f] is an object if isinstance(item[f], dict): v_item[f] = {} print(ring_map[f].properties) for p in ring_map[f].properties: #Check if the property exists in the item if p in item[f]: #Check if the property is an elasticsearch_dsl.field.String: if isinstance(ring_map[f].properties[p], String): #Check if item[f] is a string if (isinstance(item[f][p], str) or isinstance(item[f][p], unicode)): v_item[f][p] = item[f][p] valid = True else: self.lggr.error('%s not a string (%s)' % (item[f], type(item[f]))) else: self.lggr.error('%s not in item' % p) else: self.lggr.error('%s not a dictionary (%s)' % (item[f], type(item[f]))) # TO-DO: Do we want nested objects? If yes develop. if valid: # Add field to the output v_item[f] = item[f] self.lggr.info('Valid item. Will Index') else: self.lggr.info('Invalid item. Will not index') else: self.lggr.info('%s not in map' % f) self.lggr.info('END valid_item') if len(v_item) > 0: return v_item else: return False def valid_api_url(self, url): o = urlparse.urlparse(url) p = o.path.split('/') if p[1] != '_api': path = '/_api' + o.path else: path = o.path return urlparse.urlunparse( (URL_SCHEME, o.netloc, path, '', 'schema=1&limit=_all', '')) def get_items(self, url): url = self.valid_api_url( url) + '&access_token=%s&fieldid=1' % TEMP_ACCESS_TOKEN self.lggr.info('START get_items ->%s' % url) result = requests.get(url, verify=False) self.lggr.info('result ->%s' % result.text) self.lggr.info('result.text ->%s' % result.text) r = result.json() self.lggr.info('result.json() ->%s' % r) schema = {'rings': r['rings'], 'fields': r['fields']} items = r['items'] self.lggr.info('END get_items') return schema, items def prepare_class(self, schema): self.lggr.info('START prepare_class') d = {} for field in schema['fields']: if field['FieldType'] == 'INTEGER': d[field['FieldId']] = Integer() elif field['FieldType'] == 'OBJECT': if field['FieldMultilingual']: f = {} f['spa'] = String(analyzer='spanish') f['eng'] = String(analyzer='english') f['ita'] = String(analyzer='italian') f['fra'] = String(analyzer='french') d[field['FieldId']] = Object(properties=f) else: #Some other kind of object d[field['FieldId']] = String() elif field['FieldType'] == 'ARRAY': d[field['FieldId']] = String() elif field['FieldType'] == 'BOOLEAN': d[field['FieldId']] = Integer() else: d[field['FieldId']] = String() print(d) raw_map = d.copy() self.lggr.info('END prepare_class') return type(str(schema['rings'][0]['RingName']), (DocType, ), d), raw_map def subtract_h_r_i(self, origin_url): self.lggr.info('START subtract_h_r_i') url = self.valid_api_url(origin_url) print(url) o = urlparse.urlparse(url) p = o.path.split('/') handle = p[2] if len(p) >= 4: ringname = p[3] else: ringname = None if len(p) >= 5: idx = p[4] else: idx = None self.lggr.info('END subtract_h_r_i') return handle, ringname, idx def create_index(self, ring_class, origin_url): self.lggr.info('START create_index') handle, ringname, idx = self.subtract_h_r_i(origin_url) # create the mappings in elasticsearch R = ring_class.init(handle) self.lggr.info('END create_index') return R def index_item(self, ring_class, origin_url, item): self.lggr.info('START index_item') handle, ringname, idx = self.subtract_h_r_i(origin_url) #overwrite the idx with items idx = item['_id'] # create the mappings in elasticsearch #print(R) #print(handle) #print(ringname) #print(idx) #print(item) # create and save an item article = ring_class(meta={ 'index': handle, 'type': ringname, 'id': idx }, **item) print(article) article.save() print('SAVED') self.lggr.info('END index_item') return (handle, ringname, idx)
class MainModel: def __init__(self,tid=False,ip=False): logger = logging.getLogger('Avispa') self.lggr = AvispaLoggerAdapter(logger, {'tid': tid,'ip': ip}) self.couch = couchdb.Server(COUCHDB_SERVER) self.couch.resource.credentials = (COUCHDB_USER,COUCHDB_PASS) self.user_database = 'myring_users' self.roles = {} self.roles['handle_owner'] = ['get_a_home','get_a_x','post_a_x','post_a_x_y','put_a_x_y','delete_a_x_y','get_a','get_a_b','get_a_b_c','post_a','post_a_b','put_a','put_a_b','put_a_b_c','delete_a','delete_a_b','delete_a_b_c'] self.roles['org_owner'] = ['get_a_home','get_a_p','post_a_p','delete_a_p_q','get_a_m','post_a_m','get_a_m_n','put_a_m_n','delete_a_m_n','put_a_m_n_settings','put_a_m_n_invite','get_a_x','post_a_x','post_a_x_y','put_a_x_y','delete_a_x_y','get_a','get_a_b','get_a_b_c','post_a','post_a_b','put_a','put_a_b','put_a_b_c','delete_a','delete_a_b','delete_a_b_c'] self.roles['team_generic'] = ['get_a_home','get_a_m','get_a_x'] self.roles['team_reader'] = ['get_a_home','get_a_m','get_a_m_n','get_a','get_a_b','get_a_b_c'] self.roles['team_writer'] = ['get_a_home','get_a_m','get_a_m_n','get_a','get_a_b','get_a_b_c','post_a_b','put_a_b_c','delete_a_b_c'] self.roles['team_admin'] = ['get_a_home','get_a_m','get_a_m_n','get_a','get_a_b','get_a_b_c','post_a','post_a_b','put_a','put_a_b','put_a_b_c','delete_a','delete_a_b','delete_a_b_c','put_a_m_n_invite'] self.roles['anonymous'] = ['get_a_home'] self.roles['api_anonymous'] = ['get_a','get_a_b','get_a_b_c'] self.roles['handle_member'] = ['get_a','get_a_b','get_a_b_c'] self.roles['ring_owner'] = ['get_a_b','get_a_b_c','post_a','post_a_b','put_a_b','put_a_b_c','delete_a_b','delete_a_b_c'] self.roles['item_owner'] = ['get_a_b_c','put_a_b_c','delete_a_b_c'] self.roles['api_user'] = ['get_a_b','get_a_b_c'] self.roles['moderator'] = ['get_a_b','get_a_b_c','put_a_b_c','delete_a_b_c'] self.roles['capturist'] = ['get_a_b','get_a_b_c','post_a_b','put_a_b_c','delete_a_b_c'] self.roles['fact_checker'] = ['get_a_b_c','put_a_b_c'] #MAINMODEL def create_db(self,dbname): return self.couch.create(dbname) def stack_parser(self,stack): out = [] for frame,filename,lineno,functionname,context,index in stack: parts = filename.split('/') skip = False for p in parts: if p in ['env','venv','system','lib','library']: skip = True break if not skip: s = filename+':'+str(lineno)+' '+functionname+' '+str(context) print(s) #s = filename+':'+str(lineno)+' '+functionname+' -> '+str(inspect.getargvalues(frame)) #out.append(s) return out #MAINMODEL def select_db(self,dbname): result = self.couch[dbname] return result #MAINMODEL def delete_db(self,dbname): del self.couch[dbname] return True #MAINMODEL def create_doc(self,dbname,id,doc): db=self.select_db(dbname) doc['_id']= id db.save(doc) #doc.store(db) return True #MAINMODEL def create_user(self,userd,dbname=None): if not dbname: dbname=self.user_database #self.lggr.debug('flag1') self.db = self.select_db(dbname) #self.lggr.debug('flag2') if 'onLogin' not in userd: userd['onlogin'] = '' #self.lggr.debug('Notice: Creating User ->'+userd['username']) auser = MyRingUser( email= userd['email'], billingemail = userd['email'], isorg = False, passhash= userd['passhash'], onlogin= userd['onlogin']) auser._id = userd['username'] storeresult = auser.store(self.db) self.lggr.info(str(storeresult)) return True #MAINMODEL def create_orguser(self,data,dbname=None): if not dbname: dbname=self.user_database #self.lggr.debug('flag1') self.db = self.select_db(dbname) #self.lggr.debug('flag2') people = {} people[data['username']] = {} people[data['username']]['addedby'] = data['username'] people[data['username']]['added'] = str(datetime.now()) teams = {} teams['owner'] = {} teams['owner']['members'] = [] teams['owner']['members'].append(data['username']) teams['owner']['addedby'] = data['username'] teams['owner']['added'] = str(datetime.now()) #dict(data['username']:dict("addedby":data['username'],"added":datetime.now())) #dict(data['username']=dict("addedby"=data['username'],"added"=datetime.now())) people2 = {} people2['addedby'] = 'moco' people2['added'] = datetime.now() self.lggr.debug('Notice: Creating User ->%s'%data['username']) auser = MyRingUser( email= data['username']+'@id.myring.io', billingemail = data['email'], is_org = True, passhash= data['passhash'], location = data['location'], url = data['url'], profilepic = data['profilepic'], name = data['name']) #auser.people[data['username']] = {} auser.people.append(handle=data['owner'],addedby=data['owner'],added=datetime.now()) auser.teams.append(teamname='owner',addedby=data['owner'],added=datetime.now()) auser.teams.append(teamname='staff',addedby=data['owner'],added=datetime.now()) for team in auser.teams: self.lggr.debug("Teamowner:%s"%team) self.lggr.debug("team.teamname:%s"%team.teamname) self.lggr.debug("team.members:%s - %s"%(team.members, type(team.members))) self.lggr.debug("team.added:%s"%team.added) if team.teamname == 'owner': team.members.append(handle=data['owner'],addedby=data['owner'],added=datetime.now()) elif team.teamname == 'staff': team.members.append(handle=data['owner'],addedby=data['owner'],added=datetime.now()) team.roles.append(role='team_admin',addedby=data['owner'],added=datetime.now()) auser._id = data['username'] storeresult = auser.store(self.db) return True def repair_user_doc(self,element,username,dbname=None): if not dbname: dbname=self.user_database db = self.select_db(dbname) user_doc = MyRingUser.load(db, username) self.lggr.debug('user_doc: %s (%s)'%(user_doc,type(user_doc))) self.lggr.debug('element: %s (%s)'%(element,type(element))) #if not hasattr(user_doc,str(element)): try: user_doc[element] except(KeyError): self.lggr.debug('repairflag') user_doc[element] = '' if user_doc.store(db): return True return False def add_team(self,handle,team,author,user_database=None): if not user_database: user_database=self.user_database db = self.select_db(user_database) user_doc = MyRingUser.load(db,handle) user_doc.teams.append(teamname=team,addedby=author,added=datetime.now()) for teamd in user_doc.teams: if teamd['teamname'] == team: self.lggr.debug('flag at1') teamd.members.append(handle=author,addedby=author,added=datetime.now()) teamd.roles.append(role='team_writer',addedby=author,added=datetime.now()) storeresult = user_doc.store(db) return True return False def delete_team(self,handle,team,user_database=None): if not user_database: user_database=self.user_database db = self.select_db(user_database) user_doc = MyRingUser.load(db,handle) count = 0 for teamd in user_doc.teams: if teamd['teamname'] == team: del user_doc.teams[count] if user_doc.store(db): return True count += 1 return False #MAINMODEL def is_org(self,username,user_database=None): result = self.select_user_doc_view('orgs/peopleteams',username) return result def user_exists(self,username,user_database=None): result = self.select_user_doc_view('auth/userbyhandle',username) return result #MAINMODEL def user_orgs(self,username,user_database=None): result = self.select_user_doc_view('orgs/user2orgs',username,10) return result #MAINMODEL #TODO: Rename this method to get_user_doc() def select_user(self,username): db = self.select_db(USER_DB) return MyRingUser.load(db, username) def post_user_doc(self,doc): db = self.select_db(USER_DB) return doc.store(db) def select_user_doc_view(self,dbview,key,batch=None,user_database=None): if not user_database : user_database = self.user_database if not batch : batch = 1 db = self.select_db(self.user_database) options = {} options['key']=str(key) result = db.iterview(dbview,batch,**options) # This is a generator. If it comes empty, the username didn't exist. # The only way to figure that out is trying to iterate in it. #self.lggr.debug('iterview result for '+dbview+' with key '+key+':',result) #options: key, startkey, endkey if batch == 1: for r in result: return r['value'] else: out = [] for r in result: out.append(r['value']) return out return False def select_multiple_users_doc_view(self,dbview,batch,user_database=None): #BUG I tried factorizing this with select_user_doc_view but it is showing users as organizations. # By just changing key for startkey if not user_database : user_database = self.user_database if not batch : batch = 500 db = self.select_db(self.user_database) options = {} result = db.iterview(dbview,batch,**options) return result def select_ring_doc_view(self,ringdb,dbview,key=None,batch=None,showall=False): print('select_ring_doc_view::'+ringdb+','+dbview+','+str(key)+','+str(batch)) if not batch : batch = 1 db = self.select_db(ringdb) options = {} if key: options['key']=str(key) result = db.iterview(dbview,batch,**options) # This is a generator. If it comes empty, the username didn't exist. # The only way to figure that out is trying to iterate in it. #self.lggr.debug('iterview result for '+dbview+' with key '+key+':',result) #print('gen len:',sum(1 for _ in result)) if batch == 1: for r in result: if showall: rr = {'key':r['key'],'id':r['id'],'value':r['value']} return rr else: return r['value'] else: out = [] for r in result: if showall: rr = {'key':r['key'],'id':r['id'],'value':r['value']} out.append(rr) else: out.append(r['value']) return out return False def general_daily_activity(self,handle,user_database=None): #0. Create the general count dictionary (with 365 slots) #1. Retrieve all rings for this handle. Use view myringusers:ring/count #2. Rerieve all the rings of all organizations where this user has something to do #3. For each of the rings found: #3a: Load its database #3b: Call its dailyactivity view with key=handle #3c: If something is found iterate through each one of the rows looking for the last 365 days #3d: add "New" and "Update "counts to the general count for that specific day pass #MAINMODEL def delete_user(self,dbname,user): self.db = self.select_db(dbname) #self.lggr.debug('Notice: Deleting User ->'+user) #del self.db[user] return True def append_to_user_field(self,handle,field,data,sublist=None,wherefield=None,wherefieldvalue=None,user_database=None): #This only to be used by fields that hold lists if not user_database : user_database = self.user_database self.db = self.couch[self.user_database] user = MyRingUser.load(self.db,handle) if user: #Preparing user[field] if field not in user: user[field] = [] else: if type(user[field]) is not list: self.lggr.debug('Cant append things to something that is not a list') return False #Preparing user[field][x][sublist] if sublist: s = 0 for u in user[field]: if u[wherefield] == wherefieldvalue: #This is assuming that user[field][s][sublist] exists and it is a list if sublist not in u: user[field][s][sublist] = [] elif type(user[field][s][sublist]) is not list: self.lggr.debug('Cant append things to something that is not a list..') return False user[field][s][sublist].append(data) break s += 1 else: user[field].append(data) if user.store(self.db): self.lggr.debug('Data updated succesfully') return True else: self.lggr.debug('Could not update user') return False else: self.lggr.debug('No user:%s'%handle) return False #MAINMODEL def update_user(self,data,user_database=None): if not user_database : user_database = self.user_database self.db = self.couch[self.user_database] #self.lggr.debug("update_user 3:") user = MyRingUser.load(self.db, data['id']) #self.lggr.debug("update_user 4:") #self.lggr.debug(user) if user: #self.lggr.debug("update_user 5:") for field in data: if field!='id': self.lggr.debug("Old Value:%s"%str(user[field])) self.lggr.debug("New Value:%s"%str(data[field])) user[field]=data[field] if user.store(self.db): self.lggr.debug('Data updated succesfully') return True else: self.lggr.debug('Could not update user') return False else: self.lggr.debug('No user %s'%data['_id']) #ROLEMODEL def user_is_authorized(self,current_user,method,route,handle,ring=None,idx=None,collection=None,team=None,api=False): # @method : is what is going to be checked against the user_authorization list # @route : how deep to dig in the user_authorizations self.lggr.info('START AUTHORIZATION') user_authorizations = [] rolelist = [] self.lggr.debug('Method:%s'%method) self.lggr.debug('route:%s'%route) if api: user_authorizations = self.sum_role_auth(user_authorizations,'api_user') if route == '_a' or route == '_a_b' or route == '_a_b_c': if current_user == handle: #This user is a Handle Owner self.lggr.debug('This user is a Handle Owner') user_authorizations = self.sum_role_auth(user_authorizations,'handle_owner') else: if route != '_a_b' or route != '_a_b_c': #This is only important if you are not going to go deeper than _a rolelist = self.user_belongs_org_team(current_user,handle,ring='*') #rolelist = self.user_belongs_org_team(current_user,handle) if rolelist: self.lggr.debug('rolelist1:%s'%str(rolelist)) self.lggr.debug('This user is a member of a team') for role in rolelist: user_authorizations = self.sum_role_auth(user_authorizations,role) else: if current_user == '_api_anonymous': self.lggr.info('This user is API Anonymous') user_authorizations += self.roles['api_anonymous'] else: self.lggr.info('This user is Anonymous 1') user_authorizations += self.roles['anonymous'] if route == '_a_b' or route == '_a_b_c': rolelist = self.user_belongs_org_team(current_user,handle,ring=ring) if rolelist: self.lggr.debug('rolelist2:%s'%str(rolelist)) self.lggr.debug('This user can act on this ring:%s'%ring) for role in rolelist: user_authorizations = self.sum_role_auth(user_authorizations,role) if route == '_a_b_c': db_ringname=str(handle)+'_'+str(ring) #self.lggr.debug('db_ringname:%s'%db_ringname) db = self.select_db(db_ringname) #self.lggr.debug('db:%s'%db) options = {} options['key']=str(idx) #Retrieving from ring/items view result = db.iterview('item/roles',1,**options) self.lggr.debug('item/roles:%s'%str(result)) try: for roles in result: self.lggr.debug('roles for item:%s'%roles['value']) #{u'fact_checker': [u'blalab', u'camaradediputados'], u'_public': False} for role in roles['value']: self.lggr.debug(roles['value'][role]) self.lggr.debug(type(roles['value'][role])) if type(roles['value'][role]) is list and current_user in roles['value'][role]: self.lggr.debug('This user is an Item %s:%s'%(role,ring)) if role in self.roles: self.lggr.debug('Adding:%s.'%role) user_authorizations = self.sum_role_auth(user_authorizations,role) except(ResourceNotFound): #AUTOREPAIR self.lggr.debug('item/roles db view does not exist. Will regenerate') from avispa_rest.RingsModel import RingsModel #Loading here because I don't want to load for all MainModel.py #TO_REFACTOR RIM = RingsModel() RIM.ring_set_db_views(db_ringname,'item/roles') #Now issue the same request before the exception was thrown for roles in result: self.lggr.debug('roles for item:%s'%roles['value']) #{u'fact_checker': [u'blalab', u'camaradediputados'], u'_public': False} for role in roles['value']: self.lggr.debug(roles['value'][role]) self.lggr.debug(type(roles['value'][role])) if type(roles['value'][role]) is list and current_user in roles['value'][role]: self.lggr.debug('This user is an Item %s:%s '%(role,ring)) user_authorizations = self.sum_role_auth(user_authorizations,role) elif route == '_a_p' or route == '_a_p_q': self.lggr.debug('Testing authorizations for /_people section') team = 'owner' rolelist = self.user_belongs_org_team(current_user,handle,team) if rolelist: self.lggr.debug('rolelist3:%s'%rolelist) self.lggr.debug('This user is a member of team:%s'%team) for role in rolelist: user_authorizations = self.sum_role_auth(user_authorizations,role) else: self.lggr.debug('This user is Anonymous 2') user_authorizations = self.sum_role_auth(user_authorizations,'anonymous') rolelist.append('anonymous') elif route == '_a_m' or route == '_a_m_n' or route == '_a_m_n_settings' or route == '_a_m_n_invite': if not team: self.lggr.debug('Testing authorizations for /_teams section') rolelist = self.user_belongs_org_team(current_user,handle) else: self.lggr.debug('Testing authorizations for /_teams/%s'%team) rolelist = self.user_belongs_org_team(current_user,handle,team) if rolelist: self.lggr.debug('rolelist4:%s'%rolelist) for role in rolelist: user_authorizations = self.sum_role_auth(user_authorizations,role) else: self.lggr.debug('This user is Anonymous 3') user_authorizations = self.sum_role_auth(user_authorizations,'anonymous') rolelist.append('anonymous') elif route == '_a_x' or route == '_a_x_y': if current_user == handle: #This user is a Handle Owner rolelist.append('handle_owner') self.lggr.debug('This user is a Handle Owner') user_authorizations = self.sum_role_auth(user_authorizations,'handle_owner') else: rolelist = self.user_belongs_org_team(current_user,handle) if rolelist: self.lggr.debug('rolelist5:%s'%rolelist) self.lggr.debug('This user is a member of a team accesing a collection') for role in rolelist: user_authorizations = self.sum_role_auth(user_authorizations,role) ''' if role != 'org_owner': user_authorizations = self.sum_role_auth(user_authorizations,'team_generic') ''' #Here, add the retrieve of authorizations in deeper levels (just if required by route) self.lggr.debug('Final user_authorizations:%s'%str(user_authorizations)) method_parts = method.split('_') separator = '_' if 'rq' in method_parts: position = method_parts.index('rq') del method_parts[position] method = separator.join(method_parts) if 'rs' in method_parts: position = method_parts.index('rs') del method_parts[position] method = separator.join(method_parts) out={} out['user_authorizations'] = user_authorizations self.lggr.debug('Method for this screen:%s'%method) if method.lower() in user_authorizations: out['authorized'] = True else: out['authorized'] = False self.lggr.info('END AUTHORIZATION') return out def sum_role_auth(self,user_authorizations,role): if type(role) is dict: if role['role'] in self.roles: if role['ring']: self.lggr.debug('Adding ring role:%s_%s'%(role['ring'],role['role'])) self.lggr.debug(self.roles[role['role']]) for r in self.roles[role['role']]: user_authorizations.append(role['ring']+'_'+r) else: self.lggr.debug('%s was not found'%role) else: if role in self.roles: self.lggr.debug('Adding role:%s:%s'%(role,str(self.roles[role]))) user_authorizations += self.roles[role] else: self.lggr.debug(role+' was not found') return user_authorizations def is_org_owner(self,handle,org): return True def user_belongs_org_team(self,username,org,team=None,ring=None): self.lggr.debug('Will check if '+username+' belongs to a team ') rolelist = [] result = self.select_user_doc_view('orgs/peopleteams',org) if result: if team: #Check if this usernname belongs to a team. Assign roles of that team only for teamd in result['teams']: for member in teamd['members']: if member['handle'] == username: self.lggr.debug(teamd['teamname']+' team has as member: '+member['handle']) #Will add only those roles of a team the user belongs to if teamd['teamname'] == 'owner': rolelist.append('org_owner') else: for role in teamd['roles']: rolelist.append(role['role']) elif ring: #Check if this username can act on this ring for teamd in result['teams']: self.lggr.debug('flagx1') if teamd['teamname'] == 'owner': self.lggr.debug('Checking is this user is in owner team:'+str(teamd['members'])) for member in teamd['members']: if member['handle'] == username: rolelist.append('org_owner') elif teamd['teamname'] == 'staff': for member in teamd['members']: if member['handle'] == username: for role in teamd['roles']: rolelist.append(role['role']) else: for ringd in teamd['rings']: self.lggr.debug('flagx2'+ringd['ringname']+str(ring)) if ring == '*': for member in teamd['members']: if member['handle'] == username: #Ring specific permissions for role in teamd['roles']: rolelist.append({"ring":ringd['ringname'],"role":role['role']}) #It will show a lot of ring specific permissions but you still need to have the team_generic # to be able to see your team rolelist.append('team_generic') elif ringd['ringname'] == ring: self.lggr.debug('flagx3') #This team acts on this ring! for member in teamd['members']: if member['handle'] == username: #This user belongs to this team that can act on this ring! for role in teamd['roles']: rolelist.append(role['role']) else: #This is only used in /_home and /_teams to prove membership in ANY team for teamd in result['teams']: for member in teamd['members']: if member['handle'] == username: if teamd['teamname'] == 'owner': rolelist.append('org_owner') else: rolelist.append('team_generic') return rolelist return False #MAINMODEL def random_hash_generator(self,bits=36): if bits % 8 != 0: bits = bits - (bits % 8) if bits < 8: bits = 8 required_length = bits / 8 * 2 s = hex(random.getrandbits(bits)).lstrip('0x').rstrip('L') if len(s) < required_length: return self.random_hash_generator(bits) else: return s
class Upload: def __init__(self, handle): self.handle = handle self.rs_status = '' self.officialsizes = { 'r100': 100, 'r240': 240, 'r320': 320, 'r500': 500, 'r640': 640, 'r800': 800, 'r1024': 1024 } self.thumbnailsizes = {'t75': 75, 't150': 150} self.allowed_formats = set( ['txt', 'pdf', 'png', 'jpg', 'JPG', 'jpeg', 'gif']) logger = logging.getLogger('Avispa') self.lggr = AvispaLoggerAdapter(logger, { 'tid': g.get('tid', None), 'ip': g.get('ip', None) }) def blob_from_s3(self, bucket, id): #Subtract original from s3 and put it in memory image_binary = '' return image_binary def blob_from_file(self, file): #Load the image blob print(file) file.seek(0) image_binary = file.read() return image_binary #DRIVER FUNCTION def do_upload(self, image_binary): response = {} image_sizes = [] #Load the image with Image(blob=image_binary) as img: #Prepare image components imgid = self._generate_imgid() filename = imgid + '.jpg' #Image analysis longside, shortside, orientation = self._img_orientation( img.width, img.height) #Constrain original if needed if longside > 2000: img = self._img_resize(img, 2000, orientation) path = '%s/%s' % (self.handle, 'o') self._s3_save(img, path, filename) m = self._generate_metadata(img.width, img.height, 'o') image_sizes.append(m) #Save scaled down versions and thumbnail #Plan of action regular_wo, thumb_wo = self._image_workorder(longside, shortside) #Scaled down versions for wo in regular_wo: with img.clone() as i: ii = self._img_resize(i, regular_wo[wo], orientation) path = '%s/%s' % (self.handle, wo) if STORE_MODE == 'LOCAL': self._local_save(i, path, filename) elif STORE_MODE == 'S3': self._s3_save(i, path, filename) m = self._generate_metadata(ii.width, ii.height, wo) image_sizes.append(m) #Thumbnail versions for wo in thumb_wo: with img.clone() as i: ii = self._img_resize(i, thumb_wo[wo], orientation) iii = self._img_thumbcrop(ii, orientation) path = '%s/%s' % (self.handle, wo) self._file_save(i, path, filename) m = self._generate_metadata(iii.width, iii.height, wo) image_sizes.append(m) response['status'] = self.rs_status response['imgid'] = imgid response['imgsizes'] = image_sizes return response #DRIVER FUNCTION def do_copy(self, from_handle, to_handle, imgid): #Pull file from S3 bucket f = self._pull_file_from_s3(origin, targetimgid) return response def _generate_metadata(self, width, height, sizename): multiplied = {} multiplied['mime-type'] = 'image/jpeg' multiplied['extension'] = 'jpg' multiplied['width'] = width multiplied['height'] = height multiplied['sizename'] = sizename multiplied['unit'] = 'pixel' #self.lggr.debug(multiplied) return multiplied def check_extension(self, filename): #TO-DO This a very soft check. Please implement Real Format Check if not '.' in filename and filename.rsplit( '.', 1)[1] in self.allowed_formats: self.lggr.error('Error: This file format is not allowed: ' + str(filename)) flash(u'This file format is not allowed: ' + str(filename), 'ER') self.rs_status = '415' return False return True def _pull_file_from_s3(self, handle, imgid): pass #1. Subtract image from S3 #2. Put it in self.f def _generate_imgid(self): return str(random.randrange(1000000000, 9999999999)) def _image_workorder(self, longside, shortside): regular_wo = {} thumb_wo = {} for r in self.officialsizes: if longside >= self.officialsizes[r]: regular_wo[r] = self.officialsizes[r] for t in self.thumbnailsizes: if shortside >= self.thumbnailsizes[t]: thumb_wo[t] = self.thumbnailsizes[t] return (regular_wo, thumb_wo) def _img_orientation(self, width, height): if width > height: longside = width shortside = height orientation = "landscape" if width < height: longside = height shortside = width orientation = "portrait" if width == height: longside = height shortside = width orientation = "square" return longside, shortside, orientation def _img_resize(self, img, mainside, orientation): if orientation == 'portrait': img.transform(resize='x' + str(mainside)) #Height based #img.resize(height=int(mainside)) elif orientation == 'landscape': img.transform(resize=str(mainside)) #Width based #img.resize(width=int(mainside)) #img.transform(resize=str(mainside)) elif orientation == 'square': img.transform(resize=str(mainside)) #Width based #img.resize(width=int(mainside)) return img def _img_thumbcrop(self, img, orientation): offset = abs(img.width - img.height) / 2 #This centers the crop if orientation == 'portrait': img.crop(0, offset, width=img.width, height=img.width) if orientation == 'landscape': img.crop(offset, 0, width=img.height, height=img.height) return img def _file_save(self, file, path, filename): self._s3_save(file, path, filename) def _s3_save(self, file, path, filename): self.lggr.info("Storing image in S3: %s/%s" % (path, filename)) conn = boto.connect_s3(AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY) bucket = conn.get_bucket(IMAGE_BUCKET_NAME) #k = Key(bucket) k = boto.s3.key.Key(bucket) k.key = '%s/%s' % (path, filename) print(k) print(k.key) print(file) fl = cStringIO.StringIO() file.save(fl) #print fl fl.seek(0) k.set_contents_from_file(fl) k.set_acl('public-read') #AttributeError: 'Image' object has no attribute 'tell' #b = fl.read() #print(b) #k.set_contents_from_string(b) return True def check_upload_path(self, path): pass def check_filename(self): pass def set_max_filesize(self): pass def set_max_filename(self): pass def set_max_width(self): pass def set_max_height(self): pass def set_allowed_types(self, types): pass def set_image_properties(self): pass def set_xss_clean(self): pass def is_image(self): pass def is_allowed_filetype(self): pass def is_allowed_filesize(self): pass def is_allowed_dimensions(self): pass def validate_upload_path(self): pass def get_extension(self, filename): pass def clean_file_name(self, filename): pass def limit_filename_length(self, filename, length): pass def do_xss_clean(self): pass def set_error(self, msg): pass def display_errors(self): pass def mime_types(self, mime): pass def _prep_filename(self, filename): pass def _file_mime_type(self, file): pass
class AuthModel: def __init__(self): logger = logging.getLogger('Avispa') self.lggr = AvispaLoggerAdapter(logger, { 'tid': g.get('tid', None), 'ip': g.get('ip', None) }) self.couch = couchdb.Server(COUCHDB_SERVER) self.couch.resource.credentials = (COUCHDB_USER, COUCHDB_PASS) #self.lggr.info('self.couch :ATM') #self.lggr.info(self.couch) #self.lggr.info('self.couch.resource.credentials :ATM') #self.lggr.info(self.couch.resource.credentials) self.user_database = 'myring_users' self.MAM = MainModel() self.officialsizes = { 'r100': 100, 'r240': 240, 'r320': 320, 'r500': 500, 'r640': 640, 'r800': 800, 'r1024': 1024 } self.thumbnailsizes = {'t75': 75, 't150': 150} #AUTHMODEL def saas_create_user(self, user): #Added validation for SaaS users go here #Check if that username or email exists before trying to create the new user. Reject if TRUE if self.userdb_get_user_by_email(user['email']): self.lggr.info('User with this email already exists') flash('User with this email already exists', 'UI') return False self.lggr.info("self.userdb_get_user_by_handle") if self.userdb_get_user_by_handle(user['username']): self.lggr.info( 'Organization or User with this username already exists') flash('Organization or User with this username already exists', 'UI') return False if self.MAM.create_user(user): self.lggr.info( "User created in DB. Attempting to create image folders...") return True #AUTHMODEL def saas_create_orguser(self, user): #Added validation for SaaS users go here #Check if that username exists before trying to create the new orguser. Reject if TRUE self.lggr.info("self.userdb_get_user_by_handle") if self.userdb_get_user_by_handle(user['username']): self.lggr.info( 'Organization or User with this username already exists') flash('Organization or User with this username already exists', 'UI') return False if self.MAM.create_orguser(user): return True def saas_create_password_key(self, user, key): self.lggr.info("saas_create_password_key") self.lggr.info(user) self.lggr.info(key) data = {} data['id'] = user data['new_password_key'] = key return self.MAM.update_user(data) def saas_set_password(self, user, passhash): self.lggr.info("saas_set_password") self.lggr.info(user) self.lggr.info(passhash) data = {} data['id'] = user data['passhash'] = passhash return self.MAM.update_user(data) def saas_update_user_profile(self, user, changes): changes['id'] = user return self.MAM.update_user(changes) #AUTHMODEL def admin_user_db_create(self, user_database=None, *args): if not user_database: user_database = self.user_database try: #self.db = self.couch[self.user_database] self.lggr.info('Notice: Entering TRY block') self.db = self.MAM.create_db(user_database) self.lggr.info('Notice: ' + user_database + ' database did not exist. Will create') self.userdb_set_db_views(user_database) self.lggr.info('Notice: DB Views Created') return True except (PreconditionFailed): self.lggr.info("Notice: Expected error :", sys.exc_info()[0], sys.exc_info()[1]) #flash(u'Unexpected error:'+ str(sys.exc_info()[0]) + str(sys.exc_info()[1]),'error') self.rs_status = '500' #raise # Will not get here because of 'raise' self.lggr.info( "Notice: Since it already existed, selecting existing one") self.MAM.select_db(user_database) self.lggr.info('Notice: ' + user_database + ' database exists already') return False #AUTHMODEL def admin_user_create(self, data, user_database=None): if not user_database: user_database = self.user_database db = self.couch[user_database] auser = self.MAM.select_user(data['username']) self.lggr.info('Notice: User subtracted from DB ') if auser: self.lggr.info('Notice: ' + data['username'] + ' exists already') return False else: auser = MyRingUser(email=data['email'], firstname=data['firstname'], lastname=data['lastname'], passhash=data['passhash'], guid=data['guid'], salt=data['salt']) auser._id = data['username'] storeresult = auser.store(db) self.lggr.info('Notice: ' + data['username'] + ' created -> ' + str(storeresult)) return True #AUTHMODEL def userdb_set_db_views(self, user_database=None): if not user_database: user_database = self.user_database self.lggr.info('#couchdb_call:' + user_database + '->userdb_set_db_views()') db = self.couch[user_database] view = ViewDefinition( 'auth', 'userbyemail', ''' function(doc) { if(doc.email) { emit(doc.email,doc); } } ''') view.get_doc(db) view.sync(db) view = ViewDefinition( 'auth', 'userbyhandle', ''' function(doc) { if(doc.email) { emit(doc._id,doc); } } ''') view.get_doc(db) view.sync(db) view = ViewDefinition( 'auth', 'userbasic', ''' function(doc) { if(doc.email) { var x = {}; x['name'] = doc.name; x['location'] = doc.location; x['is_org'] = doc.is_org; if(doc.profilepic===''){ x['profilepic'] = ''; }else{ parts = doc.profilepic.split(',') if(parts[0]==''){ x['profilepic'] = parts[1]; }else{ x['profilepic'] = parts[0]; } } emit(doc._id,x); } } ''') view.get_doc(db) view.sync(db) view = ViewDefinition( 'rings', 'count', ''' function(doc) { if(doc.email) { var x = {}; for (var key in doc.rings){ if(!doc.rings[key]['deleted']){ x[doc.rings[key]['ringname']]=doc.rings[key]['count']; } } emit(doc._id,x); } } ''') view.get_doc(db) view.sync(db) view = ViewDefinition( 'rings', 'origin', ''' function(doc) { if(doc.email) { var x = {}; for (var key in doc.rings){ if(!doc.rings[key]['deleted']){ x[doc.rings[key]['origin']] = doc.rings[key]['origin']; } } emit(doc._id,x); } } ''') view.get_doc(db) view.sync(db) view = ViewDefinition( 'rings', 'roles', ''' function(doc) { if(doc.email) { var x = {}; for (var key in doc.rings){ if(!doc.rings[key]['deleted']){ x[doc.rings[key]['ringname']] = new Object(); x[doc.rings[key]['ringname']]['owner']=doc.rings[key]['owner']; x[doc.rings[key]['ringname']]['capturist']=doc.rings[key]['capturist']; x[doc.rings[key]['ringname']]['moderator']=doc.rings[key]['moderator']; } } emit(doc._id,x); } } ''') view.get_doc(db) view.sync(db) view = ViewDefinition( 'orgs', 'peopleteams', ''' function(doc) { if(doc.is_org) { var x = {}; x['people']=doc.people; x['teams']=doc.teams; emit(doc._id,x); } } ''') view.get_doc(db) view.sync(db) view = ViewDefinition( 'orgs', 'user2orgs', ''' function(doc) { if(doc.is_org) { var x = {}; x['handle']=doc._id; x['name']='' if(doc.name){ x['name']=doc.name; } x['location']='' if(doc.location){ x['location']=doc.location; } x['profilepic']=''; if(doc.profilepic){ if(doc.profilepic===''){ x['profilepic'] = ''; }else{ parts = doc.profilepic.split(',') if(parts[0]==''){ x['profilepic'] = parts[1]; }else{ x['profilepic'] = parts[0]; } } } for (var key in doc.people){ emit(doc.people[key]['handle'],x); } } } ''') view.get_doc(db) view.sync(db) view = ViewDefinition( 'orgs', 'invitations', ''' function(doc) { if(doc.is_org) { var x = {}; x['invitations']=doc.invitations; emit(doc._id,x); } } ''') view.get_doc(db) view.sync(db) return True #AUTHMODEL def userdb_get_user_by_email(self, email, user_database=None): #self.lggr.info('flag1.1') if not user_database: user_database = self.user_database #self.lggr.info('flag1.2') db = self.couch[user_database] #self.lggr.info('flag1.3') options = {} options['key'] = email result = db.view('auth/userbyemail', **options) #result = db.iterview('auth/userhash',1,**options) #self.lggr.info(result) #self.lggr.info('flag1.4') item = {} for row in result: item = {} item[u'id'] = row['id'] item[u'key'] = row['key'] item[u'value'] = row['value'] #self.lggr.info('flag1.5') if item: return item else: return False #AUTHMODEL def userdb_get_user_by_handle(self, handle, user_database=None): #self.lggr.info('flag1.1') if not user_database: user_database = self.user_database #self.lggr.info('flag1.2') db = self.couch[user_database] #self.lggr.info('flag1.3') options = {} # options will only accept this: 'key', 'startkey', 'endkey' options['key'] = handle result = db.view('auth/userbyhandle', **options) #result = db.iterview('auth/userhash',1,**options) #self.lggr.info(result) #self.lggr.info('flag1.4') item = {} for row in result: item = {} item[u'id'] = row['id'] item[u'key'] = row['key'] item[u'value'] = row['value'] #self.lggr.info('flag1.5') return item
class User(UserMixin): def __init__(self, username=None, email=None, passhash=None, owner=None, location=None, url=None, profilepic=None, name=None, isOrg=False, active=True, id=None, onlogin=False, about=None, tid=None, ip=None): logger = logging.getLogger('Avispa') self.lggr = AvispaLoggerAdapter(logger, {'tid': tid, 'ip': ip}) self.lggr.debug('__init__()') self.username = username self.email = email self.location = location self.passhash = passhash self.about = about self.url = url self.profilepic = profilepic self.name = name self.isOrg = isOrg self.active = active self.isAdmin = False self.id = None self.onlogin = onlogin if owner: self.owner = owner else: self.owner = username if isinstance(self.location, basestring): self.location = self.location.lower() if isinstance(self.email, basestring): self.email = self.email.lower() if isinstance(self.username, basestring): self.usernme = self.username.lower() self.ATM = AuthModel() def set_user(self): user = {} # Defaults coming via self user['username'] = self.username user['email'] = self.email user['location'] = self.location user['owner'] = self.owner user['location'] = self.location user['url'] = self.url user['profilepic'] = self.profilepic user['name'] = self.name user['passhash'] = self.passhash user['onlogin'] = self.onlogin user['about'] = self.about self.lggr.info(user) if not self.isOrg: self.lggr.info('is an Org') #You are registering a regular User if self.ATM.saas_create_user(user): self.lggr.info("new user id = %s " % user['username']) return user['username'] else: return False else: self.lggr.info('is NOT an Org') #You are registering an Organization if self.ATM.saas_create_orguser(user): self.lggr.info("new organization id = %s " % user['username']) return user['username'] else: return False def set_password_key(self, key): self.lggr.info('set_password_key:') self.lggr.info(self.id) return self.ATM.saas_create_password_key(self.id, key) def set_password(self, passhash): self.lggr.info('set_password:'******'value']['email'] self.location = dbUser['value']['location'] self.active = dbUser['value']['is_active'] self.password = dbUser['value']['passhash'] self.id = dbUser['value']['_id'] return self else: return None except: self.lggr.error("Notice: UnExpected error :", sys.exc_info()[0], sys.exc_info()[1]) self.lggr.error("there was an error") return None def get_user(self): #raise Exception ('stop here') try: if self.email: self.lggr.debug('self.email:' + self.email) dbUser = self.ATM.userdb_get_user_by_email(self.email) elif self.username: self.lggr.info('START AUTHENTICATION:' + self.username) dbUser = self.ATM.userdb_get_user_by_handle(self.username) else: return None if dbUser: self.lggr.info("END AUTHENTICATION:%s" % dbUser['value']['name']) self.name = dbUser['value']['name'] self.email = dbUser['value']['email'] self.url = dbUser['value']['url'] self.profilepic = dbUser['value']['profilepic'] self.location = dbUser['value']['location'] self.about = dbUser['value']['about'] self.onlogin = dbUser['value']['onlogin'] self.active = dbUser['value']['is_active'] self.password = dbUser['value']['passhash'] self.id = dbUser['value']['_id'] return self else: self.lggr.error('User: not found') return None except (KeyError): self.lggr.error("Notice: UnExpected error :", sys.exc_info()[0], sys.exc_info()[1]) self.lggr.error( "there was an error, we need to repair the user_document") preconditions = [ 'name', 'email', 'url', 'profilepic', 'location', 'about', 'onlogin' ] repaired = False for element_to_add in preconditions: MAM = MainModel() if MAM.repair_user_doc(element_to_add, dbUser['value']['_id']): repaired = True self.lggr.info('Repaired ' + element_to_add + '. ') #flash('Repaired '+element_to_add+'. ') #Let's try again if repaired: if self.email: dbUser = self.ATM.userdb_get_user_by_email(self.email) elif self.username: dbUser = self.ATM.userdb_get_user_by_handle(self.username) if dbUser: self.name = dbUser['value']['name'] self.email = dbUser['value']['email'] self.url = dbUser['value']['url'] self.profilepic = dbUser['value']['profilepic'] self.location = dbUser['value']['location'] self.about = dbUser['value']['about'] self.active = dbUser['value']['is_active'] self.password = dbUser['value']['passhash'] self.id = dbUser['value']['_id'] return self else: return False else: return False def update_user_profile(self, request): dbUser = self.ATM.userdb_get_user_by_handle(self.username) changes = {} if dbUser: if request.form.get('profilepic') != dbUser['value']['profilepic']: self.lggr.info('profilepic changed!') changes['profilepic'] = request.form.get('profilepic') if request.form.get('name') != dbUser['value']['name']: self.lggr.info('name changed!') changes['name'] = request.form.get('name') mp_change = True if request.form.get('url') != dbUser['value']['url']: self.lggr.info('url changed!') changes['url'] = request.form.get('url') if request.form.get('location') != dbUser['value']['location']: self.lggr.info('location changed!') changes['location'] = request.form.get('location') if request.form.get('about') != dbUser['value']['about']: self.lggr.info('about changed!') changes['about'] = request.form.get('about') if request.form.get('onlogin') != dbUser['value']['onlogin']: self.lggr.info('onlogin changed!') changes['onlogin'] = request.form.get('onlogin') return self.ATM.saas_update_user_profile(self.username, changes) def is_valid_password_key(self, email, key): try: #self.lggr.info('flag1') dbUser = self.ATM.userdb_get_user_by_email(email) #self.lggr.info('flag2') #self.lggr.info(dbUser) if dbUser['value']['new_password_key'] == key: return True else: return False except: self.lggr.error("Notice: UnExpected error :", sys.exc_info()[0], sys.exc_info()[1]) self.lggr.error("There was an error validating the Key") return False def is_active(self): return self.active def is_authenticated(self): return True def is_anonymous(self): return False
class CollectionsModel: def __init__(self, tid=None, ip=None): logger = logging.getLogger('Avispa') self.lggr = AvispaLoggerAdapter(logger, {'tid': tid, 'ip': ip}) self.MAM = MainModel(tid=tid, ip=ip) #COLLECTIONSMODEL def get_a_x(self, handle): # Returns list of collections try: doc = self.MAM.select_user(handle) collections = doc['collections'] rings = doc['rings'] # 1. Here we need to call the DB again but now to get which validring = {} ringorigins = {} ringcounts = {} for ring in rings: if not 'deleted' in ring: ringname = str(ring['ringname']) if 'origin' in ring: ringorigin = str(ring['origin']) else: ringorigin = str(handle) ringorigins[ringname] = ringorigin ringcounts[ringname] = ring['count'] #raise Exception('debug') self.lggr.info(ringcounts) for coll in collections: for ring in coll['rings']: if ring['ringname'] in ringcounts: ring['count'] = ringcounts[ring['ringname']] if ring['ringname'] in ringorigins: ring['ringorigin'] = ringorigins[ring['ringname']] return collections except (ResourceNotFound, TypeError) as e: self.lggr.error("Notice: Expected error:%s,%s" % (sys.exc_info()[0], sys.exc_info()[1])) return False #COLLECTIONSMODEL def post_a_x(self, handle, collectiond): '''Creates new collection''' doc = self.MAM.select_user(handle) if 'description' not in collectiond: collectiond['description'] = '' newcollection = { 'collectionname': str(collectiond['name']), 'collectiondescription': str(collectiond['description']), 'version': str(collectiond['version']), 'rings': collectiond['ringlist'], 'added': str(datetime.now()) } doc['collections'].append(newcollection) self.MAM.post_user_doc(doc) return True #COLLECTIONSMODEL def get_a_x_y(self, handle, collection): #Not used directly, but used by put_rq_a_x_y to return collection details #Returns just one collection try: doc = self.MAM.select_user(handle) collections = doc['collections'] rings = doc['rings'] validring = {} for ring in rings: if not 'deleted' in ring: ringname = str(ring['ringname']) validring[ringname] = ring['count'] for coll in collections: #coll['valid'] = True if coll['collectionname'] == collection: #coll['valid'] = True for ring in coll['rings']: if ring['ringname'] in validring: ring['count'] = validring[ring['ringname']] else: pass #InValid Collection, at least one of its rings is marked as deleted #coll['valid'] = False return coll return False except (ResourceNotFound, TypeError) as e: self.lggr.error("Notice: Expected error:%s,%s" % (sys.exc_info()[0], sys.exc_info()[1])) #COLLECTIONSMODEL def put_a_x_y(self, handle, collectiond): doc = self.MAM.select_user(handle) newcollection = { 'collectionname': str(collectiond['name']), 'collectiondescription': str(collectiond['description']), 'version': str(collectiond['version']), 'rings': collectiond['ringlist'], 'added': str(datetime.now()) } i = 0 for coll in doc['collections']: if coll['collectionname'] == newcollection['collectionname']: #This is a match. This is what we need to replace with incoming document doc['collections'][i] = newcollection i = i + 1 self.MAM.post_user_doc(doc) return True #COLLECTIONSMODEL def patch_a_x_y(self, handle, collection, collectiond): doc = self.MAM.select_user(handle) path = {} if 'name' in collectiond: patch['collectionname'] = str(collectiond['name']) if 'description' in collectiond: patch['collectiondescription'] = str(collectiond['description']) if 'version' in collectiond: patch['version'] = str(collectiond['version']) if 'rings' in collectiond: patch['rings'] = collectiond['ringlist'] i = 0 for coll in doc['collections']: if coll['collectionname'] == collection: for p in patch: doc['collections'][i][p] = patch[p] i = i + 1 self.MAM.post_user_doc(doc) return True def add_ring_to_collection(self, handle, collection, ringd): doc = self.MAM.select_user(handle) for coll in doc['collections']: if coll['collectionname'] == collection: coll['rings'].append(ringd) self.lggr.info('Ring added to collection:', doc) self.MAM.post_user_doc(doc) return True #COLLECTIONSMODEL def delete_a_x_y(self, handle, collection): doc = self.MAM.select_user(handle) i = 0 for coll in doc['collections']: if coll['collectionname'] == collection: del doc['collections'][i] i = i + 1 self.MAM.post_user_doc(doc) return True