def set_between_dates_filter(self, key, *args, **kwargs):
"""Sets filter that checks if key field is between two dates given dates.
The date comparators must be passed by the args compare_date_time_one and compare_date_time_two.
An other modfier can be the arg not_between."""
try:
if ('compare_date_time_one' in kwargs
and 'compare_date_time_two' in kwargs
and kwargs['compare_date_time_one']
and kwargs['compare_date_time_two']):
date_time_one = Helper().get_date_from_string(
kwargs['compare_date_time_one'])
date_time_two = Helper().get_date_from_string(
kwargs['compare_date_time_two'])
if ('not_between' in kwargs and kwargs['not_between'] == '1'):
self.filter += (not_(
self.get_context_attr(key, kwargs).between(
date_time_one, date_time_two)), )
else:
self.filter += (self.get_context_attr(key, kwargs).between(
date_time_one, date_time_two), )
except Exception as e:
raise Exception(str(e))
def process(session, data):
post = Post()
Helper().fill_object_from_data(post, data, ['name', 'title', 'description', 'status', 'is_protected', 'has_comments'])
post.publish_on = Helper().get_null_if_empty(data['publish_on'])
post.expire_on = Helper().get_null_if_empty(data['expire_on'])
post.created = Helper().get_current_datetime()
post.edited = Helper().get_current_datetime()
self.add_foreign_keys(post, data, session, [('parent_id', Post), ('post_type_id', PostType), ('language_id', Language), ('user_id', User)])
self.raise_if_has_term_and_not_is_post_page(data, session)
self.add_many_to_many_relationship('terms', post, data, Term, session)
session.add(post)
session.commit()
return self.handle_success(None, None, 'create', 'Post', post.id)
def fn(session, post):
Helper().fill_object_from_data(post, data, ['name', 'title', 'description', 'status', 'is_protected', 'has_comments'])
post.publish_on = Helper().get_null_if_empty(data['publish_on'])
post.expire_on = Helper().get_null_if_empty(data['expire_on'])
post.edited = Helper().get_current_datetime()
self.add_foreign_keys(post, data, session, [('parent_id', Post), ('post_type_id', PostType), ('language_id', Language), ('user_id', User)])
self.raise_if_has_term_and_not_is_post_page(data, session)
self.edit_many_to_many_relationship('terms', post, data, Term, session)
if post.parent_id and int(post.parent_id) == int(id):
raise BadRequestError('The Post cannot be parent of yourself.')
session.commit()
return self.handle_success(None, None, 'update', 'Post', post.id)
def valid_file_type(self, key, config):
"""Validates if the field has valid base64 mimetype."""
if ('valid_file_type' in config and key in self.request
and self.request[key] != ''):
try:
file_type_data = Helper().get_file_type_and_data(
self.request[key])
file_type = file_type_data[0]
valid_types = Helper().get_valid_mimetypes()
if (file_type not in valid_types):
self.handle_validation_error('Invalid file type.')
except Exception as e:
self.handle_validation_error(str(e))
def __init__(self):
"""Starts the repository from which data will be written or retrieved."""
super(TemplateController, self).__init__()
self.args = Helper().add_request_data(self.parser,
['s', 'get_post_types'])
self.repo = TemplateRepository(session=self.session)
def test_Helper_get_with_slug(self):
data = {
'name': 'JOão Caçou a RÃ à noite'
}
payload = 'joao-cacou-a-ra-a-noite'
response = Helper().get_with_slug(data, 'name')['name']
self.assertEqual(payload, response, 'Helper().get_with_slug does not return \'joao-cacou-a-ra-a-noite\'.')
def run(self, ctx):
print("Running Script " + self.__class__.__name__)
engctx = ctx.getEnginesContext()
if not engctx:
print('Back-end engines not initialized')
return
projects = engctx.getProjects()
if not projects:
print('There is no opened project')
return
prj = projects[0]
helper = Helper(prj)
print("exported".center(15, ' ').center(60, '-'))
exported = helper.getComponentClasses(Helper.COMPONENT_SERVICE, True)
for s in exported:
print(s.getAddress())
print("unexported".center(15, ' ').center(60, '-'))
unexported = helper.getComponentClasses(Helper.COMPONENT_SERVICE,
False)
for s in unexported:
print(s.getAddress())
print("total %d services, %d exported" %
(len(exported) + len(unexported), len(exported)))
def process(session, data):
role = Role()
Helper().fill_object_from_data(role, data, ['name', 'description', 'can_access_admin'])
self.add_many_to_many_relationship('capabilities', role, data, Capability, session)
session.add(role)
session.commit()
return self.handle_success(None, None, 'create', 'Role', role.id)
def __init__(self):
"""Starts the repository from which data will be written or retrieved."""
super(FieldFileController, self).__init__()
self.args = Helper().add_request_data(
self.parser, ['field_id', 'media_id', 'grouper_id', 'post_id'])
self.repo = FieldFileRepository(session=self.session)
def test_Helper_get_file_details_from_request(self):
data = {
'file': self.file_b64
}
payload = base64.b64decode('iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==')
response = Helper().get_file_details_from_request(data)['data']
self.assertEqual(payload, response, 'Helper().get_file_details_from_request does not match the binary data.')
def __init__(self):
"""Starts the repository from which data will be written or retrieved."""
super(MediaController, self).__init__()
self.args = Helper().add_request_data(self.parser, [
'download_file', 'return_file_data', 's', 'type', 'origin', 'created', 'user_id', 'get_user'])
self.repo = MediaRepository(session=self.session)
def set_range_of_dates_filter(self, *args, **kwargs):
"""Sets filter that get items whose current date fit with publish_on and expire_on dates."""
try:
today = Helper().get_current_datetime()
exp_kwargs = kwargs
if 'joined_key' in kwargs:
exp_kwargs = {
'joined': kwargs['joined'],
'joined_key': 'expire_on'
}
self.filter += (or_(
and_(
self.get_context_attr('publish_on', kwargs) <= today,
self.get_context_attr('expire_on', exp_kwargs) >= today,
),
or_(
self.get_context_attr('publish_on', kwargs) == None,
self.get_context_attr('expire_on', exp_kwargs) == None),
), )
except Exception as e:
raise Exception(str(e))
def update(self, id, request):
"""Updates the row whose id corresponding with the requested id.
The data comes from the request object."""
def process(session, data):
def fn(session, term):
Helper().fill_object_from_data(term, data, [
'name', 'display_name', 'description', 'parent_id',
'page_id', 'taxonomy_id', 'language_id'
])
self.add_foreign_keys(term, data, session,
[('parent_id', Term), ('page_id', Post),
('language_id', Language),
('taxonomy_id', Taxonomy)])
if term.parent_id and int(term.parent_id) == int(id):
raise BadRequestError(
'The Term cannot be parent of yourself.')
session.commit()
return self.handle_success(None, None, 'update', 'Term',
term.id)
return self.run_if_exists(fn, Term, id, session)
return self.validate_before(process,
Helper().get_with_slug(
request.get_json(), 'name'),
TermValidator,
self.session,
id=id)
def __init__(self):
"""Starts the repository from which data will be written or retrieved."""
super(BlacklistController, self).__init__()
self.args = Helper().add_request_data(self.parser,
['value', 'type', 'target'])
self.repo = BlacklistRepository(session=self.session)
def process(session, data):
comment = Comment()
Helper().fill_object_from_data(
comment, data,
['comment', 'status', 'origin_ip', 'origin_agent'])
comment.created = Helper().get_current_datetime()
self.raise_if_has_different_parent_reference(
data, session, [('parent_id', 'post_id', Comment),
('parent_id', 'language_id', Comment)])
self.add_foreign_keys(comment, data, session,
[('user_id', User), ('post_id', Post),
('language_id', Language),
('parent_id', Comment)])
session.add(comment)
session.commit()
return self.handle_success(None, None, 'create', 'Comment',
comment.id)
def process(session, data):
template = Template()
Helper().fill_object_from_data(template, data,
['name', 'description', 'value'])
session.add(template)
session.commit()
return self.handle_success(None, None, 'create', 'Template',
template.id)
def process(session, data):
sector = Sector()
Helper().fill_object_from_data(sector, data,
['name', 'description'])
session.add(sector)
session.commit()
return self.handle_success(None, None, 'create', 'Sector',
sector.id)
def __init__(self):
"""Starts the repository from which data will be written or retrieved."""
super(CommentController, self).__init__()
self.args = Helper().add_request_data(self.parser, [
'comment', 'status', 'origin_ip', 'origin_agent', 'created', 'parent_id', 'user_id', 'post_id',
'language_id', 'get_user', 'get_language', 'get_post', 'get_parent', 'get_children'])
self.repo = CommentRepository(session=self.session)
def process(session, data):
field_content = FieldContent()
Helper().fill_object_from_data(field_content, data, ['content'])
self.raise_if_has_different_parent_reference(data, session, [('field_id', 'grouper_id', Field), ('field_id', 'post_id', Field)])
self.add_foreign_keys_field_type('long-text', field_content, data, session, [('field_id', Field), ('grouper_id', Grouper), ('post_id', Post)])
session.add(field_content)
session.commit()
return self.handle_success(None, None, 'create', 'FieldContent', field_content.id)
def __init__(self):
"""Starts the repository from which data will be written or retrieved."""
super(SocialController, self).__init__()
self.args = Helper().add_request_data(
self.parser,
['name', 'origin', 'user_id', 'get_user', 'get_configuration'])
self.repo = SocialRepository(session=self.session)
def process(session, data):
taxonomy = Taxonomy()
Helper().fill_object_from_data(
taxonomy, data, ['name', 'description', 'has_child'])
session.add(taxonomy)
session.commit()
return self.handle_success(None, None, 'create', 'Taxonomy',
taxonomy.id)
def valid_file_extension(self, key, config):
"""Validates if the field has valid file extension."""
if ('valid_file_extension' in config and key in self.request
and self.request[key] != ''):
extensions = Helper().get_valid_extensions()
if (self.request[key] not in extensions):
self.handle_validation_error('Invalid file extension.')
def __init__(self):
"""Starts the repository from which data will be written or retrieved."""
super(PostTypeController, self).__init__()
self.args = Helper().add_request_data(
self.parser,
['name', 'type', 'get_template', 'get_nests', 'get_taxonomies'])
self.repo = PostTypeRepository(session=self.session)
def __init__(self):
"""Starts the repository from which data will be written or retrieved."""
super(GrouperController, self).__init__()
self.args = Helper().add_request_data(self.parser, [
's', 'parent_id', 'post_id', 'get_parent', 'get_children',
'get_post', 'get_fields'
])
self.repo = GrouperRepository(session=self.session)
def max_file_size(self, key, config):
"""Validates if the field has valid base64 size."""
if ('max_file_size' in config and key in self.request
and self.request[key] != ''):
if (int(Helper().get_base64_size(self.request[key])) > int(
app.config['MAX_UPLOAD_SIZE'])):
self.handle_validation_error(
'The file size cannot exceed 5 MB.')
def test_Helper_get_file_type_and_data(self):
payload_1 = 'image/png'
payload_2 = 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg=='
file_info = Helper().get_file_type_and_data(self.file_b64)
response_1 = file_info[0]
response_2 = file_info[1]
self.assertEqual(payload_1, response_1, 'Helper().get_file_type_and_data does not return the \'image/png\'.')
self.assertEqual(payload_2, response_2, 'Helper().get_file_type_and_data does not return the correct binary info.')
def fn(session, configuration):
Helper().fill_object_from_data(
configuration, data,
['title', 'description', 'has_comments', 'email'])
self.add_foreign_keys(configuration, data, session,
[('language_id', Language)])
session.commit()
return self.handle_success(None, None, 'update',
'Configuration', configuration.id)
def __init__(self):
"""Starts the repository from which data will be written or retrieved."""
super(MenuItemController, self).__init__()
self.args = Helper().add_request_data(self.parser, [
'type', 'behavior', 'url', 'title', 'parent_id', 'menu_id',
'get_menu', 'get_parent', 'get_children'
])
self.repo = MenuItemRepository(session=self.session)
def __init__(self):
"""Starts the repository from which data will be written or retrieved."""
super(TermController, self).__init__()
self.args = Helper().add_request_data(self.parser, [
's', 'parent_id', 'taxonomy_id', 'language_id', 'get_language',
'get_parent', 'get_children', 'get_taxonomy'
])
self.repo = TermRepository(session=self.session)
def fn(session, social):
Helper().fill_object_from_data(
social, data,
['name', 'url', 'target', 'description', 'origin'])
self.add_foreign_keys(social, data, session,
[('configuration_id', Configuration),
('user_id', User)])
session.commit()
return self.handle_success(None, None, 'update', 'Social',
social.id)