Ejemplo n.º 1
0
def change_type(**args):
    '''смена типа атрибута'''
    attr     = args['attr']
    old_type = args['old_type']
    new_type = args['new_type']
    request  = args['request']
    schema   = args['schema']
    
    success = True
    errors  = None

    '''
    OTHER
    '''
    #переход из other в other
    if old_type.id not in (7,9) and new_type.id not in (7,9):
        if not old_type.id == new_type.id:
            attr.type = new_type
    
    #переход из other в List
    if old_type.id not in (7,9) and new_type.id == 7:
        req  = ListRequired(request=request, req_params=['ref_list'])
               
        if req.success():
            ref_list = req.params()['ref_list']
            if ref_list is not None:
                #ref_list пришёл => создаём ссылку на List
                attr.type     = new_type
                attr.type_def = ref_list
        else:
            success = False
            errors  = req.errors()

    #переход из other в Reference
    if old_type.id not in (7,9) and new_type.id == 9:
        #это Reference
        req  = OTRequired(request=request, req_params=['ref_object_type'])
        
        if req.success():
            ref_object_type = req.params()['ref_object_type']
            if ref_object_type is not None:
            
                #ref_object_type пришёл => создаём новый Reference
                type_ref = Type_def.objects.create(id=nc_id.get(), type=new_type, schema=schema, object_type=ref_object_type)
                attr.type     = new_type
                attr.type_def = type_ref
        else:
            success = False
            errors  = req.errors()

    '''
    LIST
    '''
    #переход из List в other
    if old_type.id == 7 and new_type.id not in (7,9):
        attr.type_def = None
        attr.type     = new_type

    #переход из List в List
    if old_type.id == 7 and new_type.id == 7:
        req  = ListRequired(request=request, req_params=['ref_list'])
               
        if req.success():
            ref_list = req.params()['ref_list']
            if ref_list is not None:
                #ref_list пришёл => создаём ссылку на List и это ссылка на другой List
                if not attr.type_def == ref_list:
                    attr.type_def = ref_list
        else:
            success = False
            errors  = req.errors()        

    #переход из List в Reference
    if old_type.id == 7 and new_type.id == 9:
        #это Reference
        req  = OTRequired(request=request, req_params=['ref_object_type'])
        
        if req.success():
            ref_object_type = req.params()['ref_object_type']
            if ref_object_type is not None:
            
                #ref_object_type пришёл => создаём новый Reference
                type_ref = Type_def.objects.create(id=nc_id.get(), type=new_type, schema=schema, object_type=ref_object_type)
                attr.type     = new_type
                attr.type_def = type_ref
        else:
            success = False
            errors  = req.errors()
    
    '''
    REFERENCE
    '''
    #переход из Reference в other
    if old_type.id == 9 and new_type.id not in (7,9):
        attr.type_def = None
        attr.type     = new_type

    #переход из Reference в List
    if old_type.id == 9 and new_type.id == 7:
        req  = ListRequired(request=request, req_params=['ref_list'])
               
        if req.success():
            ref_list = req.params()['ref_list']
            if ref_list is not None: #ref_list пришёл => создаём ссылку на List
                attr.type_def = ref_list
                attr.type     = new_type
        else:
            success = False
            errors  = req.errors()

    #переход из Reference в Reference
    if old_type.id == 9 and new_type.id == 9:
        #это Reference
        req  = OTRequired(request=request, req_params=['ref_object_type'])
        
        if req.success():
            ref_object_type = req.params()['ref_object_type']
            if ref_object_type is not None:
            
                try:
                    #пытаем найти нужный reference
                    type_ref = Type_def.objects.get(type=new_type, schema=schema, object_type=ref_object_type)
                except ObjectDoesNotExist:
                    #такого reference ещё не существует - создадим его
                    type_ref = Type_def.objects.create(id=nc_id.get(), type=new_type, schema=schema, object_type=ref_object_type)
                    attr.type_def = type_ref
                except MultipleObjectsReturned:
                    #подобных типов много - выберем любой из них
                    type_ref = Type_def.objects.filter(type=new_type, schema=schema, object_type=ref_object_type)[0]
                    
                    if not attr.type_def == type_ref: #если текущий reference и новый не совпадают - обновим type_def
                        attr.type_def = type_ref                
                else:
                    if not attr.type_def == type_ref: #если текущий reference и новый не совпадают - обновим type_def
                        attr.type_def = type_ref                
        else:
            success = False
            errors  = req.errors()
            
    #в случае ошибок возвращаем описание ошибки
    if success and errors is None:
        return (True, None)
    else:
        return (False, errors)
Ejemplo n.º 2
0
def worker(req):
    """
    функция модификации атрибута
    """

    schema = req.params()["attr_schema"]
    object_type = req.params()["object_type"]
    group = req.params()["attr_group"]

    name = req.params()["name"]
    description = req.params()["description"]
    type = req.params()["type"]
    def_value = req.params()["def_value"]
    mask = req.params()["mask"]
    tags = req.params()["tags"]

    displayed = req.params()["displayed"]
    multiple = req.params()["multiple"]
    read_only = req.params()["read_only"]
    hidden = req.params()["hidden"]
    required = req.params()["required"]
    calculable = req.params()["calculable"]

    # создаём атрибут
    attr = ATTR.objects.create(
        id=nc_id.get(),
        group=group,
        schema=schema,
        type=type,
        name=name,
        description=description,
        def_value=def_value,
        mask=mask,
    )

    # создаём AOT
    AOT().create(schema=schema, object_type=object_type, attr=attr, options=0)
    aot = AOT.objects.get(schema=schema, object_type=object_type, attr=attr)

    # set Attr_property
    attr_prop = Attr_property(aot=aot, attr=attr)

    attr_prop.setDisplayed(displayed)
    attr_prop.setRequired(required)
    attr_prop.setMultiple(multiple)
    attr_prop.setReadOnly(read_only)
    attr_prop.setHidden(hidden)
    attr_prop.setCalculable(calculable)

    # обновляем Tag если Tags пришли
    if not tags == -1:
        attr.set(tags=tags)

    # TYPE
    if attr.type.id == 7:
        # это List
        req = ListRequired(request=req.request, req_params=["ref_list"])

        if req.success():
            # создаём ссылку на List
            attr.type_def = req.params()["ref_list"]
        else:
            return {"success": False, "errors": req.errors()}

    if attr.type.id == 9:
        # это Reference
        req = OTRequired(request=req.request, req_params=["ref_object_type"])

        if req.success():
            # создаём Reference
            attr.type_def = Type_def.objects.create(
                id=nc_id.get(), type=attr.type, schema=schema, object_type=req.params()["ref_object_type"]
            )
        else:
            return {"success": False, "errors": req.errors()}

    # сохраняем атрибут
    attr.save()

    return {"success": True, "message": "Атрибут %s успешно создан" % str(attr.id)}