def create_upload(self, page, upload, title, description):
extension = upload.filename.split(".")[-1]
if title and extension:
file_name = "%s.%s" % (slugify(title), extension)
else:
file_name = upload.filename
if page.not_editable():
message = 'Error updating page "{}" - only pages in DRAFT or REJECT can be edited'.format(page.guid)
self.logger.error(message)
raise PageUnEditable(message)
guid = create_guid(file_name)
if not self.check_upload_title_unique(page, title):
raise UploadAlreadyExists("An upload with that title already exists for this measure")
else:
self.logger.info("Upload with guid %s does not exist ok to proceed", guid)
upload.seek(0, os.SEEK_END)
size = upload.tell()
upload.seek(0)
self.upload_data(page, upload, filename=file_name)
db_upload = Upload(
guid=guid, title=title, file_name=file_name, description=description, page=page, size=size
)
page.uploads.append(db_upload)
db.session.add(page)
db.session.commit()
return db_upload
def copy(self):
# get a list of classification_links from this dimension before we make any changes
# TODO: In reality there will only ever be one of these. We should refactor the model to reflect this.
links = []
for link in self.classification_links:
db.session.expunge(link)
make_transient(link)
links.append(link)
# get the existing chart and table before we lift from session
chart_object = self.dimension_chart
table_object = self.dimension_table
# lift dimension from session
db.session.expunge(self)
make_transient(self)
# update disassociated dimension
self.guid = create_guid(self.title)
if chart_object:
self.dimension_chart = chart_object.copy()
if table_object:
self.dimension_table = table_object.copy()
for dc in links:
self.classification_links.append(dc)
return self
def create_copy(self, page_guid, page_version, version_type, created_by):
page = self.get_page_with_version(page_guid, page_version)
next_version = page.next_version_number_by_type(version_type)
if version_type != "copy" and self.already_updating(
page.guid, next_version):
raise UpdateAlreadyExists()
dimensions = [dimension for dimension in page.dimensions]
uploads = [upload for upload in page.uploads]
db.session.expunge(page)
make_transient(page)
original_guid = page.guid
if version_type == "copy":
page.guid = str(uuid.uuid4())
page.title = f"COPY OF {page.title}"
# Duplicate (URI + version) in the same subtopic would mean we can't resolve preview URLs to a single page
while self.new_uri_invalid(page, page.uri):
page.uri = f"{page.uri}-copy"
page.version = next_version
page.status = "DRAFT"
page.created_by = created_by
page.created_at = datetime.utcnow()
page.publication_date = None
page.published = False
page.internal_edit_summary = None
page.external_edit_summary = None
page.latest = True
for dimension in dimensions:
page.dimensions.append(dimension.copy())
for upload in uploads:
file_name = upload.file_name
db.session.expunge(upload)
make_transient(upload)
upload.guid = create_guid(file_name)
page.uploads.append(upload)
db.session.add(page)
db.session.commit()
previous_page = page.get_previous_version()
if previous_page is not None:
previous_page.latest = False
db.session.add(previous_page)
db.session.commit()
upload_service.copy_uploads(page, page_version, original_guid)
return page
def create_dimension(self, page, title, time_period, summary):
guid = create_guid(title)
if not self.check_dimension_title_unique(page, title):
raise DimensionAlreadyExists()
else:
self.logger.info("Dimension with guid %s does not exist ok to proceed", guid)
db_dimension = Dimension(
guid=guid,
title=title,
time_period=time_period,
summary=summary,
page=page,
position=page.dimensions.count(),
)
page.dimensions.append(db_dimension)
db.session.add(page)
db.session.commit()
return page.get_dimension(db_dimension.guid)
def create_measure_version(self, measure_version, update_type, user):
next_version_number = measure_version.next_version_number_by_type(update_type)
if update_type != NewVersionType.NEW_MEASURE and self.get_measure_version_by_measure_id_and_version(
measure_version.measure_id, next_version_number
):
raise UpdateAlreadyExists()
new_version = measure_version.copy(exclude_fields=["update_corrects_data_mistake"])
if update_type == NewVersionType.NEW_MEASURE:
new_version.title = f"COPY OF {measure_version.title}"
new_slug = f"{measure_version.measure.slug}-copy"
# In case there are multiple -copy measures, try this...
try:
while self.get_measure(
measure_version.measure.subtopic.topic.slug, measure_version.measure.subtopic.slug, new_slug
):
new_slug = f"{new_slug}-copy"
except PageNotFoundException:
pass
new_version.measure = Measure(slug=new_slug, position=len(measure_version.measure.subtopic.measures))
new_version.measure.subtopics = measure_version.measure.subtopics
else:
# We insert to the front of the `measure.versions` relationship so that we maintain ordering of
# desc(measure_version.version) as defined by the relationship on the model, as otherwise the list is not
# updated by sqlalchemy until a commit.
measure_version.measure.versions.insert(0, new_version)
new_version.version = next_version_number
new_version.status = "DRAFT"
new_version.created_by = user.email
new_version.created_at = datetime.utcnow()
new_version.published_at = None
new_version.internal_edit_summary = None
new_version.external_edit_summary = None
new_version.uploads = []
new_version.dimensions = [dimension.copy() for dimension in measure_version.dimensions]
new_version.latest = True
# We don't copy uploads or data sources for major updates, as major updates should always have new data
if update_type != NewVersionType.MAJOR_UPDATE:
for upload in measure_version.uploads:
new_upload = upload.copy()
new_upload.guid = create_guid(upload.file_name)
new_version.uploads.append(new_upload)
new_version.data_sources = measure_version.data_sources
db.session.add(new_version)
db.session.flush()
upload_service.copy_uploads_between_measure_versions(
from_measure_version=measure_version, to_measure_version=new_version
)
previous_version = new_version.get_previous_version()
if previous_version:
previous_version.latest = False
db.session.add(previous_version)
db.session.commit()
return new_version