Beispiel #1
0
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 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 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)
Beispiel #4
0
def gridData(context,
             main=None,
             add=None,
             filterinfo=None,
             session=None,
             elementId=None,
             sortColumnList=None,
             firstrecord=None,
             pagesize=None):
    u'''Функция получения данных для грида. '''
    # Создание экземпляра курсора разрешения
    subjects = subjectsCursor(context)
    # Параметры сортировки
    if sortColumnList:
        sortName = toHexForXml(sortColumnList[0].id)
        sortType = unicode(sortColumnList[0].sorting).lower()
    else:
        sortName = None

    # Определяем переменную для JSON данных
    data = {"records": {"rec": []}}
    # Определяем заголовки
    _header = {
        "rowid": ["~~id"],
        "sid": [u"SID"],
        "name": [u"Имя"],
        "properties": [u"properties"]
    }
    for column in _header:
        _header[column].append(toHexForXml(_header[column][0]))
        if sortName == _header[column][1]:
            subjects.orderBy("%s %s" % (column, sortType))

    subjects.limit(firstrecord - 1, pagesize)
    # Проходим по таблице и заполняем data
    for subjects in subjects.iterate():
        subjectsDict = {}
        subjectsDict[_header["rowid"][1]] = subjects.sid
        for column in [
                x for x in _header.keys() if x not in ("rowid", "properties")
        ]:
            subjectsDict[_header[column][1]] = getattr(subjects, column) or ''
        subjectsDict['properties'] = {
            "event": {
                "@name": "row_single_click",
                "action": {
                    "#sorted": [{
                        "main_context": 'current'
                    }, {
                        "datapanel": {
                            '@type': "current",
                            '@tab': "current"
                        }
                    }]
                }
            }
        }
        data["records"]["rec"].append(subjectsDict)

    res = XMLJSONConverter.jsonToXml(json.dumps(data))
    return JythonDTO(res, None)
Beispiel #5
0
def gridData(context,
             main=None,
             add=None,
             filterinfo=None,
             session=None,
             elementId=None,
             sortColumnList=None,
             firstrecord=0,
             pagesize=50):
    u'''Функция получения данных для грида. '''
    session = json.loads(session)["sessioncontext"]["related"]

    # Создание экземпляра курсора разрешения
    permissions = tablesPermissionsViewCursor(context)

    # Сортировка по колонке
    if sortColumnList:
        sortName = toHexForXml(sortColumnList[0].id)
        sortType = unicode(sortColumnList[0].sorting).lower()
    else:
        sortName = None

    # Один и тот же грид используется в двух местах, в одном случае он зависит от xform-ы, в другом - от грида
    gridType = "editable"
    # Фильтрация данных из xform-ы
    if "xformsContext" in session:
        filterSchema = session["xformsContext"]["formData"]["schema"]
        if filterSchema["roleid"]:
            permissions.setRange("roleid", filterSchema["roleid"])
        if filterSchema["grainid"]:
            permissions.setRange("grainid", filterSchema["grainid"])
        if filterSchema["tablename"]:
            permissions.setRange("tablename", filterSchema["tablename"])
    # Фильтрация данных из грида выше
    if 'gridContext' in session:
        permissions.setRange("roleid",
                             session['gridContext']['currentRecordId'])
        gridType = "plain"

    # Сортировка по-умолчанию
    permissions.orderBy('roleid', 'grainid', 'tablename')

    # Определяем переменную для JSON данных
    data = {"records": {"rec": []}}
    _header = {
        "id": ["~~id"],
        "roleid": [u"Роль"],
        "grainid": [u"Гранула"],
        "tablename": [u"Таблица"],
        "r": [u"Доступ на чтение"],
        "i": [u"Доступ на добавление"],
        "m": [u"Доступ на редактирование"],
        "d": [u"Доступ на удаление"],
        "properties": [u"properties"]
    }
    for column in _header:
        _header[column].append(toHexForXml(_header[column][0]))
        if sortName == _header[column][1]:
            permissions.orderBy("%s %s" % (column, sortType))

    permissions.limit(firstrecord - 1, pagesize)

    if gridType == "editable":

        def getBoolData(cursor, column):
            return getattr(cursor, column) or ''
    else:

        def getBoolData(cursor, column):
            return u'gridToolBar/yes.png:Разрешен' if getattr(
                cursor, column) else u'gridToolBar/no.png:Запрещен'

    # Проходим по таблице и заполняем data
    for permissions in permissions.iterate():
        permDict = {}
        permDict[_header["id"][1]] = json.dumps(
            [permissions.roleid, permissions.grainid, permissions.tablename])

        permDict[_header["roleid"][1]] = permissions.roleid
        permDict[_header["grainid"][1]] = permissions.grainid
        permDict[_header["tablename"][1]] = permissions.tablename
        for column in ("r", "i", "m", "d"):
            permDict[_header[column][1]] = getBoolData(permissions, column)

        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)
Beispiel #6
0
def gridData(context,
             main=None,
             add=None,
             filterinfo=None,
             session=None,
             elementId=None,
             sortColumnList=[],
             firstrecord=0,
             pagesize=50):
    u'''Функция получения данных для грида. '''

    linesOfNumbersSeries = linesOfNumbersSeriesCursor(context)
    if 'currentRecordId' in session:
        currId = json.loads(session)['sessioncontext']['related'][
            'gridContext']['currentRecordId']
        linesOfNumbersSeries.setRange("seriesId", currId)
    # Определяем переменную для JSON данных
    data = {"records": {"rec": []}}

    linesOfNumbersSeries.limit(firstrecord - 1, pagesize)

    # Проходим по таблице и заполняем data
    for linesOfNumbersSeries in linesOfNumbersSeries.iterate():
        linesDict = {}
        linesDict[toHexForXml('~~id')] = linesOfNumbersSeries.numberOfLine
        linesDict[toHexForXml(
            u"Номер серии")] = linesOfNumbersSeries.numberOfLine
        linesDict[toHexForXml(u"Начальная дата")] = SimpleDateFormat("dd.MM.yyyy HH:mm:ss").format(linesOfNumbersSeries.startingDate)\
                                                                if linesOfNumbersSeries.startingDate\
                                                                else linesOfNumbersSeries.startingDate
        linesDict[toHexForXml(
            u"Начальный номер")] = linesOfNumbersSeries.startingNumber
        linesDict[toHexForXml(
            u"Последний номер")] = linesOfNumbersSeries.endingNumber
        linesDict[u"Инкремент"] = linesOfNumbersSeries.incrimentByNumber
        linesDict[toHexForXml(u"Последний использованный номер"
                              )] = linesOfNumbersSeries.lastUsedNumber
        linesDict[
            u"Используется"] = 'gridToolBar/yes.png' if linesOfNumbersSeries.isOpened else 'gridToolBar/no.png'
        linesDict[toHexForXml(u"Дата последнего использования")] = SimpleDateFormat("dd.MM.yyyy HH:mm:ss").format(linesOfNumbersSeries.lastUsedDate)\
                                                                            if linesOfNumbersSeries.lastUsedDate\
                                                                            else linesOfNumbersSeries.lastUsedDate
        linesDict[u"Префикс"] = linesOfNumbersSeries.prefix
        linesDict[u"Постфикс"] = linesOfNumbersSeries.postfix
        linesDict[toHexForXml(
            u"Фиксированная длина"
        )] = 'gridToolBar/yes.png' if linesOfNumbersSeries.isFixedLength else 'gridToolBar/no.png'
        linesDict['properties'] = {
            "event": {
                "@name": "row_single_click",
                "action": {
                    "#sorted": [{
                        "main_context": 'current'
                    }, {
                        "datapanel": {
                            '@type': "current",
                            '@tab': "current"
                        }
                    }]
                }
            }
        }
        data["records"]["rec"].append(linesDict)

    res = XMLJSONConverter.jsonToXml(json.dumps(data))
    return JythonDTO(res, None)
Beispiel #7
0
def gridData(context,
             main=None,
             add=None,
             filterinfo=None,
             session=None,
             elementId=None,
             sortColumnList=None,
             firstrecord=None,
             pagesize=None):
    u'''Функция получения данных для грида. '''

    # Создание экземпляра курсора разрешения
    roles = RolesCursor(context)
    rolesPermissions = rolesCustomPermsCursor(context)
    if 'currentRecordId' in session:
        currId = json.loads(session)['sessioncontext']['related'][
            'gridContext']['currentRecordId']
        rolesPermissions.setRange("permissionId", currId)

    roles.orderBy("id")
    # Определяем переменную для JSON данных

    data = {"records": {"rec": []}}
    _header = {
        "id": ["~~id"],
        "roleId": [u"Роль"],
        "description": [u"Описание"],
        "exists": [u" "],
        "properties": [u"properties"]
    }

    for column in _header:
        _header[column].append(toHexForXml(_header[column][0]))

    # Считываем параметры сортировки
    if sortColumnList:
        sortName = sortColumnList[0].id
        sortType = unicode(sortColumnList[0].sorting).lower()
    else:
        sortName = None
    # Проходим по таблице и заполняем data
    if roles.tryFindSet():
        while True:
            permDict = {}
            permDict[_header["id"][1]] = json.dumps({
                "permission": currId,
                "role": roles.id
            })
            permDict[_header["roleId"][1]] = roles.id
            permDict[_header["description"][1]] = roles.description
            rolesPermissions.setRange("roleid", roles.id)
            permDict[_header["exists"][1]] = rolesPermissions.count(
            ) > 0 if rolesPermissions.count() else ''
            permDict[_header["properties"][1]] = {
                "event": {
                    "@name": "row_single_click",
                    "action": {
                        "#sorted": [{
                            "main_context": 'current'
                        }, {
                            "datapanel": {
                                '@type': "current",
                                '@tab': "current"
                            }
                        }]
                    }
                }
            }

            data["records"]["rec"].append(permDict)
            if not roles.nextInSet():
                break

    for column in _header:
        if sortName == _header[column][0]:
            keyField = column if sortName else 'exists'
            data["records"]["rec"].sort(key=lambda x:
                                        (x[_header["%s" % keyField][1]]),
                                        reverse=(sortType == 'desc'))
            data["records"]["rec"] = data["records"]["rec"][firstrecord -
                                                            1:firstrecord - 1 +
                                                            pagesize]
    res = XMLJSONConverter.jsonToXml(json.dumps(data))
    return JythonDTO(res, None)
Beispiel #8
0
def gridData(context,
             main=None,
             add=None,
             filterinfo=None,
             session=None,
             elementId=None,
             sortColumnList=None,
             firstrecord=None,
             pagesize=None):
    u'''Функция получения данных для грида. '''
    # Создание экземпляра курсора разрешения
    permissions = customPermsCursor(context)
    if sortColumnList:
        sortName = toHexForXml(sortColumnList[0].id)
        sortType = unicode(sortColumnList[0].sorting).lower()
    else:
        sortName = None

    if 'formData' in session:
        typeId = json.loads(session)['sessioncontext']['related'][
            'xformsContext']['formData']['schema']['permission']['@type']
        if typeId:
            permissions.setRange('type', typeId)

    permissions.orderBy('name')

    # Определяем переменную для JSON данных
    data = {"records": {"rec": []}}
    # Проходим по таблице и заполняем data
    _header = {
        "id": ["~~id"],
        "name": [u"Разрешение"],
        "description": [u"Описание"],
        "type": [u"Тип"],
        "properties": [u"properties"]
    }
    for column in _header:
        _header[column].append(toHexForXml(_header[column][0]))
        if sortName == _header[column][1]:
            permissions.orderBy("%s %s" % (column, sortType))
    permissions.limit(firstrecord - 1, pagesize)
    for permissions in permissions.iterate():
        permDict = {}
        permDict[_header["id"][1]] = permissions.name
        permDict[_header["name"][1]] = permissions.name or ''
        permDict[_header["description"][1]] = permissions.description or ''
        permDict[_header["type"][1]] = permissions.type or ''

        permDict['properties'] = {
            "event": {
                "@name": "row_single_click",
                "action": {
                    "#sorted": [{
                        "main_context": 'current'
                    }, {
                        "datapanel": {
                            '@type': "current",
                            '@tab': "current",
                            "element": {
                                "@id": "rolesCustomPermissionsGrid"
                            }
                        }
                    }]
                }
            }
        }
        data["records"]["rec"].append(permDict)

    res = XMLJSONConverter.jsonToXml(json.dumps(data))
    return JythonDTO(res, None)
Beispiel #9
0
def gridData(context,
             main=None,
             add=None,
             filterinfo=None,
             session=None,
             elementId=None,
             sortColumnList=None,
             firstrecord=None,
             pagesize=None):
    u'''Функция получения данных для грида списка пользователей. '''
    session = json.loads(session)["sessioncontext"]
    settings = Settings()
    logins = loginsCursor(context)
    if sortColumnList:
        sortName = toHexForXml(sortColumnList[0].id)
        sortType = unicode(sortColumnList[0].sorting).lower()
    else:
        sortName = None
    # Определяем переменную для JSON данных
    data = {"records": {"rec": []}}
    _header = {
        "id": ["~~id"],
        "sid": [u"SID"],
        "userName": [u"Имя пользователя"],
        "subject": [u"Субъект"],
        "employee": [u"Сотрудник"],
        "properties": [u"properties"]
    }
    event = {
        "event": {
            "@name": "row_single_click",
            "action": {
                "#sorted": [{
                    "main_context": 'current'
                }, {
                    "datapanel": {
                        "@type": "current",
                        "@tab": "current"
                    }
                }]
            }
        }
    }
    for column in _header:
        _header[column].append(toHexForXml(_header[column][0]))

    isEmployees = settings.isEmployees()

    if isEmployees:
        employeesGrain = settings.getEmployeesParam("employeesGrain")
        employeesTable = settings.getEmployeesParam("employeesTable")
        employeesName = settings.getEmployeesParam(
            "employeesName")  # название поля с именем
        employeesCursor = tableCursorImport(employeesGrain, employeesTable)
        employees = employeesCursor(context)

    if settings.isUseAuthServer():
        sessionId = session[
            "sessionid"]  # получаем из контекста сессии Id сессии
        server = SecurityParamsFactory.getAuthServerUrl(
        )  # получаем url mellophone
        logins_xml = func.getUsersFromAuthServer(
            server, sessionId)  # получаем xml с пользователями

    if settings.isUseAuthServer() and settings.loginIsSubject():
        # грид состоит из колонок sid, имя пользователя и сотрудник
        subjects = subjectsCursor(context)
        for i, user in enumerate(logins_xml.getElementsByTagName("user")):
            if i < firstrecord - 1:
                continue  # пропускаем элементы с 1 по firstrecord
            loginsDict = {}
            loginsDict[_header["id"][1]] = json.dumps(
                [user.getAttribute("login"),
                 user.getAttribute("SID")])
            loginsDict[_header["sid"][1]] = user.getAttribute("SID")
            loginsDict[_header["userName"][1]] = user.getAttribute("login")
            if isEmployees:
                # если таблица сотрудников существует (прописана в настройках)
                # добавляем в грид сотрудника колонку Сотрудник.
                if logins.tryGet(user.getAttribute("login")) and \
                        subjects.tryGet(logins.subjectId) and\
                        employees.tryGet(subjects.employeeId):
                    loginsDict[_header["employee"][1]] = getattr(
                        employees, employeesName)
                else:
                    loginsDict[_header["employee"][1]] = ''
            loginsDict['properties'] = event
            data["records"]["rec"].append(loginsDict)
            if i >= firstrecord + pagesize:
                break  # прерываем цикл после достижения записи № firstrecord + pagesize
    elif settings.isUseAuthServer():
        # грид состоит из колонок sid, имя пользователя и субъект
        subjects = subjectsCursor(context)
        for i, user in enumerate(logins_xml.getElementsByTagName("user")):
            if i < firstrecord - 1:
                continue  # пропускаем элементы с 1 по firstrecord

            loginsDict = {}
            loginsDict[_header["id"][1]] = user.getAttribute("login")
            loginsDict[_header["sid"][1]] = user.getAttribute("SID")
            loginsDict[_header["userName"][1]] = user.getAttribute("login")
            if logins.tryGet(user.getAttribute("login")) and subjects.tryGet(
                    logins.subjectId):
                loginsDict[_header["subject"][1]] = subjects.name
            else:
                loginsDict[_header["subject"][1]] = ''
            loginsDict['properties'] = event

            data["records"]["rec"].append(loginsDict)
            if i >= firstrecord + pagesize:
                break  # прерываем цикл после достижения записи № firstrecord + pagesize

    elif not settings.isUseAuthServer() and not settings.loginIsSubject():
        # грид состоит из колонок имя пользователя и субъект
        subjects = subjectsCursor(context)

        logins.limit(firstrecord - 1, pagesize)

        for logins in logins.iterate():
            loginsDict = {}
            loginsDict[_header["id"][1]] = logins.userName
            loginsDict[_header["userName"][1]] = logins.userName

            if subjects.tryGet(logins.subjectId):
                loginsDict[_header["subject"][1]] = subjects.name
            else:
                loginsDict[_header["subject"][1]] = ""

            loginsDict['properties'] = event

            data["records"]["rec"].append(loginsDict)
    else:
        # грид состоит из колонки имя пользователя
        subjects = subjectsCursor(context)
        logins.limit(firstrecord - 1, pagesize)
        for logins in logins.iterate():
            loginsDict = {}
            loginsDict[_header["id"][1]] = logins.userName
            loginsDict[_header["userName"][1]] = logins.userName
            if isEmployees and subjects.tryGet(
                    logins.subjectId) and employees.tryGet(
                        subjects.employeeId):
                loginsDict[_header["employee"][1]] = getattr(
                    employees, employeesName)
            else:
                loginsDict[_header["employee"][1]] = ""

            loginsDict['properties'] = event
            data["records"]["rec"].append(loginsDict)

    # сортировка
    if sortColumnList:
        data["records"]["rec"].sort(key=lambda x:
                                    (x[unicode(sortName)].lower()),
                                    reverse=(sortType == 'desc'))
    res = XMLJSONConverter.jsonToXml(json.dumps(data))
    return JythonDTO(res, None)