def cardData(context,
main,
add,
filterinfo=None,
session=None,
elementId=None):
xformsdata = {"schema": {"@xmlns": ""}}
xformssettings = {
"properties": {
"event": [{
"@name": "single_click",
"@linkId": "1",
"action": {
"#sorted": [{
"main_context": "current"
}, {
"datapanel": {
"@type": "current",
"@tab": "current",
"element": {
"@id": "customPermissionsTypesGrid",
"add_context": ""
}
}
}]
}
}]
}
}
jsonData = XMLJSONConverter.jsonToXml(json.dumps(xformsdata))
jsonSettings = XMLJSONConverter.jsonToXml(json.dumps(xformssettings))
return JythonDTO(jsonData, jsonSettings)
def cardData(context, main=None, add=None, filterinfo=None, session=None, elementId=None):
u'''Функция данных для карточки редактирования содержимого таблицы типоа разрешений. '''
#raise Exception(session)
permissionsTypes = customPermsTypesCursor(context)
if add == 'add':
xformsdata = {"schema":{"type":{"@name":"",
"@description":""}
}
}
elif add == 'edit':
currId = json.loads(session)['sessioncontext']['related']['gridContext']['currentRecordId']
permissionsTypes.get(currId)
xformsdata = {"schema":{"type":{"@name": permissionsTypes.name,
"@description": permissionsTypes.description,
"@add":add}
}
}
# print xformsdata
xformssettings = {"properties":{"event":{"@name":"single_click",
"@linkId": "1",
"action":{"#sorted":[{"main_context": "current"},
{"datapanel": {"@type": "current",
"@tab": "current",
"element": {"@id":"customPermissionsTypesGrid",
"add_context": ""}
}
}]}
}
}
}
return JythonDTO(XMLJSONConverter.jsonToXml(json.dumps(xformsdata)), XMLJSONConverter.jsonToXml(json.dumps(xformssettings)))
def cardData(context, main=None, add=None, filterinfo=None, session=None, elementId=None):
u'''Функция данных для карточки редактирования содержимого таблицы ролей. '''
settings=Settings()
#ru.curs.showcase.security.SecurityParamsFactory.getAuthServerUrl()
rolesUsers = UserRolesCursor(context)
currId = json.loads(session)['sessioncontext']['related']['gridContext']['currentRecordId']
rolesUsers.setRange("roleid", currId)
content=[]
if settings.isUseAuthServer() and settings.loginIsSubject():
sessionId=json.loads(session)["sessioncontext"]["sessionid"]
server=SecurityParamsFactory.getAuthServerUrl()
users_xml=getUsersFromAuthServer(server, sessionId)
if rolesUsers.tryFindSet():
while True:
for user in users_xml.getElementsByTagName("user"):
if user.getAttribute("SID")==rolesUsers.userid:
content.append({"@sid" : rolesUsers.userid,
"@userName" : user.getAttribute("name")
})
break
if not rolesUsers.nextInSet():
break
else:
subjects = subjectsCursor(context)
if rolesUsers.tryFindSet():
while True:
if subjects.tryGet(rolesUsers.userid):
content.append({"@sid" : subjects.sid,
"@userName" : subjects.name
})
if not rolesUsers.nextInSet():
break
if content==[]:
xformsdata = {"schema":{"users": ""
}
}
else:
xformsdata = {"schema":{"users": {"user": content}
}
}
xformssettings = {"properties":{"event":{"@name":"single_click",
"@linkId": "1",
"action":{"#sorted":[{"main_context": "current"},
{"datapanel": {"@type": "current",
"@tab": "current",
"element": {"@id":"id_roles_grid",
"add_context": ""}
}
}]}
}
}
}
return JythonDTO(XMLJSONConverter.jsonToXml(json.dumps(xformsdata)), XMLJSONConverter.jsonToXml(json.dumps(xformssettings)))
def cardData(context,
main=None,
add=None,
filterinfo=None,
session=None,
elementId=None):
u'''Функция данных для карточки редактирования содержимого таблицы ролей. '''
subjects = subjectsCursor(context)
if add == 'add':
sid = getNextNoOfSeries(context, 'subjects') + id_generator()
xformsdata = {
"schema": {
"@xmlns": "",
"subject": {
"@name": "",
"@sid": sid
}
}
}
elif add == 'edit':
currId = json.loads(session)['sessioncontext']['related'][
'gridContext']['currentRecordId']
subjects.get(currId)
xformsdata = {
"schema": {
"subject": {
"@name": subjects.name,
"@sid": subjects.sid
}
}
}
# print xformsdata
xformssettings = {
"properties": {
"event": {
"@name": "single_click",
"@linkId": "1",
"action": {
"#sorted": [{
"main_context": "current"
}, {
"datapanel": {
"@type": "current",
"@tab": "current",
"element": {
"@id": "subjectsGrid",
"add_context": ""
}
}
}]
}
}
}
}
return JythonDTO(XMLJSONConverter.jsonToXml(json.dumps(xformsdata)),
XMLJSONConverter.jsonToXml(json.dumps(xformssettings)))
def cardData(context,
main=None,
add=None,
filterinfo=None,
session=None,
elementId=None):
u'''Функция данных для карточки редактирования содержимого таблицы ролей. '''
roles = RolesCursor(context)
if add == 'add':
xformsdata = {"schema": {"role": {"id": "", "description": ""}}}
elif add == 'edit':
currId = json.loads(session)['sessioncontext']['related'][
'gridContext']['currentRecordId']
#currId = json.loads(base64.b64decode(currIdEncoded))
roles.get(currId)
xformsdata = {
"schema": {
"role": {
"id": roles.id,
"description": roles.description,
"add": add
}
}
}
#print xformsdata
xformssettings = {
"properties": {
"event": {
"@name": "single_click",
"@linkId": "1",
"action": {
"#sorted": [{
"main_context": "current"
}, {
"datapanel": {
"@type": "current",
"@tab": "current",
"element": {
"@id": "id_roles_grid",
"add_context": ""
}
}
}]
}
}
}
}
return JythonDTO(XMLJSONConverter.jsonToXml(json.dumps(xformsdata)),
XMLJSONConverter.jsonToXml(json.dumps(xformssettings)))
def submitGetFileVersions(context, main, add, filterinfo, session, data):
print 'Submit xform data from Celesta Python procedure.'
print 'User %s' % context.userId
print 'main "%s".' % main
print 'add "%s".' % add
print 'filterinfo "%s".' % filterinfo
print 'session "%s".' % session
print 'data "%s".' % data
alfURL = "http://127.0.0.1:8080/alfresco"
alfUser = "******"
alfPass = "******"
alfFileId = "97cf8b94-0407-40ed-9582-711f4d42dfa0"
resultLogin = AlfrescoManager.login(alfURL, alfUser, alfPass)
if resultLogin.getResult() == 0:
resultGetFileVersions = AlfrescoManager.getFileVersions(
alfFileId, alfURL, resultLogin.getTicket())
if resultGetFileVersions.getResult() == 0:
versions = resultGetFileVersions.getVersions()
# Далее использование полученных версий
# ............
context.error(versions)
else:
context.error(resultGetFileVersions.getErrorMessage())
else:
context.error(resultLogin.getErrorMessage())
return XMLJSONConverter.jsonToXml(data)
def treeItemsList(context, main=None, add=None, filterinfo=None, session=None, params=None,
curvalue=None, startswith=None, parent_id=None):
"""Функция для получения списка элементов в пределе одного фильтра типа tree itemset"""
all_fields, current = (x['filter'] for x in json.loads(XMLJSONConverter.xmlToJson(params))['schema']['filter'])
add = repair_add(add)
field_name = current["@id"]
for necessary_field in context.getData()[add]:
if field_name == necessary_field['@id']:
current_field = necessary_field
break
selector_path = current_field['@selector_data']
# if bound_status != 'bound':
if selector_path:
selector_path = selector_path.split('.')
selector_module, selector_function_name = '.'.join(selector_path[:-1]), selector_path[-1]
selector_module = import_module(selector_module)
selector = getattr(selector_module, selector_function_name)
return selector(context, main, add, filterinfo, session, params, curvalue, startswith, parent_id)
else:
raise NotImplementedError(
u"Автоматическая процедура для получения списка элементов не предусмотрена для treeselector")
def submitDeleteFile(context, main, add, filterinfo, session, data):
print 'Submit xform data from Celesta Python procedure.'
print 'User %s' % context.userId
print 'main "%s".' % main
print 'add "%s".' % add
print 'filterinfo "%s".' % filterinfo
print 'session "%s".' % session
print 'data "%s".' % data
alfURL = "http://127.0.0.1:8080/alfresco"
alfUser = "******"
alfPass = "******"
alfFileId = "50694ed0-63b7-47d8-8e54-67ad19e3c359"
resultLogin = AlfrescoManager.login(alfURL, alfUser, alfPass)
if resultLogin.getResult() == 0:
resultDeleteFile = AlfrescoManager.deleteFile(alfFileId, alfURL,
resultLogin.getTicket())
if resultDeleteFile.getResult() == 0:
context.message(u"Файл успешно удален из Alfresco.")
else:
context.error(resultDeleteFile.getErrorMessage())
else:
context.error(resultLogin.getErrorMessage())
return XMLJSONConverter.jsonToXml(data)
def gridMeta(context, main=None, add=None, filterinfo=None, session=None, elementId=None):
u'''Функция получения настроек грида. '''
# Курсор таблицы directories
roles = RolesCursor(context)
# Вычисляем количества записей в таблице
specialRoles = ["!'editor'", "!'reader'"]
roles.setFilter("id", '&'.join(specialRoles))
totalcount = roles.count()
# Заголовок таблицы
header = "Роли"
_header = {"id": [u"Роль"],
"description": [u"Описание"],
}
# Определяем список полей таблицы для отображения
settings = {}
settings["gridsettings"] = {"columns": {"col": []},
"properties": {"@pagesize":"50",
"@gridWidth": "100%",
"@gridHeight": getGridHeight(session, numberOfGrids=1.6, delta=35),
"@totalCount": totalcount,
"@profile": "default.properties"},
"labels": {"header": header}
}
# Добавляем поля для отображения в gridsettings
settings["gridsettings"]["columns"]["col"].append({"@id": _header["id"][0],
"@width": "80px"})
settings["gridsettings"]["columns"]["col"].append({"@id": _header["description"][0],
"@width": "400px"})
res = XMLJSONConverter.jsonToXml(json.dumps(settings))
return JythonDTO(None, res)
def standardNavigator(context, session=None):
u"""
Функция позволяет вернутть навигатор собранные из кусочков(групп),
приходящих в список navigatorsParts в виде функций, которые возвращают JSON объект"""
settingsObject = SettingsManager(context)
sessionDict = json.loads(session)
userdataNavigator = []
try:
userdataNavigator = settingsObject.getGrainSettings('navigator/userdata[@name="%s"]/group' % sessionDict["sessioncontext"]["userdata"])
finally:
allNavigator = userdataNavigator == []
localNavigators = navigatorsParts.copy()
resultJSON = {"navigator":{}}
resultNavigators = dict()
if localNavigators:
for setItem in localNavigators:
if setItem.startswith('__set_') and (allNavigator or setItem in userdataNavigator):
# re.search(r'^__set_.+$', setItem)
setOfPart = localNavigators[setItem]
setOfPartRes = setOfPart(context, session)
for part in setOfPartRes:
resultNavigators[part] = setOfPartRes[part]
elif (allNavigator or setItem in userdataNavigator):
resultNavigators[setItem] = localNavigators[setItem](context, session)
resultJSON["navigator"]["group"] = list()
for part in (sorted(resultNavigators) if allNavigator else userdataNavigator):
if part.startswith("__header__"):
resultJSON["navigator"].update(resultNavigators[part])
elif resultNavigators[part]["group"] is not None:
resultJSON["navigator"]["group"].append(resultNavigators[part]["group"])
resultNavigator = XMLJSONConverter.jsonToXml(json.dumps(resultJSON))
return resultNavigator
def gridMeta(context, main=None, add=None, filterinfo=None, session=None, elementId=None):
u'''Функция получения настроек грида. '''
# Курсор таблицы permissions
permissionsTypes = customPermsTypesCursor(context)
# Вычисляем количества записей в таблице
totalcount = permissionsTypes.count()
# Заголовок таблицы
header = "Типы разрешений"
# В случае если таблица пустая
_header = {"id": ["~~id"],
"name": [u"Тип"],
"description": [u"Описание"],
"properties": [u"properties"]
}
# Определяем список полей таблицы для отображения
settings = {}
settings["gridsettings"] = {"columns": {"col":[]},
"properties": {"@pagesize":"50",
"@gridWidth": "100%",
"@gridHeight":getGridHeight(session, delta=40),
"@totalCount":totalcount,
"@profile":"default.properties"},
"labels": {"header":header}
}
# Добавляем поля для отображения в gridsettings
settings["gridsettings"]["columns"]["col"].append({"@id": _header["name"][0],
"@width": "120px"})
settings["gridsettings"]["columns"]["col"].append({"@id": _header["description"][0],
"@width": "480px"})
res = XMLJSONConverter.jsonToXml(json.dumps(settings))
return JythonDTO(None, res)
def cardData(context, main=None, add=None, filterinfo=None,
session=None, elementId=None):
u"""Процедура, описывающая структуру фильтра для карточки телеграмм"""
session_obj = SessionContext(session)
if elementId not in context.getData():
# Курсор фильтруемой таблицы
cur = ExampleCursor(context)
# Функция, собирающая данные каждого поля, которое необходимо фильтровать
field_list = getField()
filter_assembly(context, cur, elementId,
field_list, "example.Example")# Гранула.таблица
xforms_data = {
"schema": {
"@xmlns": "",
"filters": {"filter": card_info(context, elementId)}
}
}
xforms_data["schema"]["@maxFilters"] = len(context.getData()[elementId])
xforms_settings = {
"properties": {
"event": [
{
"@name": "single_click",
"@linkId": "1",
"action": {
"@keep_user_settings": 'false',
"main_context": "current",
"datapanel": {
"@type": "current",
"@tab": "current",
"element": {
"@id": 'yourExampleGrid'
}
}
}
}
]
}
}
return JythonDTO(XMLJSONConverter.jsonToXml(json.dumps(xforms_data)),
XMLJSONConverter.jsonToXml(json.dumps(xforms_settings)))
def itemsListAndCount(context, main=None, add=None, filterinfo=None, session=None, params=None,
curvalue=None, startswith=None, firstrecord=None, recordcount=None):
"""Функция для получения списка элементов в пределе одного фильтра типа itemset"""
all_fields, current = (x['filter'] for x in json.loads(XMLJSONConverter.xmlToJson(params))['schema']['filter'])
add = repair_add(add)
grain, table = context.getData()[add][0]["@tableName"].split('.')
field_name = current["@id"]
for necessary_field in context.getData()[add]:
if field_name == necessary_field['@id']:
current_field = necessary_field
break
selector_path = current_field['@selector_data']
# if bound_status != 'bound':
if selector_path:
selector_path = selector_path.split('.')
selector_module, selector_function_name = '.'.join(selector_path[:-1]), selector_path[-1]
selector_module = import_module(selector_module)
selector = getattr(selector_module, selector_function_name)
return selector(context, main, add, filterinfo, session, params, curvalue, startswith, firstrecord, recordcount)
cursor_instance = tableCursorImport(grain, table)
cursor = cursor_instance(context)
# Булевый флаг для определения, является ли поле числовым
is_quotes = current_field['@type'] != 'float'
curvalue = curvalue.strip()
cursor.orderBy(field_name)
recordList = ArrayList()
# набираем список значений
i = 0
# if curvalue:
# cursor.setRange(field_name, curvalue)
while cursor.tryFirst() and i < (firstrecord + recordcount):
current_name = getattr(cursor, field_name)
if is_quotes:
current_name = current_name.replace("'", "''")
if (i >= firstrecord and not curvalue) or (i > firstrecord and curvalue):
rec = DataRecord()
rec.setId("rec%i" % i)
rec.setName(
unicode(current_name.replace('""', '"').replace("''", "'")) if is_quotes else unicode(current_name))
recordList.add(rec)
# Определение формы выведения в setFilter для разных типов значений
current_filter = ">%s" % ("'%s'" % current_name if is_quotes else int(current_name))
if curvalue:
current_filter = """%s&@%s'%s'%%""" % (current_filter,
"%" * (not startswith),
curvalue.replace("'", "''"))
# filtered_function(all_fields, add, cursor)
cursor.setFilter(field_name, current_filter)
i += 1
return ResultSelectorData(recordList, i)
def submissionGenPass(context,
main=None,
add=None,
filterinfo=None,
session=None,
data=None):
u"""Функция для submission, генерирующая пароль с помощью вызова id_generator
изпользуется в карточке users.xml
"""
instance = json.loads(data)
instance["schema"]["user"]["@password"] = id_generator()
return XMLJSONConverter.jsonToXml(json.dumps(instance))
def gridData(context, main=None, add=None, filterinfo=None,
session=None, elementId=None, sortColumnList=None, firstrecord=None, pagesize=None):
u'''Функция получения данных для грида. '''
# Создание экземпляра курсора разрешения
roles = RolesCursor(context)
# Определяем переменную для JSON данных
data = {"records":{"rec":[]}}
# Проходим по таблице и заполняем data
specialRoles = ["!'editor'", "!'reader'"]
roles.setFilter("id", '&'.join(specialRoles))
if sortColumnList:
sortName = toHexForXml(sortColumnList[0].id)
sortType = unicode(sortColumnList[0].sorting).lower()
else:
sortName = None
_header = {"roleId": ["~~id"],
"id": [u"Роль"],
"description": [u"Описание"],
"properties": [u"properties"]
}
for column in _header:
_header[column].append(toHexForXml(_header[column][0]))
if sortName == _header[column][1]:
roles.orderBy("%s %s" % (column, sortType))
roles.limit(firstrecord - 1, pagesize)
if roles.tryFindSet():
while True:
rolesDict = {}
rolesDict[_header["roleId"][1]] = roles.id
for column in [x for x in _header.keys() if x not in ("roleId", "properties")]:
rolesDict[_header[column][1]] = getattr(roles, column) or ''
rolesDict['properties'] = {"event": {"@name":"row_single_click",
"action": {"#sorted": [{"main_context": 'current'},
{"datapanel":{'@type':"current",
'@tab':"current",
"element":{"@id":"id_perm_roles_grid"}
}
}]
}
}
}
data["records"]["rec"].append(rolesDict)
if not roles.nextInSet():
break
res = XMLJSONConverter.jsonToXml(json.dumps(data))
return JythonDTO(res, None)
def submissionSort(context, main=None, add=None, filterinfo=None, session=None, data=None):
"""Функция для изменения состояния полей"""
# Операции для добавления постоянных нод
add = repair_add(add)
data_py = json.loads(data)['filters']['filter']
new_xforms_data = {'filters': {'filter': []}}
if not isinstance(data_py, list): data_py = [data_py]
# Операции перестроки контекста
for filter_inside in context.getData()[add]:
new_xforms_data['filters']['filter'].extend(
[filter_xform for filter_xform in data_py if filter_xform['@id'] == filter_inside['@id']])
return XMLJSONConverter.jsonToXml(json.dumps(new_xforms_data))
def gridData(context,
main=None,
add=None,
filterinfo=None,
session=None,
elementId=None,
sortColumnList=[],
firstrecord=0,
pagesize=50):
u'''Функция получения данных для грида. '''
# raise Exception(firstrecord)
# Создание экземпляра курсора
numbersSeries = numbersSeriesCursor(context)
numbersSeries.orderBy('id')
# Определяем переменную для JSON данных
data = {"records": {"rec": []}}
numbersSeries.limit(firstrecord - 1, pagesize)
# Проходим по таблице и заполняем data
for numbersSeries in numbersSeries.iterate():
nsDict = {}
nsDict[toHexForXml('~~id')] = numbersSeries.id
nsDict[u"ID"] = numbersSeries.id
nsDict[u"Описание"] = numbersSeries.description
nsDict['properties'] = {
"event": {
"@name": "row_single_click",
"action": {
"#sorted": [{
"main_context": 'current'
}, {
"datapanel": {
'@type': "current",
'@tab': "current",
'element': {
'@id': 'linesNumbersSeriesGrid'
}
}
}]
}
}
}
data["records"]["rec"].append(nsDict)
res = XMLJSONConverter.jsonToXml(json.dumps(data))
return JythonDTO(res, None)
def gridData(context, main=None, add=None, filterinfo=None,
session=None, elementId=None, sortColumnList=None, firstrecord=None, pagesize=None):
u'''Функция получения данных для грида. '''
# Создание экземпляра курсора разрешения
permissionsTypes = customPermsTypesCursor(context)
if sortColumnList:
sortName = toHexForXml(sortColumnList[0].id)
sortType = unicode(sortColumnList[0].sorting).lower()
else:
sortName = None
permissionsTypes.orderBy('name')
# Определяем переменную для JSON данных
data = {"records":{"rec":[]}}
_header = {"id": ["~~id"],
"name": [u"Тип"],
"description": [u"Описание"],
"properties": [u"properties"]
}
for column in _header:
_header[column].append(toHexForXml(_header[column][0]))
if sortName == _header[column][1]:
permissionsTypes.orderBy("%s %s" % (column, sortType))
permissionsTypes.limit(firstrecord - 1, pagesize)
# Проходим по таблице и заполняем data
for permissionsTypes in permissionsTypes.iterate():
permDict = {}
permDict[_header["id"][1]] = permissionsTypes.name
for column in [x for x in _header.keys() if x not in ("id", "properties")]:
permDict[_header[column][1]] = getattr(permissionsTypes, column) or ''
permDict['properties'] = {"event":{"@name":"row_single_click",
"action":{"#sorted":[{"main_context": 'current'},
{"datapanel":{'@type':"current",
'@tab':"current"}
}]
}
}
}
data["records"]["rec"].append(permDict)
res = XMLJSONConverter.jsonToXml(json.dumps(data))
return JythonDTO(res, None)
def submissionView(context, main=None, add=None, filterinfo=None, session=None, data=None):
"""Функция для изменения состояния полей"""
# Операции для добавления постоянных нод
add = repair_add(add)
data_py = json.loads(data)
# Операции перестроки контекста
new_context = []
for filter_inside in context.getData()[add]:
if filter_inside['@id'] == data_py['filter']['@id']:
filter_inside['@key'] = 'view'
data_py['filter']['selects'] = filter_inside['selects']
data_py['filter']['conditions'] = filter_inside['conditions']
data_py['filter']['@current_condition'] = filter_inside['@current_condition']
new_context.append(filter_inside)
context.getData()[add] = new_context
return XMLJSONConverter.jsonToXml(json.dumps(data_py))
def submissionUnview(context, main=None, add=None, filterinfo=None, session=None, data=None):
"""Функция для обнуления полей при вынесении их из фильтра"""
add = repair_add(add)
data_py = json.loads(data)
new_context = []
for filter_inside in context.getData()[add]:
if filter_inside['@id'] == data_py['filter']['@id']:
filter_inside['@key'] = 'unview'
filter_inside['@minValue'] = ''
filter_inside['@value'] = ''
filter_inside['@maxValue'] = ''
filter_inside['item'] = {"@id": '', "@name": ''}
filter_inside['@current_condition'] = data_py['filter']['@current_condition']
new_context.append(filter_inside)
context.getData()[add] = new_context
return XMLJSONConverter.jsonToXml(data)
def gridMeta(context,
main=None,
add=None,
filterinfo=None,
session=None,
elementId=None):
u'''Функция получения настроек грида. '''
numbersSeries = numbersSeriesCursor(context)
# Вычисляем количества записей в таблице
totalcount = numbersSeries.count()
# Заголовок таблицы
header = "Типы серий номеров"
# В случае если таблица пустая
if totalcount == 0 or totalcount is None:
totalcount = "0"
header = header + " ПУСТ"
# Определяем список полей таблицы для отображения
settings = {}
settings["gridsettings"] = {
"columns": {
"col": []
},
"properties": {
"@pagesize": "50",
"@gridWidth": "100%",
"@totalCount": totalcount,
"@profile": "default.properties"
},
"labels": {
"header": header
}
}
# Добавляем поля для отображения в gridsettings
settings["gridsettings"]["columns"]["col"].append({
"@id": "ID",
"@width": "100px"
})
settings["gridsettings"]["columns"]["col"].append({
"@id": "Описание",
"@width": "300px"
})
res = XMLJSONConverter.jsonToXml(json.dumps(settings))
return JythonDTO(None, res)
def submit(context, main, add, filterinfo, session, data):
print 'Submit xform data from Celesta Python procedure.'
print 'context %s' % context
print 'User %s' % context.userId
print 'main "%s".' % main
print 'add "%s".' % add
print 'filterinfo "%s".' % filterinfo
print 'session "%s".' % session
print 'ddddddddddddddddddddata "%s".' % data
# context.error(u"555");
context.message(u"Это инф<ор> мац'и+о-н\"ное сообщение")
# context.warning(u"Это предупреждение");
# context.error(u"Это ошибка");
# return UserMessage("557", None);
# return data;
return XMLJSONConverter.jsonToXml(data)
def submitCreateFolder(context, main, add, filterinfo, session, data):
print 'Submit xform data from Celesta Python procedure.'
print 'User %s' % context.userId
print 'main "%s".' % main
print 'add "%s".' % add
print 'filterinfo "%s".' % filterinfo
print 'session "%s".' % session
print 'data "%s".' % data
alfURL = "http://127.0.0.1:8080/alfresco"
alfUser = "******"
alfPass = "******"
alfParentFolderId = "a9488807-c96c-41e9-a9ee-8a176ae1ccf6"
alfCreateFolderParams = unicode(
"{\"name\": \"Новая директория1\", \"title\": \"Заголовок новой директории1\", \"description\": \"Описание новой директории1\", \"type\": \"cm:folder\"}"
)
resultLogin = AlfrescoManager.login(alfURL, alfUser, alfPass)
if resultLogin.getResult() == 0:
resultCreateFolder = AlfrescoManager.createFolder(
alfParentFolderId, alfCreateFolderParams, alfURL,
resultLogin.getTicket())
if resultCreateFolder.getResult() == 0:
nodeRef = resultCreateFolder.getNodeRef()
# Далее использование nodeRef созданной директории
# ............
context.error(
u"Директория успешно создана в Alfresco. Координаты директории в Alfresco: "
+ nodeRef)
else:
context.error(resultCreateFolder.getErrorMessage())
else:
context.error(resultLogin.getErrorMessage())
return XMLJSONConverter.jsonToXml(data)
def submitSetFileMetaData(context, main, add, filterinfo, session, data):
print 'Submit xform data from Celesta Python procedure.'
print 'User %s' % context.userId
print 'main "%s".' % main
print 'add "%s".' % add
print 'filterinfo "%s".' % filterinfo
print 'session "%s".' % session
print 'data "%s".' % data
alfURL = "http://127.0.0.1:8080/alfresco"
alfUser = "******"
alfPass = "******"
alfFileId = "97cf8b94-0407-40ed-9582-711f4d42dfa0"
# acceptLanguage = ""
acceptLanguage = "en-US,en;"
# acceptLanguage = "ru-RU,ru;"
metaData = unicode(
"{\"properties\":{\"title\":\"1Название файла\",\"description\":\"1Описание файла\"}}"
)
resultLogin = AlfrescoManager.login(alfURL, alfUser, alfPass)
if resultLogin.getResult() == 0:
resultSetFileMetaData = AlfrescoManager.setFileMetaData(
alfFileId, metaData, alfURL, resultLogin.getTicket(),
acceptLanguage)
if resultSetFileMetaData.getResult() == 0:
context.message(u"Метаданные файла из Alfresco успешно заданы.")
else:
context.error(resultSetFileMetaData.getErrorMessage())
else:
context.error(resultLogin.getErrorMessage())
return XMLJSONConverter.jsonToXml(data)
def submitGetFileMetaData(context, main, add, filterinfo, session, data):
print 'Submit xform data from Celesta Python procedure.'
print 'User %s' % context.userId
print 'main "%s".' % main
print 'add "%s".' % add
print 'filterinfo "%s".' % filterinfo
print 'session "%s".' % session
print 'data "%s".' % data
alfURL = "http://127.0.0.1:8080/alfresco"
alfUser = "******"
alfPass = "******"
alfFileId = "97cf8b94-0407-40ed-9582-711f4d42dfa0"
# acceptLanguage = ""
acceptLanguage = "en-US,en;"
# acceptLanguage = "ru-RU,ru;"
resultLogin = AlfrescoManager.login(alfURL, alfUser, alfPass)
if resultLogin.getResult() == 0:
resultGetFileMetaData = AlfrescoManager.getFileMetaData(
alfFileId, alfURL, resultLogin.getTicket(), acceptLanguage)
if resultGetFileMetaData.getResult() == 0:
metaData = resultGetFileMetaData.getMetaData()
# Далее использование полученных метаданных
# ............
context.error(metaData)
else:
context.error(resultGetFileMetaData.getErrorMessage())
else:
context.error(resultLogin.getErrorMessage())
return XMLJSONConverter.jsonToXml(data)
def gridToolBar(context,
main=None,
add=None,
filterinfo=None,
session=None,
elementId=None):
u'''Toolbar для грида. '''
if 'currentRecordId' not in json.loads(
session)['sessioncontext']['related']['gridContext']:
style = "true"
else:
style = "false"
data = {"gridtoolbar": {"item": []}}
numbersSeries = numbersSeriesCursor(context)
if numbersSeries.canInsert():
data["gridtoolbar"]["item"].append({
"@img": 'gridToolBar/addDirectory.png',
"@text": "Добавить",
"@hint": "Добавить",
"@disable": "false",
"action": {
"@show_in":
"MODAL_WINDOW",
"#sorted": [{
"main_context": "current"
}, {
"modalwindow": {
"@caption": "Добавление серии номеров",
"@height": "500",
"@width": "500"
}
}, {
"datapanel": {
"@type": "current",
"@tab": "current",
"element": {
"@id": "numbersSeriesXforms",
"add_context": "add"
}
}
}]
}
})
if numbersSeries.canModify():
data["gridtoolbar"]["item"].append({
"@img": 'gridToolBar/editDocument.png',
"@text": "Редактировать",
"@hint": "Редактировать",
"@disable": style,
"action": {
"@show_in":
"MODAL_WINDOW",
"#sorted": [{
"main_context": "current"
}, {
"modalwindow": {
"@caption": "Редактирование серии номеров",
"@height": "500",
"@width": "500"
}
}, {
"datapanel": {
"@type": "current",
"@tab": "current",
"element": {
"@id": "numbersSeriesXforms",
"add_context": "edit"
}
}
}]
}
})
if numbersSeries.canDelete():
data["gridtoolbar"]["item"].append({
"@img": 'gridToolBar/deleteDocument.png',
"@text": "Удалить",
"@hint": "Удалить",
"@disable": style,
"action": {
"@show_in":
"MODAL_WINDOW",
"#sorted": [{
"main_context": "current"
}, {
"modalwindow": {
"@caption": "Удаление серии номеров",
"@height": "300",
"@width": "450"
}
}, {
"datapanel": {
"@type": "current",
"@tab": "current",
"element": {
"@id": "numbersSeriesXformDelete",
"add_context": "delete"
}
}
}]
}
})
data["gridtoolbar"]["item"].append({
"@img": 'gridToolBar/arrowDown.png',
"@text": "Скачать",
"@hint": "Скачать серии номеров в xml",
"@disable": "false",
"action": {
"@show_in":
"MODAL_WINDOW",
"#sorted": [{
"main_context": "current"
}, {
"modalwindow": {
"@caption": "Скачать серии номеров",
"@height": "300",
"@width": "450"
}
}, {
"datapanel": {
"@type": "current",
"@tab": "current",
"element": {
"@id": "numbersSeriesDownloadXform",
"add_context": "download"
}
}
}]
}
})
data["gridtoolbar"]["item"].append({
"@img": 'gridToolBar/arrowUp.png',
"@text": "Загрузить",
"@hint": "Загрузить серии номеров из xml",
"@disable": "false",
"action": {
"@show_in":
"MODAL_WINDOW",
"#sorted": [{
"main_context": "current"
}, {
"modalwindow": {
"@caption": "Загрузить серии номеров",
"@height": "300",
"@width": "450"
}
}, {
"datapanel": {
"@type": "current",
"@tab": "current",
"element": {
"@id": "numbersSeriesUploadXform",
"add_context": "upload"
}
}
}]
}
})
return XMLJSONConverter.jsonToXml(json.dumps(data))
def datapanel(context, main=None, session=None):
u'''Продедура возвращает информационную панель для разрешений'''
data = {
"datapanel": {
"tab": [{
"@id":
1,
"@name":
u"Разрешения на таблицы",
"element": [{
"@id":
"permFilter",
"@type":
"xforms",
"@template":
"security/permissionsFilter.xml",
"@proc":
"security.xform.permissionsFilter.cardData.celesta"
}, {
"@id":
"permGrid",
"@type":
"grid",
"@subtype":
"JS_LIVE_GRID",
"@plugin":
"liveDGrid",
"@proc":
"security.grid.permissions.gridData.celesta",
"@hideOnLoad":
"true",
"proc": [{
"@id": "permGridMeta",
"@name": "security.grid.permissions.gridMeta.celesta",
"@type": "METADATA"
}, {
"@id": "permGridToolBar",
"@name":
"security.grid.permissions.gridToolBar.celesta",
"@type": "TOOLBAR"
}, {
"@id": "saveRecord",
"@name":
"security.grid.permissions.gridSaveRecord.celesta",
"@type": "SAVE"
}],
"related": {
"@id": "permFilter"
}
}, {
"@id":
"permXforms",
"@type":
"xforms",
"@template":
"security/permissions.xml",
"@neverShowInPanel":
"true",
"@proc":
"security.xform.permissions.cardData.celesta",
"proc": {
"@id": "permXformSave",
"@name":
"security.xform.permissions.cardDataSave.celesta",
"@type": "SAVE"
},
"related": [{
"@id": "permGrid"
}, {
"@id": "permFilter"
}]
}, {
"@id": "permXformDelete",
"@type": "xforms",
"@template": "security/delete.xml",
"@neverShowInPanel": "true",
"@proc":
"security.xform.permissionsDelete.cardData.celesta",
"proc": {
"@id": "permXformSave",
"@name":
"security.xform.permissionsDelete.cardDelete.celesta",
"@type": "SAVE"
},
"related": {
"@id": "permGrid"
}
}, {
"@id": "permDownloadXform",
"@type": "xforms",
"@template": "security/tableLoad.xml",
"@neverShowInPanel": "true",
"@proc": "security.xform.permissionsLoad.cardData.celesta",
"proc": {
"@id": "tableXformDownload",
"@name":
"security.xform.permissionsLoad.permissionsDownload.celesta",
"@type": "DOWNLOAD"
}
}, {
"@id":
"permUploadXform",
"@type":
"xforms",
"@template":
"security/tableLoad.xml",
"@neverShowInPanel":
"true",
"@proc":
"security.xform.permissionsLoad.cardData.celesta",
"proc": [{
"@id": "tableXformUpload",
"@name":
"security.xform.permissionsLoad.permissionsUpload.celesta",
"@type": "UPLOAD"
}, {
"@id": "permissionsXformUploadSave",
"@name":
"security.xform.permissionsLoad.cardSave.celesta",
"@type": "SAVE"
}]
}]
}, {
"@id":
2,
"@name":
u"Прочие разрешения",
"element": [{
"@id":
"customPermFilter",
"@type":
"xforms",
"@template":
"security/customPermissionsFilter.xml",
"@proc":
"security.xform.customPermissionsFilter.cardData.celesta"
}, {
"@id":
"customPermissionsGrid",
"@type":
"grid",
"@subtype":
"JS_LIVE_GRID",
"@plugin":
"liveDGrid",
"@proc":
"security.grid.customPermissions.gridData.celesta",
"@hideOnLoad":
"true",
"proc": [{
"@id": "customPermissionsGridMeta",
"@name":
"security.grid.customPermissions.gridMeta.celesta",
"@type": "METADATA"
}, {
"@id": "customPermissionsGridToolBar",
"@name":
"security.grid.customPermissions.gridToolBar.celesta",
"@type": "TOOLBAR"
}],
"related": {
"@id": "customPermFilter"
}
}, {
"@id":
"customPermissionsXforms",
"@type":
"xforms",
"@template":
"security/customPermissions.xml",
"@neverShowInPanel":
"true",
"@proc":
"security.xform.customPermissions.cardData.celesta",
"proc": {
"@id": "customPermissionsXformSave",
"@name":
"security.xform.customPermissions.cardDataSave.celesta",
"@type": "SAVE"
},
"related": [{
"@id": "customPermissionsGrid"
}, {
"@id": "customPermFilter"
}]
}, {
"@id": "customPermissionsXformDelete",
"@type": "xforms",
"@template": "security/delete.xml",
"@neverShowInPanel": "true",
"@proc":
"security.xform.customPermissionsDelete.cardData.celesta",
"proc": {
"@id": "customPermissionsXformDelete",
"@name":
"security.xform.customPermissionsDelete.cardDelete.celesta",
"@type": "SAVE"
},
"related": {
"@id": "customPermissionsGrid"
}
}, {
"@id": "customPermissionsDownloadXform",
"@type": "xforms",
"@template": "security/tableLoad.xml",
"@neverShowInPanel": "true",
"@proc":
"security.xform.customPermissionsLoad.cardData.celesta",
"proc": {
"@id": "tableXformDownload",
"@name":
"security.xform.customPermissionsLoad.permissionsDownload.celesta",
"@type": "DOWNLOAD"
}
}, {
"@id":
"customPermissionsUploadXform",
"@type":
"xforms",
"@template":
"security/tableLoad.xml",
"@neverShowInPanel":
"true",
"@proc":
"security.xform.customPermissionsLoad.cardData.celesta",
"proc": [{
"@id": "tableXformUpload",
"@name":
"security.xform.customPermissionsLoad.permissionsUpload.celesta",
"@type": "UPLOAD"
}, {
"@id": "customPermissionsXformUploadSave",
"@name":
"security.xform.customPermissionsLoad.cardSave.celesta",
"@type": "SAVE"
}]
}, {
"@id":
"rolesCustomPermissionsGrid",
"@type":
"grid",
"@subtype":
"JS_LIVE_GRID",
"@plugin":
"liveDGrid",
"@proc":
"security.grid.rolesCustomPermissions.gridData.celesta",
"@hideOnLoad":
"true",
"proc": [{
"@id": "rolesCustomPermissionsGridMeta",
"@name":
"security.grid.rolesCustomPermissions.gridMeta.celesta",
"@type": "METADATA"
}, {
"@id": "rolesCustomPermissionsGridToolBar",
"@name":
"security.grid.rolesCustomPermissions.gridToolBar.celesta",
"@type": "TOOLBAR"
}, {
"@id": "saveRecord",
"@name":
"security.grid.rolesCustomPermissions.gridSaveRecord.celesta",
"@type": "SAVE"
}],
"related": {
"@id": "customPermissionsGrid"
}
}, {
"@id": "rolesCustomPermissionsDownloadXform",
"@type": "xforms",
"@template": "security/tableLoad.xml",
"@neverShowInPanel": "true",
"@proc":
"security.xform.rolesCustomPermissionsLoad.cardData.celesta",
"proc": {
"@id": "tableXformDownload",
"@name":
"security.xform.rolesCustomPermissionsLoad.rolesPermissionsDownload.celesta",
"@type": "DOWNLOAD"
}
}, {
"@id":
"rolesCustomPermissionsUploadXform",
"@type":
"xforms",
"@template":
"security/tableLoad.xml",
"@neverShowInPanel":
"true",
"@proc":
"security.xform.rolesCustomPermissionsLoad.cardData.celesta",
"proc": [{
"@id": "tableXformUpload",
"@name":
"security.xform.rolesCustomPermissionsLoad.rolesPermissionsUpload.celesta",
"@type": "UPLOAD"
}, {
"@id": "rolesCustomPermissionsXformUploadSave",
"@name":
"security.xform.rolesCustomPermissionsLoad.cardSave.celesta",
"@type": "SAVE"
}]
}]
}, {
"@id":
3,
"@name":
u"Типы разрешений",
"element": [{
"@id":
"customPermissionsTypesGrid",
"@type":
"grid",
"@subtype":
"JS_LIVE_GRID",
"@plugin":
"liveDGrid",
"@proc":
"security.grid.customPermissionsTypes.gridData.celesta",
"proc": [{
"@id": "customPermissionsTypesGridMeta",
"@name":
"security.grid.customPermissionsTypes.gridMeta.celesta",
"@type": "METADATA"
}, {
"@id": "customPermissionsTypesGridToolBar",
"@name":
"security.grid.customPermissionsTypes.gridToolBar.celesta",
"@type": "TOOLBAR"
}]
}, {
"@id": "customPermissionsTypesXforms",
"@type": "xforms",
"@template": "security/customPermissionsTypes.xml",
"@neverShowInPanel": "true",
"@proc":
"security.xform.customPermissionsTypes.cardData.celesta",
"proc": {
"@id": "customPermissionsTypesXformSave",
"@name":
"security.xform.customPermissionsTypes.cardDataSave.celesta",
"@type": "SAVE"
},
"related": {
"@id": "customPermissionsTypesGrid"
}
}, {
"@id": "customPermissionsTypesXformDelete",
"@type": "xforms",
"@template": "security/delete.xml",
"@neverShowInPanel": "true",
"@proc":
"security.xform.customPermissionsTypesDelete.cardData.celesta",
"proc": {
"@id": "customPermissionsTypesXformDelete",
"@name":
"security.xform.customPermissionsTypesDelete.cardDelete.celesta",
"@type": "SAVE"
},
"related": {
"@id": "customPermissionsTypesGrid"
}
}, {
"@id": "customPermissionsTypesDownloadXform",
"@type": "xforms",
"@template": "security/tableLoad.xml",
"@neverShowInPanel": "true",
"@proc":
"security.xform.customPermissionsTypesLoad.cardData.celesta",
"proc": {
"@id": "tableXformDownload",
"@name":
"security.xform.customPermissionsTypesLoad.permissionsTypesDownload.celesta",
"@type": "DOWNLOAD"
}
}, {
"@id":
"customPermissionsTypesUploadXform",
"@type":
"xforms",
"@template":
"security/tableLoad.xml",
"@neverShowInPanel":
"true",
"@proc":
"security.xform.customPermissionsTypesLoad.cardData.celesta",
"proc": [{
"@id": "tableXformUpload",
"@name":
"security.xform.customPermissionsTypesLoad.permissionsTypesUpload.celesta",
"@type": "UPLOAD"
}, {
"@id": "customPermissionsTypesXformUploadSave",
"@name":
"security.xform.customPermissionsTypesLoad.cardSave.celesta",
"@type": "SAVE"
}]
}]
}]
}
}
return XMLJSONConverter.jsonToXml(json.dumps(data))
def cardData(context,
main=None,
add=None,
filterinfo=None,
session=None,
elementId=None):
u'''Функция данных для карточки редактирования содержимого таблицы разрешения. '''
gridContext = json.loads(
session)['sessioncontext']['related']['gridContext']
gridContext = gridContext if isinstance(gridContext,
list) else [gridContext]
currentId = {}
for gc in gridContext:
if "currentRecordId" in gc.keys():
currentId[gc["@id"]] = gc["currentRecordId"]
if add == 'add':
if "numbersSeriesGrid" in currentId.keys():
seriesId = currentId["numbersSeriesGrid"]
else:
seriesId = ''
xformsdata = {
"schema": {
"numberSeries": {
"@seriesId": seriesId,
"@numberOfLine": "",
"@startingDate": "",
"@startingNumber": "",
"@endingNumber": "",
"@incrimentByNumber": "",
"@lastUsedNumber": "",
"@isOpened": "",
"@lastUsedDate": "",
"@prefix": "",
"@postfix": "",
"@isFixedLength": ""
}
}
}
elif add == 'edit':
sdf = SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS")
linesOfNumbersSeries = linesOfNumbersSeriesCursor(context)
linesOfNumbersSeries.get(currentId["numbersSeriesGrid"],
int(currentId["linesNumbersSeriesGrid"]))
xformsdata = {
"schema": {
"numberSeries": {
"@seriesId":
linesOfNumbersSeries.seriesId,
"@numberOfLine":
linesOfNumbersSeries.numberOfLine,
"@startingDate":
unicode(sdf.format(linesOfNumbersSeries.startingDate)),
"@startingNumber":
linesOfNumbersSeries.startingNumber,
"@endingNumber":
linesOfNumbersSeries.endingNumber,
"@incrimentByNumber":
linesOfNumbersSeries.incrimentByNumber,
"@lastUsedNumber":
linesOfNumbersSeries.lastUsedNumber,
"@isOpened":
unicode(linesOfNumbersSeries.isOpened).lower(),
"@lastUsedDate":
unicode(sdf.format(linesOfNumbersSeries.lastUsedDate)),
"@prefix":
linesOfNumbersSeries.prefix,
"@postfix":
linesOfNumbersSeries.postfix,
"@isFixedLength":
unicode(linesOfNumbersSeries.isFixedLength).lower()
}
}
}
# print xformsdata
xformssettings = {
"properties": {
"event": {
"@name": "single_click",
"@linkId": "1",
"action": {
"#sorted": [{
"main_context": "current"
}, {
"datapanel": {
"@type": "current",
"@tab": "current",
"element": {
"@id": "linesNumbersSeriesGrid",
"add_context": ""
}
}
}]
}
}
}
}
return JythonDTO(XMLJSONConverter.jsonToXml(json.dumps(xformsdata)),
XMLJSONConverter.jsonToXml(json.dumps(xformssettings)))
import json
from ru.curs.celesta.showcase.utils import XMLJSONConverter
from inspect import isfunction
from importlib import import_module
try:
from ru.curs.showcase.core.jython import JythonDTO #@UnresolvedImport
except ImportError:
from ru.curs.celesta.showcase import JythonDTO
serializeJSON = lambda jsonDict: json.dumps(jsonDict)
deserializeJSON = lambda jsonString: json.loads(jsonString)
json2xml = lambda jsonString: XMLJSONConverter.jsonToXml(jsonString)
xml2json = lambda xmlString: XMLJSONConverter.xmlToJson(xmlString)
objectQualifiedName = lambda obj: '%s.%s' % (obj.__module__, obj.__class__.
__name__)
classQualifiedName = lambda cls: '%s.%s' % (cls.__module__, cls.__name__)
def importObject(mod, obj):
obj_ = getattr(import_module(mod), obj)
return obj_
def getCursor(tableName):
"""Возвращает класс курсора по полному имени таблицы.
@param tableName (@c string) имя таблицы в формате \<гранула>.\<таблица>
def cardData(context,
main=None,
add=None,
filterinfo=None,
session=None,
elementId=None):
u'''Функция данных для карточки редактирования содержимого таблицы разрешения. '''
permissions = PermissionsCursor(context)
if add == 'add':
formData = json.loads(session)['sessioncontext']['related'][
"xformsContext"]["formData"]["schema"]
xformsdata = {
"schema": {
"roleid": formData["roleid"],
"grainid": formData["grainid"],
"tablename": formData["tablename"],
"r": "",
"i": "",
"m": "",
"d": ""
}
}
elif add == 'edit':
currIdEncoded = json.loads(session)['sessioncontext']['related'][
'gridContext']['currentRecordId']
currId = json.loads(base64.b64decode(currIdEncoded))
permissions.get(*currId)
xformsdata = {
"schema": {
"roleid": permissions.roleid,
"grainid": permissions.grainid,
"tablename": permissions.tablename,
"r": unicode(permissions.r).lower(),
"i": unicode(permissions.i).lower(),
"m": unicode(permissions.m).lower(),
"d": unicode(permissions.d).lower()
}
}
# print xformsdata
xformssettings = {
"properties": {
"event": {
"@name": "single_click",
"@linkId": "1",
"action": {
"#sorted": [{
"main_context": "current"
}, {
"datapanel": {
"@type": "current",
"@tab": "current",
"element": {
"@id": "permGrid",
"add_context": ""
}
}
}]
}
}
}
}
return JythonDTO(XMLJSONConverter.jsonToXml(json.dumps(xformsdata)),
XMLJSONConverter.jsonToXml(json.dumps(xformssettings)))