def testing(request):
translationgist=TranslationGist(client_id=1, type='Language')
DBSession.add(translationgist)
translationatom=TranslationAtom(client_id=1, parent=translationgist, locale_id=2, content='testing objecttoc')
DBSession.add(translationatom)
lang = Language(client_id=1, translation_gist_client_id=translationgist.client_id,
translation_gist_object_id=translationgist.object_id)
DBSession.add(lang)
DBSession.rollback()
return {}
def diff_desk(request):
import base64
from lingvodoc.models import categories
from time import sleep
client = DBSession.query(Client).filter_by(id=authenticated_userid(request)).first()
if not client:
request.response.status = HTTPNotFound.code
return {'error': str("Try to login again")}
user = DBSession.query(User).filter_by(id=client.user_id).first()
if not user:
request.response.status = HTTPNotFound.code
return {'error': str("Try to login again")}
settings = request.registry.settings
existing = [row2dict(entry) for entry in DBSession.query(ObjectTOC)]
central_server = settings['desktop']['central_server']
path = central_server + 'sync/difference/server'
server = make_request(path, 'post', existing).json()
language = list()
dictionary = list()
perspective = list()
field = list()
dictionaryperspectivetofield = list()
lexicalentry = list()
entity = list()
userblobs = list()
translationgist = list()
translationatom = list()
for entry in server:
if entry['table_name'] == 'language':
language.append(entry)
if entry['table_name'] == 'dictionary':
dictionary.append(entry)
if entry['table_name'] == 'dictionaryperspective':
perspective.append(entry)
if entry['table_name'] == 'dictionaryperspectivetofield':
dictionaryperspectivetofield.append(entry)
if entry['table_name'] == 'lexicalentry':
lexicalentry.append(entry)
if entry['table_name'] == 'entity':
entity.append(entry)
if entry['table_name'] == 'userblobs':
userblobs.append(entry)
if entry['table_name'] == 'translationgist':
translationgist.append(entry)
if entry['table_name'] == 'translationatom':
translationatom.append(entry)
if entry['table_name'] == 'field':
field.append(entry)
# todo: batches
for group in DBSession.query(Group).filter_by(subject_client_id=authenticated_userid(request)).all():
path = central_server + 'group'
gr_req = row2dict(group)
gr_req['users']=[user.id]
status = make_request(path, 'post', gr_req)
if status.status_code != 200:
request.response.status = HTTPInternalServerError.code
return {'error': str("internet error")}
for entry in translationgist:
desk_gist = DBSession.query(TranslationGist).filter_by(client_id=entry['client_id'],
object_id=entry['object_id']).one()
path = central_server + 'translationgist'
status = make_request(path, 'post', row2dict(desk_gist))
if status.status_code != 200:
request.response.status = HTTPInternalServerError.code
return {'error': str("internet error")}
for entry in translationatom:
desk_atom = DBSession.query(TranslationAtom).filter_by(client_id=entry['client_id'],
object_id=entry['object_id']).one()
path = central_server + 'translationatom'
status = make_request(path, 'post', row2dict(desk_atom))
if status.status_code != 200:
request.response.status = HTTPInternalServerError.code
return {'error': str("internet error")}
for entry in language:
desk_lang = DBSession.query(Language).filter_by(client_id=entry['client_id'],
object_id=entry['object_id']).one()
path = central_server + 'language'
status = make_request(path, 'post', row2dict(desk_lang))
if status.status_code != 200:
request.response.status = HTTPInternalServerError.code
return {'error': str("internet error")}
for entry in dictionary:
desk_dict = DBSession.query(Dictionary).filter_by(client_id=entry['client_id'],
object_id=entry['object_id']).one()
path = central_server + 'dictionary'
desk_json = row2dict(desk_dict)
desk_json['category'] = categories[desk_json['category']]
status = make_request(path, 'post', desk_json)
if status.status_code != 200:
request.response.status = HTTPInternalServerError.code
return {'error': str("internet error")}
for entry in perspective:
desk_persp = DBSession.query(DictionaryPerspective).filter_by(client_id=entry['client_id'],
object_id=entry['object_id']).one()
path = central_server + 'dictionary/%s/%s/perspective' % (
desk_persp.parent_client_id, desk_persp.parent_object_id)
status = make_request(path, 'post', row2dict(desk_persp))
if status.status_code != 200:
request.response.status = HTTPInternalServerError.code
return {'error': str("internet error")}
for entry in field:
desk_field = DBSession.query(Field).filter_by(client_id=entry['client_id'],
object_id=entry['object_id']).one()
path = central_server + 'field'
status = make_request(path, 'post', row2dict(desk_field))
if status.status_code != 200:
request.response.status = HTTPInternalServerError.code
return {'error': str("internet error")}
for entry in dictionaryperspectivetofield:
desk_field = DBSession.query(DictionaryPerspectiveToField).filter_by(client_id=entry['client_id'],
object_id=entry['object_id']).one()
if desk_field.parent_client_id == client.id:
persp = desk_field.parent
path = central_server + 'dictionary/%s/%s/perspective/%s/%s/field' % (persp.parent_client_id,
persp.parent_object_id,
persp.client_id,
persp.object_id)
status = make_request(path, 'post', row2dict(desk_field))
if status.status_code != 200:
request.response.status = HTTPInternalServerError.code
return {'error': str("internet error")}
for entry in lexicalentry:
desk_lex = DBSession.query(LexicalEntry).filter_by(client_id=entry['client_id'],
object_id=entry['object_id']).one()
persp = desk_lex.parent
path = central_server + 'dictionary/%s/%s/perspective/%s/%s/lexical_entry' % (persp.parent_client_id,
persp.parent_object_id,
persp.client_id,
persp.object_id)
status = make_request(path, 'post', row2dict(desk_lex))
if status.status_code != 200:
request.response.status = HTTPInternalServerError.code
return {'error': str("internet error")}
grouping_tags = dict()
for entry in entity:
desk_ent = DBSession.query(Entity).filter_by(client_id=entry['client_id'],
object_id=entry['object_id']).one()
lex = desk_ent.parent
persp = lex.parent
path = central_server + 'dictionary/%s/%s/perspective/%s/%s/lexical_entry/%s/%s/entity' % (
persp.parent_client_id,
persp.parent_object_id,
persp.client_id,
persp.object_id,
lex.client_id,
lex.object_id) # todo: normal content upload
ent_req = row2dict(desk_ent)
content = desk_ent.content
filename = None
if desk_ent.additional_metadata:
data_type = desk_ent.additional_metadata.get('data_type')
if data_type:
data_type = data_type.lower()
if data_type == 'image' or data_type == 'sound' or 'markup' in data_type:
full_name = desk_ent.content.split('/')
filename = full_name[len(full_name) - 1]
content = make_request(desk_ent.content)
if content.status_code != 200:
log.error(desk_ent.content)
DBSession.rollback()
request.response.status = HTTPInternalServerError.code
return {'error': str("internet error")}
# return
content = content.content
content = base64.urlsafe_b64encode(content)
ent_req['content'] = content
ent_req['filename'] = filename
if desk_ent.field.data_type == 'Grouping Tag':
field_ids = str(desk_ent.field.client_id) + '_' + str(desk_ent.field.object_id)
if field_ids not in grouping_tags:
grouping_tags[field_ids] = {'field_client_id': desk_ent.field.client_id,
'field_object_id': desk_ent.field.object_id,
'tag_groups': dict()}
if desk_ent.content not in grouping_tags[field_ids]['tag_groups']:
grouping_tags[field_ids]['tag_groups'][desk_ent.content] = [row2dict(desk_ent)]
else:
grouping_tags[field_ids]['tag_groups'][desk_ent.content].append(row2dict(desk_ent))
else:
status = make_request(path, 'post', ent_req)
if status.status_code != 200:
request.response.status = HTTPInternalServerError.code
return {'error': str("internet error")}
for entry in grouping_tags:
path = central_server + 'group_entity/bulk'
req = grouping_tags[entry]
req['counter'] = client.counter
status = make_request(path, 'post', req)
if status.status_code != 200:
request.response.status = HTTPInternalServerError.code
return {'error': str("internet error")}
client.counter = status.json()['counter']
DBSession.flush()
for entry in userblobs:
desk_blob = DBSession.query(UserBlobs).filter_by(client_id=entry['client_id'],
object_id=entry['object_id']).one()
path = central_server + 'blob'
data = {'object_id': desk_blob.object_id, 'data_type': desk_blob.data_type}
files = {'blob': open(desk_blob.real_storage_path, 'rb')}
status = make_request(path, 'post', data=data, files=files)
if status.status_code != 200:
request.response.status = HTTPInternalServerError.code
return {'error': str("internet error")}
return
def diff_desk(request):
import base64
from lingvodoc.models import categories
from time import sleep
client = DBSession.query(Client).filter_by(id=authenticated_userid(request)).first()
if not client:
request.response.status = HTTPNotFound.code
return {'error': str("Try to login again")}
user = DBSession.query(User).filter_by(id=client.user_id).first()
if not user:
request.response.status = HTTPNotFound.code
return {'error': str("Try to login again")}
settings = request.registry.settings
existing = [row2dict(entry) for entry in DBSession.query(ObjectTOC)]
central_server = settings['desktop']['central_server']
path = central_server + 'sync/difference/server'
server = make_request(path, 'post', existing).json()
language = list()
dictionary = list()
perspective = list()
field = list()
dictionaryperspectivetofield = list()
lexicalentry = list()
entity = list()
userblobs = list()
translationgist = list()
translationatom = list()
for entry in server:
if entry['table_name'] == 'language':
language.append(entry)
if entry['table_name'] == 'dictionary':
dictionary.append(entry)
if entry['table_name'] == 'dictionaryperspective':
perspective.append(entry)
if entry['table_name'] == 'dictionaryperspectivetofield':
dictionaryperspectivetofield.append(entry)
if entry['table_name'] == 'lexicalentry':
lexicalentry.append(entry)
if entry['table_name'] == 'entity':
entity.append(entry)
if entry['table_name'] == 'userblobs':
userblobs.append(entry)
if entry['table_name'] == 'translationgist':
translationgist.append(entry)
if entry['table_name'] == 'translationatom':
translationatom.append(entry)
if entry['table_name'] == 'field':
field.append(entry)
# todo: batches
for group in DBSession.query(Group).filter_by(subject_client_id=authenticated_userid(request)).all():
path = central_server + 'group'
gr_req = row2dict(group)
gr_req['users']=[user.id]
status = make_request(path, 'post', gr_req)
for entry in translationgist:
desk_gist = DBSession.query(TranslationGist).filter_by(client_id=entry['client_id'],
object_id=entry['object_id']).one()
path = central_server + 'translationgist'
make_request(path, 'post', row2dict(desk_gist))
for entry in translationatom:
desk_atom = DBSession.query(TranslationAtom).filter_by(client_id=entry['client_id'],
object_id=entry['object_id']).one()
path = central_server + 'translationatom'
make_request(path, 'post', row2dict(desk_atom))
for entry in language:
desk_lang = DBSession.query(Language).filter_by(client_id=entry['client_id'],
object_id=entry['object_id']).one()
path = central_server + 'language'
make_request(path, 'post', row2dict(desk_lang))
for entry in dictionary:
desk_dict = DBSession.query(Dictionary).filter_by(client_id=entry['client_id'],
object_id=entry['object_id']).one()
path = central_server + 'dictionary'
desk_json = row2dict(desk_dict)
desk_json['category'] = categories[desk_json['category']]
make_request(path, 'post', desk_json)
for entry in perspective:
desk_persp = DBSession.query(DictionaryPerspective).filter_by(client_id=entry['client_id'],
object_id=entry['object_id']).one()
path = central_server + 'dictionary/%s/%s/perspective' % (
desk_persp.parent_client_id, desk_persp.parent_object_id)
status = make_request(path, 'post', row2dict(desk_persp))
for entry in field:
desk_field = DBSession.query(Field).filter_by(client_id=entry['client_id'],
object_id=entry['object_id']).one()
path = central_server + 'field'
status = make_request(path, 'post', row2dict(desk_field))
if status.status_code != 200:
request.response.status = HTTPInternalServerError.code
return {'error': str("internet error")}
for entry in dictionaryperspectivetofield:
desk_field = DBSession.query(DictionaryPerspectiveToField).filter_by(client_id=entry['client_id'],
object_id=entry['object_id']).one()
if desk_field.parent_client_id == client.id:
persp = desk_field.parent
path = central_server + 'dictionary/%s/%s/perspective/%s/%s/field' % (persp.parent_client_id,
persp.parent_object_id,
persp.client_id,
persp.object_id)
status = make_request(path, 'post', row2dict(desk_field))
if status.status_code != 200:
request.response.status = HTTPInternalServerError.code
return {'error': str("internet error")}
for entry in lexicalentry:
desk_lex = DBSession.query(LexicalEntry).filter_by(client_id=entry['client_id'],
object_id=entry['object_id']).one()
persp = desk_lex.parent
path = central_server + 'dictionary/%s/%s/perspective/%s/%s/lexical_entry' % (persp.parent_client_id,
persp.parent_object_id,
persp.client_id,
persp.object_id)
status = make_request(path, 'post', row2dict(desk_lex))
if status.status_code != 200:
request.response.status = HTTPInternalServerError.code
return {'error': str("internet error")}
grouping_tags = dict()
for entry in entity:
desk_ent = DBSession.query(Entity).filter_by(client_id=entry['client_id'],
object_id=entry['object_id']).one()
lex = desk_ent.parent
persp = lex.parent
path = central_server + 'dictionary/%s/%s/perspective/%s/%s/lexical_entry/%s/%s/entity' % (
persp.parent_client_id,
persp.parent_object_id,
persp.client_id,
persp.object_id,
lex.client_id,
lex.object_id) # todo: normal content upload
ent_req = row2dict(desk_ent)
content = desk_ent.content
filename = None
if desk_ent.additional_metadata:
data_type = desk_ent.additional_metadata.get('data_type')
if data_type:
data_type = data_type.lower()
if data_type == 'image' or data_type == 'sound' or 'markup' in data_type:
full_name = desk_ent.content.split('/')
filename = full_name[len(full_name) - 1]
content = make_request(desk_ent.content)
if content.status_code != 200:
log.error(desk_ent.content)
DBSession.rollback()
request.response.status = HTTPInternalServerError.code
return {'error': str("internet error")}
# return
content = content.content
content = base64.urlsafe_b64encode(content)
ent_req['content'] = content
ent_req['filename'] = filename
if desk_ent.field.data_type == 'Grouping Tag':
field_ids = str(desk_ent.field.client_id) + '_' + str(desk_ent.field.object_id)
if field_ids not in grouping_tags:
grouping_tags[field_ids] = {'field_client_id': desk_ent.field.client_id,
'field_object_id': desk_ent.field.object_id,
'tag_groups': dict()}
if desk_ent.content not in grouping_tags[field_ids]['tag_groups']:
grouping_tags[field_ids]['tag_groups'][desk_ent.content] = [row2dict(desk_ent)]
else:
grouping_tags[field_ids]['tag_groups'][desk_ent.content].append(row2dict(desk_ent))
else:
status = make_request(path, 'post', ent_req)
if status.status_code != 200:
request.response.status = HTTPInternalServerError.code
return {'error': str("internet error")}
for entry in grouping_tags:
path = central_server + 'group_entity/bulk'
req = grouping_tags[entry]
req['counter'] = client.counter
status = make_request(path, 'post', req)
if status.status_code != 200:
request.response.status = HTTPInternalServerError.code
return {'error': str("internet error")}
client.counter = status.json()['counter']
DBSession.flush()
for entry in userblobs:
desk_blob = DBSession.query(UserBlobs).filter_by(client_id=entry['client_id'],
object_id=entry['object_id']).one()
path = central_server + 'blob'
data = {'object_id': desk_blob.object_id, 'data_type': desk_blob.data_type}
files = {'blob': open(desk_blob.real_storage_path, 'rb')}
status = make_request(path, 'post', data=data, files=files)
if status.status_code != 200:
request.response.status = HTTPInternalServerError.code
return {'error': str("internet error")}
return
