def get_preview_instance(self, preview_body):
page = PageOperationMixin()
page.body = preview_body
page.title = self.title
page.revision = self.revision
page.inlinks = self.inlinks
page.outlinks = self.outlinks
page.related_links = self.related_links
page.older_title = self.older_title
page.newer_title = self.newer_title
page.updated_at = self.updated_at
return page
def validate_new_content(self, base_revision, new_body, user):
# check metadata
new_md = PageOperationMixin.parse_metadata(new_body)
## prevent self-revoke
acl_r = new_md.get('read', '')
acl_r = acl_r.split(',') if acl_r else []
acl_w = new_md.get('write', '')
acl_w = acl_w.split(',') if acl_w else []
if not self.can_read(user, acl_r=acl_r, acl_w=acl_w):
raise ValueError('Cannot restrict your permission')
if not self.can_write(user, acl_r=acl_r, acl_w=acl_w):
raise ValueError('Cannot restrict your permission')
# prevent circular-redirection
try:
WikiPage._follow_redirect(self, new_md.get(u'redirect'))
except ValueError as e:
raise e
# check data
new_data = PageOperationMixin.parse_data(self.title, new_body, new_md['schema'])
if any(type(value) == schema.InvalidProperty for value in new_data.values()):
invalid_keys = [key for key, value in new_data.iteritems() if type(value) == schema.InvalidProperty]
raise ValueError('Invalid schema data: %s' % ', '.join(invalid_keys))
# check revision
if self.revision < base_revision:
raise ValueError('Invalid revision number: %d' % base_revision)
# check headings
invalid_reason = TocGenerator(md.convert(new_body)).is_invalid()
if invalid_reason:
raise ValueError(invalid_reason)
return new_data, new_md
def get_config(cls):
result = caching.get_config()
if result is None:
result = wiki_settings.DEFAULT_CONFIG
try:
config_page = cls.get_by_title('.config')
user_config = yaml.load(PageOperationMixin.remove_metadata(config_page.body))
except:
user_config = None
user_config = user_config or {}
def merge_dict(target_dict, source_dict):
for (key, value) in source_dict.iteritems():
if type(value) != dict:
target_dict[key] = value
else:
merge_dict(target_dict.setdefault(key, {}), value)
merge_dict(result, user_config)
caching.set_config(result)
return result
def _update_content_all(self, body, base_revision, comment, user, force_update, dont_create_rev):
# do not update if the body is not changed
if not force_update and self.body == body:
return False
now = datetime.utcnow().replace(tzinfo=utc)
# validate and prepare new contents
new_data, new_md = self.validate_new_content(base_revision, body, user)
new_body = self._merge_if_needed(base_revision, body)
# get old data and metadata
try:
old_md = self.metadata.copy()
except ValueError:
old_md = {}
try:
old_data = self.data.copy()
except ValueError:
old_data = {}
# delete caches
caching.del_rendered_body(self.title)
caching.del_hashbangs(self.title)
caching.del_metadata(self.title)
caching.del_data(self.title)
# update model and save
self.body = new_body
if user and not user.is_anonymous():
self.modifier = user
self.description = PageOperationMixin.make_description(new_body)
self.acl_read = new_md.get('read', '')
self.acl_write = new_md.get('write', '')
self.comment = comment
self.itemtype_path = schema.get_itemtype_path(new_md['schema'])
self._update_pub_state(new_md, old_md)
if not dont_create_rev:
self.revision += 1
if not force_update:
self.updated_at = now
self.save()
# create revision
if not dont_create_rev:
rev = WikiPageRevision(page=self, title=self.title, body=self.body,
created_at=self.updated_at, revision=self.revision,
comment=self.comment, modifier=self.modifier)
rev.save()
self.update_links_and_data(old_md.get('redirect'), new_md.get('redirect'), old_data, new_data)
# delete config cache
if self.title == '.config':
caching.del_config()
# delete title cache if it's a new page
if self.revision == 1:
caching.del_titles()
return True
def absolute_url(self):
return u'/%s?rev=%d' % (PageOperationMixin.title_to_path(self.title), int(self.revision))
