def get_projects(**kwargs): projects = Project.query.filter_by(**kwargs).all() for project in projects: setattr(project, 'included_datasets', [ row_to_dict(d) for d in project.datasets ]) setattr(project, 'num_specs', project.specs.count()) setattr(project, 'num_datasets', project.datasets.count()) setattr(project, 'num_documents', project.documents.count()) setattr(project, 'num_analyses', project.aggregations.count() + project.comparisons.count() + project.correlations.count() + project.regressions.count()) return [ row_to_dict(project, custom_fields=[ 'included_datasets', 'num_datasets', 'num_specs', 'num_documents', 'num_analyses' ]) for project in projects ]
def get_datasets(project_id, include_preloaded=True, **kwargs): datasets = Dataset.query.filter_by(project_id=project_id, **kwargs).all() if include_preloaded: project = Project.query.get_or_404(project_id) datasets.extend(project.preloaded_datasets.all()) return [row_to_dict(dataset) for dataset in datasets]
def create_document(project_id, title='Unnamed Document', content={'blocks': []}): document = Document(project_id=project_id, title=title, content=content) db.session.add(document) db.session.commit() return row_to_dict(document)
def get(self, token): email = confirm_token(token) if not email: return jsonify({ 'status': 'failure', 'message': 'The confirmation link is invalid or expired.' }, status=401) user = get_user(email=email) parsed_user = row_to_dict(user) if user.confirmed: response = jsonify({ 'status': 'success', 'message': 'Account for %s already activated.' % email, 'alreadyActivated': True, 'user': { k: parsed_user[k] for k in ['anonymous', 'confirmed', 'email', 'id', 'username']} }, status=200) else: confirm_user(email=email) login_user(user, remember=True) response = jsonify({ 'status': 'success', 'message': 'Account for %s successfully activated.' % email, 'alreadyActivated': False, 'user': { k: parsed_user[k] for k in ['anonymous', 'confirmed', 'email', 'id', 'username']} }) response = set_cookies(response, { 'anonymous': user.anonymous, 'username': user.username, 'email': user.email, 'user_id': user.id, 'confirmed': user.confirmed }, expires=datetime.utcnow() + COOKIE_DURATION) return response
def get_public_document(document_id): try: document = Document.query.filter_by(id=document_id).one() return row_to_dict(document) except NoResultFound, e: logger.error(e) return None
def get_correlation_by_id(correlation_id, project_id, **kwargs): correlation = Correlation.query.filter_by(id=correlation_id, project_id=project_id, **kwargs).one() if correlation is None: abort(404) return row_to_dict(correlation)
def insert_dataset_properties(project_id, dataset_id, **kwargs): dataset_properties = Dataset_Properties(dataset_id=dataset_id, project_id=project_id, **kwargs) db.session.add(dataset_properties) db.session.commit() return row_to_dict(dataset_properties)
def get(self): if current_user.is_authenticated: user = current_user fresh = login_fresh() logger.info('User %s (%s) already authenticated. Fresh: %s', user.username, user.id, fresh) confirm_login() else: user = create_anonymous_user() login_user(user, remember=True) parsed_user = row_to_dict(user) response = jsonify({ 'user': { k: parsed_user[k] for k in ['anonymous', 'confirmed', 'email', 'id', 'username'] } }) response = set_cookies( response, { 'username': user.username, 'email': '', 'user_id': user.id, 'confirmed': False, 'anonymous': True }) return response
def insert_relationships(relationships, project_id): relationship_objects = [] for r in relationships: relationship_objects.append(Relationship(project_id=project_id, **r)) db.session.add_all(relationship_objects) db.session.commit() return [row_to_dict(r) for r in relationship_objects]
def insert_field_properties(project_id, dataset_id, **kwargs): field_properties = Field_Properties(dataset_id=dataset_id, project_id=project_id, **kwargs) db.session.add(field_properties) db.session.commit() return row_to_dict(field_properties)
def get_regression_from_spec(project_id, spec, **kwargs): try: regression = Regression.query.filter_by(project_id=project_id, spec=spec, **kwargs).one() #except NoResultFound, e: except NoResultFound as e: return None #except MultipleResultsFound, e: except MultipleResultsFound as e: logger.error(e) return row_to_dict( Regression.query.filter_by(project_id=project_id, spec=spec, **kwargs).all()[0]) return row_to_dict(regression)
def get_document(project_id, document_id): try: document = Document.query.filter_by(project_id=project_id, id=document_id).one() return row_to_dict(document) except NoResultFound, e: logger.error(e) return None
def insert_preloaded_dataset(**kwargs): dataset = Dataset( **kwargs ) db.session.add(dataset) db.session.commit() return row_to_dict(dataset)
def get_aggregation_by_id(aggregation_id, project_id, **kwargs): aggregation = Aggregation.query.filter_by(id=aggregation_id, project_id=project_id, **kwargs).one() if aggregation is None: abort(404) return row_to_dict(aggregation)
def get_exported_spec(project_id, exported_spec_id): try: spec = Exported_Spec.query.filter_by(id=exported_spec_id, project_id=project_id).one() return row_to_dict(spec) except NoResultFound, e: return None
def get_datasets(project_id, include_preloaded=True, **kwargs): datasets = Dataset.query.filter_by(project_id=project_id, **kwargs).all() if include_preloaded: project = Project.query.get_or_404(project_id) datasets.extend(project.preloaded_datasets.all()) return [ row_to_dict(dataset) for dataset in datasets ]
def get_regression_by_id(regression_id, project_id, **kwargs): regression = Regression.query.filter_by(id=regression_id, project_id=project_id, **kwargs).one() if regression is None: abort(404) return row_to_dict(regression)
def insert_project(**kwargs): project = Project( **kwargs ) db.session.add(project) db.session.commit() return row_to_dict(project)
def update_document(project_id, document_id, title, content): document = Document.query.filter_by(project_id=project_id, id=document_id).one() document.content = content document.title = title db.session.add(document) db.session.commit() return row_to_dict(document)
def get_public_exported_spec(exported_spec_id, spec_type): try: if spec_type == ContentType.VISUALIZATION.value: exported_spec = Exported_Spec.query.filter_by( id=exported_spec_id).one() desired_spec_keys = [ 'generating_procedure', 'type_structure', 'viz_types', 'meta', 'args', 'dataset_id' ] for desired_spec_key in desired_spec_keys: value = getattr(exported_spec.spec, desired_spec_key) setattr(exported_spec, desired_spec_key, value) return row_to_dict(exported_spec, custom_fields=desired_spec_keys) else: if spec_type == ContentType.CORRELATION.value: exported_spec = Exported_Correlation.query.filter_by( id=exported_spec_id).one() setattr(exported_spec, 'spec', exported_spec.correlation.spec) setattr(exported_spec, 'type', 'correlation') elif spec_type == ContentType.REGRESSION.value: exported_spec = Exported_Regression.query.filter_by( id=exported_spec_id).one() setattr(exported_spec, 'spec', exported_spec.regression.spec) setattr(exported_spec, 'type', 'regression') elif spec_type == ContentType.AGGREGATION.value: exported_spec = Exported_Aggregation.query.filter_by( id=exported_spec_id).one() setattr(exported_spec, 'spec', exported_spec.aggregation.spec) setattr(exported_spec, 'type', 'aggregation') elif spec_type == ContentType.COMPARISON.value: exported_spec = Exported_Comparison.query.filter_by( id=exported_spec_id).one() setattr(exported_spec, 'spec', exported_spec.comparison.spec) setattr(exported_spec, 'type', 'comparison') elif spec_type == ContentType.TEXT.value: exported_spec = {'type': ContentType.TEXT.value} return row_to_dict(exported_spec, custom_fields=['type', 'spec']) #except NoResultFound, e: except NoResultFound as e: return None #except MultipleResultsFound, e: except MultipleResultsFound as e: raise e
def insert_aggregation(project_id, spec, data, **kwargs): aggregation = Aggregation(project_id=project_id, spec=spec, data=data, **kwargs) db.session.add(aggregation) db.session.commit() return row_to_dict(aggregation)
def get_aggregation_from_spec(project_id, spec, **kwargs): try: aggregation = Aggregation.query.filter_by(project_id=project_id, spec=spec, **kwargs).one() except NoResultFound: return None return row_to_dict(aggregation)
def get_field_properties(project_id, dataset_id, **kwargs): result = Field_Properties.query.filter_by(dataset_id=dataset_id, **kwargs).all() field_properties = [ row_to_dict(r) for r in result if (r.dataset.preloaded or r.project_id == project_id) ] return field_properties
def get_exported_spec_by_fields(project_id, spec_id, **kwargs): try: spec = Exported_Spec.query.filter_by(spec_id=spec_id, project_id=project_id, **kwargs).one() return row_to_dict(spec) except NoResultFound, e: return None
def get_comparison_from_spec(project_id, spec, **kwargs): try: comparison = Comparison.query.filter_by(project_id=project_id, spec=spec, **kwargs).one() except NoResultFound: return None return row_to_dict(comparison)
def insert_dataset(project_id, **kwargs): dataset = Dataset( project_id=project_id, **kwargs ) db.session.add(dataset) db.session.commit() return row_to_dict(dataset)
def insert_regression(project_id, spec, data, **kwargs): regression = Regression(project_id=project_id, spec=spec, data=data, **kwargs) db.session.add(regression) db.session.commit() return row_to_dict(regression)
def insert_correlation(project_id, spec, data, **kwargs): correlation = Correlation(project_id=project_id, spec=spec, data=data, **kwargs) db.session.add(correlation) db.session.commit() return row_to_dict(correlation)
def update_document(project_id, document_id, title, content): document = Document.query.filter_by(project_id=project_id, id=document_id).one() document.content = content document.title = title db.session.add(document) db.session.commit() return row_to_dict(document)
def get_field_property(project_id, dataset_id, field_property_id, **kwargs): result = Field_Properties.query.filter_by(dataset_id=dataset_id, id=field_property_id, **kwargs).one() if (result.dataset.preloaded or result.project_id == project_id): return row_to_dict(result) else: return None
def get_public_exported_spec(exported_spec_id, spec_type): try: if spec_type == ContentType.VISUALIZATION.value: exported_spec = Exported_Spec.query.filter_by( id=exported_spec_id ).one() desired_spec_keys = [ 'generating_procedure', 'type_structure', 'viz_types', 'meta', 'args', 'dataset_id' ] for desired_spec_key in desired_spec_keys: value = getattr(exported_spec.spec, desired_spec_key) setattr(exported_spec, desired_spec_key, value) return row_to_dict(exported_spec, custom_fields=desired_spec_keys) else: if spec_type == ContentType.CORRELATION.value: exported_spec = Exported_Correlation.query.filter_by( id=exported_spec_id ).one() setattr(exported_spec, 'spec', exported_spec.correlation.spec) setattr(exported_spec, 'type', 'correlation') elif spec_type == ContentType.REGRESSION.value: exported_spec = Exported_Regression.query.filter_by( id=exported_spec_id ).one() setattr(exported_spec, 'spec', exported_spec.regression.spec) setattr(exported_spec, 'type', 'regression') elif spec_type == ContentType.AGGREGATION.value: exported_spec = Exported_Aggregation.query.filter_by( id=exported_spec_id ).one() setattr(exported_spec, 'spec', exported_spec.aggregation.spec) setattr(exported_spec, 'type', 'aggregation') elif spec_type == ContentType.COMPARISON.value: exported_spec = Exported_Comparison.query.filter_by( id=exported_spec_id ).one() setattr(exported_spec, 'spec', exported_spec.comparison.spec) setattr(exported_spec, 'type', 'comparison') elif spec_type == ContentType.TEXT.value: exported_spec = { 'type': ContentType.TEXT.value } return row_to_dict(exported_spec, custom_fields=['type', 'spec']) except NoResultFound, e: return None
def update_project(project_id, **kwargs): project = Project.query.get_or_404(project_id) for k, v in kwargs.iteritems(): setattr(project, k, v) db.session.add(project) db.session.commit() return row_to_dict(project)
def insert_interaction_term(project_id, dataset_id, variables): names = get_variable_names_by_id(variables) interaction_term = Interaction_Term(project_id=project_id, dataset_id=dataset_id, variables=variables, names=names) db.session.add(interaction_term) db.session.commit() return row_to_dict(interaction_term)
def insert_dataset_properties(project_id, dataset_id, **kwargs): dataset_properties = Dataset_Properties( dataset_id = dataset_id, project_id = project_id, **kwargs ) db.session.add(dataset_properties) db.session.commit() return row_to_dict(dataset_properties)
def delete_exported_spec(project_id, exported_spec_id): exported_spec = Exported_Spec.query.filter_by(project_id=project_id, id=exported_spec_id).one() if exported_spec is None: abort(404) db.session.delete(exported_spec) db.session.commit() return row_to_dict(exported_spec)
def get_exported_spec(project_id, exported_spec_id): try: spec = Exported_Spec.query.filter_by( id=exported_spec_id, project_id=project_id ).one() return row_to_dict(spec) except NoResultFound, e: return None
def create_document(project_id, title='Unnamed Document', content={ 'blocks': [] }): document = Document( project_id=project_id, title=title, content=content ) db.session.add(document) db.session.commit() return row_to_dict(document)
def update_project(project_id, **kwargs): project = Project.query.get_or_404(project_id) for k, v in kwargs.iteritems(): setattr(project, k, v) db.session.add(project) db.session.commit() return row_to_dict(project)
def insert_field_properties(project_id, dataset_id, **kwargs): field_properties = Field_Properties( dataset_id = dataset_id, project_id = project_id, **kwargs ) db.session.add(field_properties) db.session.commit() return row_to_dict(field_properties)
def get_exported_spec_by_fields(project_id, spec_id, **kwargs): try: spec = Exported_Spec.query.filter_by( spec_id = spec_id, project_id = project_id, **kwargs ).one() return row_to_dict(spec) except NoResultFound, e: return None
def get_dataset_properties(project_id, dataset_id): project_id = project_id try: dataset_properties = Dataset_Properties.query.filter_by(dataset_id=dataset_id).one() if dataset_properties.dataset.preloaded or dataset_properties.project_id == project_id: return row_to_dict(dataset_properties, custom_fields=['n_rows', 'n_cols']) else: return None except NoResultFound, e: return None
def insert_relationships(relationships, project_id): relationship_objects = [] for r in relationships: relationship_objects.append(Relationship( project_id = project_id, **r )) db.session.add_all(relationship_objects) db.session.commit() return [ row_to_dict(r) for r in relationship_objects ]
def insert_aggregation(project_id, spec, data, **kwargs): aggregation = Aggregation( project_id = project_id, spec = spec, data = data, **kwargs ) db.session.add(aggregation) db.session.commit() return row_to_dict(aggregation)
def get_exported_correlations(project_id): exported_correlations = Exported_Correlation.query.filter_by( project_id=project_id).all() for e in exported_correlations: setattr(e, 'spec', e.correlation.spec) setattr(e, 'type', 'correlation') return [ row_to_dict(exported_correlation, custom_fields=['type', 'spec']) for exported_correlation in exported_correlations ]
def get_projects(**kwargs): projects = Project.query.filter_by(**kwargs).all() for project in projects: setattr(project, 'included_datasets', [row_to_dict(d) for d in project.datasets]) setattr(project, 'num_specs', project.specs.count()) setattr(project, 'num_datasets', project.datasets.count()) setattr(project, 'num_documents', project.documents.count()) setattr( project, 'num_analyses', project.aggregations.count() + project.comparisons.count() + project.correlations.count() + project.regressions.count()) return [ row_to_dict(project, custom_fields=[ 'included_datasets', 'num_datasets', 'num_specs', 'num_documents', 'num_analyses' ]) for project in projects ]
def insert_exported_correlation(project_id, correlation_id, data, conditionals, config): exported_correlation = Exported_Correlation(project_id=project_id, correlation_id=correlation_id, data=data, conditionals=conditionals, config=config) db.session.add(exported_correlation) db.session.commit() return row_to_dict(exported_correlation)
def insert_regression(project_id, spec, data, **kwargs): regression = Regression( project_id = project_id, spec = spec, data = data, **kwargs ) db.session.add(regression) db.session.commit() return row_to_dict(regression)
def get_interaction_term_properties(interaction_term_ids): properties_list = [] for interaction_term_id in interaction_term_ids: term_properties = [] variable_ids = Interaction_Term.query.filter_by(id=interaction_term_id).one().variables for variable_id in variable_ids: data = Field_Properties.query.filter_by(id=variable_id).one() term_properties.append(row_to_dict(data)) properties_list.append(term_properties) return properties_list
def get(self, user_id): deleted_user = delete_anonymous_data(user_id) response = jsonify({'user': row_to_dict(deleted_user)}) response = set_cookies(response, { 'username': '', 'email': '', 'user_id': '', 'confirmed': str(False) }, expires=0)
def insert_correlation(project_id, spec, data, **kwargs): correlation = Correlation( project_id = project_id, spec = spec, data = data, **kwargs ) db.session.add(correlation) db.session.commit() return row_to_dict(correlation)
def delete_exported_spec(project_id, exported_spec_id): exported_spec = Exported_Spec.query.filter_by(project_id=project_id, id=exported_spec_id).one() if exported_spec is None: abort(404) db.session.delete(exported_spec) db.session.commit() return row_to_dict(exported_spec)
def insert_exported_comparison(project_id, comparison_id, data, conditionals, config): exported_comparison = Exported_Comparison( project_id = project_id, comparison_id = comparison_id, data = data, conditionals = conditionals, config = config ) db.session.add(exported_comparison) db.session.commit() return row_to_dict(exported_comparison)
def insert_interaction_term(project_id, dataset_id, variables): names = get_variable_names_by_id(variables) interaction_term = Interaction_Term( project_id=project_id, dataset_id=dataset_id, variables=variables, names=names ) db.session.add(interaction_term) db.session.commit() return row_to_dict(interaction_term)
def insert_exported_aggregation(project_id, aggregation_id, data, conditionals, config): exported_aggregation = Exported_Aggregation( project_id = project_id, aggregation_id = aggregation_id, data = data, conditionals = conditionals, config = config ) db.session.add(exported_aggregation) db.session.commit() return row_to_dict(exported_aggregation)
def get_spec(spec_id, project_id, **kwargs): spec = Spec.query.filter_by(id=spec_id, **kwargs).one() if spec is None: abort(404) exported_spec_ids = [ es.id for es in spec.exported_specs.all() ] if exported_spec_ids: exported = True else: exported = False setattr(spec, 'exported', exported) setattr(spec, 'exported_spec_ids', exported_spec_ids) return row_to_dict(spec, custom_fields=[ 'exported', 'exported_spec_ids'])
def remove_preloaded_dataset_from_project(project_id, dataset_id): try: project = Project.query.filter_by(id=project_id).one() preloaded_dataset = Dataset.query.filter_by(id=dataset_id, preloaded=True).one() if preloaded_dataset in project.preloaded_datasets: project.preloaded_datasets.remove(preloaded_dataset) db.session.commit() return row_to_dict(preloaded_dataset) else: return None except NoResultFound, e: return None
def update_dataset_properties(project_id, dataset_id, **kwargs): dataset_properties = Dataset_Properties.query.filter_by(project_id=project_id, dataset_id=dataset_id, ).one() for k, v in kwargs.iteritems(): setattr(dataset_properties, k, v) db.session.add(dataset_properties) db.session.commit() return row_to_dict(dataset_properties)
def get_dataset(project_id, dataset_id): project_id = project_id try: dataset = Dataset.query.filter_by(id=dataset_id).one() if dataset.preloaded or dataset.project_id == project_id: return row_to_dict(dataset) else: return None # TODO Decide between raising error and aborting with 404 except NoResultFound, e: logger.error(e) return None
def update_field_properties_color_by_id(project_id, field_id, field_color): field_properties = Field_Properties.query.filter_by( id=field_id, project_id=project_id, ).one() field_properties.color = field_color field_properties.manual.update({ 'color': True }) db.session.commit() return row_to_dict(field_properties)
def update_field_properties(project_id, dataset_id, name, **kwargs): title = kwargs.get('title') description = kwargs.get('description') field_properties = Field_Properties.query.filter_by(project_id=project_id, dataset_id=dataset_id, name=name).one() for k, v in kwargs.iteritems(): setattr(field_properties, k, v) db.session.commit() return row_to_dict(field_properties)