def clone_for_portal(self, division_id):
filesintext = {found[1]:True for found in re.findall('(http://file001.profi.ntaxa.com/([^/]*)/)', self.long)}
if self.image_file_id:
filesintext[self.image_file_id] = True
company = db(PortalDivision, id=division_id).one().portal.own_company
for file_id in filesintext:
filesintext[file_id] = \
File.get(file_id).copy_file(company.id, company.system_folder_file_id).save().id
article_portal = ArticlePortal(title=self.title, short=self.short,
portal_division_id=division_id,
article_company_id=self.id,
portal_id=db(PortalDivision, id=division_id).one().portal_id)
if self.image_file_id:
article_portal.image_file_id = filesintext[self.image_file_id]
long_text = self.long
for old_image_id in filesintext:
long_text = long_text.replace('http://file001.profi.ntaxa.com/%s/' % (old_image_id, ),
'http://file001.profi.ntaxa.com/%s/' % (filesintext[old_image_id], ))
article_portal.long = long_text
self.portal_article.append(article_portal)
return self
def get_all_dir(f_id, copy_id=None):
files_in_parent = [file for file in db(File, parent_id=f_id) if file.mime == 'directory' and file.id != copy_id]
for file in files_in_parent:
if file.mime == 'directory':
for fil in db(File, parent_id=file.id, mime='directory'):
files_in_parent.append(fil) if fil.id != copy_id else None
return files_in_parent
def list_reader_load(json):
next_page = json.get('next_page') if json.get('next_page') else 1
search_text = request.args.get('search_text') or ''
article_fields = 'title|id|subtitle|short|image_file_id|subtitle|publishing_tm|read_count,company.name|logo_file_id|id,' \
'division.name,portal.name|host|logo_file_id|id'
favorite = request.args.get('favorite') == 'True'
localtime = time.gmtime(time.time())
filter = and_(Publication.portal_division_id == db(PortalDivision).filter(
PortalDivision.portal_id == db(UserPortalReader, user_id=g.user.id).subquery().c.portal_id).subquery().c.id,
Publication.status == Publication.STATUSES['PUBLISHED'],
Publication.publishing_tm < datetime.datetime(*localtime[:6])) if not favorite\
else (Publication.id == db(ReaderPublication, user_id=g.user.id,
favorite=True).subquery().c.article_portal_division_id)
articles, pages, page = Search().search({'class': Publication,
'filter': filter,
'tags': True, 'return_fields': article_fields}, page=1,
items_per_page=5*next_page,
search_text=search_text)
list_articles = Publication.get_list_reader_articles(articles)
return {
'end': True if pages == 1 or pages == 0 else False,
'articles': list_articles,
'pages': pages,
'current_page': page,
'page_buttons': Config.PAGINATION_BUTTONS,
# 'portals': portals,
'favorite': favorite
}
def list_reader(page=1):
search_text = request.args.get('search_text') or ''
favorite = 'favorite' in request.args
if not favorite:
articles, pages, page = Search().search({'class': Publication,
'filter': and_(Publication.portal_division_id ==
db(PortalDivision).filter(
PortalDivision.portal_id ==
db(UserPortalReader,
user_id=g.user.id).subquery().
c.portal_id).subquery().c.id,
Publication.status ==
Publication.STATUSES['PUBLISHED']),
'tags': True, 'return_fields': 'default_dict'}, page=page)
else:
articles, pages, page = Search().search({'class': Publication,
'filter': (Publication.id == db(ReaderPublication,
user_id=g.user.id,
favorite=True).subquery().c.
article_portal_division_id),
'tags': True, 'return_fields': 'default_dict'}, page=page,
search_text=search_text)
portals = UserPortalReader.get_portals_for_user() if not articles else None
return render_template('partials/reader/reader_base.html',
articles=articles,
pages=pages,
current_page=page,
page_buttons=Config.PAGINATION_BUTTONS,
portals=portals,
favorite=favorite
)
def get_allowed_statuses(company_id=None, portal_id=None):
if company_id:
sub_query = db(MemberCompanyPortal, company_id=company_id).filter(
MemberCompanyPortal.status != "DELETED").all()
else:
sub_query = db(MemberCompanyPortal, portal_id=portal_id)
return sorted(list({partner.status for partner in sub_query}))
def __search_start(self, *args: dict, **kwargs):
""" Don't use this method, use Search().search() method """
subquery_search = self.__get_subquery(*args, ord_by=kwargs.get('order_by'))
if self.__pagination:
from ..controllers.pagination import pagination as pagination_func
subquery_search, self.__pages, page, _ = pagination_func(subquery_search, page=self.__page,
items_per_page=self.__items_per_page)
subquery_search = subquery_search.subquery()
join_search = []
for arg in args:
join_params = arg.get('join') or arg['class']
join_search.append(db(subquery_search).join(join_params,
arg['class'].id == subquery_search.c.index).subquery())
objects = collections.OrderedDict()
to_order = {}
_order_by = kwargs.get('order_by') or Search.ORDER_MD_TM
ord_by = 'text' if type(_order_by) in (str, list, tuple) \
else self.__order_by_to_str[_order_by]
for search in join_search:
for cls in db(search).all():
objects[cls.index] = {'id': cls.index, 'table_name': cls.table_name,
'order': getattr(cls, ord_by), 'md_tm': cls.md_tm}
to_order[cls.index] = (getattr(cls, ord_by), getattr(cls, 'md_tm'))
objects = {obj['id']: obj for obj in
collections.OrderedDict(sorted(objects.items())).values()}
ordered = sorted(tuple(to_order.items()), reverse=False if self.__desc_asc == 'asc' else True,
key=operator.itemgetter(1))
self.__reload_func(len(ordered), *args)
if self.__return_objects:
objects = self.__get_objects_from_db(*args, ordered_objects_list=ordered)
else:
objects = collections.OrderedDict((id, objects[id]) for id, ord in ordered)
return objects, self.__pages, self.__page
def create_company(self, data, file):
comp_dict = {"author_user_id": g.user_dict["id"]}
status = STATUS()
for x, y in zip(data.keys(), data.values()):
comp_dict[x] = y
company = Company(**comp_dict)
db_session.add(company)
db_session.commit()
user_rbac = UserCompany(user_id=company.author_user_id, company_id=company.id, status=status.ACTIVE())
db(Company, id=company.id).update(
{
"logo_file": File.upload(
file=file,
company_id=company.id,
parent_id=company.corporate_folder_file_id,
author=g.user_dict["name"],
author_user_id=g.user_dict["id"],
)
}
)
db_session.add(user_rbac)
db_session.commit()
r = Right()
r.add_rights(company.author_user_id, company.id, COMPANY_OWNER)
def crop_image(image_id, coordinates, zoom, params):
from ..models.company import Company
image_query = db(File, id=image_id).one() # get file object
company_owner = db(Company).filter(or_(
Company.system_folder_file_id == image_query.root_folder_id,
Company.journalist_folder_file_id == image_query.root_folder_id)).one() # get company file owner
return File.crop(image_query, coordinates, zoom, company_owner, params)
def update_article_portal(json, article_id):
db(ArticlePortalDivision, id=article_id).update({'status': json.get('new_status')})
json['article']['status'] = json.get('new_status')
json['new_status'] = ARTICLE_STATUS_IN_PORTAL.published \
if json.get('new_status') != ARTICLE_STATUS_IN_PORTAL.published \
else ARTICLE_STATUS_IN_PORTAL.declined
return json
def validate(self):
ret = {'errors': {}, 'warnings': {}, 'notices': {}}
if db(Portal, company_owner_id=self.company_owner_id).count():
ret['errors']['ok'] = 'portal for company already exists'
if not re.match('[^\s]{3,}', self.name):
ret['errors']['name'] = 'pls enter a bit longer name'
if not re.match(
'^(([a-zA-Z]|[a-zA-Z][a-zA-Z0-9\-]*[a-zA-Z0-9])\.)+([A-Za-z]|[A-Za-z][A-Za-z0-9\-]*[A-Za-z0-9]{1,})$',
self.host):
ret['errors']['host'] = 'pls enter valid host name'
grouped = {}
for div in self.divisions:
if div.portal_division_type_id in grouped:
grouped[div.portal_division_type_id] += 1
else:
grouped[div.portal_division_type_id] = 1
for check_division in db(PortalDivisionType).all():
if check_division.id not in grouped:
grouped[check_division.id] = 0
if check_division.min > grouped[check_division.id]:
ret['errors'][
'division_%s' % (check_division.id,)] = 'you need at least %s `%s`' % (
check_division.min, check_division.id)
if grouped[check_division.id] == 0:
ret['errors']['add_division'] = 'add at least one `%s`' % (check_division.id,)
if check_division.max < grouped[check_division.id]:
ret['errors'][
'division_%s' % (check_division.id,)] = 'you you can have only %s `%s`' % (
check_division.max, check_division.id)
return ret
def apply_company_to_portal(company_id, portal_id):
"""Add company to MemberCompanyPortal table. Company will be partner of this portal"""
g.db.add(MemberCompanyPortal(company=db(Company, id=company_id).one(),
portal=db(Portal, id=portal_id).one(),
company_portal_plan_id=db(Portal, id=portal_id).one().
portal_plan_id))
g.db.flush()
def subquery_user_articles(search_text=None, user_id=None, **kwargs):
article_filter = db(ArticleCompany, article_id=Article.id, **kwargs)
if search_text:
article_filter = article_filter.filter(ArticleCompany.title.ilike(
"%" + repr(search_text).strip("'") + "%"))
return db(Article, author_user_id=user_id).filter(article_filter.exists())
def save_all(id_f, attr, new_id):
del attr['name']
lists = File.get_all_dir(id_f, new_id)
files = [file for file in db(File, parent_id=id_f) if file.mime != 'directory']
f = File.save_files(files, new_id, attr)
new_list = []
old_list = []
for dir in lists:
if dir.parent_id == id_f:
old_list.append(dir.id)
attr['parent_id'] = new_id
files = [file for file in db(File, parent_id=dir.id) if file.mime != 'directory']
dir.detach().attr(attr)
dir.save()
new_list.append(dir)
File.save_files(files, dir.id, attr)
else:
old_list.append(dir.id)
files = [file for file in db(File, parent_id=dir.id) if file.mime != 'directory']
parent = File.get(dir.parent_id)
index = File.get_index(parent, old_list)
attr['parent_id'] = new_list[index].id
dir.detach().attr(attr)
dir.save()
new_list.append(dir)
File.save_files(files, dir.id, attr)
return old_list, new_list
def update_article_portal(json, article_id):
db(ArticlePortalDivision, id=article_id).update({'status': json.get('new_status')})
article = db(ArticlePortalDivision, id=article_id).one().get_client_side_dict()
allowed_statuses = ArticlePortalDivision.STATUSES.keys()
json['allowed_statuses'] = allowed_statuses
json['article']['status'] = json.get('new_status')
return json
def __init__(self, name=None,
# portal_plan_id=None,
logo_file_id=None,
company_owner=None,
host=None, divisions=[], portal_layout_id=None):
self.name = name
self.logo_file_id = logo_file_id
# self.company_owner_id = company_owner_id
# self.articles = articles
self.host = host
self.divisions = divisions
# self.portal_plan_id = portal_plan_id if portal_plan_id else db(MemberCompanyPortalPlan).first().id
self.portal_layout_id = portal_layout_id if portal_layout_id else db(PortalLayout).first().id
self.own_company = company_owner
self.company_members = [
MemberCompanyPortal(portal=self, company=company_owner, plan=db(MemberCompanyPortalPlan).first())]
# self.own_company.company_portals = db(MemberCompanyPortalPlan).first()
# db(MemberCompanyPortalPlan).first().portal_companies.add(MemberCompanyPortal(company=self.own_company))
# self.company_assoc = [MemberCompanyPortal(portal = self,
# company = self.own_company,
# company_portal_plan_id=db(MemberCompanyPortalPlan).first().id)]
pass
def subquery_search(filters=None, sorts=None, edit=None):
sub_query = db(TranslateTemplate)
list_filters = []; list_sorts = []
if edit:
exist = db(TranslateTemplate, template=edit['template'], name=edit['name']).first()
i = datetime.datetime.now()
TranslateTemplate.get(exist.id).attr({edit['col']: edit['newValue'], 'md_tm':i}).save().get_client_side_dict()
if 'url' in filters:
list_filters.append({'type': 'select', 'value': filters['url'], 'field': TranslateTemplate.url})
if 'template' in filters:
list_filters.append({'type': 'select', 'value': filters['template'], 'field': TranslateTemplate.template})
if 'name' in filters:
list_filters.append({'type': 'text', 'value': filters['name'], 'field': TranslateTemplate.name})
if 'uk' in filters:
list_filters.append({'type': 'text', 'value': filters['uk'], 'field': TranslateTemplate.uk})
if 'en' in filters:
list_filters.append({'type': 'text', 'value': filters['en'], 'field': TranslateTemplate.en})
if 'portal.name' in filters:
sub_query = sub_query.join(Portal,
Portal.id == TranslateTemplate.portal_id)
list_filters.append({'type': 'text', 'value': filters['portal.name'], 'field': Portal.name})
if 'cr_tm' in sorts:
list_sorts.append({'type': 'date', 'value': sorts['cr_tm'], 'field': TranslateTemplate.cr_tm})
elif 'ac_tm' in sorts:
list_sorts.append({'type': 'date', 'value': sorts['ac_tm'], 'field': TranslateTemplate.ac_tm})
else:
list_sorts.append({'type': 'date', 'value': 'desc', 'field': TranslateTemplate.cr_tm})
sub_query = Grid.subquery_grid(sub_query, list_filters, list_sorts)
return sub_query
def search_for_portal_to_join(company_id, searchtext):
"""This method return all portals which are not partners current company"""
return [port.get_client_side_dict() for port in
db(Portal).filter(~db(MemberCompanyPortal,
company_id=company_id,
portal_id=Portal.id).exists()
).filter(Portal.name.ilike("%" + searchtext + "%")).all()]
def companies_load(json):
companies, pages, page, count = pagination(query=db(Company)
.filter(
Company.id == db(UserCompany, user_id=g.user.id).subquery().c.company_id), page=1,
items_per_page=6 * json.get('next_page') if json.get('next_page') else 6)
return {'companies': [usr_cmp.get_client_side_dict() for usr_cmp in companies],
'user_id': g.user.id, 'end': True if pages == 1 or pages == 0 else False}
def list_reader_load(json):
favorite = request.args.get("favorite") == "True"
localtime = time.gmtime(time.time())
if favorite:
publication_filter = (
Publication.id == db(ReaderPublication, user_id=g.user.id, favorite=True).subquery().c.publication_id
)
else:
division_filter = and_(
PortalDivision.portal_id == db(UserPortalReader, user_id=g.user.id).subquery().c.portal_id
)
publication_filter = and_(
Publication.portal_division_id == db(PortalDivision).filter(division_filter).subquery().c.id,
Publication.status == Publication.STATUSES["PUBLISHED"],
Publication.publishing_tm < datetime.datetime(*localtime[:6]),
)
publications, next_page = Publication.get_page(
filter=publication_filter, order_by=desc(Publication.publishing_tm), page=json.get("next_page"), per_page=10
)
return {
"next_page": next_page,
"end": next_page < 0,
"articles": [p.create_article() for p in publications],
"favorite": favorite,
}
def crop_image(image_id, coordinates):
image_query = db(File, id=image_id).one()
if db(ImageCroped, original_image_id=image_id).count():
return update_croped_image(image_id, coordinates)
company_owner = db(Company).filter(or_(
Company.system_folder_file_id == image_query.root_folder_id,
Company.journalist_folder_file_id == image_query.root_folder_id)).one()
bytes_file = crop_with_coordinates(image_query, coordinates)
if bytes_file:
croped = File()
croped.md_tm = strftime("%Y-%m-%d %H:%M:%S", gmtime())
croped.size = sys.getsizeof(bytes_file.getvalue())
croped.name = image_query.name + '_cropped'
croped.parent_id = company_owner.system_folder_file_id
croped.root_folder_id = company_owner.system_folder_file_id
croped.mime = image_query.mime
fc = FileContent(content=bytes_file.getvalue(), file=croped)
copy_original_image_to_system_folder = \
File(parent_id=company_owner.system_folder_file_id, name=image_query.name+'_original',
mime=image_query.mime, size=image_query.size, user_id=g.user.id,
root_folder_id=company_owner.system_folder_file_id, author_user_id=g.user.id)
cfc = FileContent(content=image_query.file_content.content,
file=copy_original_image_to_system_folder)
g.db.add_all([croped, fc, copy_original_image_to_system_folder, cfc])
g.db.flush()
ImageCroped(original_image_id=copy_original_image_to_system_folder.id,
croped_image_id=croped.id,
x=float(coordinates['x']), y=float(coordinates['y']),
width=float(coordinates['width']),
height=float(coordinates['height']), rotate=int(coordinates['rotate'])).save()
return croped.id
else:
return image_query.id
def publications_load(json, company_id):
portal = db(Company, id=company_id).one().own_portal
if not portal:
return dict(portal_not_exist=True)
current_page = json.get('page') or 1
params = {'search_text': json.get('search_text'), 'portal_id': portal.id}
if json.get('status'):
params['status'] = json.get('status')
subquery = ArticlePortalDivision.subquery_portal_articles(**params)
if json.get('company_id'):
subquery = subquery.filter(db(ArticleCompany,
company_id=json.get('company_id'),
id=ArticlePortalDivision.article_company_id).exists())
articles, pages, current_page = pagination(subquery,
page=current_page)
companies = ArticlePortalDivision.get_companies_which_send_article_to_portal(portal.id)
statuses = {status: status for status in ARTICLE_STATUS_IN_PORTAL.all}
publications = []
for a in articles:
a = a.get_client_side_dict()
del a['long']
publications.append(a)
return {'publications': publications,
'companies': companies,
'pages': {'total': pages,
'current_page': current_page,
'page_buttons': Config.PAGINATION_BUTTONS},
'statuses': statuses}
def __init__(self, name=None,
# portal_plan_id=None,
logo_file_id=None,
company_owner=None,
favicon_file_id=None,
lang='uk',
host=None, divisions=[], portal_layout_id=None):
self.name = name
self.lang = lang
self.logo_file_id = logo_file_id
self.favicon_file_id = favicon_file_id
self.host = host
self.divisions = divisions
self.portal_layout_id = portal_layout_id if portal_layout_id else db(PortalLayout).first().id
self.own_company = company_owner
self.company_members = [
MemberCompanyPortal(portal=self, company=company_owner, status=MemberCompanyPortal.STATUSES['ACTIVE'],
plan=db(MemberCompanyPortalPlan).first())]
# self.own_company.company_portals = db(MemberCompanyPortalPlan).first()
# db(MemberCompanyPortalPlan).first().portal_companies.add(MemberCompanyPortal(company=self.own_company))
# self.company_assoc = [MemberCompanyPortal(portal = self,
# company = self.own_company,
# company_portal_plan_id=db(MemberCompanyPortalPlan).first().id)]
pass
def subquery_company_articles(search_text=None, company_id=None, **kwargs):
sub_query = db(ArticleCompany, company_id=company_id)
if 'filter' in kwargs.keys():
if 'material_status' in kwargs['filter'].keys():
sub_query = db(ArticleCompany, company_id=company_id, status=kwargs['filter']['material_status'])
if 'publication_status' in kwargs['filter'].keys() or 'portals' in kwargs['filter'].keys():
sub_query = sub_query.join(ArticlePortalDivision,
ArticlePortalDivision.article_company_id == ArticleCompany.id)
if 'publication_status' in kwargs['filter'].keys():
sub_query = sub_query.filter(ArticlePortalDivision.status == kwargs['filter']['publication_status'])
if 'portals' in kwargs['filter'].keys():
sub_query = sub_query.join(PortalDivision,
PortalDivision.id == ArticlePortalDivision.portal_division_id). \
filter(PortalDivision.portal_id == kwargs['filter']['portals'])
if search_text:
if 'title' in search_text:
sub_query = sub_query.filter(ArticleCompany.title.ilike("%" + search_text['title'] + "%"))
if 'sort' in kwargs.keys():
if 'date' in kwargs['sort'].keys():
sub_query = sub_query.order_by(ArticleCompany.md_tm.asc()) if kwargs[
'sort']['date'] == 'asc' else sub_query.order_by(
ArticleCompany.md_tm.desc())
else:
sub_query = sub_query.order_by(expression.desc(ArticleCompany.md_tm))
return sub_query
def search_for_company_to_join(user_id, searchtext):
"""Return all companies which are not current user employers yet"""
return [company.get_client_side_dict() for company in
db(Company).filter(~db(UserCompany, user_id=user_id,
company_id=Company.id).exists()).
filter(Company.name.ilike("%" + searchtext + "%")
).all()]
def get_portal_division(self):
return (
db(PortalDivision)
.filter(
PortalDivision.id == db(ArticlePortalDivision, id=self.article_portal_division_id).c.portal_division_id
)
.one()
)
def search_for_company_to_submit(user_id, article_id, searchtext):
# TODO: AA by OZ: .filter(user_id has to be employee in company and
# TODO: must have rights to submit article to this company)
return [x.to_dict('id,name') for x in db(Company).filter(~db(ArticleCompany).
filter_by(company_id=Company.id,
article_id=article_id).
exists()).filter(
Company.name.ilike("%" + searchtext + "%")).all()]
def query_all_companies(user_id):
status = STATUS()
companies = []
query_companies = db(UserCompany, user_id=user_id, status=status.ACTIVE()).all()
for x in query_companies:
companies = companies + db(Company, id=x.company_id).all()
return set(companies)
def get_all_in_dir_rev(id):
files_in_parent = [file for file in db(File, parent_id=id)]
for file in files_in_parent:
if file.mime == 'directory':
for fil in db(File, parent_id=file.id):
files_in_parent.append(fil)
files_in_parent = files_in_parent[::-1]
return files_in_parent
def change_status_employee(company_id, user_id, status=STATUS.SUSPENDED()):
"""This method make status employee in this company suspended"""
db(UserCompany, company_id=company_id, user_id=user_id). \
update({'status': status})
if status == STATUS.DELETED():
UserCompany.update_rights(user_id=user_id,
company_id=company_id,
new_rights=()
)
def articles_visibility_for_user(portal_id):
employer = True
visibilities = Publication.VISIBILITIES.copy()
if not db(UserCompany, user_id=getattr(g.user, 'id', None),
status=UserCompany.STATUSES['ACTIVE']).filter(
UserCompany.company_id == db(Portal.company_owner_id, id=portal_id)).count():
visibilities.pop(Publication.VISIBILITIES['CONFIDENTIAL'])
employer = False
return visibilities.keys(), employer
def check_fields():
form = request.form
required_fields = ['email', 'display_name', 'password', 'password1']
for field in required_fields:
if field not in form.keys():
return False
else:
if not form.get(field):
return False
elif form.get('password') != form.get('password1'):
return False
if db(User, profireader_email=request.form.get('email')).first():
flash('User with this email already exist')
return False
return True
def portal_division_dict(article, tags=None):
if (not hasattr(article, 'portal_division_id')) or (
article.portal_division_id is None):
return {'positioned_articles': []}
else:
filter = article.position_unique_filter()
return {
'positioned_articles': [
pda.get_client_side_dict(fields='id|position|title') for
pda in db(ArticlePortalDivision).filter(filter).order_by(
expression.desc(ArticlePortalDivision.position)).all()
],
'availableTags':
tags
}
def get_list_reader_liked(article_portal_division_id):
me = db(ReaderPublication,
article_portal_division_id=article_portal_division_id,
user_id=g.user.id,
liked=True).first()
limit = 15
articles = db(ReaderPublication,
article_portal_division_id=article_portal_division_id,
liked=True)
liked_users = [
User.get(article.user_id).profireader_name
for article in articles.limit(limit)
]
if me:
if g.user.profireader_name in liked_users:
index = liked_users.index(g.user.profireader_name)
del liked_users[index]
else:
del liked_users[-1]
liked_users.insert(0, g.user.profireader_name)
if articles.count() > limit:
liked_users.append('and ' + str((articles.count() - limit)) +
' more...')
return liked_users
def get_portal_dict_for_material(portal,
company,
material=None,
publication=None):
ret = portal.get_client_side_dict(
fields=
'id, name, host, logo_file_id, divisions.id|name|portal_division_type_id, own_company.name|id|logo_file_id'
)
# ret['rights'] = MemberCompanyPortal.get(company_id=company_id, portal_id=ret['id']).rights
ret['divisions'] = PRBase.get_ordered_dict([
d for d in ret['divisions']
if (d['portal_division_type_id'] == 'events'
or d['portal_division_type_id'] == 'news')
])
if material:
publication_in_portal = db(ArticlePortalDivision).filter_by(
article_company_id=material.id).filter(
ArticlePortalDivision.portal_division_id.in_([
div_id for div_id, div in ret['divisions'].items()
])).first()
else:
publication_in_portal = publication
if publication_in_portal:
ret['publication'] = publication_in_portal.get_client_side_dict(
'id,position,title,status,visibility,portal_division_id,publishing_tm'
)
ret['publication']['division'] = ret['divisions'][
ret['publication']['portal_division_id']]
ret['publication']['counts'] = '0/0/0/0'
ret['actions'] = publication_in_portal.actions(company)
ret['publication']['actions'] = ret['actions']
else:
ret['publication'] = None
canbesubmited = material.actions(company)[
ArticleCompany.ACTIONS['SUBMIT']]
if canbesubmited is True:
membership = MemberCompanyPortal.get(portal_id=portal.id,
company_id=company.id)
canbesubmited = membership.has_rights(
MemberCompanyPortal.RIGHT_AT_PORTAL.PUBLICATION_PUBLISH)
ret['actions'] = {ArticleCompany.ACTIONS['SUBMIT']: canbesubmited}
return ret
def password_reset_request(json):
if not current_user.is_anonymous():
flash('To reset your password logout first please.')
redirect(url_for('reader.list_reader'))
return False
user = db(User, profireader_email=json.get('email')).first()
if user:
user.generate_pass_reset_token().save()
SendEmail().send_email(subject='Reset password', send_to=(user.profireader_email, ""),
html=render_template('auth/email/reset_password.html', user=user),)
flash('An email with instructions to reset your password has been sent to you.')
redirect(url_for('auth.login_signup_endpoint') + '?login_signup=login')
else:
flash('You are not Profireader user yet. Sign up Profireader first please.')
return {}
def confirm(token):
user = db(User, email_conf_token=token).first()
portal_id = request.args.get('subscribe_to_portal')
if user and user.confirmed:
return render_template("auth/confirm_email.html", message='Your account has been already confirmed!')
elif not user or not user.confirm_email():
return render_template("auth/unconfirmed.html", message='Wrong or expired token',
email=user.profireader_email if user else '')
else:
logout_user()
user.confirmed = True
user.save()
login_user(user)
if portal_id:
return redirect(url_for('reader.reader_subscribe', portal_id=portal_id))
return render_template("auth/confirm_email.html")
def subquery_portal_articles(portal_id, filters, sorts):
sub_query = db(Publication)
list_filters = []
list_sorts = []
if 'publication_status' in filters:
list_filters.append({
'type': 'select',
'value': filters['publication_status'],
'field': Publication.status
})
if 'company' in filters:
sub_query = sub_query.join(Publication.company)
list_filters.append({
'type': 'select',
'value': filters['company'],
'field': Company.id
})
if 'date' in filters:
list_filters.append({
'type': 'date_range',
'value': filters['date'],
'field': Publication.publishing_tm
})
sub_query = sub_query. \
join(Publication.division). \
join(PortalDivision.portal). \
filter(Portal.id == portal_id)
if 'title' in filters:
list_filters.append({
'type': 'text',
'value': filters['title'],
'field': Publication.title
})
if 'date' in sorts:
list_sorts.append({
'type': 'date',
'value': sorts['date'],
'field': Publication.publishing_tm
})
else:
list_sorts.append({
'type': 'date',
'value': 'desc',
'field': Publication.publishing_tm
})
sub_query = Grid.subquery_grid(sub_query, list_filters, list_sorts)
return sub_query
def edit_profile(user_id):
if current_user.get_id() != user_id:
abort(403)
user_query = db(User, id=user_id)
#form = EditProfileForm()
#if form.validate_on_submit():
# pass
user = user_query.first()
if request.method == 'GET':
return render_template('general/user_edit_profile.html', user=user, avatar_size=AVATAR_SIZE)
if 'avatar' in request.form.keys():
avatar_type = request.form.get('avatar')
avatar_methods = {'Upload Image': 'upload', 'Use Gravatar': 'gravatar', 'facebook': 'facebook',
'google': 'google', 'linkedin': 'linkedin', 'microsoft': 'microsoft'}
avatar_type = avatar_methods[avatar_type]
if avatar_type == 'Upload Image':
user = user_query.first()
image = request.files['avatar']
user.avatar_update(image)
else:
user.avatar(avatar_type, size=AVATAR_SIZE, small_size=AVATAR_SMALL_SIZE)
g.db.add(user)
g.db.commit()
else:
user_fields = dict()
user_fields['profireader_name'] = request.form['name']
user_fields['profireader_first_name'] = request.form['first_name']
user_fields['profireader_last_name'] = request.form['last_name']
user_fields['profireader_gender'] = request.form['gender']
user_fields['profireader_link'] = request.form['link']
user_fields['profireader_phone'] = request.form['phone']
user_fields['lang'] = request.form['language']
user_fields['location'] = request.form['location']
user_fields['about_me'] = request.form['about_me']
user_query.update(user_fields)
flash('You have successfully updated you profile.')
#return redirect(url_for('user.profile', user_id=user_id, avatar_size=2*AVATAR_SIZE))
return render_template('general/user_edit_profile.html', user=user, avatar_size=AVATAR_SIZE)
def add_delete_liked_user_article(article_portal_division_id, liked):
articleReader = db(
ReaderPublication,
article_portal_division_id=article_portal_division_id,
user_id=g.user.id).first()
if not articleReader:
articleReader = ReaderPublication.add_to_table_if_not_exists(
article_portal_division_id)
articleReader.liked = False if articleReader.liked else True
article_division = ArticlePortalDivision.get(
article_portal_division_id)
article_division.like_count = article_division.like_count - 1 \
if articleReader.liked == False and article_division.like_count != 0 else article_division.like_count + 1
article_division.save()
articleReader.save()
return articleReader.liked
def get_unique_name(name, mime, parent_id):
if File.is_name(name, mime, parent_id):
ext = File.ext(name)
name = File.if_copy(name)
list = []
for n in db(File,parent_id = parent_id, mime=mime):
if re.match(r'^'+name+'\(\d+\)'+''+ext+'', n.name):
pos = (len(n.name) - 2) - len(ext)
list.append(int(n.name[pos:pos+1]))
if list == []:
return name+'(1)'+ext
else:
list.sort()
index = list[-1] + 1
return name+'('+str(index)+')'+ext
else:
return name
def companies_partners_load(json, company_id):
subquery = Company.subquery_company_partners(company_id, json.get('filter'),
filters_exсept=MembersRights.INITIALLY_FILTERED_OUT_STATUSES)
members, pages, current_page, count = pagination(subquery, **Grid.page_options(json.get('paginationOptions')))
return {'grid_data': [utils.dict_merge({'member': member.get_client_side_dict(more_fields='company'),
'company_id': company_id,
'portal_id': db(Portal, company_owner_id=company_id).first().id},
{'actions': MembersRights(company=company_id,
member_company=member).actions()},
{'id': member.id})
for member in members],
'grid_filters': {k: [{'value': None, 'label': TranslateTemplate.getTranslate('', '__-- all --')}] + v for
(k, v) in {'member.status': [{'value': status, 'label': status} for status in
MembersRights.STATUSES]}.items()},
'grid_filters_except': list(MembersRights.INITIALLY_FILTERED_OUT_STATUSES),
'total': count,
'page': current_page}
def send(parent_id):
parent = File.get(parent_id)
root = parent.root_folder_id
if parent.mime == 'root':
root = parent.id
company = db(Company, journalist_folder_file_id=root).one()
if File.if_action_allowed('upload', company.id) == False:
return jsonify({'error': True})
data = request.form
uploaded_file = request.files['file']
name = File.get_unique_name(
urllib.parse.unquote(uploaded_file.filename).replace('"', '_').replace(
'*', '_').replace('/', '_').replace('\\', '_'), data.get('ftype'),
parent.id)
data.get('ftype')
if re.match('^video/.*', data.get('ftype')):
body = {
'title': uploaded_file.filename,
'description': '',
'status': 'public'
}
youtube = YoutubeApi(body_dict=body,
video_file=uploaded_file.stream.read(-1),
chunk_info=dict(
chunk_size=int(data.get('chunkSize')),
chunk_number=int(data.get('chunkNumber')),
total_size=int(data.get('totalSize'))),
company_id=company.id,
root_folder_id=company.journalist_folder_file_id,
parent_folder_id=parent_id)
file = youtube.upload()
else:
file = File.upload(name,
data,
parent.id,
root,
company,
content=uploaded_file.stream.read(-1))
return jsonify({
'result': {
'size': 0
},
'error': True if file == 'error' else False,
'file_id': file
})
def set_division_page_size(self, page_size_for_divisions=None):
page_size_for_divisions = page_size_for_divisions or self.page_size_for_divisions
config = db(PortalConfig, id=self.id).first()
dps = dict()
if config and page_size_for_divisions:
dps = simplejson.loads(getattr(config, PortalConfig.PAGE_SIZE_PER_DIVISION))
dps.update(page_size_for_divisions)
elif page_size_for_divisions:
for division in self.portal.divisions:
if page_size_for_divisions.get(division.name):
dps[division.name] = page_size_for_divisions.get(division.name)
else:
dps[division.name] = Config.ITEMS_PER_PAGE
else:
for division in self.portal.divisions:
dps[division.name] = Config.ITEMS_PER_PAGE
dps = simplejson.dumps(dps)
self.division_page_size = dps
def setup_new_company(self):
"""Add new company to company table and make all necessary relationships,
if company with this name already exist raise DublicateName"""
if db(Company, name=self.name).count():
raise errors.DublicateName({
'message': 'Company name %(name)s already exist. Please choose another name',
'data': self.get_client_side_dict()})
user_company = UserCompany(status=UserCompany.STATUSES['ACTIVE'], rights={UserCompany.RIGHT_AT_COMPANY._OWNER:
True})
user_company.employer = self
g.user.employer_assoc.append(user_company)
g.user.companies.append(self)
self.youtube_playlists.append(YoutubePlaylist(name=self.name, company_owner=self))
self.save()
print(self)
return self
def get_unique_name(name, mime, parent_id):
if File.is_name(name, mime, parent_id):
ext = File.ext(name)
fromname = name[:-(len(ext) + 3)] if File.is_copy(name) else name[:-len(ext) if ext else -1]
list = []
for file in db(File, parent_id=parent_id, mime=mime):
clearName = file.name[:-(len(ext) + 3)] if File.is_copy(file.name) else file.name[:-len(ext)]
if fromname == clearName:
pos = (len(file.name) - 2) - len(ext) if File.is_copy(file.name) else None
if pos:
list.append(int(file.name[pos:pos + 1]))
if list == []:
return fromname + '(1)' + ext
else:
list.sort()
index = list[-1] + 1
return fromname + '(' + str(index) + ')' + ext
else:
return name
def employment_action(json, company_id, employment_id, action):
employment = db(UserCompany).filter_by(id=employment_id).one()
if action == UserCompany.ACTIONS['REJECT']:
employment.status = UserCompany.STATUSES['REJECTED']
elif action == UserCompany.ACTIONS['ENLIST']:
employment.status = UserCompany.STATUSES['ACTIVE']
elif action == UserCompany.ACTIONS['FIRE']:
employment.status = UserCompany.STATUSES['FIRED']
employment.save()
return PRBase.merge_dicts(
employment.employee.get_client_side_dict(),
employment.get_client_side_dict(), {
'actions':
employment.actions(
UserCompany.get(user_id=g.user.id, company_id=company_id))
})
def employment_action(json, company_id, employment_id, action):
employment = db(UserCompany).filter_by(id=employment_id).one()
if action == EmployeesRight.ACTIONS['REJECT']:
employment.status = EmployeesRight.STATUSES['REJECTED']
elif action == EmployeesRight.ACTIONS['ENLIST']:
employment.status = EmployeesRight.STATUSES['ACTIVE']
elif action == EmployeesRight.ACTIONS['FIRE']:
employment.status = EmployeesRight.STATUSES['FIRED']
employment.save()
return utils.dict_merge(
employment.employee.get_client_side_dict(),
employment.get_client_side_dict(), {
'actions':
EmployeesRight(company=company_id,
employment=employment).actions()
})
def insert_after(self, insert_after_id, filter=None):
tochange = db(self.__class__)
if filter is not None:
tochange = tochange.filter(filter)
if insert_after_id == False:
oldtop = tochange.order_by(expression.desc(
self.__class__.position)).first()
if oldtop and (oldtop.id != self.id):
self.position = None
self.save()
self.position = oldtop.position + 1
elif not oldtop:
self.position = None
self.save()
self.position = 1
elif insert_after_id == True:
oldbottom = tochange.order_by(
expression.asc(self.__class__.position)).first()
if oldbottom and (oldbottom.id != self.id):
self.position = None
self.save()
tochange.update({'position': self.__class__.position + 1})
self.position = 1
elif not oldbottom:
self.position = None
self.save()
self.position = 1
elif insert_after_id is None:
self.position = None
elif self.id != insert_after_id:
insert_after_object = self.get(insert_after_id)
if self.position != insert_after_object.position - 1:
self.position = None
self.save()
tochange = tochange.filter(
self.__class__.position >= insert_after_object.position)
tochange.update({'position': self.__class__.position + 1})
self.position = insert_after_object.position - 1
return self
def subquery_search(template=None, url=None, **kwargs):
sub_query = db(Ips)
if 'filter' in kwargs:
if 'url' in kwargs['filter']:
sub_query = sub_query.filter_by(url=kwargs['filter']['url'])
if 'template' in kwargs['filter']:
sub_query = sub_query.filter_by(template=kwargs['filter']['template'])
if 'search_text' in kwargs:
if 'name' in kwargs['search_text']:
sub_query = sub_query.filter(Ips.name.ilike("%" + kwargs['search_text']['name'] + "%"))
if 'uk' in kwargs['search_text']:
sub_query = sub_query.filter(Ips.uk.ilike("%" + kwargs['search_text']['uk'] + "%"))
if 'en' in kwargs['search_text']:
sub_query = sub_query.filter(Ips.en.ilike("%" + kwargs['search_text']['en'] + "%"))
if 'cr_tm' in kwargs['sort']:
sub_query = sub_query.order_by(Ips.cr_tm.asc()) if kwargs['sort']['cr_tm'] == 'asc' else sub_query.order_by(TranslateTemplate.cr_tm.desc())
elif 'ac_tm' in kwargs['sort']:
sub_query = sub_query.order_by(Ips.ac_tm.asc()) if kwargs['sort']['ac_tm'] == 'asc' else sub_query.order_by(TranslateTemplate.ac_tm.desc())
return sub_query
def __get_objects_from_db(self, *args, ordered_objects_list=None):
items = dict()
for cls in args:
fields = cls.get('return_fields') or 'id'
tags = cls.get('tags')
assert type(fields) is str, \
'Arg parameter return_fields must be string but %s given' % fields
for a in db(cls['class']).filter(cls['class'].id.in_(
list(map(lambda x: x[0], ordered_objects_list)))).all():
if fields != 'default_dict' and not tags:
items[a.id] = a.get_client_side_dict(fields=fields)
elif fields != 'default_dict' and tags:
items[a.id] = a.get_client_side_dict(fields=fields)
items[a.id].update(dict(tags=a.tags))
elif fields == 'default_dict' and not tags:
items[a.id] = a.get_client_side_dict()
else:
items[a.id] = a.get_client_side_dict()
items[a.id].update(dict(tags=a.tags))
return collections.OrderedDict(
(id, items[id]) for id, val in ordered_objects_list)
def wrapper(*args, **kwargs):
if g.debug or g.testing:
if not func.__dict__.get('__check_rights__'):
print('Please add "check_right" decorator for your func!')
start = time.clock()
try:
ret = func(*args, **kwargs)
except:
import sys
print("Unexpected error:", sys.exc_info()[0])
return "Unexpected error:", sys.exc_info()[0]
# return redirect(url_for('general.index'))
end = time.clock()
profiler = db(
Profiler,
name=func.__name__,
blueprint_name=func.__dict__['__endpoint__']).first()
method = ','.join([
method for method in func.__dict__['__method__']
]) if func.__dict__['__method__'] else None
if profiler:
profiler.update_profile(end - start, method)
else:
Profiler().create_profile(func.__name__,
func.__dict__['__endpoint__'],
end - start, method)
return ret
else:
if not func.__dict__['__check_rights__']:
raise Exception(
'method not allowed! Please add "check_right" decorator for your func!'
)
try:
ret = func(*args, **kwargs)
except:
import sys
print("Unexpected error:", sys.exc_info()[0])
return "Unexpected error:", sys.exc_info()[0]
return ret
def details(article_portal_division_id):
search_text, portal, _ = get_params()
if search_text:
return redirect(url_for('front.index', search_text=search_text))
article = ArticlePortalDivision.get(article_portal_division_id)
article_visibility = article.article_visibility_details()
article_dict = article.get_client_side_dict(fields='id, title,short, like_count, read_count, cr_tm, '
'md_tm, visibility,'
'publishing_tm, keywords, status, long, image_file_id,'
'division.name, division.portal.id,'
'company.name|id')
article_dict['tags'] = article.tags
division = g.db().query(PortalDivision).filter_by(id=article.portal_division_id).one()
if article_visibility is not True:
back_to_url('front.details', host=portal.host, article_portal_division_id=article_portal_division_id)
else:
article.add_recently_read_articles_to_session()
related_articles = g.db().query(ArticlePortalDivision).filter(
and_(ArticlePortalDivision.id != article.id,
ArticlePortalDivision.portal_division_id.in_(
db(PortalDivision.id).filter(PortalDivision.portal_id == article.division.portal_id))
)).order_by(ArticlePortalDivision.cr_tm.desc()).limit(5).all()
favorite = article.check_favorite_status(user_id=getattr(g.user, 'id', None))
liked = article.article_is_liked(getattr(g.user, 'id', None), article_portal_division_id)
return render_template('front/' + g.portal_layout_path + 'article_details.html',
portal=portal_and_settings(portal),
current_division=division.get_client_side_dict(),
articles_related={
a.id: a.get_client_side_dict(fields='id, title, publishing_tm, company.name|id')
for a
in related_articles},
article=article_dict,
favorite=favorite,
liked=liked,
article_visibility=article_visibility is True,
redirect_info=article_visibility
)
def config_load(json):
page = json.get('paginationOptions')['pageNumber']
pageSize = json.get('paginationOptions')['pageSize']
params = {}
params['sort'] = {}
params['filter'] = {}
params['search_text'] = {}
if json.get('sort'):
for n in json.get('sort'):
params['sort'][n] = json.get('sort')[n]
if json.get('filter'):
for b in json.get('filter'):
if json.get('filter')[b] != '-- all --':
params['filter'][b] = json.get('filter')[b]
if json.get('search_text'):
for d in json.get('search_text'):
params['search_text'][d] = json.get('search_text')[d]
if json.get('editItem'):
exist = db(Config,
template=json.get('editItem')['template'],
name=json.get('editItem')['name']).first()
i = datetime.datetime.now()
Config.get(exist.id).attr({
json.get('editItem')['col']:
json.get('editItem')['newValue'],
'md_tm':
i
}).save().get_client_side_dict()
subquery = Config.subquery_search(template=json.get('template') or None,
url=json.get('url') or None,
**params)
translations, pages, current_page, count = pagination(
subquery, page=page, items_per_page=pageSize)
grid_data = TranslateTemplate.getListGridDataTranslation(translations)
return {'grid_data': grid_data, 'total': subquery.count()}
def clone_for_portal_images_and_replace_urls(self, portal_division_id, article_portal_division):
filesintext = {found[1]: True for found in
re.findall('(https?://file001.profireader.com/([^/]*)/)', self.long)}
if self.image_file_id:
filesintext[self.image_file_id] = True
company = db(PortalDivision, id=portal_division_id).one().portal.own_company
for file_id in filesintext:
filesintext[file_id] = \
File.get(file_id).copy_file(company_id=company.id,
root_folder_id=company.system_folder_file_id,
parent_id=company.system_folder_file_id,
article_portal_division_id=article_portal_division.id).save().id
if self.image_file_id:
article_portal_division.image_file_id = filesintext[self.image_file_id]
article_portal_division.save()
long_text = self.long
for old_image_id in filesintext:
long_text = long_text.replace('://file001.profireader.com/%s/' % (old_image_id,),
'://file001.profireader.com/%s/' % (filesintext[old_image_id],))
return long_text
def init_on_load(self):
if self.portal_division_type_id == 'company_subportal':
self.settings = db(PortalDivisionSettingsCompanySubportal).filter_by(
portal_division_id=self.id).one()
def get(user_id=None, portal_id=None):
return db(UserPortalReader).filter_by(user_id=user_id , portal_id=portal_id).first()
def get_portals_for_user():
portals = db(Portal).filter(~(Portal.id.in_(db(UserPortalReader.portal_id, user_id=g.user.id)))).all()
for portal in portals:
yield (portal.id, portal.name,)
def get_portal_divisions_json(self):
return json.dumps({division[0]: {'name': division[1], 'show_division': True, 'comments': True}
for division in db(PortalDivision.id, PortalDivision.name, portal_id=self.portal_id).all()},
ensure_ascii=False)
def get_division_types():
"""Return all divisions on profireader"""
return db(PortalDivisionType).all()
def get_members(company_id, *args):
subquery = db(MemberCompanyPortal).filter(
MemberCompanyPortal.portal_id == db(Portal, company_owner_id=company_id).subquery().c.id).filter(MemberCompanyPortal.status != MemberCompanyPortal.STATUSES['REJECTED'])
return subquery
