def post(self):
password = self.get_argument('password', '')
try:
entity_id = int(password[2:-3])
entity = db.Entity(user_locale=self.get_user_locale(), user_id=entity_id)
applicant = entity.get(entity_id=entity_id, limit=1)
applicant_id = applicant.get('id')
applicant_email = applicant.get('properties', {}).get('user', {}).get('values', [])[0].get('value')
applicant_password = applicant.get('properties', {}).get('password', {}).get('values', [])[0].get('value')
if applicant_password != password:
raise Exception('Invalid password')
except:
return self.render('application/signin.html',
page_title = self.get_user_locale().translate('application'),
message = 'password_error',
)
session_key = ''.join(random.choice(string.ascii_letters + string.digits) for x in range(32)) + hashlib.md5(str(time.time())).hexdigest()
user_key = hashlib.md5(self.request.remote_ip + self.request.headers.get('User-Agent', None)).hexdigest()
db.User().create(
provider = 'application',
id = applicant_id,
email = applicant_email,
language = self.settings['default_language'],
session = session_key+user_key
)
self.set_secure_cookie('session', str(session_key))
self.redirect('/application/form')
def post(self):
"""
Saves applicant info.
"""
user = self.current_user
if not user:
return
action = self.get_argument('action', '')
entity_id = self.get_argument('entity_id', '')
if not action or not entity_id:
return
entity = db.Entity(user_locale=self.get_user_locale(), user_id=user.id)
applicant = entity.get(entity_id=user.id, limit=1, full_definition=True)
if not applicant:
return
logging.debug(action)
if action.lower() == 'subscribe':
entity.set_relations(entity_id=entity_id, related_entity_id=user.id, relationship_type='leecher')
if action.lower() == 'unsubscribe':
entity.set_relations(entity_id=entity_id, related_entity_id=user.id, relationship_type='leecher', delete=True)
def post(self):
"""
Saves applicant info.
"""
user = self.current_user
if not user:
return
entity = db.Entity(user_locale=self.get_user_locale(), user_id=user.id)
applicant = entity.get(entity_id=user.id, limit=1)
if not applicant:
return
property_definition_id = self.get_argument('property_id', default=None, strip=True)
property_id = self.get_argument('value_id', default=None, strip=True)
value = self.get_argument('value', default=None, strip=True)
uploaded_file = self.request.files.get('file', [])[0] if self.request.files.get('file', None) else None
property_id = entity.set_property(entity_id=user.id, property_definition_id=property_definition_id, value=value, property_id=property_id, uploaded_file=uploaded_file)
self.write({
'property_id': property_definition_id,
'value_id': property_id,
'value': uploaded_file['filename'] if uploaded_file else value
})
def get(self, entity_id=None, entity_definition_keyname=None):
"""
Shows Entitiy adding form.
"""
entity = db.Entity(user_locale=self.get_user_locale(),
user_id=self.current_user.id)
item = entity.get(entity_id=0,
entity_definition_keyname=entity_definition_keyname,
limit=1,
full_definition=True)
if not item:
return
entity_definition = entity.get_entity_definition(
entity_definition_keyname=entity_definition_keyname)
actions = StrToList(entity_definition[0].get('actions_add'))
self.render(
'entity/edit.html',
entity=item,
parent_entity_id=entity_id,
entity_definition_keyname=entity_definition_keyname,
actions=actions,
)
def get(self, test_id=None):
test_id = test_id.strip('-')
entity = db.Entity(user_locale=self.get_user_locale(),
user_id=self.current_user.id)
if not test_id:
return self.redirect('/test')
test_ids = entity.get_relatives(ids_only=True,
related_entity_id=self.current_user.id,
entity_definition_id=60,
relation_type='leecher',
reverse_relation=True)
if not test_ids:
return self.redirect('/')
test_id = int(test_id)
if test_id not in test_ids:
return self.redirect('/test')
db_con = db.connection()
test_questions = entity.get_relatives(ids_only=True,
entity_id=test_id,
relation_type='child')
unanswered = False
for q in test_questions:
prop = db_con.get(
"""
SELECT
property.value_string AS value
FROM
relationship,
property
WHERE property.relationship_id = relationship.id
AND relationship.relationship_definition_id = 10
AND relationship.entity_id = %s
AND relationship.related_entity_id = %s
AND relationship.deleted IS NULL
AND property.deleted IS NULL
LIMIT 1;
""", q, self.current_user.id)
if not prop:
unanswered = True
if unanswered == False:
entity.set_relations(entity_id=test_id,
related_entity_id=self.current_user.id,
relationship_type='leecher',
delete=True)
return self.redirect('/test')
self.redirect('/test-%s' % test_id)
def post(self):
ester_id = self.get_argument('ester_id', default=None, strip=True)
parent_entity_id = self.get_argument('parent_entity_id',
default=None,
strip=True)
entity_definition_keyname = self.get_argument(
'entity_definition_keyname', default=None, strip=True)
if not ester_id or not parent_entity_id or not entity_definition_keyname:
return
entity = GetExistingID(ester_id)
if entity.get('entity_id'):
return self.write(str(entity.get('entity_id')))
response = httpclient.HTTPClient().fetch(
'http://tallinn.ester.ee/search~S1?/.' + ester_id + '/.' +
ester_id + '/1,1,1,B/marc~' + ester_id)
marc = response.body.split('<pre>')[1].split('</pre>')[0].strip()
# item = ParseMARC(HTMLParser().unescape((marc))
item = ParseMARC(marc)
if not item:
return
item['ester-id'] = ester_id
db_connection = db.connection()
logging.debug(str(item))
entity = db.Entity(user_locale=self.get_user_locale(),
user_id=self.current_user.id)
entity_id = entity.create(
entity_definition_keyname=entity_definition_keyname,
parent_entity_id=parent_entity_id)
for field, values in item.iteritems():
sql = 'SELECT keyname FROM property_definition WHERE dataproperty = \'%s\' AND entity_definition_keyname = \'%s\' LIMIT 1;' % (
field, entity_definition_keyname)
logging.debug(sql)
property_definition = db_connection.get(sql)
if not property_definition:
logging.warning('%s: %s' % (field, values))
continue
if type(values) is not list:
values = [values]
for value in values:
entity.set_property(
entity_id=entity_id,
property_definition_keyname=property_definition.keyname,
value=value)
self.write(str(entity_id))
def get(self, path=None, search=None):
if not path:
self.redirect('/public')
search = search.strip('/').strip('-')
if not search:
self.redirect('/public-%s' % path)
locale = self.get_user_locale()
items = []
if len(search) > 1:
db_connection = db.connection()
entity_definitions = [
x.keyname for x in db_connection.query(
'SELECT keyname FROM entity_definition WHERE public_path = %s;',
path)
]
entities = db.Entity(user_locale=self.get_user_locale()).get(
search=search,
entity_definition_keyname=entity_definitions,
only_public=True)
if entities:
for item in entities:
items.append({
'url':
'/public-%s/entity-%s/%s' % (path, item.get(
'id', ''), toURL(item.get('displayname', ''))),
'name':
item.get('displayname', ''),
'date':
item.get('created'),
'file':
item.get('file_count', 0),
})
if len(search) < 2:
itemcount = locale.translate('search_term_to_short') % search
elif len(items) == 0:
itemcount = locale.translate('search_noresult')
elif len(items) == 1:
itemcount = locale.translate('search_result_count1')
else:
itemcount = locale.translate('search_result_count2') % len(items)
self.render(
'public/list.html',
entities=sorted(items, key=itemgetter('name')),
itemcount=itemcount,
paths=get_paths(self.get_user_locale()),
path=path,
search=urllib.unquote_plus(search),
)
def post(self):
"""
Saves Entitiy info.
"""
entity_id = self.get_argument('entity_id', default=None, strip=True)
parent_entity_id = self.get_argument('parent_entity_id',
default=None,
strip=True)
entity_definition_keyname = self.get_argument(
'entity_definition_keyname', default=None, strip=True)
property_definition_keyname = self.get_argument(
'property_definition_keyname', default=None, strip=True)
property_id = self.get_argument('value_id', default=None, strip=True)
value = self.get_argument('value', default=None, strip=True)
is_counter = self.get_argument('counter', default='false', strip=True)
is_public = self.get_argument('is_public', default='false', strip=True)
uploaded_file = self.request.files.get(
'file', [])[0] if self.request.files.get('file', None) else None
entity = db.Entity(user_locale=self.get_user_locale(),
user_id=self.current_user.id)
if not entity_id and parent_entity_id and entity_definition_keyname:
entity_id = entity.create(
entity_definition_keyname=entity_definition_keyname,
parent_entity_id=parent_entity_id)
if is_counter.lower() == 'true':
value = entity.set_counter(entity_id=entity_id)
elif is_public.lower() == 'true':
value = True if value.lower() == 'true' else False
value = entity.set_public(entity_id=entity_id, is_public=value)
else:
property_id = entity.set_property(
entity_id=entity_id,
property_definition_keyname=property_definition_keyname,
value=value,
property_id=property_id,
uploaded_file=uploaded_file)
self.write({
'entity_id':
entity_id,
'property_definition_keyname':
property_definition_keyname,
'value_id':
property_id,
'value':
uploaded_file['filename'] if uploaded_file else value
})
def post(self):
file_id = self.get_argument('file_id', None)
delimiter = self.get_argument('delimiter', ',')
first_row = self.get_argument('first_row', 1)
parent_entity_id = self.get_argument('parent_entity_id', None)
entity_definition_keyname = self.get_argument(
'entity_definition_keyname', None)
if not file_id or not delimiter or not parent_entity_id or not entity_definition_keyname:
return
first_row = int(first_row)
db_connection = db.connection()
tmp_file = db_connection.get(
'SELECT * FROM tmp_file WHERE id = %s AND created_by = %s LIMIT 1;',
file_id, self.current_user.id)
if not tmp_file:
return
csv_headers = None
row_count = 0
for row in csv.reader(StringIO.StringIO(tmp_file.file),
delimiter=str(delimiter)):
if not csv_headers:
csv_headers = row
row_count += 1
entity = db.Entity(user_locale=self.get_user_locale(),
user_id=self.current_user.id)
item = entity.get(entity_id=0,
entity_definition_keyname=entity_definition_keyname,
limit=1,
full_definition=True)
self.render(
'action/csv_read.html',
file_id=file_id,
file_name=tmp_file.filename,
delimiter=delimiter,
first_row=first_row,
row_count=row_count,
csv_headers=csv_headers,
properties=item.get('properties', {}).values(),
parent_entity_id=parent_entity_id,
entity_definition_keyname=entity_definition_keyname,
)
def post(self):
file_id = self.get_argument('file_id', None)
delimiter = self.get_argument('delimiter', ',')
first_row = self.get_argument('first_row', 1)
parent_entity_id = self.get_argument('parent_entity_id', None)
entity_definition_keyname = self.get_argument(
'entity_definition_keyname', None)
first_row = int(first_row)
db_connection = db.connection()
tmp_file = db_connection.get(
'SELECT * FROM tmp_file WHERE id = %s AND created_by = %s LIMIT 1;',
file_id, self.current_user.id)
if not tmp_file:
return
entity = db.Entity(user_locale=self.get_user_locale(),
user_id=self.current_user.id)
item = entity.get(entity_id=0,
entity_definition_keyname=entity_definition_keyname,
limit=1,
full_definition=True)
properties = item.get('properties', {}).values()
row_num = 0
for row in csv.reader(StringIO.StringIO(tmp_file.file),
delimiter=str(delimiter)):
row_num += 1
if row_num < first_row:
continue
entity_id = entity.create(
entity_definition_keyname=entity_definition_keyname,
parent_entity_id=parent_entity_id)
for p in properties:
field = self.get_argument('field_%s' % p.get('dataproperty'),
None)
if not field:
continue
value = row[int(field)]
if not value:
continue
property_id = entity.set_property(
entity_id=entity_id,
property_definition_keyname=p.get('keyname'),
value=value)
def post(self, entity_definition_keyname=None):
"""
Returns searched Entitiy IDs as JSON.
"""
entity_definition_keyname = entity_definition_keyname.strip('/')
search = self.get_argument('search', None, True)
self.write({
'items':
db.Entity(user_locale=self.get_user_locale(),
user_id=self.current_user.id).get(
ids_only=True,
search=search,
entity_definition_keyname=entity_definition_keyname,
limit=303)
})
def get(self, entity_id, dataproperty):
"""
Shows HTML property in modal box
"""
entity = db.Entity(user_locale=self.get_user_locale(),
user_id=self.current_user.id)
item = entity.get(entity_id=entity_id, limit=1, full_definition=False)
if not item:
return
self.write('\n'.join([
x.get('value', '') for x in item.get('properties', {}).get(
dataproperty, {}).get('values') if x.get('value', '')
]))
def get_definitions(user_locale, path):
db_connection = db.connection()
entity_definitions = []
entity = db.Entity(user_locale=user_locale)
for entity_definition_keyname in [
x.keyname for x in db_connection.query(
'SELECT keyname FROM entity_definition WHERE public_path = %s;',
path)
]:
entity_definitions.append(
entity.get(entity_id=0,
entity_definition_keyname=entity_definition_keyname,
full_definition=True,
limit=1,
only_public=True))
return entity_definitions
def post(self, entity_id=None):
"""
Returns Entitiy info for list as JSON.
"""
entity = db.Entity(user_locale=self.get_user_locale(),
user_id=self.current_user.id)
item = entity.get(entity_id=entity_id, limit=1)
if not item:
return self.missing()
self.write({
'id': item['id'],
'title': item['displayname'],
'info': item['displayinfo'],
'image': item['displaypicture'],
})
def get(self, entity_id=None):
"""
Shows Entitiy relate form.
"""
entity = db.Entity(user_locale=self.get_user_locale(),
user_id=self.current_user.id)
item = entity.get(entity_id=entity_id, limit=1, full_definition=True)
if not item:
return
self.render(
'entity/edit.html',
entity=item,
parent_entity_id='',
entity_definition_keyname='',
)
def get(self, entity_id=None, url=None):
"""
Shows Entitiy info.
"""
entity = db.Entity(user_locale=self.get_user_locale(),
user_id=self.current_user.id)
item = entity.get(entity_id=entity_id, limit=1)
if not item:
return self.missing()
relatives = entity.get_relatives(
entity_id=item['id'],
relationship_definition_keyname=['child', 'leecher'])
parents = entity.get_relatives(related_entity_id=item['id'],
relationship_definition_keyname='child',
reverse_relation=True)
allowed_childs = entity.get_allowed_childs(entity_id=item['id'])
leecher_in = entity.get_relatives(
related_entity_id=item['id'],
relationship_definition_keyname='leecher',
reverse_relation=True)
can_edit = False if self.current_user.provider == 'application' else True #entity.get_relatives(ids_only=True, entity_id=item['id'], related_entity_id=self.current_user.id, relationship_definition_keyname=['viewer', 'editor', 'owner'])
can_add = False if self.current_user.provider == 'application' else True #entity.get_relatives(ids_only=True, entity_id=item['id'], related_entity_id=self.current_user.id, relationship_definition_keyname=['viewer', 'editor', 'owner'])
rating_scale = None
# rating_scale_list = [x.get('values', []) for x in item.get('properties', []) if x.get('dataproperty', '') == 'rating_scale']
# if rating_scale_list:
# rating_scale = rating_scale_list[0][0]
self.render(
'entity/item.html',
page_title=item['displayname'],
entity=item,
relatives=dict(leecher_in.items() + relatives.items()),
parents=parents,
allowed_childs=allowed_childs,
rating_scale=rating_scale,
can_edit=can_edit,
can_add=can_add,
is_owner=True,
)
def get(self, path=None, entity_id=None, url=None):
try:
entity_id = int(entity_id.split('/')[0])
except:
return self.missing()
item = db.Entity(user_locale=self.get_user_locale()).get(
entity_id=entity_id, limit=1, only_public=True)
if not item:
return self.missing()
self.render(
'public/item.html',
page_title=item['displayname'],
entity=item,
paths=get_paths(self.get_user_locale()),
path=path,
search='',
)
def get(self, file_id=None, url=None):
try:
file_id = int(file_id.split('/')[0])
except:
return self.missing()
file = db.Entity(user_locale=self.get_user_locale()).get_file(file_id)
if not file:
return self.missing()
ms = magic.open(magic.MAGIC_MIME)
ms.load()
mime = ms.buffer(file.file)
ms.close()
self.add_header('Content-Type', mime)
self.add_header('Content-Disposition',
'attachment; filename="%s"' % file.filename)
self.write(file.file)
def post(self, entity_id=None):
if not self.get_argument('to', None):
return self.missing()
to = self.get_argument('to', None)
message = self.get_argument('message', '')
entity = db.Entity(user_locale=self.get_user_locale(),
user_id=self.current_user.id)
item = entity.get(entity_id=entity_id, limit=1)
if not item:
return self.missing()
url = 'http://%s/entitygroup-%s#%s' % (self.request.headers.get(
'Host'), item['definition_id'], item['id'])
self.mail_send(
to=to,
subject=item['displayname'],
message='%s\n\n%s\n\n%s\n%s' %
(message, url, self.current_user.name, self.current_user.email))
def post(self):
entity_id = self.get_argument('entity_id', default=None, strip=True)
value = self.get_argument('value', default=None, strip=True)
if not entity_id:
return
db_con = db.connection()
entity = db.Entity(user_locale=self.get_user_locale(),
user_id=self.current_user.id)
if value:
entity.set_relations(entity_id=entity_id,
related_entity_id=self.current_user.id,
relationship_type='rating',
update=True)
ratings = entity.get_relatives(
relationship_ids_only=True,
entity_id=entity_id,
related_entity_id=self.current_user.id,
relation_type='rating',
reverse_relation=True)
if ratings:
prop = db_con.get(
'SELECT id FROM property WHERE property_definition_id = 513 AND relationship_id = %s AND deleted IS NULL LIMIT 1;',
ratings[0])
if prop:
property_id = prop.id
else:
property_id = None
entity.set_property(property_id=property_id,
relationship_id=ratings[0],
property_definition_id=513,
value=value)
else:
entity.set_relations(entity_id=entity_id,
related_entity_id=self.current_user.id,
relationship_type='rating',
delete=True)
def post(self):
"""
Creates applicant and sends login information to email.
"""
email = self.get_argument('email', '')
if not checkEmail(email):
self.render('application/signin.html',
page_title = self.get_user_locale().translate('application'),
message = 'email_error',
)
return
applicant_definition = 10
applicant_user_definition = 113
applicant_password_definition = 501
entity = db.Entity(user_locale=self.get_user_locale())
entity_id = entity.create(entity_definition_id=applicant_definition)
entity.set_relations(entity_id=entity_id, related_entity_id=entity_id, relationship_type='viewer')
password = ''.join(random.choice(string.ascii_letters) for x in range(2))
password += str(entity_id)
password += ''.join(random.choice(string.ascii_letters) for x in range(3))
password = password.replace('O', random.choice(string.ascii_lowercase))
entity.set_property(entity_id=entity_id, property_definition_id=applicant_user_definition, value=email)
entity.set_property(entity_id=entity_id, property_definition_id=applicant_password_definition, value=password)
self.mail_send(
to = email,
subject = self.get_user_locale().translate('application_signup_email_subject'),
message = self.get_user_locale().translate('application_signup_email_message') % password
)
self.render('application/signin.html',
page_title = self.get_user_locale().translate('application'),
message = 'email_success',
)
def get(self, entity_definition_keyname=None):
"""
Show entities page with menu.
"""
entity_definition_keyname = entity_definition_keyname.strip('/')
entity = db.Entity(user_locale=self.get_user_locale(),
user_id=self.current_user.id)
entity_definition = None
if entity_definition_keyname:
entity_definition = entity.get_entity_definition(
entity_definition_keyname=entity_definition_keyname)
self.render(
'entity/start.html',
page_title=entity_definition[0].label_plural
if entity_definition else '',
menu=entity.get_menu(),
show_list=True if entity_definition_keyname else False,
entity_definition=entity_definition_keyname,
)
def get(self):
user = self.current_user
if not user:
return self.redirect('/application')
entity = db.Entity(user_locale=self.get_user_locale(), user_id=user.id)
applicant = entity.get(entity_id=user.id, limit=1, full_definition=True)
submissions = {}
for s in entity.get(entity_definition_id=20, only_public=True):
start_datetime = s.get('properties', {}).get('start_datetime', {}).get('values', [])
if not start_datetime:
continue
start_datetime = start_datetime[0]
if not start_datetime['db_value']:
continue
if start_datetime['db_value'] > datetime.now():
continue
end_datetime = s.get('properties', {}).get('end_datetime', {}).get('values', [])
if not end_datetime:
continue
end_datetime = end_datetime[0]
if not end_datetime['db_value']:
continue
if end_datetime['db_value'] < datetime.now():
continue
parent1 = entity.get_relatives(related_entity_id=s.get('id'), relation_type='child', reverse_relation=True, only_public=True).values()
if not parent1:
continue
parent1 = parent1[0][0]
parent2 = entity.get_relatives(related_entity_id=parent1.get('id'), relation_type='child', reverse_relation=True, only_public=True).values()
if not parent2:
continue
parent2 = parent2[0][0]
submissions.setdefault(parent2.get('displayname'), {})['label'] = parent2.get('displayname')
submissions.setdefault(parent2.get('displayname'), {}).setdefault('childs', []).append({
'id': s.get('id'),
'label': s.get('displayname'),
'info': s.get('displayinfo'),
'url': ''.join([x['value'] for x in s.get('properties', {}).get('url', {}).get('values', []) if x['value']]),
'subscribed': True if entity.get_relatives(entity_id=s.get('id'), related_entity_id=user.id, relation_type='leecher', reverse_relation=True) else False
})
properties = {}
for k, p in applicant.get('properties', {}).iteritems():
if not p.get('fieldset'):
continue
properties.setdefault(p.get('fieldset'), {})['label'] = p.get('fieldset')
properties.setdefault(p.get('fieldset'), {}).setdefault('properties', {})[k] = p
childs = []
for ed in entity.get_entity_definition(entity_definition_id=[5, 19, 21, 25, 50, 51, 12]):
relatives = entity.get_relatives(entity_id=user.id, entity_definition_id=ed.id, relation_type='child', full_definition=True)
if relatives:
relatives = relatives.values()[0]
else:
relatives = [entity.get(entity_id=0, entity_definition_id=ed.id, limit=1, full_definition=True)]
childs.append({
'label': ed.label,
'description': ed.description if ed.description else '',
'childs': relatives,
'ordinal': ed.ordinal
})
self.render('application/form.html',
page_title = self.get_user_locale().translate('application'),
properties = properties,
submissions = submissions,
childs = childs,
)
def get(self, path=None, search=None):
if not path:
self.redirect('/public')
if not self.get_argument('ed', None):
self.redirect('/public-%s' % path)
entity_definition_keyname = self.get_argument('ed')
entity = db.Entity(user_locale=self.get_user_locale())
entity_definition = entity.get(
entity_id=0,
entity_definition_keyname=entity_definition_keyname,
full_definition=True,
limit=1,
only_public=True)
db_connection = db.connection()
entity_ids = None
for p in entity_definition.get('properties', {}).values():
if not p['public'] or p['datatype'] not in [
'string', 'text', 'datetime', 'date', 'integer', 'decimal',
'boolean', 'counter_value'
]:
continue
sql = ''
if p['datatype'] in ['string', 'counter_value']:
if self.get_argument('t%s' % p['keyname'], None):
sql += ' AND value_string LIKE \'%%%%%s%%%%\'' % self.get_argument(
't%s' % p['keyname']).replace('\'', '\\\'')
if p['datatype'] in ['integer', 'decimal']:
if self.get_argument('t%s' % p['keyname'], None):
sql += ' AND value_decimal = %s' % self.get_argument(
't%s' % p['keyname']).replace('\'', '\\\'')
elif p['datatype'] in ['datetime', 'date']:
if self.get_argument('s%s' % p['keyname'], None):
sql += ' AND value_datetime >= \'%s\'' % self.get_argument(
's%s' % p['keyname']).replace('\'', '\\\'')
if self.get_argument('e%s' % p['keyname'], None):
sql += ' AND value_datetime <= \'%s\'' % self.get_argument(
'e%s' % p['keyname']).replace('\'', '\\\'')
if sql:
sql = 'SELECT DISTINCT entity.id FROM property, entity WHERE entity.id = property.entity_id AND entity.entity_definition_keyname = \'%s\' AND property.property_definition_keyname = \'%s\' AND entity.public = 1 %s' % (
entity_definition_keyname, p['keyname'], sql)
logging.debug(sql)
ids = [x.id for x in db_connection.query(sql)]
if entity_ids == None:
entity_ids = ids
entity_ids = ListMatch(entity_ids, ids)
locale = self.get_user_locale()
items = []
if entity_ids:
entity_definitions = [
x.keyname for x in db_connection.query(
'SELECT keyname FROM entity_definition WHERE public_path = %s;',
path)
]
entities = db.Entity(user_locale=self.get_user_locale()).get(
entity_id=entity_ids,
entity_definition_keyname=entity_definitions,
only_public=True)
if entities:
for item in entities:
items.append({
'url':
'/public-%s/entity-%s/%s' % (path, item.get(
'id', ''), toURL(item.get('displayname', ''))),
'name':
item.get('displayname', ''),
'date':
item.get('created'),
'file':
item.get('file_count', 0),
})
if len(items) == 0:
itemcount = locale.translate('search_noresult')
elif len(items) == 1:
itemcount = locale.translate('search_result_count1')
else:
itemcount = locale.translate('search_result_count2') % len(items)
self.render(
'public/list.html',
entities=sorted(items, key=itemgetter('name')),
itemcount=itemcount,
paths=get_paths(self.get_user_locale()),
path=path,
search='',
)
def get(self, test_id=None):
test_id = test_id.strip('-')
entity = db.Entity(user_locale=self.get_user_locale(),
user_id=self.current_user.id)
test_ids = entity.get_relatives(ids_only=True,
related_entity_id=self.current_user.id,
entity_definition_id=60,
relation_type='leecher',
reverse_relation=True)
if not test_ids:
return self.redirect('/oldauth')
test_ids = sorted(test_ids)
if not test_id:
test_id = test_ids[0]
test_id = int(test_id)
if test_id not in test_ids:
return self.redirect('/test')
db_con = db.connection()
pages = []
row = 0
for id in test_ids:
row += 1
pages.append({
'label': row,
'id': id,
'active': True if id == test_id else False
})
test = entity.get(entity_id=test_id, limit=1)
test_questions = entity.get_relatives(entity_id=test_id,
relation_type='child')
questions = {}
if test_questions.values():
for q in test_questions.values()[0]:
group = ''.join([
x['value'] for x in q.get('properties', {}).get(
'group', []).get('values', []) if x['value']
])
prop = db_con.get(
"""
SELECT
property.value_string AS value
FROM
relationship,
property
WHERE property.relationship_id = relationship.id
AND relationship.relationship_definition_id = 10
AND relationship.entity_id = %s
AND relationship.related_entity_id = %s
AND relationship.deleted IS NULL
AND property.deleted IS NULL
LIMIT 1;
""", q.get('id'), self.current_user.id)
questions.setdefault(group, []).append({
'id':
q['id'],
'label':
''.join([
x['value'] for x in q.get('properties', {}).get(
'question', []).get('values', []) if x['value']
]),
'type':
''.join([
x['value'] for x in q.get('properties', {}).get(
'type', []).get('values', []) if x['value']
]),
'value':
prop.value if prop else ''
})
self.render(
'test/start.html',
page_title=test.get('displayname', ''),
test_id=test.get('id', ''),
test_name=test.get('displayname', ''),
test_description=''.join([
x['value'] for x in test.get('properties', {}).get(
'description', []).get('values', []) if x['value']
]),
pages=pages,
questions=questions,
)
