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)
